From 24ba6854b66d46d89900184650403fdac1db7301 Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Wed, 10 Jun 2026 10:33:07 -0400 Subject: [PATCH 1/7] rework the workflow --- .gitattributes | 1 - .github/CODE_OF_CONDUCT.md | 58 + .github/CONTRIBUTING.md | 42 + .github/ISSUE_TEMPLATE/bug_report.yml | 64 + .github/ISSUE_TEMPLATE/feature_request.yml | 44 + .github/pull_request_template.md | 19 + .github/workflows/build_dist.yml | 83 +- .github/workflows/coverage_badge.yml | 51 + .github/workflows/docs.yml | 38 +- .github/workflows/publish.yml | 40 - .github/workflows/tests.yml | 166 +- .gitignore | 6 +- .pre-commit-config.yaml | 42 + AGENTS.md | 44 + CLAUDE.md | 1 + README.md | 25 +- archives/_pfaffian.py | 88 +- archives/_test_pfaffian.py | 44 +- archives/pfaffian_perm.py | 12 +- notebooks/_strategies_benchmark_helpers.py | 185 + notebooks/strategies_benchmark.ipynb | 326 ++ poetry.lock | 563 --- pyproject.toml | 193 +- requirements.txt | 471 +- run_pytests.py | 37 - setup.py | 16 +- sphinx/clean_html_files.py | 30 +- sphinx/generate_doc.py | 27 +- sphinx/make_html_files_list.py | 18 +- sphinx/source/conf.py | 70 +- sphinx/source/index.rst | 6 + src/torch_pfaffian/__init__.py | 14 +- src/torch_pfaffian/__main__.py | 15 - src/torch_pfaffian/py.typed | 0 src/torch_pfaffian/strategies/__init__.py | 9 +- .../strategies/pfaffian_block_det.py | 34 +- src/torch_pfaffian/strategies/pfaffian_det.py | 21 + .../strategies/pfaffian_fdbpf.py | 15 +- src/torch_pfaffian/strategies/strategy.py | 9 +- tests/__init__.py | 11 +- tests/configs.py | 3 - tests/conftest.py | 45 - tests/test_strategies/__init__.py | 0 .../test_pfaffian_block_det.py | 82 + tests/test_strategies/test_pfaffian_det.py | 78 + tests/test_strategies/test_pfaffian_fdbpf.py | 103 + tests/test_strategies/test_strategy.py | 28 + tests/test_torch_pfaffian.py | 81 +- tests/test_utils.py | 30 + uv.lock | 4379 +++++++++++++++++ 50 files changed, 6666 insertions(+), 1101 deletions(-) create mode 100644 .github/CODE_OF_CONDUCT.md create mode 100644 .github/CONTRIBUTING.md create mode 100644 .github/ISSUE_TEMPLATE/bug_report.yml create mode 100644 .github/ISSUE_TEMPLATE/feature_request.yml create mode 100644 .github/pull_request_template.md create mode 100644 .github/workflows/coverage_badge.yml delete mode 100644 .github/workflows/publish.yml create mode 100644 .pre-commit-config.yaml create mode 100644 AGENTS.md create mode 100644 CLAUDE.md create mode 100644 notebooks/_strategies_benchmark_helpers.py create mode 100644 notebooks/strategies_benchmark.ipynb delete mode 100644 poetry.lock delete mode 100644 run_pytests.py delete mode 100644 src/torch_pfaffian/__main__.py create mode 100644 src/torch_pfaffian/py.typed create mode 100644 src/torch_pfaffian/strategies/pfaffian_det.py create mode 100644 tests/test_strategies/__init__.py create mode 100644 tests/test_strategies/test_pfaffian_block_det.py create mode 100644 tests/test_strategies/test_pfaffian_det.py create mode 100644 tests/test_strategies/test_pfaffian_fdbpf.py create mode 100644 tests/test_strategies/test_strategy.py create mode 100644 tests/test_utils.py create mode 100644 uv.lock diff --git a/.gitattributes b/.gitattributes index a8dc694..91d7e6c 100644 --- a/.gitattributes +++ b/.gitattributes @@ -2,4 +2,3 @@ # Auto detect text files and perform LF normalization * text=auto - diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..6e8dfb8 --- /dev/null +++ b/.github/CODE_OF_CONDUCT.md @@ -0,0 +1,58 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We pledge to make our community welcoming, safe, and equitable for all. + +We are committed to fostering an environment that respects and promotes the dignity, rights, and contributions of all individuals, regardless of characteristics including race, ethnicity, caste, color, age, physical characteristics, neurodiversity, disability, sex or gender, gender identity or expression, sexual orientation, language, philosophy or religion, national or social origin, socio-economic position, level of education, or other status. The same privileges of participation are extended to everyone who participates in good faith and in accordance with this Covenant. + +## Encouraged Behaviors + +While acknowledging differences in social norms, we all strive to meet our community’s expectations for positive behavior. We also understand that our words and actions may be interpreted differently than we intend based on culture, background, or native language. + +With these considerations in mind, we agree to behave mindfully toward each other and act in ways that center our shared values, including: + +1. Respecting the **purpose of our community**, our activities, and our ways of gathering. +2. Engaging **kindly and honestly** with others. +3. Respecting **different viewpoints** and experiences. +4. **Taking responsibility** for our actions and contributions. +5. Gracefully giving and accepting **constructive feedback**. +6. Committing to **repairing harm** when it occurs. +7. Behaving in other ways that promote and sustain the **well-being of our community**. + +## Restricted Behaviors + +We agree to restrict the following behaviors in our community. Instances, threats, and promotion of these behaviors are violations of this Code of Conduct. + +1. **Harassment**. Violating explicitly expressed boundaries or engaging in unnecessary personal attention after any clear request to stop. +2. **Character attacks**. Making insulting, demeaning, or pejorative comments directed at a community member or group of people. +3. **Stereotyping or discrimination**. Characterizing anyone’s personality or behavior on the basis of immutable identities or traits. +4. **Sexualization**. Behaving in a way that would generally be considered inappropriately intimate in the context or purpose of the community. +5. **Violating confidentiality**. Sharing or acting on someone’s personal or private information without their permission. +6. **Endangerment**. Causing, encouraging, or threatening violence or other harm toward any person or group. +7. Behaving in other ways that **threaten the well-being** of our community. + +### Other Restrictions + +1. **Misleading identity**. Impersonating someone else for any reason, or pretending to be someone else to evade enforcement actions. +2. **Failing to credit sources**. Not properly crediting the sources of content you contribute. +3. **Promotional materials**. Sharing marketing or other commercial content in a way that is outside the norms of the community. +4. **Irresponsible communication**. Failing to responsibly present content which includes, links or describes any other restricted behaviors. + + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. + + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. + + + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 3.0, available at [https://www.contributor-covenant.org/version/3/0/code_of_conduct/](https://www.contributor-covenant.org/version/3/0/code_of_conduct/) diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 0000000..f7f87c8 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,42 @@ +# Introduction + +Thank you for your interest in contributing to our project! We welcome contributions from the community and appreciate your efforts to help improve our codebase. This document provides guidelines and instructions for contributing to our project. + + +## Installation + +To set up the development environment, please follow these steps: + +1. Fork the repository: + ```bash + gh repo fork MatchCake/TorchPfaffian + ``` +2. Clone your forked repository: + ```bash + git clone + ``` +3. Navigate to the project directory: +4. Initialize the Virtual Environment using [uv](https://docs.astral.sh/uv/): + ```bash + uv sync --dev --extra + ``` + - Extra options: See the [README.md](../README.md) for details on extra options for installation. +5. Set up Pre-commit hooks: + ```bash + uv run pre-commit install + ``` + +# Guidelines + +1. When you whish to contribute, please create a new fork of the repository and create a new branch for your changes. +2. Make your changes and commit them with clear and descriptive commit messages. +3. Push your changes to your forked repository. +4. Create a pull request to the main repository on the `dev` branch, describing the changes you have made and why they are necessary. +5. Our team will review your pull request and provide feedback. We may ask for changes or improvements before merging your contribution. +6. Once your contribution is approved, it will be merged into the main repository on the `dev` branch and will eventually be included in the next release. +7. Please ensure that your code follows the project's coding standards and guidelines, and that it includes appropriate tests and documentation. + + +## Code of Conduct + +We expect all contributors to adhere to our code of conduct, which can be found in the [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) file. This code of conduct outlines our expectations for behavior and communication within the community, and we take it seriously to ensure a welcoming and inclusive environment for all contributors. diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml new file mode 100644 index 0000000..4bad241 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -0,0 +1,64 @@ +name: Bug report +description: File a bug report +title: '[BUG]' +labels: "bug :bug:" + +body: + - type: markdown + id: description + attributes: + value: | + ## Before posting a bug report + Search existing GitHub issues to make sure the issue does not already exist. + + # Issue description + Description of the issue - include code snippets in the Source code section below and screenshots if relevant. + - type: textarea + id: expected + attributes: + label: Expected behavior + description: | + What do you expect to happen? + validations: + required: true + - type: textarea + id: actual + attributes: + label: Actual behavior + description: | + What actually happens? + validations: + required: true + - type: textarea + id: info + attributes: + label: Additional information + description: | + Please provide any additional information here that might be necessary to reproduce the issue. + - type: textarea + id: sourcecode + attributes: + label: Source code + description: Please include a minimal non-working example, or any other code related to the issue. + render: shell + - type: textarea + id: tracebacks + attributes: + label: Tracebacks + description: Please include the error tracebacks related to the issue here. + render: shell + - type: textarea + id: system + attributes: + label: System information + description: Please provide informations about you python version and os. The command `python -c "import sys; print(sys.version, sys.platform)"` can be used to get this information. Provide also the output of `pip list` command. + render: shell + validations: + required: true + - type: checkboxes + id: terms + attributes: + label: Existing GitHub issues + options: + - label: I have searched existing GitHub issues to make sure the issue does not already exist. + required: true diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml new file mode 100644 index 0000000..9ca5a64 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.yml @@ -0,0 +1,44 @@ +name: Feature request +description: Suggest a new feature +labels: "enhancement :sparkles:" + +body: + - type: markdown + id: description + attributes: + value: | + ## Before posting a feature request + Search existing GitHub issues to make sure the issue does not already exist. + + # Feature description + Description of the feature request - include code snippets and screenshots here if relevant. + - type: textarea + id: details + attributes: + label: Feature details + description: | + What feature would you like to have? + validations: + required: true + - type: textarea + id: implementation + attributes: + label: Implementation + description: | + Do you have an idea for how this could be implemented? Please include those details here. + - type: dropdown + id: urgency + attributes: + label: How important would you say this feature is? + options: + - "1: Not important. Would be nice to have." + - "2: Somewhat important. Needed this quarter." + - "3: Very important! Blocking work." + validations: + required: true + - type: textarea + id: info + attributes: + label: Additional information + description: | + Please provide any additional information here. Include potential alternative solutions, or workarounds, as well as references, if any. diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000..38248d1 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,19 @@ +# Description + +Please provide a brief description of the changes you are making in this pull request. + +------------------------------------------------------------------------------------------------------------ + +# Checklist + +Please complete the following checklist when submitting a PR. The PR will not be reviewed until all items are checked. + +- [ ] All new features include a unit test. + Make sure that the tests passed and the coverage is + sufficient by running + `uv run pytest --session-timeout=600`. +- [ ] All new functions and code are clearly documented. +- [ ] The code passes all pre-commit hooks. + You can do this by running `uvx pre-commit run --all-files`. +- [ ] The code is type-checked using Mypy. + You can do this by running `uv run mypy src tests`. diff --git a/.github/workflows/build_dist.yml b/.github/workflows/build_dist.yml index 7ce5d56..95fc29b 100644 --- a/.github/workflows/build_dist.yml +++ b/.github/workflows/build_dist.yml @@ -4,6 +4,15 @@ on: push: branches: ["main"] +permissions: + contents: write + pull-requests: write + actions: write + checks: write + statuses: write + issues: write + discussions: write + id-token: write jobs: Build-Dist: @@ -12,35 +21,83 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + - name: Set up Python 3.11 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.11" + - name: Install uv + uses: astral-sh/setup-uv@v6 + with: + version: "0.9.2" + python-version: "3.11" + enable-cache: true - name: Install dependencies run: | - python -m pip install --upgrade pip - pip install flake8 - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - pip install wheel - python -m pip install --upgrade build + uv venv .venv + uv sync --locked --dev --extra cpu + + - name: Gather new package version + id: version + uses: anothrNick/github-tag-action@1.61.0 + env: + GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}} + WITH_V: false + DEFAULT_BUMP: patch + DRY_RUN: true + + - name: Bump package version in pyproject.toml + run: | + uv version ${{steps.version.outputs.new_tag}} + uv lock - name: Build dist run: | - python -m build + uv run python -m build --sdist --wheel --no-isolation --outdir dist/ . + uv run twine check dist/* - - name: Commit + - name: Commit updated pyproject.toml run: | - git add -f dist git config --local user.email "action@github.com" git config --local user.name "GitHub Action" - git commit -m "Update dist" + git add pyproject.toml + git add uv.lock + git diff-index --quiet HEAD || git commit -m "Updating version of pyproject.toml" - - name: Push + - name: Push the new pyproject.toml uses: ad-m/github-push-action@master with: github_token: ${{secrets.GITHUB_TOKEN}} branch: main force: true - directory: dist + - name: Create Tag + id: tag + uses: anothrNick/github-tag-action@1.61.0 + env: + GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}} + WITH_V: false + DEFAULT_BUMP: patch + DRY_RUN: false + + - name: Create Release + uses: softprops/action-gh-release@v1 + with: + tag_name: ${{ steps.tag.outputs.new_tag }} + generate_release_notes: true + + - name: Merge 'main' branch -> 'dev' branch + uses: devmasx/merge-branch@master + with: + type: now + from_branch: main + target_branch: dev + message: "Automatic merge from 'main' into 'dev' [skip actions]" + label_name: "gh-actions" + github_token: ${{ secrets.GITHUB_TOKEN }} + + - name: Publish distribution to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + skip_existing: true + verbose: true diff --git a/.github/workflows/coverage_badge.yml b/.github/workflows/coverage_badge.yml new file mode 100644 index 0000000..158c43b --- /dev/null +++ b/.github/workflows/coverage_badge.yml @@ -0,0 +1,51 @@ +name: Update-Coverage-Badge + +on: + push: + branches: ["main"] + +permissions: + contents: write + pull-requests: write + actions: write + checks: write + statuses: write + issues: write + discussions: write + id-token: write + +jobs: + Update-Coverage-Badge: + name: Update-Coverage-Badge + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + - name: Set up Python 3.11 + uses: actions/setup-python@v3 + with: + python-version: "3.11" + + - name: Install uv + uses: astral-sh/setup-uv@v6 + with: + version: "0.9.2" + python-version: "3.11" + enable-cache: true + + - name: Install dependencies + run: | + uv venv .venv + uv sync --locked --dev --extra cpu + + - name: Test Unittests with pytest + run: | + uv run pytest tests --cov=src --cov-branch --cov-report="xml:tests/.tmp/coverage.xml" --cov-report=term-missing + + - name: Upload Coverage to Codecov + uses: codecov/codecov-action@v5 + with: + fail_ci_if_error: true + token: ${{ secrets.CODECOV_TOKEN }} + files: tests/.tmp/coverage.xml + verbose: true diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 7ddad9b..6dfd348 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -2,7 +2,7 @@ name: Docs on: push: - branches: ["main"] + branches: ["main", "dev"] jobs: @@ -12,28 +12,32 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Set up Python 3.10 + with: + fetch-depth: 0 + + - name: Set up Python 3.11 uses: actions/setup-python@v3 with: - python-version: "3.10" + python-version: "3.11" + + - name: Install uv + uses: astral-sh/setup-uv@v6 + with: + version: "0.9.2" + python-version: "3.11" + enable-cache: true - name: Install dependencies run: | - python -m pip install --upgrade pip - pip install flake8 - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - pip install -U sphinx==6.2.1 docutils==0.18.1 sphinx_rtd_theme==1.2.2 sphinxcontrib-bibtex==2.5.0 - pip install sphinx-theme - pip install groundwork-sphinx-theme - pip install karma_sphinx_theme - pip install sphinx-mdinclude + uv venv .venv + uv sync --locked --dev --group docs --extra cpu - name: Build the sphinx docs run: | - sphinx-apidoc -f -o ./sphinx/source ./src/torch_pfaffian - make -C sphinx clean - python sphinx/clean_html_files.py - make -C sphinx html + uv run sphinx-apidoc -f -o ./sphinx/source ./src/torch_pfaffian + uv run make -C sphinx clean + uv run python sphinx/clean_html_files.py + uv run make -C sphinx html touch sphinx/build/html/.nojekyll - name: Checkout gh-pages branch @@ -44,7 +48,7 @@ jobs: - name: Copy build files to docs folder run: | cp -a sphinx/build/html/. docs/ - python sphinx/make_html_files_list.py + uv run python sphinx/make_html_files_list.py rm -rf sphinx/build - name: Commit to gh-pages branch @@ -60,4 +64,4 @@ jobs: github_token: ${{secrets.GITHUB_TOKEN}} branch: gh-pages force: true - directory: docs \ No newline at end of file + directory: docs diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml deleted file mode 100644 index bdbd65e..0000000 --- a/.github/workflows/publish.yml +++ /dev/null @@ -1,40 +0,0 @@ -name: Publish to PyPI.org -on: - release: - types: [published] -jobs: - pypi: - runs-on: ubuntu-latest - environment: - name: pypi - url: https://pypi.org/p/TorchPfaffian - permissions: - id-token: write - steps: - - name: Checkout - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - - name: Set up Python 3.10 - uses: actions/setup-python@v3 - with: - python-version: "3.10" - - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install flake8 - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - pip install wheel - - - name: Build dist - run: | - python -m pip install --upgrade build - python -m build - - name: Publish distribution to PyPI - if: startsWith(github.ref, 'refs/tags') - uses: pypa/gh-action-pypi-publish@release/v1 - with: - skip_existing: true - verbose: true diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index b0d6784..cb599e5 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -1,67 +1,137 @@ -# This workflow will install Python dependencies, run tests and lint with a single version of Python -# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions - name: Tests on: - push: - branches: [ "main" ] pull_request: - branches: [ "main" ] + branches: [ "*" ] permissions: - contents: read + contents: write + pull-requests: write + actions: write + checks: write + statuses: write + issues: write + discussions: write jobs: Run-tests-on-Ubuntu: name: Run tests on Ubuntu-latest runs-on: ubuntu-latest + strategy: + matrix: + python-version: [ "3.10", "3.11", "3.12", "3.13", "3.14", ] steps: - - uses: actions/checkout@v3 - - name: Set up Python 3.10 - uses: actions/setup-python@v3 - with: - python-version: "3.10" - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install flake8 pytest - pip install -U pytest-cov coverage-lcov - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - - name: Lint with flake8 - run: | - # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics - # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - - name: Test with pytest - run: | - python run_pytests.py tests --N_RANDOM_TESTS_PER_CASE=10 --run_slow=False - coverage-lcov + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v3 + with: + python-version: ${{ matrix.python-version }} + - name: Install uv + uses: astral-sh/setup-uv@v6 + with: + version: "0.9.2" + python-version: ${{ matrix.python-version }} + enable-cache: true + - name: Install dependencies + run: | + uv venv .venv + uv sync --locked --dev --extra cpu + - name: Test Linting + run: | + uv run ruff format --check src tests + uv run ruff check src tests + - name: Test Typing + continue-on-error: true + run: | + uv run mypy src tests + - name: Test Unittests with pytest + run: | + uv run pytest tests \ + ${{ github.event.pull_request.head.repo.full_name != github.repository && '--cov-fail-under=98' || '' }} \ + --cov=src --cov-branch --cov-report="xml:tests/.tmp/coverage.xml" --cov-report=term-missing --durations=30 --session-timeout=600 + + - name: Debug coverage before upload + if: matrix.python-version == '3.11' + run: | + echo "=== Coverage summary ===" + head -5 tests/.tmp/coverage.xml + + - name: Upload coverage artifact + if: | + matrix.python-version == '3.11' && + github.event.pull_request.head.repo.full_name == github.repository + uses: actions/upload-artifact@v4 + with: + name: coverage + path: tests/.tmp/coverage.xml + if-no-files-found: error + retention-days: 1 + + - name: Test Build + if: ${{ matrix.python-version == '3.11' }} + run: | + uv run python -m build --sdist --wheel --no-isolation --outdir dist/ . + uv run twine check dist/* Run-tests-on-Windows: name: Run tests on Windows-latest + needs: [ Run-tests-on-Ubuntu ] runs-on: windows-latest + if: success() + strategy: + matrix: + python-version: [ "3.10", "3.11", "3.12", "3.13", "3.14", ] steps: - - uses: actions/checkout@v3 - - name: Set up Python 3.10 - uses: actions/setup-python@v3 - with: - python-version: "3.10" - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install flake8 pytest - pip install -r requirements.txt - pip install git+https://github.com/JeremieGince/PythonBasicTools - - name: Lint with flake8 - run: | - # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics - # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - - name: Test with pytest - run: | - python run_pytests.py tests --N_RANDOM_TESTS_PER_CASE=10 --run_slow=False + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v3 + with: + python-version: ${{ matrix.python-version }} + - name: Install uv + uses: astral-sh/setup-uv@v6 + with: + version: "0.9.2" + python-version: ${{ matrix.python-version }} + enable-cache: true + - name: Install dependencies + run: | + uv venv .venv + uv sync --locked --dev --extra cpu + - name: Test Unittests with pytest + run: | + uv run pytest tests --session-timeout=600 + + + Coverage: + name: Post Coverage Report + needs: [ Run-tests-on-Ubuntu ] + runs-on: ubuntu-latest + if: success() && github.event.pull_request.head.repo.full_name == github.repository + permissions: + contents: write + pull-requests: write + actions: write + checks: write + statuses: write + issues: write + discussions: write + steps: + - uses: actions/checkout@v4 + - name: Download coverage artifact + uses: actions/download-artifact@v4 + with: + path: tests/.tmp + name: coverage + - run: ls -R tests/.tmp + - name: Debug coverage file + run: cat tests/.tmp/coverage.xml | head -50 + - name: Post coverage + uses: orgoro/coverage@v3.2 + with: + token: ${{ secrets.GITHUB_TOKEN }} + coverageFile: tests/.tmp/coverage.xml + thresholdAll: 0.98 + thresholdNew: 0.98 + thresholdModified: 0.98 diff --git a/.gitignore b/.gitignore index a368195..840287c 100644 --- a/.gitignore +++ b/.gitignore @@ -178,6 +178,7 @@ instance/ # Sphinx documentation docs/_build/ doc/_build/ +sphinx/source/notebooks/ # PyBuilder target/ @@ -294,6 +295,7 @@ pip-selfcheck.json user/ tests/tmp +tests/.tmp .report.json tests/master_src report_dir @@ -301,4 +303,6 @@ auxil out tmp_report_dir .tmp_report.json -coverage.json \ No newline at end of file +coverage.json +dist/*.whl +dist/*.tar.gz diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..c90d531 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,42 @@ +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + - id: check-added-large-files + # uv.lock is a generated lockfile that legitimately exceeds the 500 KB default. + args: ["--maxkb=1024"] + - id: check-docstring-first + - id: check-merge-conflict + - id: check-toml + - id: check-yaml + - id: detect-private-key + - id: trailing-whitespace + - id: end-of-file-fixer + + - repo: https://github.com/astral-sh/uv-pre-commit + rev: 0.9.28 + hooks: + - id: uv-sync + - id: uv-lock + - id: uv-export + args: + [ + "--frozen", + "--no-hashes", + "--output-file=requirements.txt", + "--quiet", + ] + + - repo: https://github.com/tsvikas/sync-with-uv + rev: v0.5.0 + hooks: + - id: sync-with-uv + + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.15.16 + hooks: + # Run the linter. + - id: ruff-check + args: [--fix, --exit-non-zero-on-fix] + # Run the formatter. + - id: ruff-format diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..2dce1fc --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,44 @@ +# Code style + +## Files +- No file-level docstrings. Move any documentation into the class docstring instead. +- For files with only module-level functions, omit the module docstring entirely. + +## Comments +- No separator comments between methods or functions (e.g. no `# --- Public interface ---`). +- Inline comments inside function bodies are fine when they clarify non-obvious things (e.g. tensor shape annotations). +- Use em dashes (—) sparingly in docstrings and comments. Prefer plain sentence structure over dashes. + +## Naming conventions +- Variable names must be lowercase with underscores (`snake_case`). No single-letter or abbreviated names unless the meaning is unambiguous in context (e.g. `n` for the matrix dimension, `k` for a loop index). +- Choose descriptive names that reflect the role of the variable (e.g. `block_size` instead of `m`, `n_terms` instead of `K`). +- Module-level constants must be `UPPER_SNAKE_CASE`. + +## Type hints and docstrings +- All public functions and methods must have full type annotations on every parameter and the return type. +- Docstrings use Sphinx style: `:param name: description`, `:return: description`, `:rtype: type`. + +## Tensors and backends +- Any function that accepts a tensor argument must return a tensor with the same backend, dtype, and device as its primary input. +- Tensor functions must support arbitrary leading batch dimensions (expressed as `...` in shape comments, e.g. `(..., 2n, 2n)`). +- Hardware-specific branches (CUDA, platform-only code) that cannot run in CI must be marked `# pragma: no cover`. + +## Testing +- Every new class or module-level function must have an associated test class added in the same PR/commit. +- Tests must achieve >98% code coverage for the new code. Numerical comparisons use tolerance constants from `tests/configs.py` (`ATOL_SCALAR_COMPARISON`, `ATOL_MATRIX_COMPARISON`, etc.) — never hardcode tolerance values. +- The `tests/` folder must mirror the package structure (replacing `src/torch_pfaffian/` with `tests/` and prefixing each path segment with `test_`). For example, `src/torch_pfaffian/utils.py` → `tests/test_utils.py`, and `src/torch_pfaffian/strategies/pfaffian_block_det.py` → `tests/test_strategies/test_pfaffian_block_det.py`. +- One test class per file. Each test file contains exactly one `Test*` class. +- All tests must be methods of a `Test*` class. No module-level `test_*` functions. +- Tests must be compatible with pytest-xdist parallel execution: no shared mutable state between tests, no dependency on execution order, and no hardcoded resources (ports, file paths) that would conflict across workers. +- Prefer `np.testing` and `torch.testing` assertion helpers over bare `assert` statements for numerical comparisons. Use `torch.autograd.gradcheck` when testing gradient correctness. + +## Class method ordering +Methods within a class must appear in this order: +1. `@staticmethod` +2. `@classmethod` +3. Constructor (`__init__`) +4. Operator / dunder methods (`__call__`, `__repr__`, …) +5. Public methods +6. Protected methods (`_method`) +7. Private methods (`__method`) +8. Properties (`@property`) diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..c317064 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1 @@ +AGENTS.md diff --git a/README.md b/README.md index 7c20897..e2c9feb 100644 --- a/README.md +++ b/README.md @@ -10,21 +10,21 @@ ![Tests Workflow](https://github.com/MatchCake/TorchPfaffian/actions/workflows/tests.yml/badge.svg) ![Dist Workflow](https://github.com/MatchCake/TorchPfaffian/actions/workflows/build_dist.yml/badge.svg) ![Doc Workflow](https://github.com/MatchCake/TorchPfaffian/actions/workflows/docs.yml/badge.svg) -![Publish Workflow](https://github.com/MatchCake/TorchPfaffian/actions/workflows/publish.yml/badge.svg) +![Coverage Badge Workflow](https://github.com/MatchCake/TorchPfaffian/actions/workflows/coverage_badge.yml/badge.svg) # Description -TorchPfaffian is a Python package for efficiently computing the Pfaffian of skew-symmetric matrices using PyTorch. -Designed as a PyTorch-based alternative to [pfapack](https://github.com/basnijholt/pfapack), it enables GPU -acceleration and supports automatic differentiation, making it particularly useful in physics, quantum computing, -and machine learning applications. +TorchPfaffian is a Python package for efficiently computing the Pfaffian of skew-symmetric matrices using PyTorch. +Designed as a PyTorch-based alternative to [pfapack](https://github.com/basnijholt/pfapack), it enables GPU +acceleration and supports automatic differentiation, making it particularly useful in physics, quantum computing, +and machine learning applications. ## Features: -- Efficient Pfaffian computation for skew-symmetric matrices -- GPU acceleration via PyTorch -- Support for automatic differentiation -- Seamless integration with PyTorch tensors +- Efficient Pfaffian computation for skew-symmetric matrices +- GPU acceleration via PyTorch +- Support for automatic differentiation +- Seamless integration with PyTorch tensors @@ -36,10 +36,13 @@ With `python` and `pip` installed, run the following commands to install TorchPf pip install torchpfaffian ``` -With `poetry` installed, run the following commands to install TorchPfaffian: +For development, this project uses [uv](https://docs.astral.sh/uv/). Clone the repository and set up the +environment with: ```bash -poetry add torchpfaffian +uv sync --dev --extra cpu ``` +Use the `cu128` or `cu130` extra instead of `cpu` to install a CUDA-enabled build of PyTorch. See +[.github/CONTRIBUTING.md](.github/CONTRIBUTING.md) for the full contribution workflow. # Important Links diff --git a/archives/_pfaffian.py b/archives/_pfaffian.py index 45b7101..13b4aed 100644 --- a/archives/_pfaffian.py +++ b/archives/_pfaffian.py @@ -5,13 +5,12 @@ It is used as a reference to implement the `pfaffian` functions. """ - -from typing import Union, Literal, Optional -import numpy as np import warnings +from typing import Literal, Optional, Union -import tqdm +import numpy as np import pennylane as qml +import tqdm from torch_pfaffian import Pfaffian @@ -51,26 +50,24 @@ def _compute_gauss_vector(__matrix, k): zero_like = convert_and_cast_like(0, __matrix) tau_norm = __matrix[..., k, k + 1][..., None] zero_mask = qml.math.isclose(tau_norm, zero_like) - tau = qml.math.where(zero_mask, zero_like, __matrix[..., k, k + 2:] / tau_norm) + tau = qml.math.where(zero_mask, zero_like, __matrix[..., k, k + 2 :] / tau_norm) return tau def _update_matrix_block_kp2_kp2(__matrix, k, tau): add_matrix = qml.math.zeros_like(__matrix) - add_matrix[..., k + 2:, k + 2:] += ( - qml.math.einsum("...i,...j->...ij", tau, __matrix[..., k + 2:, k + 1]) - - - qml.math.einsum("...i,...j->...ij", __matrix[..., k + 2:, k + 1], tau) - ) + add_matrix[..., k + 2 :, k + 2 :] += qml.math.einsum( + "...i,...j->...ij", tau, __matrix[..., k + 2 :, k + 1] + ) - qml.math.einsum("...i,...j->...ij", __matrix[..., k + 2 :, k + 1], tau) return __matrix + add_matrix def batch_pfaffian_ltl( - __matrix: TensorLike, - overwrite_input: bool = False, - test_input: bool = False, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False + __matrix: TensorLike, + overwrite_input: bool = False, + test_input: bool = False, + p_bar: Optional[tqdm.tqdm] = None, + show_progress: bool = False, ) -> Union[float, complex, TensorLike]: r""" Compute the Pfaffian of a real or complex skew-symmetric @@ -117,7 +114,7 @@ def batch_pfaffian_ltl( # Quick return if possible if n % 2 == 1: - p_bar.n = n//2 + p_bar.n = n // 2 p_bar.set_description("Odd-sized matrix") p_bar.close() return pfaffian_val * zero_like * matrix[..., 0, 0] # 0.0 but with require grad if needed @@ -125,7 +122,7 @@ def batch_pfaffian_ltl( p_bar.set_description(f"Computing Pfaffian of {shape} matrix") for k in p_bar: # First, find the largest entry in A[k+1:,k] and permute it to A[k+1,k] - kp = k + 1 + qml.math.abs(matrix[..., k + 1:, k]).argmax(-1) + kp = k + 1 + qml.math.abs(matrix[..., k + 1 :, k]).argmax(-1) kp1 = qml.math.convert_like(k + 1, kp) # Check if we need to pivot @@ -139,7 +136,7 @@ def batch_pfaffian_ltl( zero_ss_condition = qml.math.isclose(matrix[..., k + 1, k], zero_like) pfaffian_val *= qml.math.where(zero_ss_condition, zero_like, matrix[..., k, k + 1]) if qml.math.all(zero_ss_condition): - p_bar.n = n//2 + p_bar.n = n // 2 p_bar.set_description("Pfaffian is zero") p_bar.close() return pfaffian_val @@ -176,7 +173,7 @@ def batch_householder_complex(x: TensorLike): v_frobenius_norm = qml.math.einsum("...i,...i->...", qml.math.conjugate(v), v) ** 0.5 v = v / v_frobenius_norm[..., None] - tau = convert_and_cast_like(2.0+0.0j, x) + tau = convert_and_cast_like(2.0 + 0.0j, x) return v, tau, -phase * norm_x @@ -200,14 +197,14 @@ def _eliminate_ith_column_householder(matrix, i, alpha): where_mask = qml.math.cast(qml.math.zeros_like(matrix), dtype=bool) where_mask[..., i + 1, i] = True where_mask[..., i, i + 1] = True - where_mask[..., i + 2:, i] = True - where_mask[..., i, i + 2:] = True + where_mask[..., i + 2 :, i] = True + where_mask[..., i, i + 2 :] = True values = qml.math.zeros_like(matrix) values[..., i + 1, i] = alpha values[..., i, i + 1] = -alpha - values[..., i + 2:, i] = zero_like - values[..., i, i + 2:] = zero_like + values[..., i + 2 :, i] = zero_like + values[..., i, i + 2 :] = zero_like matrix = qml.math.where(where_mask, values, matrix) return matrix @@ -227,22 +224,20 @@ def _update_matrix_block_householder(matrix, i, v, tau): :param tau: :return: """ - w = tau * qml.math.einsum("...ij,...j->...i", matrix[..., i + 1:, i + 1:], qml.math.conjugate(v)) + w = tau * qml.math.einsum("...ij,...j->...i", matrix[..., i + 1 :, i + 1 :], qml.math.conjugate(v)) values = qml.math.zeros_like(matrix) - values[..., i + 1:, i + 1:] += ( - qml.math.einsum("...i,...j->...ij", v, w) - - - qml.math.einsum("...i,...j->...ij", w, v) + values[..., i + 1 :, i + 1 :] += qml.math.einsum("...i,...j->...ij", v, w) - qml.math.einsum( + "...i,...j->...ij", w, v ) return matrix + values def batch_pfaffian_householder( - __matrix: TensorLike, - overwrite_input: bool = False, - test_input: bool = False, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False + __matrix: TensorLike, + overwrite_input: bool = False, + test_input: bool = False, + p_bar: Optional[tqdm.tqdm] = None, + show_progress: bool = False, ): """pfaffian(A, overwrite_a=False) @@ -284,7 +279,7 @@ def batch_pfaffian_householder( p_bar.set_description(f"Computing Pfaffian of {shape} matrix") for i in p_bar: # Find a Householder vector to eliminate the i-th column - v, tau, alpha = batch_householder_complex(matrix[..., i + 1:, i]) + v, tau, alpha = batch_householder_complex(matrix[..., i + 1 :, i]) matrix = _eliminate_ith_column_householder(matrix, i, alpha) matrix = _update_matrix_block_householder(matrix, i, v, tau) @@ -299,10 +294,7 @@ def batch_pfaffian_householder( def pfaffian_by_det( - __matrix: TensorLike, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False, - epsilon: float = 1e-12 + __matrix: TensorLike, p_bar: Optional[tqdm.tqdm] = None, show_progress: bool = False, epsilon: float = 1e-12 ): shape = qml.math.shape(__matrix) p_bar = p_bar or tqdm.tqdm(total=1, disable=not show_progress) @@ -323,12 +315,12 @@ def pfaffian_by_det( def pfaffian( - __matrix: TensorLike, - overwrite_input: bool = False, - method: Literal["P", "H", "det", "bLTL", "bH"] = "bLTL", - epsilon: float = 1e-12, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False + __matrix: TensorLike, + overwrite_input: bool = False, + method: Literal["P", "H", "det", "bLTL", "bH"] = "bLTL", + epsilon: float = 1e-12, + p_bar: Optional[tqdm.tqdm] = None, + show_progress: bool = False, ) -> Union[float, complex, TensorLike]: """pfaffian(A, overwrite_a=False, method='P') @@ -362,17 +354,17 @@ def pfaffian( if method == "P": from pfapack.pfaffian import pfaffian + warnings.warn( - "The method 'P' is not implemented yet. " - "It is recommended to use the method 'det' instead.", + "The method 'P' is not implemented yet. It is recommended to use the method 'det' instead.", UserWarning, ) return pfaffian(__matrix, overwrite_input, method="P") elif method == "H": from pfapack.pfaffian import pfaffian_householder + warnings.warn( - "The method 'H' is not implemented yet. " - "It is recommended to use the method 'det' instead.", + "The method 'H' is not implemented yet. It is recommended to use the method 'det' instead.", UserWarning, ) return pfaffian_householder(__matrix, overwrite_input) diff --git a/archives/_test_pfaffian.py b/archives/_test_pfaffian.py index 897dcc3..a320154 100644 --- a/archives/_test_pfaffian.py +++ b/archives/_test_pfaffian.py @@ -2,12 +2,12 @@ import pytest from tests.configs import ( - N_RANDOM_TESTS_PER_CASE, - TEST_SEED, - ATOL_SCALAR_COMPARISON, - RTOL_SCALAR_COMPARISON, ATOL_MATRIX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, RTOL_MATRIX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, set_seed, ) from torch_pfaffian import utils @@ -34,7 +34,7 @@ def gen_skew_symmetric_matrix_and_det(n, batch_size=None): gen_skew_symmetric_matrix_and_det(i, batch_size=None) for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) for _ in range(N_RANDOM_TESTS_PER_CASE) - ] + ], ) def test_get_skew_symmetric_matrix_and_det(matrix, det): try: @@ -42,7 +42,7 @@ def test_get_skew_symmetric_matrix_and_det(matrix, det): except ImportError: pytest.skip("pfapack is not installed.") pf = pfaffian(matrix) - np.testing.assert_allclose(pf ** 2, det, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) + np.testing.assert_allclose(pf**2, det, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) @pytest.mark.parametrize( @@ -53,11 +53,11 @@ def test_get_skew_symmetric_matrix_and_det(matrix, det): for _ in range(N_RANDOM_TESTS_PER_CASE) for mth in RECOMMENDED_METHODS for batch_size in [None, BATCH_SIZE] - ] + ], ) def test_pfaffian_methods(matrix, det, mth): pf = utils.pfaffian(matrix, method=mth) - np.testing.assert_allclose(pf ** 2, det, atol=10 * ATOL_SCALAR_COMPARISON, rtol=10 * RTOL_SCALAR_COMPARISON) + np.testing.assert_allclose(pf**2, det, atol=10 * ATOL_SCALAR_COMPARISON, rtol=10 * RTOL_SCALAR_COMPARISON) @pytest.mark.parametrize( @@ -66,11 +66,11 @@ def test_pfaffian_methods(matrix, det, mth): gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) for _ in range(N_RANDOM_TESTS_PER_CASE) - ] + ], ) def test_batch_pfaffian_ltl(matrix, det): pf = utils._pfaffian.batch_pfaffian_ltl(matrix) - np.testing.assert_allclose(pf ** 2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) @pytest.mark.parametrize( @@ -79,11 +79,11 @@ def test_batch_pfaffian_ltl(matrix, det): gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) for _ in range(N_RANDOM_TESTS_PER_CASE) - ] + ], ) def test_pfaffian_bltl(matrix, det): pf = utils.pfaffian(matrix, method="bLTL") - np.testing.assert_allclose(pf ** 2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) @pytest.mark.parametrize( @@ -93,11 +93,11 @@ def test_pfaffian_bltl(matrix, det): for batch_size in [None, 1] for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) for _ in range(N_RANDOM_TESTS_PER_CASE) - ] + ], ) def test_pfaffian_bltl_single_item(matrix, det): pf = utils.pfaffian(matrix, method="bLTL") - np.testing.assert_allclose(pf ** 2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) @pytest.mark.parametrize( @@ -108,7 +108,7 @@ def test_pfaffian_bltl_single_item(matrix, det): for _ in range(N_RANDOM_TESTS_PER_CASE) for mth in RECOMMENDED_METHODS for batch_size in [None, BATCH_SIZE] - ] + ], ) def test_pfaffian_methods_grads(n, batch_size, mth): try: @@ -130,7 +130,7 @@ def test_pfaffian_methods_grads(n, batch_size, mth): matrix = torch.from_numpy(np_matrix).requires_grad_() pf = utils.pfaffian(matrix, method=mth) - pred_det = torch.real(pf ** 2) + pred_det = torch.real(pf**2) with torch.no_grad(): np.testing.assert_allclose(pred_det, det, atol=10 * ATOL_SCALAR_COMPARISON, rtol=10 * RTOL_SCALAR_COMPARISON) @@ -140,9 +140,7 @@ def test_pfaffian_methods_grads(n, batch_size, mth): assert pred_grad is not None if mth == "det": np.testing.assert_allclose( - torch.abs(pred_grad), torch.abs(true_grad), - atol=ATOL_MATRIX_COMPARISON, - rtol=RTOL_MATRIX_COMPARISON + torch.abs(pred_grad), torch.abs(true_grad), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON ) @@ -152,11 +150,11 @@ def test_pfaffian_methods_grads(n, batch_size, mth): gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) for _ in range(N_RANDOM_TESTS_PER_CASE) - ] + ], ) def test_pfaffian_bh(matrix, det): pf = utils.pfaffian(matrix, method="bH") - np.testing.assert_allclose(pf ** 2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) @pytest.mark.parametrize( @@ -166,8 +164,8 @@ def test_pfaffian_bh(matrix, det): for batch_size in [None, 1] for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) for _ in range(N_RANDOM_TESTS_PER_CASE) - ] + ], ) def test_pfaffian_bltl_single_item(matrix, det): pf = utils.pfaffian(matrix, method="bH") - np.testing.assert_allclose(pf ** 2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) diff --git a/archives/pfaffian_perm.py b/archives/pfaffian_perm.py index 90859f0..fd4ce3c 100644 --- a/archives/pfaffian_perm.py +++ b/archives/pfaffian_perm.py @@ -1,7 +1,6 @@ -import itertools -from typing import Any -import torch import numpy as np +import torch + from .strategy import PfaffianStrategy @@ -10,6 +9,7 @@ class PfaffianPerm(PfaffianStrategy): This class implements the Pfaffian using the determinant of the matrix for the forward pass and the derivative of the Pfaffian with respect to the input matrix for the backward pass. """ + NAME = "PfaffianPerm" @staticmethod @@ -34,7 +34,7 @@ def forward(matrix: torch.Tensor): for i in range(_i_matrix.shape[0]) for j in range(i, _j_matrix.shape[0]) ], - axis=0 + axis=0, ) pf_matrix = torch.prod(matrix[..., ij_matrix[..., 0], ij_matrix[..., 1]], dim=-1) @@ -57,7 +57,5 @@ def backward(ctx: torch.autograd.function.FunctionCtx, grad_output): matrix, pf = ctx.saved_tensors grad_matrix = None if ctx.needs_input_grad[0]: - grad_matrix = torch.einsum('...,...ij->...ji', 0.5 * grad_output * pf, torch.linalg.pinv(matrix)) + grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pf, torch.linalg.pinv(matrix)) return grad_matrix - - diff --git a/notebooks/_strategies_benchmark_helpers.py b/notebooks/_strategies_benchmark_helpers.py new file mode 100644 index 0000000..e7557d0 --- /dev/null +++ b/notebooks/_strategies_benchmark_helpers.py @@ -0,0 +1,185 @@ +import time +from collections.abc import Callable + +import matplotlib.pyplot as plt +import numpy as np +import torch +from torch.profiler import ProfilerActivity, profile + +from torch_pfaffian.strategies.strategy import PfaffianStrategy + +Strategy = type[PfaffianStrategy] +BenchmarkResults = dict[str, dict[str, list[float]]] + +METRICS = ("forward_time", "backward_time", "forward_memory", "forward_backward_memory") + + +def make_block_antidiagonal( + n: int, batch_size: int, dtype: torch.dtype = torch.float64, device: str = "cpu" +) -> torch.Tensor: + """ + Build a batch of block-antidiagonal skew matrices ``[[0, B], [-B^T, 0]]``. + + :param n: Half the matrix dimension; the result has shape ``(batch_size, 2n, 2n)``. + :param batch_size: Number of matrices in the batch. + :param dtype: Floating dtype of the matrices. + :param device: Device on which to allocate the matrices. + :return: A tensor of shape ``(batch_size, 2n, 2n)``. + :rtype: torch.Tensor + """ + block = torch.randn(batch_size, n, n, dtype=dtype, device=device) + zero = torch.zeros_like(block) + top = torch.cat([zero, block], dim=-1) + bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) + return torch.cat([top, bottom], dim=-2) + + +def _synchronize(is_cuda: bool) -> None: + if is_cuda: + torch.cuda.synchronize() + + +def _median_time(fn: Callable[[], object], is_cuda: bool, n_repeats: int = 3) -> float: + fn() # warm-up + _synchronize(is_cuda) + timings = [] + for _ in range(n_repeats): + _synchronize(is_cuda) + start = time.perf_counter() + fn() + _synchronize(is_cuda) + timings.append(time.perf_counter() - start) + return float(np.median(timings)) + + +def _peak_memory(fn: Callable[[], object], is_cuda: bool) -> float: + # On CUDA this is the true peak; on CPU it is the profiler-reported allocated bytes. + if is_cuda: + torch.cuda.reset_peak_memory_stats() + fn() + torch.cuda.synchronize() + return float(torch.cuda.max_memory_allocated()) + with profile(activities=[ProfilerActivity.CPU], profile_memory=True) as prof: + fn() + return float(sum(e.cpu_memory_usage for e in prof.key_averages() if e.cpu_memory_usage > 0)) + + +def _forward_call(strategy: Strategy, matrix: torch.Tensor) -> torch.Tensor: + return strategy.apply(matrix) + + +def _forward_backward_call(strategy: Strategy, matrix: torch.Tensor) -> torch.Tensor: + grad_matrix = matrix.detach().clone().requires_grad_(True) + strategy.apply(grad_matrix).sum().backward() + return grad_matrix + + +def _confidence_interval(values: np.ndarray, confidence_z: float = 1.96) -> float: + # Half-width of the normal-approximation confidence interval for the mean. + if values.size < 2: + return 0.0 + return float(confidence_z * values.std(ddof=1) / np.sqrt(values.size)) + + +def benchmark_strategies( + strategies: list[Strategy], + sizes_n: list[int], + batch_size: int, + device: str = "cpu", + n_seeds: int = 20, + n_repeats: int = 3, +) -> BenchmarkResults: + """ + Benchmark forward/backward time and memory of each strategy over several random seeds. + + For each matrix dimension and strategy the metric is measured once per seed; the returned + values are the across-seed mean and the half-width of the 95% confidence interval. + + :param strategies: The strategy classes to benchmark (each exposes ``NAME`` and ``apply``). + :param sizes_n: Half-dimensions to sweep; each yields matrices of dimension ``2n``. + :param batch_size: Number of matrices per benchmarked batch. + :param device: Device on which to run the benchmark. + :param n_seeds: Number of random seeds used to build the confidence intervals. + :param n_repeats: Number of timed repeats per seed (the median is kept). + :return: A mapping ``strategy_name -> {"dimension", "_mean", "_ci"}``. + :rtype: dict + """ + is_cuda = device == "cuda" + results: BenchmarkResults = { + strategy.NAME: { + "dimension": [], + **{f"{metric}_mean": [] for metric in METRICS}, + **{f"{metric}_ci": [] for metric in METRICS}, + } + for strategy in strategies + } + + for n in sizes_n: + per_seed: dict[str, dict[str, list[float]]] = { + strategy.NAME: {metric: [] for metric in METRICS} for strategy in strategies + } + for seed in range(n_seeds): + torch.manual_seed(seed) + matrix = make_block_antidiagonal(n, batch_size, dtype=torch.float64, device=device) + for strategy in strategies: + forward_time = _median_time(lambda: _forward_call(strategy, matrix), is_cuda, n_repeats) + full_time = _median_time(lambda: _forward_backward_call(strategy, matrix), is_cuda, n_repeats) + record = per_seed[strategy.NAME] + record["forward_time"].append(forward_time) + record["backward_time"].append(max(full_time - forward_time, 0.0)) + record["forward_memory"].append(_peak_memory(lambda: _forward_call(strategy, matrix), is_cuda)) + record["forward_backward_memory"].append( + _peak_memory(lambda: _forward_backward_call(strategy, matrix), is_cuda) + ) + + for strategy in strategies: + results[strategy.NAME]["dimension"].append(2 * n) + for metric in METRICS: + values = np.asarray(per_seed[strategy.NAME][metric], dtype=float) + results[strategy.NAME][f"{metric}_mean"].append(float(values.mean())) + results[strategy.NAME][f"{metric}_ci"].append(_confidence_interval(values)) + return results + + +def plot_results( + results: BenchmarkResults, strategies: list[Strategy], batch_size: int, device: str = "cpu" +) -> plt.Figure: + """ + Plot the benchmark results as a 2x2 grid of time and memory panels with 95% CI bands. + + :param results: The mapping returned by :func:`benchmark_strategies`. + :param strategies: The strategy classes that were benchmarked. + :param batch_size: Batch size used for the benchmark (shown in the title). + :param device: Device used for the benchmark (shown in the title and memory label). + :return: The matplotlib figure. + :rtype: matplotlib.figure.Figure + """ + memory_label = "peak memory (bytes, CUDA)" if device == "cuda" else "allocated bytes (CPU)" + panels = [ + ("forward_time", "Forward time", "time [s]"), + ("backward_time", "Backward time", "time [s]"), + ("forward_memory", "Forward memory", memory_label), + ("forward_backward_memory", "Forward + backward memory", memory_label), + ] + + fig, axes = plt.subplots(2, 2, figsize=(12, 9)) + for ax, (key, title, ylabel) in zip(axes.flat, panels): + for strategy in strategies: + record = results[strategy.NAME] + dimension = np.asarray(record["dimension"], dtype=float) + mean = np.asarray(record[f"{key}_mean"], dtype=float) + ci = np.asarray(record[f"{key}_ci"], dtype=float) + line = ax.plot(dimension, mean, marker="o", label=strategy.NAME)[0] + lower = np.clip(mean - ci, np.finfo(float).tiny, None) + ax.fill_between(dimension, lower, mean + ci, alpha=0.2, color=line.get_color()) + ax.set_title(title) + ax.set_xlabel("matrix dimension (2n)") + ax.set_ylabel(ylabel) + ax.set_xscale("log", base=2) + ax.set_yscale("log") + ax.grid(True, which="both", linestyle=":", alpha=0.5) + ax.legend() + + fig.suptitle(f"Pfaffian strategies benchmark (batch_size={batch_size}, device={device}, 95% CI over seeds)") + fig.tight_layout() + return fig diff --git a/notebooks/strategies_benchmark.ipynb b/notebooks/strategies_benchmark.ipynb new file mode 100644 index 0000000..3742965 --- /dev/null +++ b/notebooks/strategies_benchmark.ipynb @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "56c973ab", + "metadata": {}, + "source": [ + "# Benchmarking the Pfaffian strategies\n", + "\n", + "This notebook benchmarks the available Pfaffian strategies in terms of **time** and **memory** for both the **forward** and **backward** passes.\n", + "\n", + "Three strategies are compared:\n", + "\n", + "- `PfaffianFDBPf`: computes the Pfaffian from `sqrt(|det(A)|)` with a custom **analytic** backward. Valid for any skew-symmetric matrix.\n", + "- `PfaffianBlockDet`: computes the Pfaffian from the determinant of the upper-right block, with a custom analytic backward.\n", + "- `PfaffianDet`: a reference baseline that also computes `pf = sqrt(|det(A)|)` but differentiates straight through `det`/`sqrt` with **plain autograd** (no custom backward), to expose the cost of naive autodiff against the analytic backward of `PfaffianFDBPf`.\n", + "\n", + "Each strategy is invoked through `Strategy.apply(matrix)`.\n", + "\n", + "For each strategy and matrix size we report, **averaged over 20 random seeds with 95% confidence intervals**:\n", + "\n", + "- the median forward time,\n", + "- the median backward time,\n", + "- the forward peak memory,\n", + "- the forward + backward peak memory." + ] + }, + { + "cell_type": "markdown", + "id": "55b95a09", + "metadata": {}, + "source": [ + "## Validity note\n", + "\n", + "`PfaffianBlockDet`'s forward only returns the *true* Pfaffian for **block-antidiagonal** skew matrices of the form\n", + "\n", + "$$ A = \\begin{pmatrix} 0 & B \\\\ -B^{T} & 0 \\end{pmatrix}. $$\n", + "\n", + "To keep the comparison both **fair** and **numerically valid**, we benchmark *all* strategies on block-antidiagonal inputs. `PfaffianFDBPf` and `PfaffianDet` are valid on any skew matrix (including this form), so this input shape is a common ground on which all strategies compute the same quantity." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2305932f", + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-10T14:25:10.025490742Z", + "start_time": "2026-06-10T14:25:08.874486863Z" + }, + "execution": { + "iopub.execute_input": "2026-06-10T14:16:52.667639Z", + "iopub.status.busy": "2026-06-10T14:16:52.667294Z", + "iopub.status.idle": "2026-06-10T14:16:54.207116Z", + "shell.execute_reply": "2026-06-10T14:16:54.205473Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running benchmarks on device: cpu\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "\n", + "# The helper module lives next to this notebook; ensure it is importable both when\n", + "# running the notebook directly and when it is executed during the Sphinx docs build.\n", + "sys.path.insert(0, os.getcwd())\n", + "\n", + "import torch\n", + "from _strategies_benchmark_helpers import benchmark_strategies, plot_results\n", + "\n", + "from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet\n", + "from torch_pfaffian.strategies.pfaffian_det import PfaffianDet\n", + "from torch_pfaffian.strategies.pfaffian_fdbpf import PfaffianFDBPf\n", + "\n", + "strategies = [PfaffianFDBPf, PfaffianBlockDet, PfaffianDet]\n", + "\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "print(f\"Running benchmarks on device: {device}\")" + ] + }, + { + "cell_type": "markdown", + "id": "8838f08f", + "metadata": {}, + "source": [ + "## Running the benchmark\n", + "\n", + "The benchmarking and plotting logic lives in `_strategies_benchmark_helpers.py` to keep this notebook focused on the narrative. `benchmark_strategies` sweeps the matrix dimension `2n` and, for every strategy, measures each metric once per seed across `n_seeds` seeds, returning the across-seed mean and the half-width of the 95% confidence interval." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b6a3c6b4", + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-10T14:25:22.671153790Z", + "start_time": "2026-06-10T14:25:10.033292322Z" + }, + "execution": { + "iopub.execute_input": "2026-06-10T14:16:54.210625Z", + "iopub.status.busy": "2026-06-10T14:16:54.210309Z", + "iopub.status.idle": "2026-06-10T14:17:21.107161Z", + "shell.execute_reply": "2026-06-10T14:17:21.105779Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/local/USHERBROOKE/ginj2102/github/TorchPfaffian/.venv/lib/python3.14/site-packages/torch/profiler/profiler.py:217: UserWarning: Warning: Profiler clears events at the end of each cycle.Only events from the current cycle will be reported.To keep events across cycles, set acc_events=True.\n", + " _warn_once(\n" + ] + }, + { + "data": { + "text/plain": [ + "{'PfaffianFDBPf': {'dimension': [4, 8, 16, 32, 64],\n", + " 'forward_time_mean': [8.39531006931793e-05,\n", + " 8.420960039074998e-05,\n", + " 0.0048694635002902945,\n", + " 0.0038942812007007888,\n", + " 0.005135932300981949],\n", + " 'backward_time_mean': [0.00023082459956640377,\n", + " 0.005614171149136382,\n", + " 0.0037422726509248605,\n", + " 0.0035597407983004813,\n", + " 0.007134951999250916],\n", + " 'forward_memory_mean': [5578.0, 13622.0, 42042.4, 147885.2, 556360.8],\n", + " 'forward_backward_memory_mean': [51952.75,\n", + " 191664.4,\n", + " 741525.9,\n", + " 2922178.35,\n", + " 11609078.25],\n", + " 'forward_time_ci': [9.135929690982144e-06,\n", + " 3.2582327167016847e-06,\n", + " 0.0009277367240195104,\n", + " 0.0012259096343144602,\n", + " 0.0024523398701700883],\n", + " 'backward_time_ci': [1.66414058654275e-05,\n", + " 0.0011459601539736321,\n", + " 0.0012184828913370757,\n", + " 0.0010552649404508374,\n", + " 0.002653286676583563],\n", + " 'forward_memory_ci': [29.3318367720307,\n", + " 24.815081322708405,\n", + " 102.10139647068085,\n", + " 30.656304800154892,\n", + " 40.23282740303128],\n", + " 'forward_backward_memory_ci': [4.743538874367067,\n", + " 21.21989739545609,\n", + " 162.69658520403138,\n", + " 34.345881944220274,\n", + " 52.56864599840158]},\n", + " 'PfaffianBlockDet': {'dimension': [4, 8, 16, 32, 64],\n", + " 'forward_time_mean': [7.726129915681667e-05,\n", + " 7.922490076452959e-05,\n", + " 8.57123999594478e-05,\n", + " 0.0034056200998747953,\n", + " 0.0026923404508124803],\n", + " 'backward_time_mean': [0.00013435915170703083,\n", + " 0.0001344478991086362,\n", + " 0.00016380800007027575,\n", + " 0.0020619140501366927,\n", + " 0.00030570419985451733],\n", + " 'forward_memory_mean': [2748.0, 5211.6, 13258.0, 41630.8, 147519.2],\n", + " 'forward_backward_memory_mean': [19599.05,\n", + " 71313.3,\n", + " 274652.7,\n", + " 1091927.6,\n", + " 4345071.7],\n", + " 'forward_time_ci': [3.169456596676188e-06,\n", + " 2.4604736536371967e-06,\n", + " 2.3125298299448165e-06,\n", + " 0.0013217441709651864,\n", + " 0.0012497851096257763],\n", + " 'backward_time_ci': [3.1405466727071304e-06,\n", + " 4.261377559919364e-06,\n", + " 5.229660731091481e-06,\n", + " 0.0011858865161943775,\n", + " 0.00018241185806708765],\n", + " 'forward_memory_ci': [25.777422026179995,\n", + " 22.071778484609798,\n", + " 22.287644535647285,\n", + " 25.872,\n", + " 30.415286129112605],\n", + " 'forward_backward_memory_ci': [84.88650624773861,\n", + " 66.22060255651084,\n", + " 3213.0211251070227,\n", + " 29.615975830977654,\n", + " 39.7277365762723]},\n", + " 'PfaffianDet': {'dimension': [4, 8, 16, 32, 64],\n", + " 'forward_time_mean': [2.814660001604352e-05,\n", + " 3.418759915803093e-05,\n", + " 0.004134788549345103,\n", + " 0.002652941150518018,\n", + " 0.00029987425114086363],\n", + " 'backward_time_mean': [0.0001211243503348669,\n", + " 0.0001411523018759908,\n", + " 5.7608549832366406e-05,\n", + " 0.00020152409961156082,\n", + " 0.0013275362496642628],\n", + " 'forward_memory_mean': [5464.4, 13483.2, 41928.4, 147770.4, 556153.2],\n", + " 'forward_backward_memory_mean': [39437.6,\n", + " 143664.2,\n", + " 554873.8,\n", + " 2188320.6,\n", + " 8699278.2],\n", + " 'forward_time_ci': [1.2732541170077155e-06,\n", + " 1.207109827186109e-06,\n", + " 0.0013741837643709278,\n", + " 0.0012392837411897722,\n", + " 0.00019687483453382923],\n", + " 'backward_time_ci': [2.5277217525177566e-06,\n", + " 5.454397998524737e-06,\n", + " 3.565945106097614e-05,\n", + " 0.00010193383971478204,\n", + " 0.00023040019338968858],\n", + " 'forward_memory_ci': [45.91907264788897,\n", + " 16.69521850237682,\n", + " 96.97527751795408,\n", + " 35.6852606931327,\n", + " 52.39233383857443],\n", + " 'forward_backward_memory_ci': [34.74130008778419,\n", + " 29.6061432600878,\n", + " 34.246935795314904,\n", + " 22.767103951003282,\n", + " 46.1319567830325]}}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sizes_n = [2, 4, 8, 16, 32]\n", + "batch_size = 16\n", + "n_seeds = 20\n", + "\n", + "results = benchmark_strategies(strategies, sizes_n, batch_size, device=device, n_seeds=n_seeds)\n", + "results" + ] + }, + { + "cell_type": "markdown", + "id": "0ad995ad", + "metadata": {}, + "source": [ + "## Results" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e414240b2fc6064e", + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-10T14:25:48.810201185Z", + "start_time": "2026-06-10T14:25:47.642776418Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plot_results(results, strategies, batch_size, device=device)" + ] + }, + { + "cell_type": "markdown", + "id": "8e444db9", + "metadata": {}, + "source": [ + "## Conclusions and caveats\n", + "\n", + "The figure above reports, as a function of the matrix dimension $2n$, the median forward time, the median backward time, the forward peak memory, and the combined forward + backward peak memory for every strategy, evaluated on block-antidiagonal skew matrices. Shaded bands are 95% confidence intervals over the 20 seeds (they are essentially invisible for memory, which is seed-independent for a fixed shape).\n", + "\n", + "**Memory-metric caveat.** The memory numbers depend on the device:\n", + "\n", + "- On **CUDA**, the reported value is a true peak obtained from `torch.cuda.reset_peak_memory_stats()` / `torch.cuda.max_memory_allocated()`.\n", + "- On **CPU** (the continuous-integration case), no equivalent peak counter exists, so we report the **allocated bytes** measured by `torch.profiler` instead. This is an aggregate of allocations rather than a strict instantaneous peak, so CPU and CUDA memory values are not directly comparable and the absolute CPU numbers should be read as a relative indicator across strategies and sizes.\n", + "\n", + "`PfaffianFDBPf` and `PfaffianDet` share the same forward (`sqrt(|det(A)|)`); their difference is the backward, so the backward panels highlight the analytic custom backward against plain autograd." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.14.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/poetry.lock b/poetry.lock deleted file mode 100644 index a593822..0000000 --- a/poetry.lock +++ /dev/null @@ -1,563 +0,0 @@ -# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand. - -[[package]] -name = "filelock" -version = "3.16.1" -description = "A platform independent file lock." -optional = false -python-versions = ">=3.8" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"}, - {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"}, -] - -[package.extras] -docs = ["furo (>=2024.8.6)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4.1)"] -testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "diff-cover (>=9.2)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.26.4)"] -typing = ["typing-extensions (>=4.12.2)"] - -[[package]] -name = "fsspec" -version = "2025.2.0" -description = "File-system specification" -optional = false -python-versions = ">=3.8" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "fsspec-2025.2.0-py3-none-any.whl", hash = "sha256:9de2ad9ce1f85e1931858535bc882543171d197001a0a5eb2ddc04f1781ab95b"}, - {file = "fsspec-2025.2.0.tar.gz", hash = "sha256:1c24b16eaa0a1798afa0337aa0db9b256718ab2a89c425371f5628d22c3b6afd"}, -] - -[package.extras] -abfs = ["adlfs"] -adl = ["adlfs"] -arrow = ["pyarrow (>=1)"] -dask = ["dask", "distributed"] -dev = ["pre-commit", "ruff"] -doc = ["numpydoc", "sphinx", "sphinx-design", "sphinx-rtd-theme", "yarl"] -dropbox = ["dropbox", "dropboxdrivefs", "requests"] -full = ["adlfs", "aiohttp (!=4.0.0a0,!=4.0.0a1)", "dask", "distributed", "dropbox", "dropboxdrivefs", "fusepy", "gcsfs", "libarchive-c", "ocifs", "panel", "paramiko", "pyarrow (>=1)", "pygit2", "requests", "s3fs", "smbprotocol", "tqdm"] -fuse = ["fusepy"] -gcs = ["gcsfs"] -git = ["pygit2"] -github = ["requests"] -gs = ["gcsfs"] -gui = ["panel"] -hdfs = ["pyarrow (>=1)"] -http = ["aiohttp (!=4.0.0a0,!=4.0.0a1)"] -libarchive = ["libarchive-c"] -oci = ["ocifs"] -s3 = ["s3fs"] -sftp = ["paramiko"] -smb = ["smbprotocol"] -ssh = ["paramiko"] -test = ["aiohttp (!=4.0.0a0,!=4.0.0a1)", "numpy", "pytest", "pytest-asyncio (!=0.22.0)", "pytest-benchmark", "pytest-cov", "pytest-mock", "pytest-recording", "pytest-rerunfailures", "requests"] -test-downstream = ["aiobotocore (>=2.5.4,<3.0.0)", "dask[dataframe,test]", "moto[server] (>4,<5)", "pytest-timeout", "xarray"] -test-full = ["adlfs", "aiohttp (!=4.0.0a0,!=4.0.0a1)", "cloudpickle", "dask", "distributed", "dropbox", "dropboxdrivefs", "fastparquet", "fusepy", "gcsfs", "jinja2", "kerchunk", "libarchive-c", "lz4", "notebook", "numpy", "ocifs", "pandas", "panel", "paramiko", "pyarrow", "pyarrow (>=1)", "pyftpdlib", "pygit2", "pytest", "pytest-asyncio (!=0.22.0)", "pytest-benchmark", "pytest-cov", "pytest-mock", "pytest-recording", "pytest-rerunfailures", "python-snappy", "requests", "smbprotocol", "tqdm", "urllib3", "zarr", "zstandard"] -tqdm = ["tqdm"] - -[[package]] -name = "jinja2" -version = "3.1.5" -description = "A very fast and expressive template engine." -optional = false -python-versions = ">=3.7" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"}, - {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"}, -] - -[package.dependencies] -MarkupSafe = ">=2.0" - -[package.extras] -i18n = ["Babel (>=2.7)"] - -[[package]] -name = "markupsafe" -version = "2.1.5" -description = "Safely add untrusted strings to HTML/XML markup." -optional = false -python-versions = ">=3.7" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"}, - {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"}, - {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"}, - {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"}, - {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"}, - {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"}, - {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, - {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, -] - -[[package]] -name = "mpmath" -version = "1.3.0" -description = "Python library for arbitrary-precision floating-point arithmetic" -optional = false -python-versions = "*" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"}, - {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"}, -] - -[package.extras] -develop = ["codecov", "pycodestyle", "pytest (>=4.6)", "pytest-cov", "wheel"] -docs = ["sphinx"] -gmpy = ["gmpy2 (>=2.1.0a4)"] -tests = ["pytest (>=4.6)"] - -[[package]] -name = "networkx" -version = "3.1" -description = "Python package for creating and manipulating graphs and networks" -optional = false -python-versions = ">=3.8" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "networkx-3.1-py3-none-any.whl", hash = "sha256:4f33f68cb2afcf86f28a45f43efc27a9386b535d567d2127f8f61d51dec58d36"}, - {file = "networkx-3.1.tar.gz", hash = "sha256:de346335408f84de0eada6ff9fafafff9bcda11f0a0dfaa931133debb146ab61"}, -] - -[package.extras] -default = ["matplotlib (>=3.4)", "numpy (>=1.20)", "pandas (>=1.3)", "scipy (>=1.8)"] -developer = ["mypy (>=1.1)", "pre-commit (>=3.2)"] -doc = ["nb2plots (>=0.6)", "numpydoc (>=1.5)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.13)", "sphinx (>=6.1)", "sphinx-gallery (>=0.12)", "texext (>=0.6.7)"] -extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.10)", "sympy (>=1.10)"] -test = ["codecov (>=2.1)", "pytest (>=7.2)", "pytest-cov (>=4.0)"] - -[[package]] -name = "numpy" -version = "1.24.4" -description = "Fundamental package for array computing in Python" -optional = false -python-versions = ">=3.8" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "numpy-1.24.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0bfb52d2169d58c1cdb8cc1f16989101639b34c7d3ce60ed70b19c63eba0b64"}, - {file = "numpy-1.24.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ed094d4f0c177b1b8e7aa9cba7d6ceed51c0e569a5318ac0ca9a090680a6a1b1"}, - {file = "numpy-1.24.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79fc682a374c4a8ed08b331bef9c5f582585d1048fa6d80bc6c35bc384eee9b4"}, - {file = "numpy-1.24.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ffe43c74893dbf38c2b0a1f5428760a1a9c98285553c89e12d70a96a7f3a4d6"}, - {file = "numpy-1.24.4-cp310-cp310-win32.whl", hash = "sha256:4c21decb6ea94057331e111a5bed9a79d335658c27ce2adb580fb4d54f2ad9bc"}, - {file = "numpy-1.24.4-cp310-cp310-win_amd64.whl", hash = "sha256:b4bea75e47d9586d31e892a7401f76e909712a0fd510f58f5337bea9572c571e"}, - {file = "numpy-1.24.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f136bab9c2cfd8da131132c2cf6cc27331dd6fae65f95f69dcd4ae3c3639c810"}, - {file = "numpy-1.24.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2926dac25b313635e4d6cf4dc4e51c8c0ebfed60b801c799ffc4c32bf3d1254"}, - {file = "numpy-1.24.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:222e40d0e2548690405b0b3c7b21d1169117391c2e82c378467ef9ab4c8f0da7"}, - {file = "numpy-1.24.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7215847ce88a85ce39baf9e89070cb860c98fdddacbaa6c0da3ffb31b3350bd5"}, - {file = "numpy-1.24.4-cp311-cp311-win32.whl", hash = "sha256:4979217d7de511a8d57f4b4b5b2b965f707768440c17cb70fbf254c4b225238d"}, - {file = "numpy-1.24.4-cp311-cp311-win_amd64.whl", hash = "sha256:b7b1fc9864d7d39e28f41d089bfd6353cb5f27ecd9905348c24187a768c79694"}, - {file = "numpy-1.24.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1452241c290f3e2a312c137a9999cdbf63f78864d63c79039bda65ee86943f61"}, - {file = "numpy-1.24.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:04640dab83f7c6c85abf9cd729c5b65f1ebd0ccf9de90b270cd61935eef0197f"}, - {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5425b114831d1e77e4b5d812b69d11d962e104095a5b9c3b641a218abcc050e"}, - {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd80e219fd4c71fc3699fc1dadac5dcf4fd882bfc6f7ec53d30fa197b8ee22dc"}, - {file = "numpy-1.24.4-cp38-cp38-win32.whl", hash = "sha256:4602244f345453db537be5314d3983dbf5834a9701b7723ec28923e2889e0bb2"}, - {file = "numpy-1.24.4-cp38-cp38-win_amd64.whl", hash = "sha256:692f2e0f55794943c5bfff12b3f56f99af76f902fc47487bdfe97856de51a706"}, - {file = "numpy-1.24.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2541312fbf09977f3b3ad449c4e5f4bb55d0dbf79226d7724211acc905049400"}, - {file = "numpy-1.24.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9667575fb6d13c95f1b36aca12c5ee3356bf001b714fc354eb5465ce1609e62f"}, - {file = "numpy-1.24.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a86ed21e4f87050382c7bc96571755193c4c1392490744ac73d660e8f564a9"}, - {file = "numpy-1.24.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d11efb4dbecbdf22508d55e48d9c8384db795e1b7b51ea735289ff96613ff74d"}, - {file = "numpy-1.24.4-cp39-cp39-win32.whl", hash = "sha256:6620c0acd41dbcb368610bb2f4d83145674040025e5536954782467100aa8835"}, - {file = "numpy-1.24.4-cp39-cp39-win_amd64.whl", hash = "sha256:befe2bf740fd8373cf56149a5c23a0f601e82869598d41f8e188a0e9869926f8"}, - {file = "numpy-1.24.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:31f13e25b4e304632a4619d0e0777662c2ffea99fcae2029556b17d8ff958aef"}, - {file = "numpy-1.24.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95f7ac6540e95bc440ad77f56e520da5bf877f87dca58bd095288dce8940532a"}, - {file = "numpy-1.24.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e98f220aa76ca2a977fe435f5b04d7b3470c0a2e6312907b37ba6068f26787f2"}, - {file = "numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463"}, -] - -[[package]] -name = "nvidia-cublas-cu12" -version = "12.4.5.8" -description = "CUBLAS native runtime libraries" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0f8aa1706812e00b9f19dfe0cdb3999b092ccb8ca168c0db5b8ea712456fd9b3"}, - {file = "nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl", hash = "sha256:2fc8da60df463fdefa81e323eef2e36489e1c94335b5358bcb38360adf75ac9b"}, - {file = "nvidia_cublas_cu12-12.4.5.8-py3-none-win_amd64.whl", hash = "sha256:5a796786da89203a0657eda402bcdcec6180254a8ac22d72213abc42069522dc"}, -] - -[[package]] -name = "nvidia-cuda-cupti-cu12" -version = "12.4.127" -description = "CUDA profiling tools runtime libs." -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:79279b35cf6f91da114182a5ce1864997fd52294a87a16179ce275773799458a"}, - {file = "nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:9dec60f5ac126f7bb551c055072b69d85392b13311fcc1bcda2202d172df30fb"}, - {file = "nvidia_cuda_cupti_cu12-12.4.127-py3-none-win_amd64.whl", hash = "sha256:5688d203301ab051449a2b1cb6690fbe90d2b372f411521c86018b950f3d7922"}, -] - -[[package]] -name = "nvidia-cuda-nvrtc-cu12" -version = "12.4.127" -description = "NVRTC native runtime libraries" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0eedf14185e04b76aa05b1fea04133e59f465b6f960c0cbf4e37c3cb6b0ea198"}, - {file = "nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a178759ebb095827bd30ef56598ec182b85547f1508941a3d560eb7ea1fbf338"}, - {file = "nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-win_amd64.whl", hash = "sha256:a961b2f1d5f17b14867c619ceb99ef6fcec12e46612711bcec78eb05068a60ec"}, -] - -[[package]] -name = "nvidia-cuda-runtime-cu12" -version = "12.4.127" -description = "CUDA Runtime native Libraries" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:961fe0e2e716a2a1d967aab7caee97512f71767f852f67432d572e36cb3a11f3"}, - {file = "nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:64403288fa2136ee8e467cdc9c9427e0434110899d07c779f25b5c068934faa5"}, - {file = "nvidia_cuda_runtime_cu12-12.4.127-py3-none-win_amd64.whl", hash = "sha256:09c2e35f48359752dfa822c09918211844a3d93c100a715d79b59591130c5e1e"}, -] - -[[package]] -name = "nvidia-cudnn-cu12" -version = "9.1.0.70" -description = "cuDNN runtime libraries" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f"}, - {file = "nvidia_cudnn_cu12-9.1.0.70-py3-none-win_amd64.whl", hash = "sha256:6278562929433d68365a07a4a1546c237ba2849852c0d4b2262a486e805b977a"}, -] - -[package.dependencies] -nvidia-cublas-cu12 = "*" - -[[package]] -name = "nvidia-cufft-cu12" -version = "11.2.1.3" -description = "CUFFT native runtime libraries" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5dad8008fc7f92f5ddfa2101430917ce2ffacd86824914c82e28990ad7f00399"}, - {file = "nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f083fc24912aa410be21fa16d157fed2055dab1cc4b6934a0e03cba69eb242b9"}, - {file = "nvidia_cufft_cu12-11.2.1.3-py3-none-win_amd64.whl", hash = "sha256:d802f4954291101186078ccbe22fc285a902136f974d369540fd4a5333d1440b"}, -] - -[package.dependencies] -nvidia-nvjitlink-cu12 = "*" - -[[package]] -name = "nvidia-curand-cu12" -version = "10.3.5.147" -description = "CURAND native runtime libraries" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_aarch64.whl", hash = "sha256:1f173f09e3e3c76ab084aba0de819c49e56614feae5c12f69883f4ae9bb5fad9"}, - {file = "nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a88f583d4e0bb643c49743469964103aa59f7f708d862c3ddb0fc07f851e3b8b"}, - {file = "nvidia_curand_cu12-10.3.5.147-py3-none-win_amd64.whl", hash = "sha256:f307cc191f96efe9e8f05a87096abc20d08845a841889ef78cb06924437f6771"}, -] - -[[package]] -name = "nvidia-cusolver-cu12" -version = "11.6.1.9" -description = "CUDA solver native runtime libraries" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_aarch64.whl", hash = "sha256:d338f155f174f90724bbde3758b7ac375a70ce8e706d70b018dd3375545fc84e"}, - {file = "nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl", hash = "sha256:19e33fa442bcfd085b3086c4ebf7e8debc07cfe01e11513cc6d332fd918ac260"}, - {file = "nvidia_cusolver_cu12-11.6.1.9-py3-none-win_amd64.whl", hash = "sha256:e77314c9d7b694fcebc84f58989f3aa4fb4cb442f12ca1a9bde50f5e8f6d1b9c"}, -] - -[package.dependencies] -nvidia-cublas-cu12 = "*" -nvidia-cusparse-cu12 = "*" -nvidia-nvjitlink-cu12 = "*" - -[[package]] -name = "nvidia-cusparse-cu12" -version = "12.3.1.170" -description = "CUSPARSE native runtime libraries" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_aarch64.whl", hash = "sha256:9d32f62896231ebe0480efd8a7f702e143c98cfaa0e8a76df3386c1ba2b54df3"}, - {file = "nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl", hash = "sha256:ea4f11a2904e2a8dc4b1833cc1b5181cde564edd0d5cd33e3c168eff2d1863f1"}, - {file = "nvidia_cusparse_cu12-12.3.1.170-py3-none-win_amd64.whl", hash = "sha256:9bc90fb087bc7b4c15641521f31c0371e9a612fc2ba12c338d3ae032e6b6797f"}, -] - -[package.dependencies] -nvidia-nvjitlink-cu12 = "*" - -[[package]] -name = "nvidia-nccl-cu12" -version = "2.21.5" -description = "NVIDIA Collective Communication Library (NCCL) Runtime" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_nccl_cu12-2.21.5-py3-none-manylinux2014_x86_64.whl", hash = "sha256:8579076d30a8c24988834445f8d633c697d42397e92ffc3f63fa26766d25e0a0"}, -] - -[[package]] -name = "nvidia-nvjitlink-cu12" -version = "12.4.127" -description = "Nvidia JIT LTO Library" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4abe7fef64914ccfa909bc2ba39739670ecc9e820c83ccc7a6ed414122599b83"}, - {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:06b3b9b25bf3f8af351d664978ca26a16d2c5127dbd53c0497e28d1fb9611d57"}, - {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-win_amd64.whl", hash = "sha256:fd9020c501d27d135f983c6d3e244b197a7ccad769e34df53a42e276b0e25fa1"}, -] - -[[package]] -name = "nvidia-nvtx-cu12" -version = "12.4.127" -description = "NVIDIA Tools Extension" -optional = false -python-versions = ">=3" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\"" -files = [ - {file = "nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7959ad635db13edf4fc65c06a6e9f9e55fc2f92596db928d169c0bb031e88ef3"}, - {file = "nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:781e950d9b9f60d8241ccea575b32f5105a5baf4c2351cab5256a24869f12a1a"}, - {file = "nvidia_nvtx_cu12-12.4.127-py3-none-win_amd64.whl", hash = "sha256:641dccaaa1139f3ffb0d3164b4b84f9d253397e38246a4f2f36728b48566d485"}, -] - -[[package]] -name = "setuptools" -version = "75.3.0" -description = "Easily download, build, install, upgrade, and uninstall Python packages" -optional = false -python-versions = ">=3.8" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "setuptools-75.3.0-py3-none-any.whl", hash = "sha256:f2504966861356aa38616760c0f66568e535562374995367b4e69c7143cf6bcd"}, - {file = "setuptools-75.3.0.tar.gz", hash = "sha256:fba5dd4d766e97be1b1681d98712680ae8f2f26d7881245f2ce9e40714f1a686"}, -] - -[package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)", "ruff (>=0.5.2)"] -core = ["importlib-metadata (>=6)", "importlib-resources (>=5.10.2)", "jaraco.collections", "jaraco.functools", "jaraco.text (>=3.7)", "more-itertools", "more-itertools (>=8.8)", "packaging", "packaging (>=24)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"] -cover = ["pytest-cov"] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"] -enabler = ["pytest-enabler (>=2.2)"] -test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test (>=5.5)", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"] -type = ["importlib-metadata (>=7.0.2)", "jaraco.develop (>=7.21)", "mypy (==1.12.*)", "pytest-mypy"] - -[[package]] -name = "sympy" -version = "1.12.1" -description = "Computer algebra system (CAS) in Python" -optional = false -python-versions = ">=3.8" -groups = ["main"] -markers = "python_version == \"3.8\"" -files = [ - {file = "sympy-1.12.1-py3-none-any.whl", hash = "sha256:9b2cbc7f1a640289430e13d2a56f02f867a1da0190f2f99d8968c2f74da0e515"}, - {file = "sympy-1.12.1.tar.gz", hash = "sha256:2877b03f998cd8c08f07cd0de5b767119cd3ef40d09f41c30d722f6686b0fb88"}, -] - -[package.dependencies] -mpmath = ">=1.1.0,<1.4.0" - -[[package]] -name = "sympy" -version = "1.13.1" -description = "Computer algebra system (CAS) in Python" -optional = false -python-versions = ">=3.8" -groups = ["main"] -markers = "python_version >= \"3.9\"" -files = [ - {file = "sympy-1.13.1-py3-none-any.whl", hash = "sha256:db36cdc64bf61b9b24578b6f7bab1ecdd2452cf008f34faa33776680c26d66f8"}, - {file = "sympy-1.13.1.tar.gz", hash = "sha256:9cebf7e04ff162015ce31c9c6c9144daa34a93bd082f54fd8f12deca4f47515f"}, -] - -[package.dependencies] -mpmath = ">=1.1.0,<1.4" - -[package.extras] -dev = ["hypothesis (>=6.70.0)", "pytest (>=7.1.0)"] - -[[package]] -name = "torch" -version = "2.5.1" -description = "Tensors and Dynamic neural networks in Python with strong GPU acceleration" -optional = false -python-versions = ">=3.8.0" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "torch-2.5.1-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:71328e1bbe39d213b8721678f9dcac30dfc452a46d586f1d514a6aa0a99d4744"}, - {file = "torch-2.5.1-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:34bfa1a852e5714cbfa17f27c49d8ce35e1b7af5608c4bc6e81392c352dbc601"}, - {file = "torch-2.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:32a037bd98a241df6c93e4c789b683335da76a2ac142c0973675b715102dc5fa"}, - {file = "torch-2.5.1-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:23d062bf70776a3d04dbe74db950db2a5245e1ba4f27208a87f0d743b0d06e86"}, - {file = "torch-2.5.1-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:de5b7d6740c4b636ef4db92be922f0edc425b65ed78c5076c43c42d362a45457"}, - {file = "torch-2.5.1-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:340ce0432cad0d37f5a31be666896e16788f1adf8ad7be481196b503dad675b9"}, - {file = "torch-2.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:603c52d2fe06433c18b747d25f5c333f9c1d58615620578c326d66f258686f9a"}, - {file = "torch-2.5.1-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:31f8c39660962f9ae4eeec995e3049b5492eb7360dd4f07377658ef4d728fa4c"}, - {file = "torch-2.5.1-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:ed231a4b3a5952177fafb661213d690a72caaad97d5824dd4fc17ab9e15cec03"}, - {file = "torch-2.5.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:3f4b7f10a247e0dcd7ea97dc2d3bfbfc90302ed36d7f3952b0008d0df264e697"}, - {file = "torch-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:73e58e78f7d220917c5dbfad1a40e09df9929d3b95d25e57d9f8558f84c9a11c"}, - {file = "torch-2.5.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:8c712df61101964eb11910a846514011f0b6f5920c55dbf567bff8a34163d5b1"}, - {file = "torch-2.5.1-cp313-cp313-manylinux1_x86_64.whl", hash = "sha256:9b61edf3b4f6e3b0e0adda8b3960266b9009d02b37555971f4d1c8f7a05afed7"}, - {file = "torch-2.5.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:1f3b7fb3cf7ab97fae52161423f81be8c6b8afac8d9760823fd623994581e1a3"}, - {file = "torch-2.5.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:7974e3dce28b5a21fb554b73e1bc9072c25dde873fa00d54280861e7a009d7dc"}, - {file = "torch-2.5.1-cp39-cp39-win_amd64.whl", hash = "sha256:46c817d3ea33696ad3b9df5e774dba2257e9a4cd3c4a3afbf92f6bb13ac5ce2d"}, - {file = "torch-2.5.1-cp39-none-macosx_11_0_arm64.whl", hash = "sha256:8046768b7f6d35b85d101b4b38cba8aa2f3cd51952bc4c06a49580f2ce682291"}, -] - -[package.dependencies] -filelock = "*" -fsspec = "*" -jinja2 = "*" -networkx = "*" -nvidia-cublas-cu12 = {version = "12.4.5.8", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cuda-cupti-cu12 = {version = "12.4.127", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cuda-nvrtc-cu12 = {version = "12.4.127", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cuda-runtime-cu12 = {version = "12.4.127", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cudnn-cu12 = {version = "9.1.0.70", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cufft-cu12 = {version = "11.2.1.3", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-curand-cu12 = {version = "10.3.5.147", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cusolver-cu12 = {version = "11.6.1.9", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cusparse-cu12 = {version = "12.3.1.170", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-nccl-cu12 = {version = "2.21.5", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-nvjitlink-cu12 = {version = "12.4.127", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-nvtx-cu12 = {version = "12.4.127", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -setuptools = {version = "*", markers = "python_version >= \"3.12\""} -sympy = [ - {version = "1.12.1", markers = "python_version == \"3.8\""}, - {version = "1.13.1", markers = "python_version >= \"3.9\""}, -] -triton = {version = "3.1.0", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\" and python_version < \"3.13\""} -typing-extensions = ">=4.8.0" - -[package.extras] -opt-einsum = ["opt-einsum (>=3.3)"] -optree = ["optree (>=0.12.0)"] - -[[package]] -name = "triton" -version = "3.1.0" -description = "A language and compiler for custom Deep Learning operations" -optional = false -python-versions = "*" -groups = ["main"] -markers = "python_version == \"3.8\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" or python_version >= \"3.9\" and platform_system == \"Linux\" and platform_machine == \"x86_64\" and python_version < \"3.13\"" -files = [ - {file = "triton-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b0dd10a925263abbe9fa37dcde67a5e9b2383fc269fdf59f5657cac38c5d1d8"}, - {file = "triton-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f34f6e7885d1bf0eaaf7ba875a5f0ce6f3c13ba98f9503651c1e6dc6757ed5c"}, - {file = "triton-3.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8182f42fd8080a7d39d666814fa36c5e30cc00ea7eeeb1a2983dbb4c99a0fdc"}, - {file = "triton-3.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6dadaca7fc24de34e180271b5cf864c16755702e9f63a16f62df714a8099126a"}, - {file = "triton-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aafa9a20cd0d9fee523cd4504aa7131807a864cd77dcf6efe7e981f18b8c6c11"}, -] - -[package.dependencies] -filelock = "*" - -[package.extras] -build = ["cmake (>=3.20)", "lit"] -tests = ["autopep8", "flake8", "isort", "llnl-hatchet", "numpy", "pytest", "scipy (>=1.7.1)"] -tutorials = ["matplotlib", "pandas", "tabulate"] - -[[package]] -name = "typing-extensions" -version = "4.12.2" -description = "Backported and Experimental Type Hints for Python 3.8+" -optional = false -python-versions = ">=3.8" -groups = ["main"] -markers = "python_version == \"3.8\" or python_version >= \"3.9\"" -files = [ - {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, - {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, -] - -[metadata] -lock-version = "2.1" -python-versions = ">=3.8" -content-hash = "86cbdcc9942ce0fe264ccaf656b9a1faaf82a1281d609dd55483eb95e5db46ae" diff --git a/pyproject.toml b/pyproject.toml index 5593271..c789a1b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,60 +1,179 @@ -[tool.pytest.ini_options] -pythonpath = [ - ".", "src", -] -addopts = [ - "--cov=src", -# "--no-cov", - "--durations=10", -] - - -[build-system] -requires = [ - "numpy>=1.23.0", - "setuptools>=57.0.0", - "pytest>=7.4.2", - "pytest-cov>=4.1.0", - "wheel", - "torch", -] -build-backend = "setuptools.build_meta" - - - [project] name = "TorchPfaffian" -dynamic = ["version", "readme"] -description = "" -authors = [ - { name="Jérémie Gince", email="gincejeremie@gmail.com" }, -] +version = "0.0.1" +description = "PyTorch-based Pfaffian computation for skew-symmetric matrices." +authors = [{ name = "Jérémie Gince", email = "gincejeremie@gmail.com" }] +requires-python = ">=3.10,<3.15" +license = { file = "LICENSE" } classifiers = [ "Development Status :: 3 - Alpha", "Intended Audience :: Science/Research", "License :: OSI Approved :: Apache Software License", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", "Topic :: Scientific/Engineering", + "Topic :: Scientific/Engineering :: Artificial Intelligence", "Topic :: Software Development :: Libraries :: Python Modules", "Operating System :: OS Independent", ] -requires-python = ">=3.8" dependencies = [ - "numpy>=1.23.0", + "numpy (>=1.23,<3.0.0)", + "setuptools (>=80.10)", + "torch (>=2.1,<3.0.0)", +] +dynamic = ["readme"] + +[project.urls] +homepage = "https://github.com/MatchCake/TorchPfaffian" +Documentation = "https://MatchCake.github.io/TorchPfaffian" +Source = "https://github.com/MatchCake/TorchPfaffian" + +[tool.pytest.ini_options] +pythonpath = [ + ".", "src", +] +testpaths = ["tests"] +addopts = [ + "-n=auto", + "--cov-branch", + "--cov=src", + '--cov-report=xml:tests/.tmp/coverage.xml', + "--cov-report=term-missing", + "--durations=10", +] + +[dependency-groups] +dev = [ + "pytest-cov>=6.1,<7", + "pytest-json-report>=1.5,<2", + "pytest>=8.4,<9", + "mypy>=1.15,<2", + "ruff>=0.9,<1", + "nbmake>=1.5,<2", + "wheel>=0.45,<0.46", + "build>=1.4,<2", + "twine>=6.1,<7", + "pytest-xdist>=3.7,<4", + "pytest-timeout>=2.4", + "pip>=25", + "pre-commit>=4.5.1", +] +docs = [ + "wheel>=0.45,<0.46", + "build>=1.4,<2", + "twine>=6.1,<7", + "sphinx>=6.2,<6.3", + "docutils>=0.18,<0.20", + "sphinx-rtd-theme>=3.0,<4", + "sphinxcontrib-bibtex>=2.5,<2.6", + "sphinx-theme~=1.0", + "groundwork-sphinx-theme>=1.1,<2", + "karma-sphinx-theme>=0.0.8,<0.0.9", + "sphinx-mdinclude>=0.6,<0.7", + "myst-nb>=1.1,<2", + "ipykernel>=6.29,<7", + "matplotlib>=3.8,<4", + "nbconvert>=7.16,<8", +] + +[tool.uv] +default-groups = [ + "dev", + "docs", +] +conflicts = [ + [ + { extra = "cpu" }, + { extra = "cu128" }, + { extra = "cu130" }, + ], +] + +[project.optional-dependencies] +cpu = [ + "torch (>=2.1.2,<3.0.0)", +] +cu128 = [ + "torch (>=2.1.2,<3.0.0)", +] +cu130 = [ + "torch (>=2.1.2,<3.0.0)", +] + +[tool.uv.sources] +torch = [ + { index = "pytorch-cpu", extra = "cpu" }, + { index = "pytorch-cu128", extra = "cu128" }, + { index = "pytorch-cu130", extra = "cu130" }, +] + +[[tool.uv.index]] +name = "pytorch-cpu" +url = "https://download.pytorch.org/whl/cpu" +explicit = true + +[[tool.uv.index]] +name = "pytorch-cu128" +url = "https://download.pytorch.org/whl/cu128" +explicit = true + +[[tool.uv.index]] +name = "pytorch-cu130" +url = "https://download.pytorch.org/whl/cu130" +explicit = true + +[build-system] +requires = [ "setuptools>=57.0.0", - "torch", - "numpy" + "wheel>=0.45.1,<0.46", + "build>=1.2.2.post1,<2", + "twine>=6.1.0,<7", ] +build-backend = "setuptools.build_meta" +[tool.setuptools.dynamic] +readme = { file = "README.md", content-type = "text/markdown" } [tool.setuptools] -package-dir = {"" = "src"} +package-dir = { "" = "src" } [tool.setuptools.packages.find] where = ["src"] +[tool.setuptools.package-data] +torch_pfaffian = ["py.typed"] -[tool.poetry] -packages = [{include = "torch_pfaffian", from = "src"}] -version = "0.0.1" +[tool.coverage.report] +exclude_also = [ + 'def __repr__', + 'if self.debug:', + 'if settings.DEBUG', + 'raise AssertionError', + 'raise NotImplementedError', + 'if __name__ == .__main__.:', + 'if TYPE_CHECKING:', + '@(abc\.)?abstractmethod', +] + +[tool.coverage.run] +relative_files = true + +[[tool.mypy.overrides]] +module = [] +ignore_missing_imports = true + +[tool.ruff] +line-length = 120 +extend-exclude = ["archives"] +force-exclude = true + +[tool.ruff.lint] +select = ["E", "F", "I"] + +[tool.ruff.lint.per-file-ignores] +"**/__init__.py" = ["F401", "F403", "F405"] +"sphinx/source/conf.py" = ["E402"] + +[tool.ruff.format] +quote-style = "double" diff --git a/requirements.txt b/requirements.txt index 234cad5..7141f32 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,9 +1,462 @@ -pytest>=7.4.2 -pytest_cov>=4.1.0 -pytest_json_report>=1.5.0 -pythonbasictools>=0.0.1a10 -setuptools>=65.5.1 -tqdm>=4.66.1 -psutil>=5.9.6 -numpy>=1.23.0 -torch \ No newline at end of file +# This file was autogenerated by uv via the following command: +# uv export --frozen --no-hashes --output-file=requirements.txt +-e . +alabaster==0.7.16 + # via sphinx +appnope==0.1.4 ; sys_platform == 'darwin' + # via ipykernel +asttokens==3.0.1 + # via stack-data +attrs==26.1.0 + # via + # jsonschema + # jupyter-cache + # referencing +babel==2.18.0 + # via sphinx +backports-tarfile==1.2.0 ; python_full_version < '3.12' and platform_machine != 'ppc64le' and platform_machine != 's390x' + # via jaraco-context +beautifulsoup4==4.15.0 + # via nbconvert +bleach==6.4.0 + # via nbconvert +build==1.5.0 +certifi==2026.5.20 + # via requests +cffi==2.0.0 ; (implementation_name == 'pypy' and platform_machine == 'ppc64le') or (implementation_name == 'pypy' and platform_machine == 's390x') or (implementation_name == 'pypy' and platform_machine != 'ppc64le' and platform_machine != 's390x' and platform_python_implementation == 'PyPy') or (implementation_name == 'pypy' and sys_platform != 'linux') or (platform_machine != 'ppc64le' and platform_machine != 's390x' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') + # via + # cryptography + # pyzmq +cfgv==3.5.0 + # via pre-commit +charset-normalizer==3.4.7 + # via requests +click==8.4.1 + # via jupyter-cache +colorama==0.4.6 ; os_name == 'nt' or sys_platform == 'win32' + # via + # build + # click + # ipython + # pytest + # sphinx +comm==0.2.3 + # via ipykernel +contourpy==1.3.2 ; python_full_version < '3.11' + # via matplotlib +contourpy==1.3.3 ; python_full_version >= '3.11' + # via matplotlib +coverage==7.14.1 + # via pytest-cov +cryptography==48.0.1 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'linux' + # via secretstorage +cycler==0.12.1 + # via matplotlib +debugpy==1.8.21 + # via ipykernel +decorator==5.3.1 + # via ipython +defusedxml==0.7.1 + # via nbconvert +distlib==0.4.2 + # via virtualenv +docutils==0.19 + # via + # myst-parser + # pybtex-docutils + # readme-renderer + # sphinx + # sphinx-mdinclude + # sphinx-rtd-theme + # sphinxcontrib-bibtex +exceptiongroup==1.3.1 ; python_full_version < '3.11' + # via + # ipython + # pytest +execnet==2.1.2 + # via pytest-xdist +executing==2.2.1 + # via stack-data +fastjsonschema==2.21.2 + # via nbformat +filelock==3.29.1 + # via + # python-discovery + # torch + # virtualenv +fonttools==4.63.0 + # via matplotlib +fsspec==2026.4.0 + # via torch +greenlet==3.5.1 ; platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64' + # via sqlalchemy +groundwork-sphinx-theme==1.1.1 +id==1.6.1 + # via twine +identify==2.6.19 + # via pre-commit +idna==3.18 + # via requests +imagesize==2.0.0 + # via sphinx +importlib-metadata==9.0.0 + # via + # build + # jupyter-cache + # keyring + # myst-nb +iniconfig==2.3.0 + # via pytest +ipykernel==6.31.0 + # via + # myst-nb + # nbmake +ipython==8.39.0 ; python_full_version < '3.11' + # via + # ipykernel + # myst-nb +ipython==9.14.1 ; python_full_version >= '3.11' + # via + # ipykernel + # myst-nb +ipython-pygments-lexers==1.1.1 ; python_full_version >= '3.11' + # via ipython +jaraco-classes==3.4.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' + # via keyring +jaraco-context==6.1.2 ; platform_machine != 'ppc64le' and platform_machine != 's390x' + # via keyring +jaraco-functools==4.5.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' + # via keyring +jedi==0.20.0 + # via ipython +jeepney==0.9.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'linux' + # via + # keyring + # secretstorage +jinja2==3.1.6 + # via + # myst-parser + # nbconvert + # sphinx + # torch +jsonschema==4.26.0 + # via nbformat +jsonschema-specifications==2025.9.1 + # via jsonschema +jupyter-cache==1.0.1 + # via myst-nb +jupyter-client==8.9.1 + # via + # ipykernel + # nbclient +jupyter-core==5.9.1 + # via + # ipykernel + # jupyter-client + # nbclient + # nbconvert + # nbformat +jupyterlab-pygments==0.3.0 + # via nbconvert +karma-sphinx-theme==0.0.8 +keyring==25.7.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' + # via twine +kiwisolver==1.5.0 + # via matplotlib +latexcodec==3.0.1 + # via pybtex +librt==0.11.0 ; platform_python_implementation != 'PyPy' + # via mypy +markdown-it-py==3.0.0 + # via + # mdit-py-plugins + # myst-parser + # rich +markupsafe==3.0.3 + # via + # jinja2 + # nbconvert +matplotlib==3.10.9 +matplotlib-inline==0.2.2 + # via + # ipykernel + # ipython +mdit-py-plugins==0.6.1 + # via myst-parser +mdurl==0.1.2 + # via markdown-it-py +mistune==3.2.1 + # via + # nbconvert + # sphinx-mdinclude +more-itertools==11.1.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' + # via + # jaraco-classes + # jaraco-functools +mpmath==1.3.0 + # via sympy +mypy==1.20.2 +mypy-extensions==1.1.0 + # via mypy +myst-nb==1.4.0 +myst-parser==3.0.1 + # via myst-nb +nbclient==0.11.0 + # via + # jupyter-cache + # myst-nb + # nbconvert + # nbmake +nbconvert==7.17.1 +nbformat==5.10.4 + # via + # jupyter-cache + # myst-nb + # nbclient + # nbconvert + # nbmake +nbmake==1.5.5 +nest-asyncio==1.6.0 + # via ipykernel +networkx==3.4.2 ; python_full_version < '3.11' + # via torch +networkx==3.6.1 ; python_full_version >= '3.11' + # via torch +nh3==0.3.5 + # via readme-renderer +nodeenv==1.10.0 + # via pre-commit +numpy==2.2.6 ; python_full_version < '3.11' + # via + # contourpy + # matplotlib + # torchpfaffian +numpy==2.4.6 ; python_full_version >= '3.11' + # via + # contourpy + # matplotlib + # torchpfaffian +packaging==26.2 + # via + # build + # ipykernel + # matplotlib + # nbconvert + # pytest + # sphinx + # twine +pandocfilters==1.5.1 + # via nbconvert +parso==0.8.7 + # via jedi +pathspec==1.1.1 + # via mypy +pexpect==4.9.0 ; sys_platform != 'emscripten' and sys_platform != 'win32' + # via ipython +pillow==12.2.0 + # via matplotlib +pip==26.1.2 +platformdirs==4.10.0 + # via + # jupyter-core + # python-discovery + # virtualenv +pluggy==1.6.0 + # via + # pytest + # pytest-cov +pre-commit==4.6.0 +prompt-toolkit==3.0.52 + # via ipython +psutil==7.2.2 + # via + # ipykernel + # ipython +ptyprocess==0.7.0 ; sys_platform != 'emscripten' and sys_platform != 'win32' + # via pexpect +pure-eval==0.2.3 + # via stack-data +pybtex==0.26.1 + # via + # pybtex-docutils + # sphinxcontrib-bibtex +pybtex-docutils==1.0.3 + # via sphinxcontrib-bibtex +pycparser==3.0 ; (implementation_name == 'pypy' and platform_machine == 'ppc64le') or (implementation_name == 'pypy' and platform_machine == 's390x') or (implementation_name == 'pypy' and platform_machine != 'ppc64le' and platform_machine != 's390x' and platform_python_implementation == 'PyPy') or (implementation_name != 'PyPy' and platform_machine != 'ppc64le' and platform_machine != 's390x' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (implementation_name == 'pypy' and sys_platform != 'linux') + # via cffi +pygments==2.20.0 + # via + # ipython + # ipython-pygments-lexers + # nbconvert + # nbmake + # pytest + # readme-renderer + # rich + # sphinx + # sphinx-mdinclude +pyparsing==3.3.2 + # via matplotlib +pyproject-hooks==1.2.0 + # via build +pytest==8.4.2 + # via + # nbmake + # pytest-cov + # pytest-json-report + # pytest-metadata + # pytest-timeout + # pytest-xdist +pytest-cov==6.3.0 +pytest-json-report==1.5.0 +pytest-metadata==3.1.1 + # via pytest-json-report +pytest-timeout==2.4.0 +pytest-xdist==3.8.0 +python-dateutil==2.9.0.post0 + # via + # jupyter-client + # matplotlib +python-discovery==1.4.0 + # via virtualenv +pywin32-ctypes==0.2.3 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'win32' + # via keyring +pyyaml==6.0.3 + # via + # jupyter-cache + # myst-nb + # myst-parser + # pre-commit + # pybtex +pyzmq==27.1.0 + # via + # ipykernel + # jupyter-client +readme-renderer==43.0 + # via twine +referencing==0.37.0 + # via + # jsonschema + # jsonschema-specifications +requests==2.34.2 + # via + # requests-toolbelt + # sphinx + # twine +requests-toolbelt==1.0.0 + # via twine +rfc3986==2.0.0 + # via twine +rich==15.0.0 + # via twine +rpds-py==0.30.0 ; python_full_version < '3.11' + # via + # jsonschema + # referencing +rpds-py==2026.5.1 ; python_full_version >= '3.11' + # via + # jsonschema + # referencing +ruff==0.15.16 +secretstorage==3.5.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'linux' + # via keyring +setuptools==82.0.1 + # via + # torch + # torchpfaffian +six==1.17.0 + # via python-dateutil +snowballstemmer==3.1.1 + # via sphinx +soupsieve==2.8.4 + # via beautifulsoup4 +sphinx==6.2.1 + # via + # groundwork-sphinx-theme + # myst-nb + # myst-parser + # sphinx-mdinclude + # sphinx-rtd-theme + # sphinxcontrib-bibtex + # sphinxcontrib-jquery +sphinx-mdinclude==0.6.2 +sphinx-rtd-theme==3.1.0 +sphinx-theme==1.0 +sphinxcontrib-applehelp==2.0.0 + # via sphinx +sphinxcontrib-bibtex==2.5.0 +sphinxcontrib-devhelp==2.0.0 + # via sphinx +sphinxcontrib-htmlhelp==2.1.0 + # via sphinx +sphinxcontrib-jquery==4.1 + # via sphinx-rtd-theme +sphinxcontrib-jsmath==1.0.1 + # via sphinx +sphinxcontrib-qthelp==2.0.0 + # via sphinx +sphinxcontrib-serializinghtml==2.0.0 + # via sphinx +sqlalchemy==2.0.50 + # via jupyter-cache +stack-data==0.6.3 + # via ipython +sympy==1.14.0 + # via torch +tabulate==0.10.0 + # via jupyter-cache +tinycss2==1.5.1 + # via bleach +tomli==2.4.1 ; python_full_version <= '3.11' + # via + # build + # coverage + # mypy + # pytest +torch==2.10.0 + # via torchpfaffian +tornado==6.5.7 + # via + # ipykernel + # jupyter-client +traitlets==5.15.1 + # via + # ipykernel + # ipython + # jupyter-client + # jupyter-core + # matplotlib-inline + # nbclient + # nbconvert + # nbformat +twine==6.2.0 +typing-extensions==4.15.0 + # via + # beautifulsoup4 + # cryptography + # exceptiongroup + # ipython + # jupyter-client + # mistune + # mypy + # myst-nb + # referencing + # sqlalchemy + # torch + # virtualenv +urllib3==2.7.0 + # via + # id + # requests + # twine +virtualenv==21.4.2 + # via pre-commit +wcwidth==0.8.1 + # via prompt-toolkit +webencodings==0.5.1 + # via + # bleach + # tinycss2 +wheel==0.45.1 +zipp==4.1.0 + # via importlib-metadata diff --git a/run_pytests.py b/run_pytests.py deleted file mode 100644 index a2706a8..0000000 --- a/run_pytests.py +++ /dev/null @@ -1,37 +0,0 @@ -import json -import os - -import pytest -import pythonbasictools as pbt -from pytest_jsonreport.plugin import JSONReport -from pytest_cov.plugin import CovPlugin - -from tests import configs -from tests.conftest import RUN_SLOW_ARG_NAME - -if __name__ == '__main__': - sys_args_dict = pbt.cmds.get_cmd_kwargs( - { - 1 : os.path.join(os.getcwd(), "tests"), - "N_RANDOM_TESTS_PER_CASE": configs.N_RANDOM_TESTS_PER_CASE, - "save_report" : "True", - "cov" : "src", - "cov-report" : "xml", - RUN_SLOW_ARG_NAME : "True", - "durations" : 10, - } - ) - sys_args_dict["cov-report"] = sys_args_dict["cov_report"] # fix - configs.N_RANDOM_TESTS_PER_CASE = sys_args_dict["N_RANDOM_TESTS_PER_CASE"] - configs.RUN_SLOW_TESTS = 't' in str(sys_args_dict[RUN_SLOW_ARG_NAME]).lower() - json_plugin = JSONReport() - pytest_main_args_names = ["cov", "cov-report", "durations"] - pytest_main_args = [f"--{k}={sys_args_dict[k]}" for k in pytest_main_args_names] - pytest.main([sys_args_dict[1], *pytest_main_args], plugins=[json_plugin]) - json_path = os.path.join(os.getcwd(), "tests", "tmp", f"tests_report_rn{configs.N_RANDOM_TESTS_PER_CASE}.json") - save_report = 't' in str(sys_args_dict["save_report"]).lower() - if save_report: - json_plugin.save_report(json_path) - json_data = json.load(open(json_path)) - with open(json_path, "w") as f: - json.dump(json_data, f, indent=4) diff --git a/setup.py b/setup.py index 739cb90..53a465e 100644 --- a/setup.py +++ b/setup.py @@ -1,28 +1,29 @@ -from setuptools import setup import setuptools +from setuptools import setup setup( - name='TorchPfaffian', - long_description='file: README.md', + name="TorchPfaffian", + long_description="file: README.md", long_description_content_type="text/markdown", package_dir={"": "src"}, packages=setuptools.find_packages(where="src"), - python_requires=">=3.8", + python_requires=">=3.10", classifiers=[ "Development Status :: 3 - Alpha", "Intended Audience :: Science/Research", "License :: OSI Approved :: Apache Software License", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", "Topic :: Scientific/Engineering", "Topic :: Scientific/Engineering :: Artificial Intelligence", "Topic :: Software Development :: Libraries :: Python Modules", "Operating System :: OS Independent", ], project_urls={ - 'Homepage': 'https://https://github.com/MatchCake/TorchPfaffian', - 'Source': 'https://https://github.com/MatchCake/TorchPfaffian', - 'Documentation': 'https://MatchCake.github.io/TorchPfaffian', + "Homepage": "https://github.com/MatchCake/TorchPfaffian", + "Source": "https://github.com/MatchCake/TorchPfaffian", + "Documentation": "https://MatchCake.github.io/TorchPfaffian", }, ) @@ -37,4 +38,3 @@ # twine check dist/* # twine upload --repository-url https://test.pypi.org/legacy/ dist/* # twine upload dist/* - diff --git a/sphinx/clean_html_files.py b/sphinx/clean_html_files.py index c066388..8499831 100644 --- a/sphinx/clean_html_files.py +++ b/sphinx/clean_html_files.py @@ -3,20 +3,20 @@ def clean_html_files(): - meta_filename = "docs/html_files_list.txt" - if not os.path.exists(meta_filename): - return - with open(meta_filename, "r") as f: - files = f.readlines() - for file in files: - path = os.path.join(os.getcwd(), "docs", file.strip()) - if os.path.exists(path): - if os.path.isdir(path): - shutil.rmtree(path) - else: - os.remove(path) - os.remove(meta_filename) + meta_filename = "docs/html_files_list.txt" + if not os.path.exists(meta_filename): + return + with open(meta_filename, "r") as f: + files = f.readlines() + for file in files: + path = os.path.join(os.getcwd(), "docs", file.strip()) + if os.path.exists(path): + if os.path.isdir(path): + shutil.rmtree(path) + else: + os.remove(path) + os.remove(meta_filename) -if __name__ == '__main__': - clean_html_files() +if __name__ == "__main__": + clean_html_files() diff --git a/sphinx/generate_doc.py b/sphinx/generate_doc.py index 25de62e..f2f30a3 100644 --- a/sphinx/generate_doc.py +++ b/sphinx/generate_doc.py @@ -1,17 +1,18 @@ -import os, sys +import os +import sys -def generate_doc(path_to_root_dir: str = '.'): - commands = [ - rf"sphinx-apidoc -f -o {path_to_root_dir}/sphinx/source {path_to_root_dir}/src/neurotorch", - rf"{path_to_root_dir}\sphinx\make clean html", - rf"{path_to_root_dir}\sphinx\make html", - ] - for command in commands: - print(f"Executing: {command}") - os.system(command) +def generate_doc(path_to_root_dir: str = "."): + commands = [ + rf"sphinx-apidoc -f -o {path_to_root_dir}/sphinx/source {path_to_root_dir}/src/neurotorch", + rf"{path_to_root_dir}\sphinx\make clean html", + rf"{path_to_root_dir}\sphinx\make html", + ] + for command in commands: + print(f"Executing: {command}") + os.system(command) -if __name__ == '__main__': - root_dir = sys.argv[1] if len(sys.argv) > 1 else '..' - generate_doc(root_dir) +if __name__ == "__main__": + root_dir = sys.argv[1] if len(sys.argv) > 1 else ".." + generate_doc(root_dir) diff --git a/sphinx/make_html_files_list.py b/sphinx/make_html_files_list.py index 1422259..cc37bbf 100644 --- a/sphinx/make_html_files_list.py +++ b/sphinx/make_html_files_list.py @@ -2,12 +2,12 @@ def make_html_file_list(): - meta_filename = "./docs/html_files_list.txt" - os.makedirs(os.path.dirname(meta_filename), exist_ok=True) - files = os.listdir(os.path.join('sphinx', "build", "html")) - with open(meta_filename, "w") as f: - f.write("\n".join(files)) - - -if __name__ == '__main__': - make_html_file_list() + meta_filename = "./docs/html_files_list.txt" + os.makedirs(os.path.dirname(meta_filename), exist_ok=True) + files = os.listdir(os.path.join("sphinx", "build", "html")) + with open(meta_filename, "w") as f: + f.write("\n".join(files)) + + +if __name__ == "__main__": + make_html_file_list() diff --git a/sphinx/source/conf.py b/sphinx/source/conf.py index 98193c8..cf7d59f 100644 --- a/sphinx/source/conf.py +++ b/sphinx/source/conf.py @@ -4,13 +4,18 @@ # https://www.sphinx-doc.org/en/master/usage/configuration.html import os -import pprint -import sys import shutil -basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'src')) +import sys + +basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src")) sys.path.insert(0, basedir) import torch_pfaffian +_nb_src = os.path.join(os.path.dirname(__file__), "..", "..", "notebooks") +_nb_dst = os.path.join(os.path.dirname(__file__), "notebooks") +if os.path.isdir(_nb_src): + shutil.rmtree(_nb_dst, ignore_errors=True) + shutil.copytree(_nb_src, _nb_dst) _html_folders_formatted = {} _allowed_special_methods = ["__init__", "__call__"] @@ -24,44 +29,44 @@ def skip(app, what, name, obj, would_skip, options): def setup(app): app.connect("autodoc-skip-member", skip) - app.connect('html-page-context', change_pathto) - app.connect('build-finished', move_private_folders) + app.connect("html-page-context", change_pathto) + app.connect("build-finished", move_private_folders) def change_pathto(app, pagename, templatename, context, doctree): """ Replace pathto helper to change paths to folders with a leading underscore. """ - pathto = context.get('pathto') - + pathto = context.get("pathto") + def gh_pathto(otheruri, *args, **kw): - if otheruri.startswith('_'): + if otheruri.startswith("_"): otheruri_fmt = otheruri[1:] _html_folders_formatted[os.path.dirname(otheruri)] = os.path.dirname(otheruri_fmt) else: otheruri_fmt = otheruri return pathto(otheruri_fmt, *args, **kw) - - context['pathto'] = gh_pathto + + context["pathto"] = gh_pathto def move_private_folders(app, e): """ Remove leading underscore from folders in in the output folder. """ - + def join(dir): return os.path.join(app.builder.outdir, dir) - + for item in os.listdir(app.builder.outdir): - if item.startswith('_') and os.path.isdir(join(item)) and item in _html_folders_formatted: + if item.startswith("_") and os.path.isdir(join(item)) and item in _html_folders_formatted: shutil.move(join(item), join(item[1:])) # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information -project = 'torch_pfaffian' +project = "torch_pfaffian" copyright = torch_pfaffian.__copyright__.replace("Copyright ", "") author = torch_pfaffian.__author__ version = torch_pfaffian.__version__ @@ -70,38 +75,41 @@ def join(dir): # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration extensions = [ - 'sphinx.ext.autodoc', - 'sphinx.ext.napoleon', - 'sphinx.ext.githubpages', + "sphinx.ext.autodoc", + "sphinx.ext.napoleon", + "sphinx.ext.githubpages", # 'sphinx_rtd_theme', - 'sphinxcontrib.bibtex', - 'sphinx_mdinclude', - # 'nbsphinx', - 'sphinx.ext.mathjax', + "sphinxcontrib.bibtex", + "sphinx_mdinclude", + "myst_nb", + "sphinx.ext.mathjax", # 'sphinx.ext.mathbase', - 'sphinx.ext.todo', + "sphinx.ext.todo", ] -bibtex_bibfiles = ['references.bib'] +bibtex_bibfiles = ["references.bib"] + +nb_execution_mode = "force" +nb_execution_timeout = 300 -templates_path = ['_templates'] +templates_path = ["_templates"] exclude_patterns = [] # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output -html_theme = 'karma_sphinx_theme' -html_static_path = ['_static'] +html_theme = "karma_sphinx_theme" +html_static_path = ["_static"] # html_css_files = [ # 'css/float_right.css', # ] # mathjax_path = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js" mathjax_path = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" -latex_engine = 'xelatex' +latex_engine = "xelatex" latex_elements = { - 'preamble': r'\usepackage{physics}' - r'\usepackage{mathtools}' - r'\usepackage{amsmath}' - r'\usepackage{nicefrac}' + "preamble": r"\usepackage{physics}" + r"\usepackage{mathtools}" + r"\usepackage{amsmath}" + r"\usepackage{nicefrac}" } diff --git a/sphinx/source/index.rst b/sphinx/source/index.rst index 388f894..360fc34 100644 --- a/sphinx/source/index.rst +++ b/sphinx/source/index.rst @@ -12,6 +12,12 @@ Welcome to 's documentation! readme +.. toctree:: + :maxdepth: 4 + :caption: Tutorials: + + notebooks/strategies_benchmark + .. toctree:: :maxdepth: 4 :caption: Modules: diff --git a/src/torch_pfaffian/__init__.py b/src/torch_pfaffian/__init__.py index 1461dad..53aa80b 100644 --- a/src/torch_pfaffian/__init__.py +++ b/src/torch_pfaffian/__init__.py @@ -1,5 +1,5 @@ """ -Project description. +TorchPfaffian is a Python package for efficiently computing the Pfaffian of skew-symmetric matrices using PyTorch. """ __author__ = "Jérémie Gince" @@ -14,16 +14,13 @@ import torch -warnings.filterwarnings("ignore", category=Warning, module="docutils") -warnings.filterwarnings("ignore", category=Warning, module="sphinx") - from .strategies import * from .utils import get_all_subclasses -pfaffian_strategy_map = { - _cls.NAME.lower().strip(): _cls - for _cls in get_all_subclasses(PfaffianStrategy) -} +warnings.filterwarnings("ignore", category=Warning, module="docutils") +warnings.filterwarnings("ignore", category=Warning, module="sphinx") + +pfaffian_strategy_map = {_cls.NAME.lower().strip(): _cls for _cls in get_all_subclasses(PfaffianStrategy)} def get_pfaffian_function(name: str = PfaffianFDBPf.NAME) -> Callable[[torch.Tensor], torch.Tensor]: @@ -31,4 +28,3 @@ def get_pfaffian_function(name: str = PfaffianFDBPf.NAME) -> Callable[[torch.Ten if name not in pfaffian_strategy_map: raise ValueError(f"Unknown strategy name: {name}. Available strategies: {list(pfaffian_strategy_map.keys())}") return pfaffian_strategy_map[name].apply - diff --git a/src/torch_pfaffian/__main__.py b/src/torch_pfaffian/__main__.py deleted file mode 100644 index 36f5609..0000000 --- a/src/torch_pfaffian/__main__.py +++ /dev/null @@ -1,15 +0,0 @@ -import argparse -import sys - - -def parse_args(): - paser = argparse.ArgumentParser() - return paser.parse_args() - - -def main(): - pass - - -if __name__ == '__main__': - sys.exit(main()) diff --git a/src/torch_pfaffian/py.typed b/src/torch_pfaffian/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/src/torch_pfaffian/strategies/__init__.py b/src/torch_pfaffian/strategies/__init__.py index 983c798..5df968c 100644 --- a/src/torch_pfaffian/strategies/__init__.py +++ b/src/torch_pfaffian/strategies/__init__.py @@ -1,9 +1,8 @@ from typing import Callable + import torch -from .strategy import PfaffianStrategy +from .pfaffian_block_det import PfaffianBlockDet +from .pfaffian_det import PfaffianDet from .pfaffian_fdbpf import PfaffianFDBPf -# from .pfaffian_block_det import PfaffianBlockDet -# from .pfaffian_perm import PfaffianPerm - - +from .strategy import PfaffianStrategy diff --git a/src/torch_pfaffian/strategies/pfaffian_block_det.py b/src/torch_pfaffian/strategies/pfaffian_block_det.py index 0768598..526bd59 100644 --- a/src/torch_pfaffian/strategies/pfaffian_block_det.py +++ b/src/torch_pfaffian/strategies/pfaffian_block_det.py @@ -1,5 +1,7 @@ -from typing import Any +from typing import cast + import torch + from .strategy import PfaffianStrategy @@ -10,6 +12,7 @@ class PfaffianBlockDet(PfaffianStrategy): The input matrix is considered to be a skew-symmetric matrix. """ + NAME = "PfaffianBlockDet" @staticmethod @@ -22,24 +25,31 @@ def forward(matrix: torch.Tensor): # take the upper right block of shape (..., N, N) of the input matrix n = matrix.shape[-1] // 2 sub_matrix = matrix[..., :n, n:] - pf = (-1)**(n*(n-1)//2) * torch.linalg.det(sub_matrix) + pf = (-1) ** (n * (n - 1) // 2) * torch.linalg.det(sub_matrix) return pf @staticmethod - def backward(ctx: torch.autograd.function.FunctionCtx, grad_output): + def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output): r""" + Compute the gradient of the Pfaffian with respect to the full input matrix. - ..math: - \frac{\partial \text{pf}(A)}{\partial A_{ij}} = \frac{\text{pf}(A)}{2} A^{-1}_{ji} + The forward depends only on the upper-right block ``block = matrix[..., :n, n:]`` through + ``pf = c * det(block)``. By Jacobi's formula ``d det(block) / d block = det(block) * (block^{-1})^T``, + so ``d pf / d block = pf * (block^{-1})^T``. The gradient is therefore zero everywhere except in + the upper-right block. - :param ctx: Context - :param grad_output: Gradient of the output - :return: Gradient of the input + :param ctx: Context holding the saved input matrix and the forward Pfaffian. + :param grad_output: Gradient of the output with respect to the loss. + :return: Gradient of the input matrix, or ``None`` when the input does not require grad. + :rtype: torch.Tensor | None """ - matrix, pf = ctx.saved_tensors + matrix, pf = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) grad_matrix = None if ctx.needs_input_grad[0]: - grad_matrix = torch.einsum('...,...ij->...ji', 0.5 * grad_output * pf, torch.linalg.pinv(matrix)) + n = matrix.shape[-1] // 2 + sub_matrix = matrix[..., :n, n:] # (..., n, n) upper-right block + inverse_transpose = torch.linalg.inv(sub_matrix).transpose(-1, -2) + grad_block = grad_output[..., None, None] * pf[..., None, None] * inverse_transpose + grad_matrix = torch.zeros_like(matrix) + grad_matrix[..., :n, n:] = grad_block return grad_matrix - - diff --git a/src/torch_pfaffian/strategies/pfaffian_det.py b/src/torch_pfaffian/strategies/pfaffian_det.py new file mode 100644 index 0000000..7051779 --- /dev/null +++ b/src/torch_pfaffian/strategies/pfaffian_det.py @@ -0,0 +1,21 @@ +import torch + +from .strategy import PfaffianStrategy + + +class PfaffianDet(PfaffianStrategy): + """ + Compute the Pfaffian as ``pf = sqrt(|det(A)|)`` and rely on autograd for the backward pass. + + The other strategies are full ``torch.autograd.Function`` implementations with a custom analytic + backward. This strategy instead differentiates straight through ``det`` and ``sqrt`` with PyTorch + autograd, so it overrides :meth:`apply` to bypass the ``torch.autograd.Function`` machinery. The + radicand is clamped to ``EPSILON`` for numerical stability, matching the other determinant-based + strategy. + """ + + NAME = "PfaffianDet" + + @staticmethod + def apply(matrix: torch.Tensor) -> torch.Tensor: + return torch.sqrt(torch.clamp(torch.abs(torch.linalg.det(matrix)), min=PfaffianStrategy.EPSILON)) diff --git a/src/torch_pfaffian/strategies/pfaffian_fdbpf.py b/src/torch_pfaffian/strategies/pfaffian_fdbpf.py index 1ab2b3f..1695251 100644 --- a/src/torch_pfaffian/strategies/pfaffian_fdbpf.py +++ b/src/torch_pfaffian/strategies/pfaffian_fdbpf.py @@ -1,5 +1,7 @@ -from typing import Any +from typing import cast + import torch + from .strategy import PfaffianStrategy @@ -8,6 +10,7 @@ class PfaffianFDBPf(PfaffianStrategy): This class implements the Pfaffian using the determinant of the matrix for the forward pass and the derivative of the Pfaffian with respect to the input matrix for the backward pass. """ + NAME = "PfaffianFDBPf" @staticmethod @@ -16,11 +19,11 @@ def forward(matrix: torch.Tensor): if _2n % 2 != 0: return torch.zeros_like(matrix[..., 0, 0]) det = torch.linalg.det(matrix) - pf = torch.sqrt(torch.abs(det) + PfaffianFDBPf.EPSILON) + pf = torch.sqrt(torch.clamp(torch.abs(det), min=PfaffianFDBPf.EPSILON)) return pf @staticmethod - def backward(ctx: torch.autograd.function.FunctionCtx, grad_output): + def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output): r""" ..math: @@ -30,10 +33,8 @@ def backward(ctx: torch.autograd.function.FunctionCtx, grad_output): :param grad_output: Gradient of the output :return: Gradient of the input """ - matrix, pf = ctx.saved_tensors + matrix, pf = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) grad_matrix = None if ctx.needs_input_grad[0]: - grad_matrix = torch.einsum('...,...ij->...ji', 0.5 * grad_output * pf, torch.linalg.pinv(matrix)) + grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pf, torch.linalg.pinv(matrix)) return grad_matrix - - diff --git a/src/torch_pfaffian/strategies/strategy.py b/src/torch_pfaffian/strategies/strategy.py index ff5b03f..7723d9f 100644 --- a/src/torch_pfaffian/strategies/strategy.py +++ b/src/torch_pfaffian/strategies/strategy.py @@ -1,14 +1,13 @@ -from abc import ABC, abstractmethod import torch class PfaffianStrategy(torch.autograd.Function): - EPSILON = 1e-12 + EPSILON = 1e-30 NAME = "PfaffianStrategy" @staticmethod def setup_context(ctx: torch.autograd.function.FunctionCtx, inputs, output): - matrix, = inputs + (matrix,) = inputs pf = output ctx.save_for_backward(matrix, pf) @@ -17,7 +16,5 @@ def forward(matrix: torch.Tensor): pass @staticmethod - def backward(ctx: torch.autograd.function.FunctionCtx, grad_output): + def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output): pass - - diff --git a/tests/__init__.py b/tests/__init__.py index 15102d4..bac659d 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,13 +1,6 @@ -import pytest import numpy as np +import pytest + from .configs import TEST_SEED np.random.seed(TEST_SEED) - - -def get_slow_test_mark(): - from .configs import RUN_SLOW_TESTS - return pytest.mark.skipif( - not RUN_SLOW_TESTS, - reason=f"Only run when configs.{RUN_SLOW_TESTS} is True.", - ) diff --git a/tests/configs.py b/tests/configs.py index 2217dab..b2a9393 100644 --- a/tests/configs.py +++ b/tests/configs.py @@ -1,4 +1,3 @@ - N_RANDOM_TESTS_PER_CASE = 10 TEST_SEED = 42 @@ -14,8 +13,6 @@ ATOL_SHAPE_COMPARISON = 0 RTOL_SHAPE_COMPARISON = 0 -RUN_SLOW_TESTS = True - def set_seed(seed: int = TEST_SEED): import numpy as np diff --git a/tests/conftest.py b/tests/conftest.py index 8cf7624..e69de29 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,45 +0,0 @@ -import pytest -from .configs import RUN_SLOW_TESTS - -RUN_SLOW_ARG_NAME = "run_slow" - - -@pytest.hookimpl() -def pytest_sessionstart(session): - pass - - -# @pytest.hookimpl() -# def pytest_sessionfinish(session, exitstatus): -# reporter = session.config.pluginmanager.get_plugin('terminalreporter') -# print('passed amount:', len(reporter.stats['passed'])) - - -def pytest_addoption(parser): - r""" - Add options to the pytest command. - - See: https://jwodder.github.io/kbits/posts/pytest-mark-off/. - - :param parser: The pytest parser. - :return: None - """ - parser.addoption( - f"--{RUN_SLOW_ARG_NAME}", - action="store_true", - default=RUN_SLOW_TESTS, - help="Run slow tests", - ) - - -def pytest_collection_modifyitems(config, items): - if config.getoption(f"--{RUN_SLOW_ARG_NAME}"): - # if RUN_SLOW_TESTS: - # print("Running slow tests") - pass - else: - # print("Skipping slow tests") - skipper = pytest.mark.skip(reason=f"Only run when '--{RUN_SLOW_ARG_NAME}=True' is given") - for item in items: - if "slow" in item.keywords: - item.add_marker(skipper) diff --git a/tests/test_strategies/__init__.py b/tests/test_strategies/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_strategies/test_pfaffian_block_det.py b/tests/test_strategies/test_pfaffian_block_det.py new file mode 100644 index 0000000..c819f12 --- /dev/null +++ b/tests/test_strategies/test_pfaffian_block_det.py @@ -0,0 +1,82 @@ +import numpy as np +import pytest +import torch +from torch.autograd import gradcheck + +from tests.configs import ( + ATOL_APPROX_COMPARISON, + ATOL_MATRIX_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_MATRIX_COMPARISON, + TEST_SEED, +) +from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet + +_RNG = np.random.default_rng(TEST_SEED) +_BLOCK_SIZES = [1, 2, 3, 4] +_RANDOM_BLOCKS = [_RNG.random((size, size)) for size in _BLOCK_SIZES for _ in range(N_RANDOM_TESTS_PER_CASE)] + + +def _block_antidiagonal(block: np.ndarray) -> torch.Tensor: + # Build the skew-symmetric matrix [[0, block], [-block^T, 0]] that PfaffianBlockDet targets. + zero = np.zeros_like(block) + top = np.concatenate([zero, block], axis=-1) + bottom = np.concatenate([-np.einsum("...ij->...ji", block), zero], axis=-1) + return torch.tensor(np.concatenate([top, bottom], axis=-2)) + + +def _well_conditioned_blocks(sizes: list[int], count: int, min_abs_det: float = 0.1) -> list[np.ndarray]: + # The gradient relies on the inverse of the upper-right block, which is unstable for near-singular + # blocks, so the gradcheck inputs are restricted to blocks whose determinant is away from zero. + blocks = [] + for size in sizes: + kept = 0 + while kept < count: + candidate = _RNG.random((size, size)) + if np.abs(np.linalg.det(candidate)) > min_abs_det: + blocks.append(candidate) + kept += 1 + return blocks + + +_GRADCHECK_BLOCKS = _well_conditioned_blocks(_BLOCK_SIZES, N_RANDOM_TESTS_PER_CASE) + + +class TestPfaffianBlockDet: + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_square_of_pfaffian_matches_determinant(self, block): + matrix = _block_antidiagonal(block) + pfaffian = PfaffianBlockDet.apply(matrix) + determinant = torch.linalg.det(matrix) + torch.testing.assert_close(pfaffian**2, determinant, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_forward_supports_batched_input(self): + matrix = _block_antidiagonal(_RNG.random((5, 3, 3))) + pfaffian = PfaffianBlockDet.apply(matrix) + assert pfaffian.shape == matrix.shape[:-2] + torch.testing.assert_close( + pfaffian**2, torch.linalg.det(matrix), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) + def test_forward_preserves_dtype(self, dtype): + matrix = _block_antidiagonal(_RNG.random((3, 3))).to(dtype) + assert PfaffianBlockDet.apply(matrix).dtype == dtype + + @pytest.mark.parametrize("block", _GRADCHECK_BLOCKS) + def test_backward_passes_gradcheck(self, block): + matrix = _block_antidiagonal(block).to(torch.float64).requires_grad_(True) + assert gradcheck( + PfaffianBlockDet.apply, (matrix,), eps=1e-6, atol=ATOL_APPROX_COMPARISON, rtol=RTOL_APPROX_COMPARISON + ) + + def test_backward_returns_none_when_input_does_not_require_grad(self): + matrix = _block_antidiagonal(_RNG.random((4, 4))) + pfaffian = PfaffianBlockDet.apply(matrix) + + class _Context: + saved_tensors = (matrix, pfaffian) + needs_input_grad = (False,) + + assert PfaffianBlockDet.backward(_Context(), torch.ones_like(pfaffian)) is None diff --git a/tests/test_strategies/test_pfaffian_det.py b/tests/test_strategies/test_pfaffian_det.py new file mode 100644 index 0000000..137821b --- /dev/null +++ b/tests/test_strategies/test_pfaffian_det.py @@ -0,0 +1,78 @@ +import numpy as np +import pytest +import torch +from torch.autograd import gradcheck + +from tests.configs import ( + ATOL_APPROX_COMPARISON, + ATOL_MATRIX_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_MATRIX_COMPARISON, + TEST_SEED, +) +from torch_pfaffian.strategies.pfaffian_det import PfaffianDet +from torch_pfaffian.strategies.pfaffian_fdbpf import PfaffianFDBPf + +_RNG = np.random.default_rng(TEST_SEED) + + +def _skew(matrix: np.ndarray) -> np.ndarray: + return matrix - np.einsum("...ij->...ji", matrix) + + +def _well_conditioned_skew_matrices(shapes: list[tuple[int, ...]], count: int, min_abs_det: float = 0.1): + matrices = [] + for shape in shapes: + kept = 0 + while kept < count: + candidate = _skew(_RNG.random(shape)) + if np.all(np.abs(np.linalg.det(candidate)) > min_abs_det): + matrices.append(candidate) + kept += 1 + return matrices + + +_FORWARD_MATRICES = [ + _skew(_RNG.random(shape)) for shape in [(8, 8), (16, 6, 6)] for _ in range(N_RANDOM_TESTS_PER_CASE) +] +_GRADCHECK_MATRICES = _well_conditioned_skew_matrices([(4, 4), (6, 6), (8, 4, 4)], N_RANDOM_TESTS_PER_CASE) + + +class TestPfaffianDet: + @pytest.mark.parametrize("skew_matrix", _FORWARD_MATRICES) + def test_forward_square_of_pfaffian_matches_determinant(self, skew_matrix): + skew_tensor = torch.tensor(skew_matrix) + pfaffian = PfaffianDet.apply(skew_tensor) + determinant = torch.linalg.det(skew_tensor) + torch.testing.assert_close(pfaffian**2, determinant, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + @pytest.mark.parametrize("skew_matrix", _FORWARD_MATRICES) + def test_forward_matches_fdbpf(self, skew_matrix): + skew_tensor = torch.tensor(skew_matrix) + torch.testing.assert_close( + PfaffianDet.apply(skew_tensor), + PfaffianFDBPf.apply(skew_tensor), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) + + @pytest.mark.parametrize("skew_matrix", _GRADCHECK_MATRICES) + def test_backward_passes_gradcheck(self, skew_matrix): + skew_tensor = torch.tensor(skew_matrix, requires_grad=True) + assert gradcheck( + PfaffianDet.apply, (skew_tensor,), eps=1e-6, atol=ATOL_APPROX_COMPARISON, rtol=RTOL_APPROX_COMPARISON + ) + + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) + def test_forward_preserves_dtype(self, dtype): + matrix = torch.tensor(_skew(_RNG.random((6, 6))), dtype=dtype) + assert PfaffianDet.apply(matrix).dtype == dtype + + def test_forward_supports_batched_input(self): + batched_matrix = torch.tensor(_skew(_RNG.random((5, 6, 6)))) + pfaffian = PfaffianDet.apply(batched_matrix) + assert pfaffian.shape == batched_matrix.shape[:-2] + torch.testing.assert_close( + pfaffian**2, torch.linalg.det(batched_matrix), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) diff --git a/tests/test_strategies/test_pfaffian_fdbpf.py b/tests/test_strategies/test_pfaffian_fdbpf.py new file mode 100644 index 0000000..3f7246f --- /dev/null +++ b/tests/test_strategies/test_pfaffian_fdbpf.py @@ -0,0 +1,103 @@ +import numpy as np +import pytest +import torch +from torch.autograd import gradcheck + +from tests.configs import ( + ATOL_APPROX_COMPARISON, + ATOL_MATRIX_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_MATRIX_COMPARISON, + TEST_SEED, +) +from torch_pfaffian.strategies.pfaffian_fdbpf import PfaffianFDBPf + +_RNG = np.random.default_rng(TEST_SEED) + + +def _skew(matrix: np.ndarray) -> np.ndarray: + return matrix - np.einsum("...ij->...ji", matrix) + + +def _random_skew_matrices(shapes: list[tuple[int, ...]], count: int) -> list[np.ndarray]: + return [_skew(_RNG.random(shape)) for shape in shapes for _ in range(count)] + + +def _well_conditioned_skew_matrices(shapes: list[tuple[int, ...]], count: int, min_abs_det: float = 0.1): + # The gradient relies on the (pseudo)inverse, which is unstable for near-singular matrices, so the + # gradcheck inputs are restricted to skew matrices whose determinant is comfortably away from zero. + matrices = [] + for shape in shapes: + kept = 0 + while kept < count: + candidate = _skew(_RNG.random(shape)) + if np.all(np.abs(np.linalg.det(candidate)) > min_abs_det): + matrices.append(candidate) + kept += 1 + return matrices + + +_FORWARD_MATRICES = _random_skew_matrices([(8, 8), (16, 6, 6), (18, 10, 10)], N_RANDOM_TESTS_PER_CASE) +_GRADCHECK_MATRICES = _well_conditioned_skew_matrices([(4, 4), (6, 6), (8, 4, 4)], N_RANDOM_TESTS_PER_CASE) + + +class TestPfaffianFDBPf: + @pytest.mark.parametrize("skew_matrix", _FORWARD_MATRICES) + def test_forward_square_of_pfaffian_matches_determinant(self, skew_matrix): + skew_tensor = torch.tensor(skew_matrix) + pfaffian = PfaffianFDBPf.apply(skew_tensor) + determinant = torch.linalg.det(skew_tensor) + torch.testing.assert_close(pfaffian**2, determinant, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + @pytest.mark.parametrize("skew_matrix", _GRADCHECK_MATRICES) + def test_backward_passes_gradcheck(self, skew_matrix): + skew_tensor = torch.tensor(skew_matrix, requires_grad=True) + assert gradcheck( + PfaffianFDBPf.apply, (skew_tensor,), eps=1e-6, atol=ATOL_APPROX_COMPARISON, rtol=RTOL_APPROX_COMPARISON + ) + + def test_forward_matches_known_pfaffian_magnitude(self): + # For the 2x2 skew matrix [[0, a], [-a, 0]] the Pfaffian is a, so its magnitude is |a|. + value = 0.7 + matrix = torch.tensor([[0.0, value], [-value, 0.0]], dtype=torch.float64) + pfaffian = PfaffianFDBPf.apply(matrix) + expected = torch.tensor(abs(value), dtype=torch.float64) + torch.testing.assert_close(pfaffian, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_forward_returns_absolute_value_so_sign_is_not_recovered(self): + # The strategy computes |pf| via sqrt(|det|); the true Pfaffian of [[0, -a], [a, 0]] is -a, + # but the strategy returns +|a|. + value = 0.7 + matrix = torch.tensor([[0.0, -value], [value, 0.0]], dtype=torch.float64) + pfaffian = PfaffianFDBPf.apply(matrix) + expected = torch.tensor(abs(value), dtype=torch.float64) + torch.testing.assert_close(pfaffian, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) + def test_forward_preserves_dtype(self, dtype): + matrix = torch.tensor(_skew(_RNG.random((6, 6))), dtype=dtype) + assert PfaffianFDBPf.apply(matrix).dtype == dtype + + def test_forward_supports_batched_input(self): + batched_matrix = torch.tensor(_skew(_RNG.random((5, 6, 6)))) + pfaffian = PfaffianFDBPf.apply(batched_matrix) + assert pfaffian.shape == batched_matrix.shape[:-2] + torch.testing.assert_close( + pfaffian**2, torch.linalg.det(batched_matrix), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + + def test_forward_returns_zero_for_odd_dimension(self): + odd_matrix = torch.tensor(_skew(_RNG.random((3, 3)))) + pfaffian = PfaffianFDBPf.apply(odd_matrix) + torch.testing.assert_close(pfaffian, torch.zeros_like(odd_matrix[..., 0, 0])) + + def test_backward_returns_none_when_input_does_not_require_grad(self): + matrix = torch.tensor(_skew(_RNG.random((4, 4)))) + pfaffian = PfaffianFDBPf.apply(matrix) + + class _Context: + saved_tensors = (matrix, pfaffian) + needs_input_grad = (False,) + + assert PfaffianFDBPf.backward(_Context(), torch.ones_like(pfaffian)) is None diff --git a/tests/test_strategies/test_strategy.py b/tests/test_strategies/test_strategy.py new file mode 100644 index 0000000..2ae0e93 --- /dev/null +++ b/tests/test_strategies/test_strategy.py @@ -0,0 +1,28 @@ +import torch + +from torch_pfaffian.strategies.strategy import PfaffianStrategy + + +class _RecordingContext: + def save_for_backward(self, *tensors): + self.saved_tensors = tensors + + +class TestPfaffianStrategy: + def test_class_attributes(self): + assert PfaffianStrategy.NAME == "PfaffianStrategy" + assert PfaffianStrategy.EPSILON == 1e-30 + + def test_setup_context_saves_inputs_and_output(self): + matrix = torch.eye(2, dtype=torch.float64) + pfaffian = torch.tensor(1.0, dtype=torch.float64) + context = _RecordingContext() + PfaffianStrategy.setup_context(context, (matrix,), pfaffian) + assert context.saved_tensors[0] is matrix + assert context.saved_tensors[1] is pfaffian + + def test_base_forward_is_not_implemented(self): + assert PfaffianStrategy.forward(torch.eye(2, dtype=torch.float64)) is None + + def test_base_backward_is_not_implemented(self): + assert PfaffianStrategy.backward(None, None) is None diff --git a/tests/test_torch_pfaffian.py b/tests/test_torch_pfaffian.py index d39f328..dcbea59 100644 --- a/tests/test_torch_pfaffian.py +++ b/tests/test_torch_pfaffian.py @@ -1,69 +1,32 @@ -import numpy as np import pytest - -from .configs import ( - N_RANDOM_TESTS_PER_CASE, - TEST_SEED, - ATOL_APPROX_COMPARISON, - RTOL_APPROX_COMPARISON, - set_seed, -) import torch -from torch_pfaffian import pfaffian_strategy_map, get_pfaffian_function -from torch.autograd import gradcheck -set_seed(TEST_SEED) +from torch_pfaffian import get_pfaffian_function, pfaffian_strategy_map +from torch_pfaffian.strategies import PfaffianDet, PfaffianFDBPf -@pytest.mark.parametrize( - "matrix, function_name", - [ - (np.random.rand(*shape), function_name) - for shape in [ - (8, 8), - (16, 6, 6), - (18, 10, 10), - ] - for _ in range(N_RANDOM_TESTS_PER_CASE) - for function_name in pfaffian_strategy_map.keys() - ] -) -def test_torch_pfaffian_gradcheck(matrix, function_name): - func = get_pfaffian_function(function_name) - skew_matrix = matrix - np.einsum("...ij->...ji", matrix) - skew_tensor = torch.tensor(skew_matrix, requires_grad=True) - assert gradcheck( - func, (skew_tensor,), - eps=1e-3, - atol=ATOL_APPROX_COMPARISON, - rtol=RTOL_APPROX_COMPARISON - ) +class TestTorchPfaffian: + def test_pfaffian_strategy_map_contains_registered_strategies(self): + assert PfaffianFDBPf.NAME.lower().strip() in pfaffian_strategy_map + assert PfaffianDet.NAME.lower().strip() in pfaffian_strategy_map + assert all(issubclass(cls, PfaffianFDBPf.__bases__[0]) for cls in pfaffian_strategy_map.values()) + def test_get_pfaffian_function_returns_apply_of_registered_strategy(self): + function = get_pfaffian_function(PfaffianFDBPf.NAME) + assert function == PfaffianFDBPf.apply -@pytest.mark.parametrize( - "matrix, function_name", - [ - (np.random.rand(*shape), function_name) - for shape in [ - (8, 8), - (16, 6, 6), - (18, 10, 10), - ] - for _ in range(N_RANDOM_TESTS_PER_CASE) - for function_name in pfaffian_strategy_map.keys() - ] -) -def test_torch_pfaffian_forward_against_det(matrix, function_name): - func = get_pfaffian_function(function_name) - skew_matrix = matrix - np.einsum("...ij->...ji", matrix) - skew_tensor = torch.tensor(skew_matrix, requires_grad=True) + def test_get_pfaffian_function_dispatches_to_pfaffian_det(self): + assert get_pfaffian_function(PfaffianDet.NAME) == PfaffianDet.apply - pf = func(skew_tensor) - det = torch.linalg.det(skew_tensor) + def test_get_pfaffian_function_default_name_is_callable(self): + function = get_pfaffian_function() + matrix = torch.tensor([[0.0, 1.0], [-1.0, 0.0]], dtype=torch.float64) + torch.testing.assert_close(function(matrix), matrix[..., 0, 1]) - assert torch.allclose( - pf ** 2, det, - atol=ATOL_APPROX_COMPARISON, - rtol=RTOL_APPROX_COMPARISON - ) + def test_get_pfaffian_function_is_case_and_whitespace_insensitive(self): + function = get_pfaffian_function(f" {PfaffianFDBPf.NAME.upper()} ") + assert function == PfaffianFDBPf.apply + def test_get_pfaffian_function_unknown_name_raises_value_error(self): + with pytest.raises(ValueError, match="Unknown strategy name"): + get_pfaffian_function("not_a_real_strategy") diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..16f8505 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,30 @@ +from torch_pfaffian.utils import get_all_subclasses + + +class TestUtils: + def test_get_all_subclasses_returns_empty_for_leaf(self): + class Leaf: + pass + + assert get_all_subclasses(Leaf) == [] + + def test_get_all_subclasses_returns_direct_subclasses(self): + class Base: + pass + + class Child(Base): + pass + + assert get_all_subclasses(Base) == [Child] + + def test_get_all_subclasses_returns_nested_subclasses(self): + class Base: + pass + + class Child(Base): + pass + + class GrandChild(Child): + pass + + assert set(get_all_subclasses(Base)) == {Child, GrandChild} diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..55df965 --- /dev/null +++ b/uv.lock @@ -0,0 +1,4379 @@ +version = 1 +revision = 3 +requires-python = ">=3.10, <3.15" +resolution-markers = [ + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +conflicts = [[ + { package = "torchpfaffian", extra = "cpu" }, + { package = "torchpfaffian", extra = "cu128" }, + { package = "torchpfaffian", extra = "cu130" }, +]] + +[[package]] +name = "alabaster" +version = "0.7.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c9/3e/13dd8e5ed9094e734ac430b5d0eb4f2bb001708a8b7856cbf8e084e001ba/alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65", size = 23776, upload-time = "2024-01-10T00:56:10.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/34/d4e1c02d3bee589efb5dfa17f88ea08bdb3e3eac12bc475462aec52ed223/alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92", size = 13511, upload-time = "2024-01-10T00:56:08.388Z" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, +] + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + +[[package]] +name = "babel" +version = "2.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" }, +] + +[[package]] +name = "backports-tarfile" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406, upload-time = "2024-05-28T17:01:54.731Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/c6/92fcd42f1ba33e1184263f25bfabf3d27c383410470f169e4b8163bf9c17/beautifulsoup4-4.15.0-py3-none-any.whl", hash = "sha256:d6f88de62e1d4e38ecb1077eb9724cd0eff29d2a08ca16a401e9b9e93f117cf9", size = 109924, upload-time = "2026-06-07T16:44:21.566Z" }, +] + +[[package]] +name = "bleach" +version = "6.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/3c/e12ac860709702bd5ebeb9b56a4fe334f1001246ee1b8f2b7ee28912df7d/bleach-6.4.0.tar.gz", hash = "sha256:4202482733d85cedd04e59fcb2f89f4e4c7c385a78d3c3c23c30446843a37452", size = 204857, upload-time = "2026-06-05T13:01:13.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/9d/40b6267367182187139a4000b82a3b287d84d745bccd808e75d916920e9d/bleach-6.4.0-py3-none-any.whl", hash = "sha256:4b6b6a54fff2e69a3dde9d21cc6301220bee3c3cb792187d11403fd795031081", size = 165109, upload-time = "2026-06-05T13:01:12.504Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "build" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "(os_name == 'nt' and sys_platform != 'darwin') or (os_name == 'nt' and extra != 'extra-13-torchpfaffian-cpu') or (os_name != 'nt' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (os_name != 'nt' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (os_name != 'nt' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10.2' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "packaging" }, + { name = "pyproject-hooks" }, + { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/e0/df5e171f685f82f37b12e1f208064e24244911079d7b767447d1af7e0d70/build-1.5.0.tar.gz", hash = "sha256:302c22c3ba2a0fd5f3911918651341ebb3896176cbdec15bd421f80b1afc7647", size = 89796, upload-time = "2026-04-30T03:18:25.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/fe/6bea5c9162869c5beba5d9c8abbed835ec85bf1ec1fba05a3822325c45f3/build-1.5.0-py3-none-any.whl", hash = "sha256:13f3eecb844759ab66efec90ca17639bbf14dc06cb2fdf37a9010322d9c50a6f", size = 26018, upload-time = "2026-04-30T03:18:23.644Z" }, +] + +[[package]] +name = "certifi" +version = "2026.5.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/ce/ee2ecad540810a79593028e88299baeae54d346cc7a0d94b6199988b89b1/certifi-2026.5.20.tar.gz", hash = "sha256:69dea482ab64caa7b9f6aba1c6bf48bb6a5448d1c0f1b17ab42ad8c763a5344d", size = 135422, upload-time = "2026-05-20T11:46:50.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/59/8c/57e832b7af6d7c5abe66eb3fbe3a3a32f4d11ea23a1aa7131371035be991/certifi-2026.5.20-py3-none-any.whl", hash = "sha256:3c52e209ba0a4ad7aebe60436a4ab349c39e1e602e8c134221e546902ad25897", size = 134134, upload-time = "2026-05-20T11:46:48.578Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" }, + { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" }, + { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" }, + { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" }, + { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" }, + { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" }, + { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" }, + { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" }, + { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" }, + { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" }, + { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" }, + { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" }, + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "cfgv" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/08/0f303cb0b529e456bb116f2d50565a482694fbb94340bf56d44677e7ed03/charset_normalizer-3.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cdd68a1fb318e290a2077696b7eb7a21a49163c455979c639bf5a5dcdc46617d", size = 315182, upload-time = "2026-04-02T09:25:40.673Z" }, + { url = "https://files.pythonhosted.org/packages/24/47/b192933e94b546f1b1fe4df9cc1f84fcdbf2359f8d1081d46dd029b50207/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e17b8d5d6a8c47c85e68ca8379def1303fd360c3e22093a807cd34a71cd082b8", size = 209329, upload-time = "2026-04-02T09:25:42.354Z" }, + { url = "https://files.pythonhosted.org/packages/c2/b4/01fa81c5ca6141024d89a8fc15968002b71da7f825dd14113207113fabbd/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:511ef87c8aec0783e08ac18565a16d435372bc1ac25a91e6ac7f5ef2b0bff790", size = 231230, upload-time = "2026-04-02T09:25:44.281Z" }, + { url = "https://files.pythonhosted.org/packages/20/f7/7b991776844dfa058017e600e6e55ff01984a063290ca5622c0b63162f68/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:007d05ec7321d12a40227aae9e2bc6dca73f3cb21058999a1df9e193555a9dcc", size = 225890, upload-time = "2026-04-02T09:25:45.475Z" }, + { url = "https://files.pythonhosted.org/packages/20/e7/bed0024a0f4ab0c8a9c64d4445f39b30c99bd1acd228291959e3de664247/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf29836da5119f3c8a8a70667b0ef5fdca3bb12f80fd06487cfa575b3909b393", size = 216930, upload-time = "2026-04-02T09:25:46.58Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ab/b18f0ab31cdd7b3ddb8bb76c4a414aeb8160c9810fdf1bc62f269a539d87/charset_normalizer-3.4.7-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:12d8baf840cc7889b37c7c770f478adea7adce3dcb3944d02ec87508e2dcf153", size = 202109, upload-time = "2026-04-02T09:25:48.031Z" }, + { url = "https://files.pythonhosted.org/packages/82/e5/7e9440768a06dfb3075936490cb82dbf0ee20a133bf0dd8551fa096914ec/charset_normalizer-3.4.7-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d560742f3c0d62afaccf9f41fe485ed69bd7661a241f86a3ef0f0fb8b1a397af", size = 214684, upload-time = "2026-04-02T09:25:49.245Z" }, + { url = "https://files.pythonhosted.org/packages/71/94/8c61d8da9f062fdf457c80acfa25060ec22bf1d34bbeaca4350f13bcfd07/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b14b2d9dac08e28bb8046a1a0434b1750eb221c8f5b87a68f4fa11a6f97b5e34", size = 212785, upload-time = "2026-04-02T09:25:50.671Z" }, + { url = "https://files.pythonhosted.org/packages/66/cd/6e9889c648e72c0ab2e5967528bb83508f354d706637bc7097190c874e13/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:bc17a677b21b3502a21f66a8cc64f5bfad4df8a0b8434d661666f8ce90ac3af1", size = 203055, upload-time = "2026-04-02T09:25:51.802Z" }, + { url = "https://files.pythonhosted.org/packages/92/2e/7a951d6a08aefb7eb8e1b54cdfb580b1365afdd9dd484dc4bee9e5d8f258/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:750e02e074872a3fad7f233b47734166440af3cdea0add3e95163110816d6752", size = 232502, upload-time = "2026-04-02T09:25:53.388Z" }, + { url = "https://files.pythonhosted.org/packages/58/d5/abcf2d83bf8e0a1286df55cd0dc1d49af0da4282aa77e986df343e7de124/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:4e5163c14bffd570ef2affbfdd77bba66383890797df43dc8b4cc7d6f500bf53", size = 214295, upload-time = "2026-04-02T09:25:54.765Z" }, + { url = "https://files.pythonhosted.org/packages/47/3a/7d4cd7ed54be99973a0dc176032cba5cb1f258082c31fa6df35cff46acfc/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6ed74185b2db44f41ef35fd1617c5888e59792da9bbc9190d6c7300617182616", size = 227145, upload-time = "2026-04-02T09:25:55.904Z" }, + { url = "https://files.pythonhosted.org/packages/1d/98/3a45bf8247889cf28262ebd3d0872edff11565b2a1e3064ccb132db3fbb0/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:94e1885b270625a9a828c9793b4d52a64445299baa1fea5a173bf1d3dd9a1a5a", size = 218884, upload-time = "2026-04-02T09:25:57.074Z" }, + { url = "https://files.pythonhosted.org/packages/ad/80/2e8b7f8915ed5c9ef13aa828d82738e33888c485b65ebf744d615040c7ea/charset_normalizer-3.4.7-cp310-cp310-win32.whl", hash = "sha256:6785f414ae0f3c733c437e0f3929197934f526d19dfaa75e18fdb4f94c6fb374", size = 148343, upload-time = "2026-04-02T09:25:58.199Z" }, + { url = "https://files.pythonhosted.org/packages/35/1b/3b8c8c77184af465ee9ad88b5aea46ea6b2e1f7b9dc9502891e37af21e30/charset_normalizer-3.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:6696b7688f54f5af4462118f0bfa7c1621eeb87154f77fa04b9295ce7a8f2943", size = 159174, upload-time = "2026-04-02T09:25:59.322Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/feb40dca40dbb21e0a908801782d9288c64fc8d8e562c2098e9994c8c21b/charset_normalizer-3.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:66671f93accb62ed07da56613636f3641f1a12c13046ce91ffc923721f23c008", size = 147805, upload-time = "2026-04-02T09:26:00.756Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" }, + { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" }, + { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" }, + { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" }, + { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" }, + { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" }, + { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" }, + { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" }, + { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" }, + { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" }, + { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" }, + { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" }, + { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" }, + { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" }, + { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" }, + { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" }, + { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" }, + { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" }, + { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" }, + { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" }, + { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" }, + { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" }, + { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" }, + { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" }, + { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" }, + { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" }, + { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" }, + { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" }, + { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" }, + { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" }, + { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" }, + { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" }, + { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" }, + { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" }, + { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" }, + { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" }, + { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" }, + { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" }, + { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" }, + { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" }, + { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" }, + { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" }, + { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" }, + { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" }, + { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" }, + { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" }, + { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" }, + { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" }, + { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" }, + { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" }, + { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" }, +] + +[[package]] +name = "click" +version = "8.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" }, + { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" }, + { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" }, + { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" }, + { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" }, + { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" }, + { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" }, + { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" }, + { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" }, + { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload-time = "2025-04-15T17:35:54.473Z" }, + { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload-time = "2025-04-15T17:35:58.283Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload-time = "2025-04-15T17:36:03.235Z" }, + { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload-time = "2025-04-15T17:36:08.275Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload-time = "2025-04-15T17:36:13.29Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload-time = "2025-04-15T17:36:18.329Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload-time = "2025-04-15T17:36:33.878Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload-time = "2025-04-15T17:36:51.295Z" }, + { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload-time = "2025-04-15T17:36:55.002Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload-time = "2025-04-15T17:36:58.576Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/44785876384eff370c251d58fd65f6ad7f39adce4a093c934d4a67a7c6b6/contourpy-1.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4caf2bcd2969402bf77edc4cb6034c7dd7c0803213b3523f111eb7460a51b8d2", size = 271580, upload-time = "2025-04-15T17:37:03.105Z" }, + { url = "https://files.pythonhosted.org/packages/93/3b/0004767622a9826ea3d95f0e9d98cd8729015768075d61f9fea8eeca42a8/contourpy-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:82199cb78276249796419fe36b7386bd8d2cc3f28b3bc19fe2454fe2e26c4c15", size = 255530, upload-time = "2025-04-15T17:37:07.026Z" }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7bd49e1f4fa805772d9fd130e0d375554ebc771ed7172f48dfcd4ca61549/contourpy-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106fab697af11456fcba3e352ad50effe493a90f893fca6c2ca5c033820cea92", size = 307688, upload-time = "2025-04-15T17:37:11.481Z" }, + { url = "https://files.pythonhosted.org/packages/fc/97/e1d5dbbfa170725ef78357a9a0edc996b09ae4af170927ba8ce977e60a5f/contourpy-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d14f12932a8d620e307f715857107b1d1845cc44fdb5da2bc8e850f5ceba9f87", size = 347331, upload-time = "2025-04-15T17:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/6f/66/e69e6e904f5ecf6901be3dd16e7e54d41b6ec6ae3405a535286d4418ffb4/contourpy-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:532fd26e715560721bb0d5fc7610fce279b3699b018600ab999d1be895b09415", size = 318963, upload-time = "2025-04-15T17:37:22.76Z" }, + { url = "https://files.pythonhosted.org/packages/a8/32/b8a1c8965e4f72482ff2d1ac2cd670ce0b542f203c8e1d34e7c3e6925da7/contourpy-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b383144cf2d2c29f01a1e8170f50dacf0eac02d64139dcd709a8ac4eb3cfe", size = 323681, upload-time = "2025-04-15T17:37:33.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/c6/12a7e6811d08757c7162a541ca4c5c6a34c0f4e98ef2b338791093518e40/contourpy-1.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c49f73e61f1f774650a55d221803b101d966ca0c5a2d6d5e4320ec3997489441", size = 1308674, upload-time = "2025-04-15T17:37:48.64Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8a/bebe5a3f68b484d3a2b8ffaf84704b3e343ef1addea528132ef148e22b3b/contourpy-1.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d80b2c0300583228ac98d0a927a1ba6a2ba6b8a742463c564f1d419ee5b211e", size = 1380480, upload-time = "2025-04-15T17:38:06.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/db/fcd325f19b5978fb509a7d55e06d99f5f856294c1991097534360b307cf1/contourpy-1.3.2-cp312-cp312-win32.whl", hash = "sha256:90df94c89a91b7362e1142cbee7568f86514412ab8a2c0d0fca72d7e91b62912", size = 178489, upload-time = "2025-04-15T17:38:10.338Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/fadd0b92ffa7b5eb5949bf340a63a4a496a6930a6c37a7ba0f12acb076d6/contourpy-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c942a01d9163e2e5cfb05cb66110121b8d07ad438a17f9e766317bcb62abf73", size = 223042, upload-time = "2025-04-15T17:38:14.239Z" }, + { url = "https://files.pythonhosted.org/packages/2e/61/5673f7e364b31e4e7ef6f61a4b5121c5f170f941895912f773d95270f3a2/contourpy-1.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:de39db2604ae755316cb5967728f4bea92685884b1e767b7c24e983ef5f771cb", size = 271630, upload-time = "2025-04-15T17:38:19.142Z" }, + { url = "https://files.pythonhosted.org/packages/ff/66/a40badddd1223822c95798c55292844b7e871e50f6bfd9f158cb25e0bd39/contourpy-1.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f9e896f447c5c8618f1edb2bafa9a4030f22a575ec418ad70611450720b5b08", size = 255670, upload-time = "2025-04-15T17:38:23.688Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c7/cf9fdee8200805c9bc3b148f49cb9482a4e3ea2719e772602a425c9b09f8/contourpy-1.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71e2bd4a1c4188f5c2b8d274da78faab884b59df20df63c34f74aa1813c4427c", size = 306694, upload-time = "2025-04-15T17:38:28.238Z" }, + { url = "https://files.pythonhosted.org/packages/dd/e7/ccb9bec80e1ba121efbffad7f38021021cda5be87532ec16fd96533bb2e0/contourpy-1.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de425af81b6cea33101ae95ece1f696af39446db9682a0b56daaa48cfc29f38f", size = 345986, upload-time = "2025-04-15T17:38:33.502Z" }, + { url = "https://files.pythonhosted.org/packages/dc/49/ca13bb2da90391fa4219fdb23b078d6065ada886658ac7818e5441448b78/contourpy-1.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:977e98a0e0480d3fe292246417239d2d45435904afd6d7332d8455981c408b85", size = 318060, upload-time = "2025-04-15T17:38:38.672Z" }, + { url = "https://files.pythonhosted.org/packages/c8/65/5245ce8c548a8422236c13ffcdcdada6a2a812c361e9e0c70548bb40b661/contourpy-1.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:434f0adf84911c924519d2b08fc10491dd282b20bdd3fa8f60fd816ea0b48841", size = 322747, upload-time = "2025-04-15T17:38:43.712Z" }, + { url = "https://files.pythonhosted.org/packages/72/30/669b8eb48e0a01c660ead3752a25b44fdb2e5ebc13a55782f639170772f9/contourpy-1.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c66c4906cdbc50e9cba65978823e6e00b45682eb09adbb78c9775b74eb222422", size = 1308895, upload-time = "2025-04-15T17:39:00.224Z" }, + { url = "https://files.pythonhosted.org/packages/05/5a/b569f4250decee6e8d54498be7bdf29021a4c256e77fe8138c8319ef8eb3/contourpy-1.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8b7fc0cd78ba2f4695fd0a6ad81a19e7e3ab825c31b577f384aa9d7817dc3bef", size = 1379098, upload-time = "2025-04-15T17:43:29.649Z" }, + { url = "https://files.pythonhosted.org/packages/19/ba/b227c3886d120e60e41b28740ac3617b2f2b971b9f601c835661194579f1/contourpy-1.3.2-cp313-cp313-win32.whl", hash = "sha256:15ce6ab60957ca74cff444fe66d9045c1fd3e92c8936894ebd1f3eef2fff075f", size = 178535, upload-time = "2025-04-15T17:44:44.532Z" }, + { url = "https://files.pythonhosted.org/packages/12/6e/2fed56cd47ca739b43e892707ae9a13790a486a3173be063681ca67d2262/contourpy-1.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e1578f7eafce927b168752ed7e22646dad6cd9bca673c60bff55889fa236ebf9", size = 223096, upload-time = "2025-04-15T17:44:48.194Z" }, + { url = "https://files.pythonhosted.org/packages/54/4c/e76fe2a03014a7c767d79ea35c86a747e9325537a8b7627e0e5b3ba266b4/contourpy-1.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0475b1f6604896bc7c53bb070e355e9321e1bc0d381735421a2d2068ec56531f", size = 285090, upload-time = "2025-04-15T17:43:34.084Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e2/5aba47debd55d668e00baf9651b721e7733975dc9fc27264a62b0dd26eb8/contourpy-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c85bb486e9be652314bb5b9e2e3b0d1b2e643d5eec4992c0fbe8ac71775da739", size = 268643, upload-time = "2025-04-15T17:43:38.626Z" }, + { url = "https://files.pythonhosted.org/packages/a1/37/cd45f1f051fe6230f751cc5cdd2728bb3a203f5619510ef11e732109593c/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:745b57db7758f3ffc05a10254edd3182a2a83402a89c00957a8e8a22f5582823", size = 310443, upload-time = "2025-04-15T17:43:44.522Z" }, + { url = "https://files.pythonhosted.org/packages/8b/a2/36ea6140c306c9ff6dd38e3bcec80b3b018474ef4d17eb68ceecd26675f4/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:970e9173dbd7eba9b4e01aab19215a48ee5dd3f43cef736eebde064a171f89a5", size = 349865, upload-time = "2025-04-15T17:43:49.545Z" }, + { url = "https://files.pythonhosted.org/packages/95/b7/2fc76bc539693180488f7b6cc518da7acbbb9e3b931fd9280504128bf956/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6c4639a9c22230276b7bffb6a850dfc8258a2521305e1faefe804d006b2e532", size = 321162, upload-time = "2025-04-15T17:43:54.203Z" }, + { url = "https://files.pythonhosted.org/packages/f4/10/76d4f778458b0aa83f96e59d65ece72a060bacb20cfbee46cf6cd5ceba41/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc829960f34ba36aad4302e78eabf3ef16a3a100863f0d4eeddf30e8a485a03b", size = 327355, upload-time = "2025-04-15T17:44:01.025Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/10cf483ea683f9f8ab096c24bad3cce20e0d1dd9a4baa0e2093c1c962d9d/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d32530b534e986374fc19eaa77fcb87e8a99e5431499949b828312bdcd20ac52", size = 1307935, upload-time = "2025-04-15T17:44:17.322Z" }, + { url = "https://files.pythonhosted.org/packages/78/73/69dd9a024444489e22d86108e7b913f3528f56cfc312b5c5727a44188471/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e298e7e70cf4eb179cc1077be1c725b5fd131ebc81181bf0c03525c8abc297fd", size = 1372168, upload-time = "2025-04-15T17:44:33.43Z" }, + { url = "https://files.pythonhosted.org/packages/0f/1b/96d586ccf1b1a9d2004dd519b25fbf104a11589abfd05484ff12199cca21/contourpy-1.3.2-cp313-cp313t-win32.whl", hash = "sha256:d0e589ae0d55204991450bb5c23f571c64fe43adaa53f93fc902a84c96f52fe1", size = 189550, upload-time = "2025-04-15T17:44:37.092Z" }, + { url = "https://files.pythonhosted.org/packages/b0/e6/6000d0094e8a5e32ad62591c8609e269febb6e4db83a1c75ff8868b42731/contourpy-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:78e9253c3de756b3f6a5174d024c4835acd59eb3f8e2ca13e775dbffe1558f69", size = 238214, upload-time = "2025-04-15T17:44:40.827Z" }, + { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" }, + { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" }, + { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload-time = "2025-04-15T17:45:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload-time = "2025-04-15T17:45:20.166Z" }, + { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload-time = "2025-04-15T17:45:24.794Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +dependencies = [ + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" }, + { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" }, + { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" }, + { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" }, + { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" }, + { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" }, + { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" }, + { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" }, + { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" }, + { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" }, + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, + { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" }, + { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" }, + { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" }, + { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" }, +] + +[[package]] +name = "coverage" +version = "7.14.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/fd/0ab2772530e946e1be1abd0bc09e647ec9b02e88f0867857601fefca8953/coverage-7.14.1.tar.gz", hash = "sha256:30c08f7d90415aa98b3c990385dea2939b0da55f38515e5b369b83655f8523be", size = 920132, upload-time = "2026-05-26T20:41:36.783Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/69/0d2ef01ff4b8fcecd4cba920d11e92fa4f96ae412441d3b56a90a258e69b/coverage-7.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3e3680291c4a1d0dadfa84a2c459576a4af5133abb617905714339a0c73138cf", size = 219722, upload-time = "2026-05-26T20:38:14.002Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ae/9afdeaa31b9d9ce98124b6abf8bb49119bf71aecae04f8567c189d91299f/coverage-7.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a5274669f37f2343635a347b91a60777621341ab3378e9c6ac9335eee704bddf", size = 220240, upload-time = "2026-05-26T20:38:17.424Z" }, + { url = "https://files.pythonhosted.org/packages/51/69/c998589871df7ea7dba865cc5ee32b5a3e1d47ba6c68ef91104c7c46fa5e/coverage-7.14.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cfe5a5fec635799ef33428f1e5e61bafa45a92a96190ba731561ba558ccc214d", size = 246981, upload-time = "2026-05-26T20:38:19.266Z" }, + { url = "https://files.pythonhosted.org/packages/fc/10/1c7d04c13040dac531d21b712bbe08f902e6dd9b58f5d77875c4d030f8f2/coverage-7.14.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:62a9f70b52e0b5a95cfef4a5c5641b06983cadc5e538a3feeb5c00211f523ac2", size = 248812, upload-time = "2026-05-26T20:38:20.75Z" }, + { url = "https://files.pythonhosted.org/packages/c1/65/2a38a4607ef27cadcfbcee034dba5830ae2569f90144a0f4c7dbf47d30b0/coverage-7.14.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c18ebc343e15be53049b3a2dce38fe82d58f37e20ab9094b3a39c0aa4f6bb47", size = 250675, upload-time = "2026-05-26T20:38:22.159Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a2/a446ed9752a4a59b79e0fb6cbb319f6facb2183045c0725462625e66f87e/coverage-7.14.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b84ffdf877644e7096aa936991efeed873f7f3df57b9cd001312b7668ab08550", size = 252590, upload-time = "2026-05-26T20:38:23.63Z" }, + { url = "https://files.pythonhosted.org/packages/9e/fd/e81fbd7ba752365546e9842b1cbdaad3d6919d2a522c590aef16a281ec5e/coverage-7.14.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e854312c4103f2ad4c0dc023b69b77ebfd2c89db5f86c4c94dc2353f9a92167e", size = 247691, upload-time = "2026-05-26T20:38:25.057Z" }, + { url = "https://files.pythonhosted.org/packages/53/35/f3c26fdaae9ea937d154ca4d372e5ea0a4167ff70d36c6074ac2eacb2f83/coverage-7.14.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c643734307300234fafa36bf2a040a7235f8f177ea1fd6ec1423aea6fb7b929f", size = 248716, upload-time = "2026-05-26T20:38:26.406Z" }, + { url = "https://files.pythonhosted.org/packages/2e/14/940b6c49551fd343e8507ee2b0ba7af5d0aa04ed5bf768285cb7c72a9884/coverage-7.14.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:84ac9499e48700399a5dd0ea7085b5091961fec52c68d66b4ec0d3cf7f4441b1", size = 246721, upload-time = "2026-05-26T20:38:28.282Z" }, + { url = "https://files.pythonhosted.org/packages/aa/2c/40fc0634186c28292a662dff578866b3913983d6c375a3c2a74020938719/coverage-7.14.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:7f02d09f70776579b926d889a4c9c235070a1f47c40458aeaca563fae5acfdb5", size = 250533, upload-time = "2026-05-26T20:38:29.753Z" }, + { url = "https://files.pythonhosted.org/packages/de/e3/2c26bf1e811f9df991ff2a9bdddebdd13ee0665d564df7d05979f9146297/coverage-7.14.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:ce66d8e46da2bb5ee313a745cbd2e391d319176c1f7a9451bfcd3a2fb920859b", size = 246990, upload-time = "2026-05-26T20:38:31.516Z" }, + { url = "https://files.pythonhosted.org/packages/a8/b0/060260ef56bd92363ebdce0c7095ce422b06e69aae71828efeca473ab1ca/coverage-7.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c912c259304cfb5ee584481cfb7ce1ff932b4d61e6c9140b8f19cb7b5ed82332", size = 247593, upload-time = "2026-05-26T20:38:33.065Z" }, + { url = "https://files.pythonhosted.org/packages/63/f3/501502046efeb0d6d94b5ca54941d95f1184183dd6bdb7f283985783bb4a/coverage-7.14.1-cp310-cp310-win32.whl", hash = "sha256:1238cb94638e610e972c60dac68e813f868dc7d6e982535270558443058d9d59", size = 222330, upload-time = "2026-05-26T20:38:35.36Z" }, + { url = "https://files.pythonhosted.org/packages/a0/5d/1bf99f2c558f128faf7906817ccbdb576ba815d3b41ce2ac1719b70a3663/coverage-7.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:fc459e5d73be2d6332fcfe8dbf3d8994671fe33c700f4565988ecfa511547253", size = 223261, upload-time = "2026-05-26T20:38:37.196Z" }, + { url = "https://files.pythonhosted.org/packages/7d/d7/477ad149490e6cb849f28abea1dabb9c823cea72e7500c81b4240ce619c0/coverage-7.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:478b5bcd63c2e1357c5c7e16c070690df7b07f676b1c114d7b93e533c664309f", size = 219848, upload-time = "2026-05-26T20:38:38.715Z" }, + { url = "https://files.pythonhosted.org/packages/91/82/a5eb47257c50601bb7b9a9d2857c67b7a3a85ad74180eb2c98bb1fbe0ce5/coverage-7.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a24a81f9715ee42ef59a316cc11611c98fe23920f7c81861315c9f3ff4a230f4", size = 220354, upload-time = "2026-05-26T20:38:40.232Z" }, + { url = "https://files.pythonhosted.org/packages/43/8b/78419b5391a5cb706b6544390507e469d83ffc9a8248b02c4011aceb9365/coverage-7.14.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:196a13319ad88d6d8ef5ab489ec4f44ddde2143c0c7d5b27786f6c3ffd56a7e1", size = 250771, upload-time = "2026-05-26T20:38:41.782Z" }, + { url = "https://files.pythonhosted.org/packages/77/63/e77aaacd491182210d639636b7a8bba23ffffa9b82aa3762da9431855fa9/coverage-7.14.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3d452fd08b5c72c5167c93e6867b5c08500bd40f2a21e1e854a500550b6cc36f", size = 252683, upload-time = "2026-05-26T20:38:43.305Z" }, + { url = "https://files.pythonhosted.org/packages/65/1c/a022e3cfbec2ac241640003cb3a817e161d9c7f5aa9b49173756cdc03204/coverage-7.14.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23bf7fa51ac02e07fc7c96849b82946da47ae862dc8f86d183b2a4864fc38129", size = 254791, upload-time = "2026-05-26T20:38:45.361Z" }, + { url = "https://files.pythonhosted.org/packages/61/d6/967e408aca4c1ceb88cb0cc677169110ae7f5995fb5eaf5fb1f5a1bb8f5d/coverage-7.14.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bcaa50684dcaadfa599ac48f81103c756d791cfd85c97203d2217c593d48b860", size = 256748, upload-time = "2026-05-26T20:38:46.91Z" }, + { url = "https://files.pythonhosted.org/packages/b8/be/869188f7fe28638078ec479331ace6dc5f7b40b7153eb616f47ab79404d8/coverage-7.14.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4ea1c034f95c9b056e856b794630b17f9fa3d57e4800ff1e503d3be0f9c9078c", size = 250907, upload-time = "2026-05-26T20:38:48.493Z" }, + { url = "https://files.pythonhosted.org/packages/07/aa/adb7d3b4278d690e68703abcd76ab1b948242e3668d921711551b78f9ddb/coverage-7.14.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c7e057326434e441306226fbeb5d1aaf14a2637efe97ba668306635835f32ad7", size = 252483, upload-time = "2026-05-26T20:38:50.074Z" }, + { url = "https://files.pythonhosted.org/packages/43/61/331c74103c62dcb0c4b9b3a0de9a61aca016208b0a90f109592a9f9ecc28/coverage-7.14.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:59baf88468dbc8d63b1887afd92bda52e40bb1561696e5819670601403810cec", size = 250545, upload-time = "2026-05-26T20:38:51.613Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b6/c5dae3c104d89be04828f61810e6b3473825482e4c288cc4ed04553e08ae/coverage-7.14.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d34d75f892b3ab73ba11cab5442cce7b3e168fd64162b16f0e1e0d09c508edef", size = 254310, upload-time = "2026-05-26T20:38:53.503Z" }, + { url = "https://files.pythonhosted.org/packages/ad/a1/2b9d5863e3b83c01ad8199e3c597802fbb3a9dc90b058885804c20296d31/coverage-7.14.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3a56abc20a472baf0304c455721bc601477440d28ecfde8a03dde79ede07e0df", size = 250266, upload-time = "2026-05-26T20:38:55.414Z" }, + { url = "https://files.pythonhosted.org/packages/7f/5e/0e511fbdb269359be26fe678a1c3fa1f2aa2a01573cc3f54268c8d6d4797/coverage-7.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6a3cb83d1552c0cd1b4906655b6a33fd4a8473229633a901c6b73bf86914dee9", size = 251174, upload-time = "2026-05-26T20:38:57.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/10/e55307b622b3dd9671cb321824502dc10f93e72f2802b9946159a8edadeb/coverage-7.14.1-cp311-cp311-win32.whl", hash = "sha256:10274a1fbeb8ec5d72966e17bb198a3104257aca4ac09d98667c5f8aca8c8548", size = 222354, upload-time = "2026-05-26T20:38:58.727Z" }, + { url = "https://files.pythonhosted.org/packages/71/cf/107421693cfb71e4f1ca5bf70443f64d4161878068d07a3e51c7ad21d17b/coverage-7.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:87ebdf787d4888e3f3f2d523eadc6e18c6d18c6d0eb173801a189641627fb37e", size = 223290, upload-time = "2026-05-26T20:39:00.413Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1d/3e3644585eb29e9dafefb19555078529a4d7cce12bd21929664eea989277/coverage-7.14.1-cp311-cp311-win_arm64.whl", hash = "sha256:dd34767fa19848d35659ffc0a75314f58c7af3f1cd87ec521e8292a1238398a3", size = 221953, upload-time = "2026-05-26T20:39:02.159Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b7/bdbb725ba02c5b42825b200c940f38b7a54fcad24627b7192f78f8110d76/coverage-7.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a06c76364a9360e33d6d23769aefdf7f66f38e2ffb60ceb1baaa4989d83b695c", size = 220022, upload-time = "2026-05-26T20:39:03.702Z" }, + { url = "https://files.pythonhosted.org/packages/72/81/fdc0898a55c6219223291ec1a1fe89966ef212ce82276aa0899df84b5de0/coverage-7.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fad54e871165f6ec2f536063ac74c3104508a12963e64072ba44bd822de52b0c", size = 220379, upload-time = "2026-05-26T20:39:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/de/72/de048c4a25e13bce59ac6a339351c10bdf2515e07459afcdaf04dc3143a2/coverage-7.14.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:84b535f00655ecafe1d929d1fb00ed5d6fa3051ea643ab2c161a3887b86f294b", size = 251888, upload-time = "2026-05-26T20:39:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/28/30/300c343f68beb9d4cbb64ec81e58c5b6b80b56927f72d2b38654ac26e013/coverage-7.14.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6b6b0853b895fe0e98cbfc580d1ec3393d9302b4b1e96a77b3f5c91fdab899e6", size = 254624, upload-time = "2026-05-26T20:39:09.037Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ed/7b25642496e8170b6bac14adce00537c6e5fa2d586159401a4de3e8b49e6/coverage-7.14.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:442cc9c952b2df400cda54bb04ab87330cf2cd08a8692cbbea36773531eb6f37", size = 255739, upload-time = "2026-05-26T20:39:10.889Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a2/abd210b8c4e29c24e4624916db97bb519097a91034aaeb767f937e7da794/coverage-7.14.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8270544c361ed405a27a060dbc9ed2c124b084d96dfdc2d9a2510482aef981ad", size = 257998, upload-time = "2026-05-26T20:39:12.722Z" }, + { url = "https://files.pythonhosted.org/packages/7f/24/7c50beed3792fe62f6ce0545c6686ce83379719e2c0276179333d97eae92/coverage-7.14.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:48b283b1dd6372e8de2a7a9a4c4d5dc06f4d4fd209b876f3c88a7a205a0c8f84", size = 252296, upload-time = "2026-05-26T20:39:14.259Z" }, + { url = "https://files.pythonhosted.org/packages/15/05/0f874628ebcbfc77ead559ff210281ef06a97db08481832e7dd39274a135/coverage-7.14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5b0c99ba93a07d56f6df340bb79be53202a082b2fdb81bfe6190b741a3470d54", size = 253658, upload-time = "2026-05-26T20:39:15.923Z" }, + { url = "https://files.pythonhosted.org/packages/99/6f/ca6ad067364b337ef997802115e7ecad2abd2248b05471464b0dea02b4d4/coverage-7.14.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e471bc5769ff073b058cfadb0d736b56ce067c8560eabeb0da88462df98c23e7", size = 251803, upload-time = "2026-05-26T20:39:17.537Z" }, + { url = "https://files.pythonhosted.org/packages/c0/30/b9b4d377cd9f40baf228068f5a81faf8450c6228503011bd499708483a50/coverage-7.14.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f497a1ea81d4cd7c10ddcaa685135b9aabd291af3d55775a9ddf3cb7a364cdd9", size = 255873, upload-time = "2026-05-26T20:39:19.414Z" }, + { url = "https://files.pythonhosted.org/packages/3c/21/7c721a9e5e6bb88547d30a787aefb97512d3f54c1324c7488d9b3743f7f9/coverage-7.14.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2222be86d0b54f5dd5a38f45f17f315f737245e857bf0bdedc70734f84a13c02", size = 251372, upload-time = "2026-05-26T20:39:21.169Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f8ae5a2200130e1503cd7661a6cd3b2b7bacef98277fbf3571fb13f8b766/coverage-7.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:85e85586565842f6932abebd4c18bcb1074223dc0b3576e7d173ca710622813a", size = 253245, upload-time = "2026-05-26T20:39:23.097Z" }, + { url = "https://files.pythonhosted.org/packages/34/62/70a9024672a5f6910517d9628c52c9afbdd3cf8f46426af52bb148a56fff/coverage-7.14.1-cp312-cp312-win32.whl", hash = "sha256:4a28fd227808366b196a75476dced2eb35b351d6766ba9c858dc93319e87f4f1", size = 222567, upload-time = "2026-05-26T20:39:24.868Z" }, + { url = "https://files.pythonhosted.org/packages/f6/81/8b7cd386839b039ebe1855733b9f9449a8dec5d79564018234f185a7fa70/coverage-7.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:54acdb6674a4661768d7bf7db32dfb9f46ab1d764f8aba6df75ce1a6a088724e", size = 223372, upload-time = "2026-05-26T20:39:26.603Z" }, + { url = "https://files.pythonhosted.org/packages/ae/ba/b44d472022f620d289d95fa830143235c0c36461c6f2437ea8d51e5481ed/coverage-7.14.1-cp312-cp312-win_arm64.whl", hash = "sha256:99cd41ff91afd94896fea3bc002706b6ae4ce95727d06e4a0f39c0a8d8bd8b1a", size = 221989, upload-time = "2026-05-26T20:39:28.242Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9e/5f6d56327c62b185225d145191c607e07515294a0aa6338e58805cd4a5ac/coverage-7.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:be9f2c802dcfce3f71298303aa5dad0dce440a76c52f2f60dacd8656dab78793", size = 220044, upload-time = "2026-05-26T20:39:29.902Z" }, + { url = "https://files.pythonhosted.org/packages/75/92/e82aca356744cbbc0f77a0b623e38918c1872361963413a3bab5d0340393/coverage-7.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6223a72fd0e4c7156353ec0f08a5f93623e1d3034d0e2683b9bb8ea674131b1d", size = 220412, upload-time = "2026-05-26T20:39:31.561Z" }, + { url = "https://files.pythonhosted.org/packages/27/c9/385bde0bf7ed0f4bf3a7ee5367060a86b5d218718cfd6fb943c0f836b34f/coverage-7.14.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7279d2110a28cebc738b6459ecda2771735a4c18465fbbd36b3288fe5ed92247", size = 251412, upload-time = "2026-05-26T20:39:33.337Z" }, + { url = "https://files.pythonhosted.org/packages/51/8c/23faf6a2343a0d17f960a4bd56c43bc7eb4cf312f774dd6ceebd82c7d8fc/coverage-7.14.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9eeb3fcbc13ba40dfbdb22d01d196a28e9cef9ed4c29b60061a1e0e823a9929d", size = 254008, upload-time = "2026-05-26T20:39:35.009Z" }, + { url = "https://files.pythonhosted.org/packages/42/06/36f4aa9ca8a815e6036156e80706a67828bb97bd826948244f6996dda957/coverage-7.14.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f0cfc27c539f07cf5c0a4cfe211d0b6cae039f8f40526dbaa71944e64b50a7b", size = 255241, upload-time = "2026-05-26T20:39:36.71Z" }, + { url = "https://files.pythonhosted.org/packages/ca/79/95266316352f90f6b1c6736bb413302edfde2453fb32422d3911642691b3/coverage-7.14.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:221c70f316241a78e77e607c227cefc8808d4e08f28d99c04f35694690e940be", size = 257373, upload-time = "2026-05-26T20:39:38.412Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9c/58316d1f66c488b5fca8a0eb3e98348807813efa8a0d0833b9021be27488/coverage-7.14.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:da028256b04ec30e5e0114b6f76172938c313991f0a2d3d894271315cf5d5e43", size = 251635, upload-time = "2026-05-26T20:39:40.268Z" }, + { url = "https://files.pythonhosted.org/packages/ef/5a/ca2398a568e16fed7bb713e84ba3603a7164fb65779abe645c565ec890d5/coverage-7.14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76a085d7005236a767e3426148b2c407e53ad61695c562f8a81da2d373324901", size = 253373, upload-time = "2026-05-26T20:39:42.145Z" }, + { url = "https://files.pythonhosted.org/packages/6e/2c/0396562c32deaebe7be51d865b3a41e9a87d7561acafe1a28f53b07e019a/coverage-7.14.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b553d04b5e778a8e56d57eb134aff42a92718ecba45e79c4764ecfa40efd92ff", size = 251341, upload-time = "2026-05-26T20:39:43.907Z" }, + { url = "https://files.pythonhosted.org/packages/fd/8f/a94f9221184c9cae1ee115820e3798e48b6b17777a9f19e46fb9a0c8dc74/coverage-7.14.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:46f714d2fb8ae2f4f29f23ada7f1e79b759fff5a70f94a1dac23af204c3ec9e4", size = 255497, upload-time = "2026-05-26T20:39:46.166Z" }, + { url = "https://files.pythonhosted.org/packages/71/69/505d70e47db1eaebcd002c39759707621ef184cd6b1ae084d9f41293f323/coverage-7.14.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:1896f5e19ff3f0431c7ce2172adc54890fd97f86b59ced8ca1649145d9ffe35d", size = 251159, upload-time = "2026-05-26T20:39:48.03Z" }, + { url = "https://files.pythonhosted.org/packages/e0/aa/58681c383aa33a9d2ed40a02d7a22fbf780d1fa4d575396365777828198c/coverage-7.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:62fd185ef9df3c33d1c8178c5af105f762afbad96038de9a4ae100aa6297ca33", size = 252934, upload-time = "2026-05-26T20:39:49.872Z" }, + { url = "https://files.pythonhosted.org/packages/eb/fd/11c928cd6bdffc7074bb5965c173d9ebf517fb00205e1da524b98d29ef92/coverage-7.14.1-cp313-cp313-win32.whl", hash = "sha256:ab4af6352741a604c431c6072fce5bee33bf0f20dc7a56618d6bf6bb89e9810c", size = 222584, upload-time = "2026-05-26T20:39:51.68Z" }, + { url = "https://files.pythonhosted.org/packages/6f/92/fb416fc26d340dcba19518c418d6048e913186e17243982c5e435e41fa7a/coverage-7.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:7af486dabe8954d03b087f0021540897afe084f04e16ff5579e08cc46f871416", size = 223394, upload-time = "2026-05-26T20:39:53.472Z" }, + { url = "https://files.pythonhosted.org/packages/73/c6/02d56e3867972f77d5036de924643f26c056e848f00452cafb4dbc3c29b4/coverage-7.14.1-cp313-cp313-win_arm64.whl", hash = "sha256:2224f89ffd0c5605ccce1ed7a584da162bc7c55f601ab1c946bc9de31a486b42", size = 222015, upload-time = "2026-05-26T20:39:55.374Z" }, + { url = "https://files.pythonhosted.org/packages/4d/9e/fcc77914050df73f7662fa1f00902774c79c075a8388ab334074574bf77e/coverage-7.14.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:de286598cc65d2b489411174b1faec2f5a7775fb3201fd925db2a76b4030f37d", size = 220733, upload-time = "2026-05-26T20:39:57.189Z" }, + { url = "https://files.pythonhosted.org/packages/f7/67/2963cbdaf5cbadec44efa3a1e39eaa1f02df4079585f05387607a221e126/coverage-7.14.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:042c46ded7c288aeb07cf14a28b6c1e10b78fcba40171c3fa1e939377eeef0b5", size = 221086, upload-time = "2026-05-26T20:39:59.019Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c5/8701645574e11881f2f47d8930f98bc48b5d43b25eb5b4430dfc4a2f9f48/coverage-7.14.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f4ddbe407477f04c45115d1a4e5bc480f753553b534d338d4c3358b1cdd0ea52", size = 262381, upload-time = "2026-05-26T20:40:00.822Z" }, + { url = "https://files.pythonhosted.org/packages/7c/28/7a64d73598263e0c5abd5084211a8474488d31b3c552ff531c719dfcff62/coverage-7.14.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d13e6725992e2d2fd7d81d4f5241952d13740121dfd501da09201be39b2c003a", size = 264458, upload-time = "2026-05-26T20:40:02.506Z" }, + { url = "https://files.pythonhosted.org/packages/fa/d8/4969179db9f7eb4df218e69540adf829d1c835f59452513d065d15446802/coverage-7.14.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f747dc8edcfe740130f28f32f3995e955494285717e86ee25af51db2219df08a", size = 266884, upload-time = "2026-05-26T20:40:04.421Z" }, + { url = "https://files.pythonhosted.org/packages/a6/78/a45d5794dbc9bafd97afc96a4377c86c7820d78b6cf51b89bc1d4e919275/coverage-7.14.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced2f09ef276fd58611a1ef502164ad266d2b75174e5a40cabbdb4033f9f6cf2", size = 268022, upload-time = "2026-05-26T20:40:06.298Z" }, + { url = "https://files.pythonhosted.org/packages/21/cb/4f5e354e9e3e67af96bd4e57113e6db6b22298c7168b13eec408a549903d/coverage-7.14.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b84800013769a78ccb9ef4659402e26d06867e337b61ec365f77ad008adea80e", size = 261631, upload-time = "2026-05-26T20:40:08.226Z" }, + { url = "https://files.pythonhosted.org/packages/ec/49/eced49af4cb996d5d8b7e94e736175c513e4facd3398507b89892b4326d8/coverage-7.14.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ea8cd6ca0ee9f616aaef3afc6882e32c2cbf18b00d96313ffd76af650574034d", size = 264443, upload-time = "2026-05-26T20:40:10.137Z" }, + { url = "https://files.pythonhosted.org/packages/f1/d8/5603a88a7c5913a6b54f6cb1a8c46f7b39cbb30f27cd3f492908da09b2d7/coverage-7.14.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:aa5e304a873fabddc11e484e9b6b738bd38bd7bed17b09aa84eecf5332e8b8bb", size = 262069, upload-time = "2026-05-26T20:40:11.999Z" }, + { url = "https://files.pythonhosted.org/packages/f0/59/2ae3cb79da554a06c8619d6c88ea19dd1e4aed4b834b6a83bb1fa243bdc5/coverage-7.14.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5a1c5215be81035e629d5bc756650634d0bf31991038db7a0eccb90f025ce16d", size = 265780, upload-time = "2026-05-26T20:40:13.858Z" }, + { url = "https://files.pythonhosted.org/packages/af/5f/b130c1dc999031f2648bd25317fbce505ad8d5562079b4ed81e736a84967/coverage-7.14.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:79058c47dae6788504b5effb319961bcd72d7240551464b91d474bc0ed186d69", size = 260970, upload-time = "2026-05-26T20:40:16.142Z" }, + { url = "https://files.pythonhosted.org/packages/87/d1/ec13ccddeb48ec963bdfa72a11224bac2584bd045ba13beca82f8113e9c7/coverage-7.14.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:370c5afae3fa0658e11694a32b24c2778f6bc2d17718121f94ee185e69f26b54", size = 263157, upload-time = "2026-05-26T20:40:18.382Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c2/cd91ead503045161092d3845f7bb95ea2f25131ce96d3e314dd835d91b9c/coverage-7.14.1-cp313-cp313t-win32.whl", hash = "sha256:3758dd0a7f1fa57365ef2e781df0f0731d38b6e3772259d13dae4bd8a958d4b1", size = 223259, upload-time = "2026-05-26T20:40:20.381Z" }, + { url = "https://files.pythonhosted.org/packages/71/9f/1e28d97e6bd2c76b07f38b7c02870f1371255ff6717f54eca578fcbbdd0e/coverage-7.14.1-cp313-cp313t-win_amd64.whl", hash = "sha256:6ff665fb023a77386fe11685190cee1f60a7d635994a30d9b0a061533d470fce", size = 224320, upload-time = "2026-05-26T20:40:22.316Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e0/d936e908f0e1efa55e52b91e01b52f1055cef5e1ab2718493390ed8e2fb8/coverage-7.14.1-cp313-cp313t-win_arm64.whl", hash = "sha256:17a5a241e5997621a956a7f402a7433ef4221e5152809b785bec79e2323799f1", size = 222577, upload-time = "2026-05-26T20:40:24.894Z" }, + { url = "https://files.pythonhosted.org/packages/d6/34/fc2f101b151af3799a101f0550b0454aa008afdc0add677394ec4aa8ea10/coverage-7.14.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d5ed429d0b8edaac649e889b4ffcedb6c80b06629a3f93050e3dddfb99235bee", size = 220091, upload-time = "2026-05-26T20:40:27.249Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a7/1ebae2ab5b961b5c79bb09fe7b3ac99edb190d8be4a8c510b2cf66f46468/coverage-7.14.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8011224a62280e50dab346960c03cf47aca1a1e09e608c0fb33fd6e0cc8e9500", size = 220421, upload-time = "2026-05-26T20:40:30.084Z" }, + { url = "https://files.pythonhosted.org/packages/5e/90/92aca9cf0acc95123c96cd1eb1f08917897a7f5dee01e15738922971ec31/coverage-7.14.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:12c42ec1e14f553c4f817e989365982e646e27211f10a0f717855b94a79c8906", size = 251466, upload-time = "2026-05-26T20:40:32.542Z" }, + { url = "https://files.pythonhosted.org/packages/26/2b/78048cbe3b999f6cbf9cc0d90abba6a88a3e0863a8c1c6cbc762f3f8802f/coverage-7.14.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:06144cd511cf2624873a035c5069cf297144f6e77a73ee3d7a55b605ec5efb42", size = 253973, upload-time = "2026-05-26T20:40:34.473Z" }, + { url = "https://files.pythonhosted.org/packages/8e/21/c2e33b29d1cfde484a19d437afc343c6cd30b08d78cbbf9f5aff14e57b2b/coverage-7.14.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a311d8e1da24be5c1ccf85cbfb06315dbaa1703d5a1eab3f6432c72b837917c8", size = 255318, upload-time = "2026-05-26T20:40:38.154Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ee/aad2f108d63b769121005302f16bf66db8625c88ceaba466942e09a2607e/coverage-7.14.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c79cead5b5bc584d9c71451cb984d0e3a84e0c0937379c8efcbf27c8d661b851", size = 257633, upload-time = "2026-05-26T20:40:40.164Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f8/11a2c29b4fd76d9849f81d0bb812ec0017a9396df3217214e38934a8c837/coverage-7.14.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dcbf65f1f66a26cdd88c35cf68fb4729c5d1cd2e88added72420541dfb212034", size = 251488, upload-time = "2026-05-26T20:40:42.631Z" }, + { url = "https://files.pythonhosted.org/packages/c9/b8/9a5820de4b8ac2b71d85e3b5fb49108d7469c665f0e2ad0dd7569023e305/coverage-7.14.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fd86572566fb40189a8260446158235159bc7a82dfbc87a3b39cf4fb57fcec1c", size = 253329, upload-time = "2026-05-26T20:40:45.208Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ff/f33e4823667e27548e8fd8df44217515303f9808d0ff29817db56f87d990/coverage-7.14.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:7771b601718fdde84832c3a434ca9bbf4ae9adbc49d84198b4110700c3c77c36", size = 251291, upload-time = "2026-05-26T20:40:47.502Z" }, + { url = "https://files.pythonhosted.org/packages/68/9b/489db0ebb209054766b90a9014a45f6d26eb724c02ec21311c3733b5a644/coverage-7.14.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:39b21e212c55af06fa375e3dbf90a8a8e38792f3a910c580066d23563830ddd5", size = 255564, upload-time = "2026-05-26T20:40:49.372Z" }, + { url = "https://files.pythonhosted.org/packages/27/b5/16bc2d4c2409b23c7737edb68c83bc89e345f378050549fe1d75ac7d34d5/coverage-7.14.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f2302660e32562a532b442480121aef8aa61a5bdb20b30bf0adab29f10a5a4b4", size = 251107, upload-time = "2026-05-26T20:40:51.677Z" }, + { url = "https://files.pythonhosted.org/packages/7d/0c/2629997469a00cd069d588a41c9dc887610f2775ae89d250c4791e65272a/coverage-7.14.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:03a6f93c1ec3b7f2e77b5dbcc5573a2c21f12529a5c6bbe0f16f72303cc2fa4d", size = 252764, upload-time = "2026-05-26T20:40:54.267Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ee/f78d63c8f079e0d7211c7e2401fa17e311514534ba61bae03e4b287ce4ab/coverage-7.14.1-cp314-cp314-win32.whl", hash = "sha256:8a3ce026d73290f42f08dafecbd82c193a74df280461fbf97300fec51fd133ee", size = 222837, upload-time = "2026-05-26T20:40:56.496Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b9/be539854f93a70dfbeec69117f33ec70dc42ff0b65b5b07ab8d40d04228e/coverage-7.14.1-cp314-cp314-win_amd64.whl", hash = "sha256:114c95ef29302423b87d159075805f4ab973254a2638a5d7d046c94887cc87d7", size = 223650, upload-time = "2026-05-26T20:40:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/fe/9e/24e2842fef40f35ac82ba3a7719c8023d011bf3bf652d0675316a9d088a1/coverage-7.14.1-cp314-cp314-win_arm64.whl", hash = "sha256:a07891c3f4805442b31b71e84ba3cf29ed1aa9a428284e06deeb4b23e5b46343", size = 222218, upload-time = "2026-05-26T20:41:00.321Z" }, + { url = "https://files.pythonhosted.org/packages/0a/1d/ac0a9df5fe31c1e8bdd658074905fc12844a05c1a7e3fdb8417e97c31e23/coverage-7.14.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1101a5ebb083aecb625ebb6209d4105b58f647b093cb2dc8122d7b33f743cfe1", size = 220822, upload-time = "2026-05-26T20:41:02.281Z" }, + { url = "https://files.pythonhosted.org/packages/32/cf/f964fd9aff20323f9f1a726c97135f8a76bcd87b92dad141a456a43f3c64/coverage-7.14.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:851b9e1e4e8a4608e77c79714b2e77c0970d2ed7202a05e92ae407817481887b", size = 221084, upload-time = "2026-05-26T20:41:04.593Z" }, + { url = "https://files.pythonhosted.org/packages/d8/5e/7e5ef2aba844de2b80d678619fcf0841b42e3f37f16411226f3fe4c1016f/coverage-7.14.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d5b89cdfb2ee051b71e8c3c70bd81a9eff81100f736a269136fe1a68efe00474", size = 262454, upload-time = "2026-05-26T20:41:06.641Z" }, + { url = "https://files.pythonhosted.org/packages/64/62/75809bded87015cc4935524218a2a8ed8dd1a8498bfed30a2f4f7a4b4d34/coverage-7.14.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0177614a0370f227888b4e436a7c55686d6a9f90eb1ade2b624ba685a1686e86", size = 264578, upload-time = "2026-05-26T20:41:08.556Z" }, + { url = "https://files.pythonhosted.org/packages/f3/42/d33392dc14633525012d2d504fa1a33b05538bf535f5c1d64675e5754b78/coverage-7.14.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d69af5dea2de76fc485a83032a630523f985198b7e25be901ec60181587b01e", size = 266981, upload-time = "2026-05-26T20:41:10.824Z" }, + { url = "https://files.pythonhosted.org/packages/2a/49/0157c4428c2aca7f1e09d5565930586fd5ae36f1655f08b0daa7cf1fcae1/coverage-7.14.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:35ab22d91de736e8966b980dc355cbcdd2c6dbbcfe275f9a2991bc8a91b3df65", size = 268112, upload-time = "2026-05-26T20:41:12.966Z" }, + { url = "https://files.pythonhosted.org/packages/96/26/86b9ce71f4092b1ed325ce1421698081df1286b833400b6836912834d6e0/coverage-7.14.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:357d4e32935c36588aaba057d734fa32428c360c9fc2e4442afbf1b646beee6e", size = 261558, upload-time = "2026-05-26T20:41:15Z" }, + { url = "https://files.pythonhosted.org/packages/20/4c/c311210c5472cf5401d8422b0d7812cdd520f24417673afabda6c323faca/coverage-7.14.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:51bd64741cc6fa065abd300ede1afe5a5291ece9c31da8b24884deda48bcc3f8", size = 264447, upload-time = "2026-05-26T20:41:17.369Z" }, + { url = "https://files.pythonhosted.org/packages/fb/71/59513f8710ed3e6b0ac0a050a5b7e977bb9c9e880354863b5d00d8809256/coverage-7.14.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:9132cd363a68a4c3daa7c8704a654b1e39d3360f6f5b8ddd470608a945236c07", size = 262048, upload-time = "2026-05-26T20:41:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/bceed32dc494f5bbf50f775cd2e78ca814953942b5ea28d3c1c3ac316f14/coverage-7.14.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:07c6290b1697b862c0478eab545eec949a0d0e4d6d03497f446d706da3b4f2de", size = 265781, upload-time = "2026-05-26T20:41:21.559Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c5/9348fe40dbfd4991aaf78df2c6c3098bfb2cc834d1fd362a64b4efef855a/coverage-7.14.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5ea0c297e27133853b4d8a3eb799bff5a2dbd9f2f41537a240d337ac9b4df890", size = 260896, upload-time = "2026-05-26T20:41:23.428Z" }, + { url = "https://files.pythonhosted.org/packages/ca/92/1ea0f03929da7cf87206b1fa24f4c8e9c158be0455481af29ec0a1f3503f/coverage-7.14.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:01b7733daad0237daa01ef80fe2dfceffc911e6a17fa7b55d14aa8214eaaaecd", size = 263214, upload-time = "2026-05-26T20:41:25.419Z" }, + { url = "https://files.pythonhosted.org/packages/f6/a9/b2493c054c0e01a643266742ab45e15744e60743f9260cd930c7142b1124/coverage-7.14.1-cp314-cp314t-win32.whl", hash = "sha256:6adc5a36984624a70bf11d7184e20fa0a49aa7c47ffab43804106a1a695ea22e", size = 223624, upload-time = "2026-05-26T20:41:27.795Z" }, + { url = "https://files.pythonhosted.org/packages/fc/bd/3e1e6a57fccd2d7c83fcdf338e93ba98eb85c6e877dd34731ac585375490/coverage-7.14.1-cp314-cp314t-win_amd64.whl", hash = "sha256:ddf799247318f34dbcd2efa8c95a8d0642674e926bb1774cf9b63dfd2a389d1c", size = 224728, upload-time = "2026-05-26T20:41:30.098Z" }, + { url = "https://files.pythonhosted.org/packages/bb/d7/31066cf1d2f0c6c797fce911bcfa01dd35642dc6da992a950256097c5860/coverage-7.14.1-cp314-cp314t-win_arm64.whl", hash = "sha256:145986fe66647eb489f18d9a997567a3fd358584c4b5a808769113abc07466af", size = 222752, upload-time = "2026-05-26T20:41:32.123Z" }, + { url = "https://files.pythonhosted.org/packages/8a/3c/1a983b9a745d7f83d53f057bcc5bf79ba6a2bbc08266b3f0c7d6fe630c9b/coverage-7.14.1-py3-none-any.whl", hash = "sha256:a252f21c27e38347e60111a3266b03827422a7d5525951aceee313aa68bab1d2", size = 211815, upload-time = "2026-05-26T20:41:34.078Z" }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", marker = "python_full_version <= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] + +[[package]] +name = "cryptography" +version = "48.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "(platform_python_implementation != 'PyPy' and sys_platform != 'darwin') or (platform_python_implementation != 'PyPy' and extra != 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform != 'darwin') or (python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/12/45/870e7f4bef50e5f53b9f51d4428aee5290eedf58ba443f16b1ebb7ab8e66/cryptography-48.0.1.tar.gz", hash = "sha256:266f4ee051abb2f725b74ef8072b521ce1feacf685a3364fa6a6b45548db791a", size = 832989, upload-time = "2026-06-09T22:32:31.8Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/bc/ee4137cbbe105652c0ee4252792b78fc8e7afa4b8e61d9d5dc05a7f45731/cryptography-48.0.1-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:3e4a1a3232eef2e6c732827d5722db29a0cc8b27af2a4d865b094cf954be9ca1", size = 8008324, upload-time = "2026-06-09T22:31:00.702Z" }, + { url = "https://files.pythonhosted.org/packages/d5/85/6379d42181bfc713094f081360fc5784d6c816b599d45e7f082502d173ce/cryptography-48.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:32143b24adb918f078134e1e230f1eb8cc04886b92c28b5f0041aaf3e5699225", size = 4696243, upload-time = "2026-06-09T22:32:33.446Z" }, + { url = "https://files.pythonhosted.org/packages/9c/87/c85d147b53323c7eb4d850920c8901377323c2a0ff8d79c262d4fee89aa2/cryptography-48.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0d27a5696721ef7a672b8c810f6aded391058e0b9486e63e6d93baf765da691", size = 4713235, upload-time = "2026-06-09T22:31:40.141Z" }, + { url = "https://files.pythonhosted.org/packages/79/58/67cbf8cf1ee7c54b439ca07bbecf8362c07afc11a3724fea70f745784add/cryptography-48.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eb86ce1af36fe65041b6db9a8bb064ee621a7e5fded0f80d475ec243477cd242", size = 4702323, upload-time = "2026-06-09T22:31:42.191Z" }, + { url = "https://files.pythonhosted.org/packages/89/c6/24266ac10c47f6cd2a865f4446062b466da1d1f10b27189eac00e61bf0c9/cryptography-48.0.1-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:b024e784ad6c077ee0147b35ea9cbfc1e34e1fd4c1dcca214c2794d73a12df08", size = 5300085, upload-time = "2026-06-09T22:31:58.703Z" }, + { url = "https://files.pythonhosted.org/packages/d2/bb/cc4b78784f97efc8c5874c2a9743708d172be6663024b34a0467885ae0c8/cryptography-48.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3752f2dbc8f07a30aad2932c986cea495b03bb554887828225da104f732852b6", size = 4746137, upload-time = "2026-06-09T22:31:31.01Z" }, + { url = "https://files.pythonhosted.org/packages/1f/52/0c44de3f5267f8fbe8e835138017522a333436166e406f0db9b9e6e3033f/cryptography-48.0.1-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:bd81490cd5801d755cf97bb68ac191f14b708470b1c7cf4580f669b9c9264cd8", size = 4333867, upload-time = "2026-06-09T22:32:28.096Z" }, + { url = "https://files.pythonhosted.org/packages/9a/2e/772d7adbfa931537bc401640b7cac9976bff689bda187833e5d63b428e49/cryptography-48.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:66fd0771e7b9c6dcd44cf1120690d2338d16d72795cf40cae2786a39eba65429", size = 4701805, upload-time = "2026-06-09T22:31:38.284Z" }, + { url = "https://files.pythonhosted.org/packages/f8/a3/b06844f303873493c963caf581c04df31c7035e0c1b0f02c4814d319ec80/cryptography-48.0.1-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:3fd2ca57062b241c856670b073487d2e86c4637937ca5601e48f97bf8e11fc8f", size = 5258461, upload-time = "2026-06-09T22:31:04.187Z" }, + { url = "https://files.pythonhosted.org/packages/9f/13/8b765e2e12b07c74941caadb9d1c8fdc006c4dfbf2b8f2d610519758954d/cryptography-48.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:0ee6ea481db1ab889cba043ec1eda17bb9c1ea79db6722f779c3667f9f70322f", size = 4745488, upload-time = "2026-06-09T22:32:30.07Z" }, + { url = "https://files.pythonhosted.org/packages/2e/aa/48972bce55049b32a94f4907eda4d75fa385aad8a39506cc2fc72196ecf0/cryptography-48.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f2ceef93cb096aa3c4cc4b5c94ca6131f9196d28c64d6111533402a9b2054d41", size = 4830256, upload-time = "2026-06-09T22:31:43.868Z" }, + { url = "https://files.pythonhosted.org/packages/47/a2/e5079a032fb85cf6005046ca92bbd78b0c82dad2b5751ab8c311659da06f/cryptography-48.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9bd3f92d76217892b15df84ca256c2c113d386fdda7a7d8691aeeced976507c6", size = 4979117, upload-time = "2026-06-09T22:31:05.845Z" }, + { url = "https://files.pythonhosted.org/packages/b7/a0/8f50cae9c74e718ed769d63ed5c74bd0ea830c9550a74629cebd1b9c7bc7/cryptography-48.0.1-cp311-abi3-win32.whl", hash = "sha256:b9a32b876490d66c8bcc9963ef220199569748434ab01a9d6aaeabf88e7f5158", size = 3304154, upload-time = "2026-06-09T22:32:16.845Z" }, + { url = "https://files.pythonhosted.org/packages/c5/69/0572c77dbace6fef72f33755bd52ea399c71367250d366237f8691826b9e/cryptography-48.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:39489bfca54c7a1f6b297efcd8bc608ab92d16c4ca631b0cad4da46724588b24", size = 3817138, upload-time = "2026-06-09T22:32:00.388Z" }, + { url = "https://files.pythonhosted.org/packages/42/06/3e768b4c3bc78201583fa35a0e18f640dd782ff41afba88f8545481a8874/cryptography-48.0.1-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:f817adc181390bd54f2f700107a7419040fb7c1bdf2fc26f36551a06a68c3345", size = 7989830, upload-time = "2026-06-09T22:31:07.8Z" }, + { url = "https://files.pythonhosted.org/packages/8a/13/6476736484b94041110c8340a3eb63962fea4975baea8cb4a512adb44d4d/cryptography-48.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d5d30989c6917b478b5817902e85fddaea2261efa8648383d965381ccb9e1ac4", size = 4689201, upload-time = "2026-06-09T22:31:09.745Z" }, + { url = "https://files.pythonhosted.org/packages/79/62/65a87f34d2a431546e2509b85d55e8c90df86d668f6731da64d538512ac2/cryptography-48.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:df637c05205ea7c1d7fbcbe54bbfea648a52951155f997af13d895d0ecc96991", size = 4702822, upload-time = "2026-06-09T22:32:24.409Z" }, + { url = "https://files.pythonhosted.org/packages/7f/59/810b5204b0a9b10f4b6bc06bd551a8b609803cd931806bc3b71884b225e5/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:869c3b8a53bfe27147832df48b32adadf558249d50e76cb3769d40e986b13265", size = 4694875, upload-time = "2026-06-09T22:32:08.737Z" }, + { url = "https://files.pythonhosted.org/packages/24/dc/d8ca05ffea724eec6d232ea6f18e74c269eb6bdfdcc9bfba689790d1325f/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:e361afba8918070d376df76f408a4f67fec0ee9cff81a99e48fe9a233ef59e17", size = 5290385, upload-time = "2026-06-09T22:31:15.212Z" }, + { url = "https://files.pythonhosted.org/packages/03/8c/3be6cb4da181f5bb6c19cf560c2359d60644a6b5fc5b57854e528f47b296/cryptography-48.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:d069066deead00ac7f090be101be875a06855908f7ec004c27b8fefb4acfb411", size = 4737082, upload-time = "2026-06-09T22:32:22.66Z" }, + { url = "https://files.pythonhosted.org/packages/aa/f6/d5f60a5a1434dbfd949e227fd0065d194c7e6b6ac526b17f5c06152b8231/cryptography-48.0.1-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:09f73a725d582cef64b91281a322cd798d14a33b2b6f2b7ad9531dc336d84c02", size = 4325328, upload-time = "2026-06-09T22:32:10.777Z" }, + { url = "https://files.pythonhosted.org/packages/17/b7/ba75dd947a14b6ad907b01ae8f6b5b348cdd1b48142f0063dee9e20c1d9d/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:15254441469dd6bf027039453288e2072124f8b6603563f5d759e1c9b69273fa", size = 4694530, upload-time = "2026-06-09T22:31:53.105Z" }, + { url = "https://files.pythonhosted.org/packages/62/29/50d6b9e8aff12d8b67afaeb3569335e32dc83a5723e3bbded24fdac9f809/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:8ace4507d1e6533c125f4fac754f8bb8b6a74c08e92179dabd7e16571a3efbf3", size = 5245046, upload-time = "2026-06-09T22:31:25.774Z" }, + { url = "https://files.pythonhosted.org/packages/9f/04/618f4115cfc0add0838c82507aa18a346089428da8653ad38b3ff36f5cb3/cryptography-48.0.1-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:b4e391975f038e66432328639620a4aff2d307513b004f1ca06d6225bced815c", size = 4736660, upload-time = "2026-06-09T22:32:12.676Z" }, + { url = "https://files.pythonhosted.org/packages/24/9c/06e062462a0de28a3b3911322eded4c16deb9f441b1b7575d3dc59488ab5/cryptography-48.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42fcd8e26fe555d9b3577a135f5091fefa0aa4e99129c23fb56787a1bd4ada72", size = 4822229, upload-time = "2026-06-09T22:31:17.062Z" }, + { url = "https://files.pythonhosted.org/packages/f4/be/0561971eaaee4b8a0e7d5113c536921063ab91aaf23278ac374eaf881e11/cryptography-48.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c1400da5e32a43253392277eac7490a60e497d810a63dd5608d71bbd7af507c9", size = 4966364, upload-time = "2026-06-09T22:31:32.842Z" }, + { url = "https://files.pythonhosted.org/packages/a4/27/728c77876f12b000820b69ae490f3c4083775e79e07827e9e60be07ad209/cryptography-48.0.1-cp314-cp314t-win32.whl", hash = "sha256:0df56b056bc17c1b7d6821dfa65216e62bd232d8ab05eb3db44e71d235651471", size = 3278498, upload-time = "2026-06-09T22:31:29.154Z" }, + { url = "https://files.pythonhosted.org/packages/06/e3/79a612c6d7b1e6ee0edd43633d53035bec2cfb78c82b76f7864f39e36f34/cryptography-48.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:9de21387aa95e2a895823d0745b430bed4f33503ba9ab5e0b5311f33e37d66d2", size = 3798790, upload-time = "2026-06-09T22:31:56.697Z" }, + { url = "https://files.pythonhosted.org/packages/ca/6c/00fa2a95997164c8b2072ce327c23d4ab20809ccc323ea5fab91e53a4bba/cryptography-48.0.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:4fdc69f8e4316bcf0c8c8ec1f26f285d12e8142d88d96c876a59a03be3f6ae67", size = 7987408, upload-time = "2026-06-09T22:32:20.777Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d9/45f309a7e4e5f3f8f121d6d3be9e94024a7726ec598d6e08ae04edb2f04d/cryptography-48.0.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48fe40804d4caa2288f24e70ca8c64c42dd826da0ad7e4f1b41b2128d679e6c8", size = 4690196, upload-time = "2026-06-09T22:31:54.74Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9f/a1bc8bcc798811b8527eb374bbccf30a3f3e806829d967118222bf1125eb/cryptography-48.0.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:86be3b1b0b6bf09482fb50a979c508d2950ed95f5621ec77f4e385962006b83a", size = 4696782, upload-time = "2026-06-09T22:31:45.615Z" }, + { url = "https://files.pythonhosted.org/packages/66/c2/81a4fb4e4373c500bb526bc337ac5719dd31dd15b970b84a238168c6aa08/cryptography-48.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4ab0a343c807bbcd90c971cd1ecf072937cd01847a9e002bef88fb47ac6be577", size = 4696618, upload-time = "2026-06-09T22:31:11.564Z" }, + { url = "https://files.pythonhosted.org/packages/e5/0b/aa68b221dde92d09cb29a024ede17550ee21e77a404e59fc093c82bb51e1/cryptography-48.0.1-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9621de99d2da096006b629979efd8ae7eb2d8b822488d0c89ee4000c306c59b1", size = 5289970, upload-time = "2026-06-09T22:31:20.368Z" }, + { url = "https://files.pythonhosted.org/packages/78/13/fba657f958d2af66ea959a4ba01212632089249d34af1ae48054136344d7/cryptography-48.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:88c852a0ae366e262e5a1744b685e6a433dc8788dd2a277e418bf4904203609d", size = 4731873, upload-time = "2026-06-09T22:31:22.253Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4c/9a964756d24a26b3e34dfcb16f961b89838786e6700b635b0d1e3adff4b6/cryptography-48.0.1-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:43c5835e2cb98c8733d86f57d6fc879b613f5c3478607281c3e36daffc6dd8a6", size = 4330804, upload-time = "2026-06-09T22:31:36.56Z" }, + { url = "https://files.pythonhosted.org/packages/4b/0f/a10f3a6eb12950a10e3a874070283aa2dd5875b2bfd15fad8a3e17b3f13e/cryptography-48.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:fe0180af5bf9236518a087e35bf2d9a347d5f5f51e63c579d683ddff424e3d46", size = 4696217, upload-time = "2026-06-09T22:31:13.351Z" }, + { url = "https://files.pythonhosted.org/packages/f3/6f/5cd12f951165ea73ef85266775d97e4c763b2474ccfd816dd69d3a18d6f8/cryptography-48.0.1-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:b7a2d1a937a738a881737cec135a38bb61470589b17515b9f73f571d0ae10401", size = 5245252, upload-time = "2026-06-09T22:32:02.193Z" }, + { url = "https://files.pythonhosted.org/packages/68/ab/8aaa12e4516ec4464033ab79b6f3b592bd5a92102467c4ace8a0d970203f/cryptography-48.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:b74ca3b8e5ecdd833bf6a002ca41b4793bb27fb8f1c06ffaf2643c9e9140e31b", size = 4731388, upload-time = "2026-06-09T22:32:04.019Z" }, + { url = "https://files.pythonhosted.org/packages/1b/24/50027ea4dca85ec1f40688f3c24fb32ccacd520583c9592c3cc95628e6fb/cryptography-48.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2c37f2461406063b417837f5f3daab668652acd82423efcd7f0a9f04be972de1", size = 4824186, upload-time = "2026-06-09T22:32:18.707Z" }, + { url = "https://files.pythonhosted.org/packages/52/41/04cb5eb17085ade6f50cc611fb657df6a0f5885350de8764ece89c050197/cryptography-48.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:86fe77abb1bd87afb251d4d02ada7ecf53a32cee9b67d976abb2e45a13297475", size = 4964539, upload-time = "2026-06-09T22:31:18.793Z" }, + { url = "https://files.pythonhosted.org/packages/36/bf/ed70785c496e89d7e73b7cda2d21f2447fd6d4e821714b8d04ff217fed92/cryptography-48.0.1-cp39-abi3-win32.whl", hash = "sha256:6b2c0c3e6ccf3ade7750f836ef3ee36eea250cc467d45c256895573ac08cc6f1", size = 3282307, upload-time = "2026-06-09T22:30:53.162Z" }, + { url = "https://files.pythonhosted.org/packages/b3/ff/371ea7d252656ee1eb6d83eeeef3d1d0c6baf1d6497687d081ea03814670/cryptography-48.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:9a49ca6c81417f6a5edb50375a60cccdd70fa0a91a5211829dbea74eba94d2ac", size = 3793408, upload-time = "2026-06-09T22:32:15.191Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d3/eb4e394e587341fdad09a09101fa76478ead3a78b0ad63e55c22f0d75c02/cryptography-48.0.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:08a597acce1ff37f347400087776599e2348a3a8bc53b44120e463cd274efe4a", size = 3951747, upload-time = "2026-06-09T22:31:23.871Z" }, + { url = "https://files.pythonhosted.org/packages/e0/4a/3f43451b4f858bfceaaaffc649e6e787e8d4fb332a1d443af39ab02cc8f1/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:735824ec41b7f74a7c45fb1591349333e4c696cb6c044e5f46356e560143e4cd", size = 4641226, upload-time = "2026-06-09T22:31:02.532Z" }, + { url = "https://files.pythonhosted.org/packages/73/4e/855584c2c23b09e4ce2d3b9c30e983e679cd60b068c513c6bbdb91e11782/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:92a46e1d638daa264ba2971c0b0489c9409787943efae4d60ffda3d091ef832c", size = 4668958, upload-time = "2026-06-09T22:32:06.213Z" }, + { url = "https://files.pythonhosted.org/packages/42/3b/d35750e41d803d1e516fd6d6011f065424924da7af1748cef4cc9cb3ede1/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:7e234ac052af99f2700826a5c29ea99d9c1b1f80341cde62d11c8154dc8e0bd9", size = 4640793, upload-time = "2026-06-09T22:32:26.331Z" }, + { url = "https://files.pythonhosted.org/packages/ca/aa/cdb7181fe865285e87e96825aaab239400f1de0c3bfba9bd9769b79f1a92/cryptography-48.0.1-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:33842cf0888951cef5bc7ac724ab844a42044c1727b967b7f8997289a0464f92", size = 4668505, upload-time = "2026-06-09T22:31:27.534Z" }, + { url = "https://files.pythonhosted.org/packages/5d/8c/ce3823c06c2804f194f9e64f0d67fa3f4094a39f2bb1a990cd03603af8fc/cryptography-48.0.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6184ca7b174f28d7c703f1290d4b297217c45355f77a98f67e9b7f14549ac54a", size = 3742204, upload-time = "2026-06-09T22:31:34.773Z" }, +] + +[[package]] +name = "cuda-bindings" +version = "12.9.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] +dependencies = [ + { name = "cuda-pathfinder", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/31/bfcc870f69c6a017c4ad5c42316207fc7551940db6f3639aa4466ec5faf3/cuda_bindings-12.9.4-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a022c96b8bd847e8dc0675523431149a4c3e872f440e3002213dbb9e08f0331a", size = 11800959, upload-time = "2025-10-21T14:51:26.458Z" }, + { url = "https://files.pythonhosted.org/packages/7a/d8/b546104b8da3f562c1ff8ab36d130c8fe1dd6a045ced80b4f6ad74f7d4e1/cuda_bindings-12.9.4-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d3c842c2a4303b2a580fe955018e31aea30278be19795ae05226235268032e5", size = 12148218, upload-time = "2025-10-21T14:51:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/b5/1e/9c8ed3f3dbed7b7d038805fdc65cbc65fda9983e84437778a9571e7092bc/cuda_bindings-12.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:f69107389e6b9948969bfd0a20c4f571fd1aefcfb1d2e1b72cc8ba5ecb7918ab", size = 11464568, upload-time = "2025-10-21T14:51:31.454Z" }, + { url = "https://files.pythonhosted.org/packages/a9/2b/ebcbb60aa6dba830474cd360c42e10282f7a343c0a1f58d24fbd3b7c2d77/cuda_bindings-12.9.4-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6a429dc6c13148ff1e27c44f40a3dd23203823e637b87fd0854205195988306", size = 11840604, upload-time = "2025-10-21T14:51:34.565Z" }, + { url = "https://files.pythonhosted.org/packages/45/e7/b47792cc2d01c7e1d37c32402182524774dadd2d26339bd224e0e913832e/cuda_bindings-12.9.4-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c912a3d9e6b6651853eed8eed96d6800d69c08e94052c292fec3f282c5a817c9", size = 12210593, upload-time = "2025-10-21T14:51:36.574Z" }, + { url = "https://files.pythonhosted.org/packages/dd/be/90d32049e06abcfba4b2e7df1dbcb5e16215c8852eef0cd8b25f38a66bd4/cuda_bindings-12.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:443b0875916879c2e4c3722941e25e42d5ab9bcbf34c9e83404fb100fa1f6913", size = 11490933, upload-time = "2025-10-21T14:51:38.792Z" }, + { url = "https://files.pythonhosted.org/packages/0c/c2/65bfd79292b8ff18be4dd7f7442cea37bcbc1a228c1886f1dea515c45b67/cuda_bindings-12.9.4-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:694ba35023846625ef471257e6b5a4bc8af690f961d197d77d34b1d1db393f56", size = 11760260, upload-time = "2025-10-21T14:51:40.79Z" }, + { url = "https://files.pythonhosted.org/packages/a9/c1/dabe88f52c3e3760d861401bb994df08f672ec893b8f7592dc91626adcf3/cuda_bindings-12.9.4-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fda147a344e8eaeca0c6ff113d2851ffca8f7dfc0a6c932374ee5c47caa649c8", size = 12151019, upload-time = "2025-10-21T14:51:43.167Z" }, + { url = "https://files.pythonhosted.org/packages/df/6b/9c1b1a6c01392bfdd758e9486f52a1a72bc8f49e98f9355774ef98b5fb4e/cuda_bindings-12.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:696ca75d249ddf287d01b9a698b8e2d8a05046495a9c051ca15659dc52d17615", size = 11586961, upload-time = "2025-10-21T14:51:45.394Z" }, + { url = "https://files.pythonhosted.org/packages/05/8b/b4b2d1c7775fa403b64333e720cfcfccef8dcb9cdeb99947061ca5a77628/cuda_bindings-12.9.4-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cf8bfaedc238f3b115d957d1fd6562b7e8435ba57f6d0e2f87d0e7149ccb2da5", size = 11570071, upload-time = "2025-10-21T14:51:47.472Z" }, + { url = "https://files.pythonhosted.org/packages/63/56/e465c31dc9111be3441a9ba7df1941fe98f4aa6e71e8788a3fb4534ce24d/cuda_bindings-12.9.4-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:32bdc5a76906be4c61eb98f546a6786c5773a881f3b166486449b5d141e4a39f", size = 11906628, upload-time = "2025-10-21T14:51:49.905Z" }, + { url = "https://files.pythonhosted.org/packages/05/d0/d0e4e2e047d8e899f023fa15ad5e9894ce951253f4c894f1cd68490fdb14/cuda_bindings-12.9.4-cp313-cp313-win_amd64.whl", hash = "sha256:a2e82c8985948f953c2be51df45c3fe11c812a928fca525154fb9503190b3e64", size = 11556719, upload-time = "2025-10-21T14:51:52.248Z" }, + { url = "https://files.pythonhosted.org/packages/ec/07/6aff13bc1e977e35aaa6b22f52b172e2890c608c6db22438cf7ed2bf43a6/cuda_bindings-12.9.4-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3adf4958dcf68ae7801a59b73fb00a8b37f8d0595060d66ceae111b1002de38d", size = 11566797, upload-time = "2025-10-21T14:51:54.581Z" }, + { url = "https://files.pythonhosted.org/packages/a3/84/1e6be415e37478070aeeee5884c2022713c1ecc735e6d82d744de0252eee/cuda_bindings-12.9.4-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56e0043c457a99ac473ddc926fe0dc4046694d99caef633e92601ab52cbe17eb", size = 11925991, upload-time = "2025-10-21T14:51:56.535Z" }, + { url = "https://files.pythonhosted.org/packages/4d/3c/972edfddb4ae8a9fccd3c3766ed47453b6f805b6026b32f10209dd4b8ad4/cuda_bindings-12.9.4-cp313-cp313t-win_amd64.whl", hash = "sha256:b32d8b685f0e66f5658bcf4601ef034e89fc2843582886f0a58784a4302da06c", size = 11894363, upload-time = "2025-10-21T14:51:58.633Z" }, + { url = "https://files.pythonhosted.org/packages/1e/b5/96a6696e20c4ffd2b327f54c7d0fde2259bdb998d045c25d5dedbbe30290/cuda_bindings-12.9.4-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f53a7f453d4b2643d8663d036bafe29b5ba89eb904c133180f295df6dc151e5", size = 11624530, upload-time = "2025-10-21T14:52:01.539Z" }, + { url = "https://files.pythonhosted.org/packages/d1/af/6dfd8f2ed90b1d4719bc053ff8940e494640fe4212dc3dd72f383e4992da/cuda_bindings-12.9.4-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8b72ee72a9cc1b531db31eebaaee5c69a8ec3500e32c6933f2d3b15297b53686", size = 11922703, upload-time = "2025-10-21T14:52:03.585Z" }, + { url = "https://files.pythonhosted.org/packages/e6/87/652796522cc1a7af559460e1ce59b642e05c1468b9c08522a9a096b4cf04/cuda_bindings-12.9.4-cp314-cp314-win_amd64.whl", hash = "sha256:53a10c71fdbdb743e0268d07964e5a996dd00b4e43831cbfce9804515d97d575", size = 11517716, upload-time = "2025-10-21T14:52:06.013Z" }, + { url = "https://files.pythonhosted.org/packages/39/73/d2fc40c043bac699c3880bf88d3cebe9d88410cd043795382826c93a89f0/cuda_bindings-12.9.4-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20f2699d61d724de3eb3f3369d57e2b245f93085cab44fd37c3bea036cea1a6f", size = 11565056, upload-time = "2025-10-21T14:52:08.338Z" }, + { url = "https://files.pythonhosted.org/packages/6c/19/90ac264acc00f6df8a49378eedec9fd2db3061bf9263bf9f39fd3d8377c3/cuda_bindings-12.9.4-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d80bffc357df9988dca279734bc9674c3934a654cab10cadeed27ce17d8635ee", size = 11924658, upload-time = "2025-10-21T14:52:10.411Z" }, + { url = "https://files.pythonhosted.org/packages/ab/52/a30f46e822bfa6b4a659d1e8de8c4a4adf908ea075dac568b55362541bd8/cuda_bindings-12.9.4-cp314-cp314t-win_amd64.whl", hash = "sha256:53e11991a92ff6f26a0c8a98554cd5d6721c308a6b7bfb08bebac9201e039e43", size = 12055608, upload-time = "2025-10-21T14:52:12.335Z" }, +] + +[[package]] +name = "cuda-bindings" +version = "13.0.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] +dependencies = [ + { name = "cuda-pathfinder", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/98/0666ee759cd2e5306f911cbc95d2c6c814326906ed6b9c09e817a4b4a7c8/cuda_bindings-13.0.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56e46a9e984bb754e56b9d060cf027fe99f08a97651ce6d8aa1c2032476d01e", size = 11762523, upload-time = "2025-10-21T15:08:45.913Z" }, + { url = "https://files.pythonhosted.org/packages/e1/36/2b2a43c8a6f8d8ff7a5ec7de1357ba3f1438ea69281c9deb90df29d55d56/cuda_bindings-13.0.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5f797ce534a303525259be0ae7ee9cfcf4f7874b22f1f9b8e85555509dccb83", size = 12136098, upload-time = "2025-10-21T15:08:48.233Z" }, + { url = "https://files.pythonhosted.org/packages/47/67/5de1d48189511114859a1a131193896f88271c067a64b1159787e2d9f89b/cuda_bindings-13.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:74307cea1feee6c32a6e27b42e77beb22cd21cff4b7764fd214fa6ff89f8bd69", size = 11106982, upload-time = "2025-10-21T15:08:50.433Z" }, + { url = "https://files.pythonhosted.org/packages/dc/67/9e171ee6359d4aabf2d8202802c85487cae6c2eb52b9352bb7754583802f/cuda_bindings-13.0.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfd66c25a133365c4f93e3396c38c64b04400ccafd18c3a889ae251a1bfabaa1", size = 11807212, upload-time = "2025-10-21T15:08:52.988Z" }, + { url = "https://files.pythonhosted.org/packages/3a/66/d7036d9e402e6b5b57877a7496aba3bf2a0090f4fa3f072743fce3373eba/cuda_bindings-13.0.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9afede5937474864aa794eb57399dbdf5d2b05427aadcac275209b0857528a61", size = 12198791, upload-time = "2025-10-21T15:08:55.687Z" }, + { url = "https://files.pythonhosted.org/packages/83/25/620ce2afb6ea6d5da89d98375c85641f691924eef574247f7f0dd99f8bee/cuda_bindings-13.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:fce6d6b162457475b35e1a259ab643e683d1d20a84459fea898782e2f1e10a3b", size = 11138783, upload-time = "2025-10-21T15:08:57.741Z" }, + { url = "https://files.pythonhosted.org/packages/61/3c/c33fd3aa5fcc89aa1c135e477a0561f29142ab5fe028ca425fc87f7f0a74/cuda_bindings-13.0.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b899e5a513c11eaa18648f9bf5265d8de2a93f76ef66a6bfca0a2887303965cd", size = 11709086, upload-time = "2025-10-21T15:09:00.005Z" }, + { url = "https://files.pythonhosted.org/packages/21/ac/6b34452a3836c9fbabcd360689a353409d15f500dd9d9ced7f837549e383/cuda_bindings-13.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf41d9e69019939aa15296fa66ea7d3fdb8d2c6383f729f4b1156c8b37808a06", size = 12128303, upload-time = "2025-10-21T15:09:02.889Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/ad9cc2f0496886c37aefbc00256197a6043a3f04bbe959481e6908310afe/cuda_bindings-13.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:6b12ccd98f447aea9589d32caf9efda0c193994080752a60f790b646d519fe8c", size = 11237397, upload-time = "2025-10-21T15:09:05.421Z" }, + { url = "https://files.pythonhosted.org/packages/2f/36/41ccc303eb6be8ae82c5edd2ccae938876e8a794660e8bb96a193174a978/cuda_bindings-13.0.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fb16a7f769c9c67469add7a1d9f6c14dd44637f6921cb6b9eb82cb5015b35c3d", size = 11537064, upload-time = "2025-10-21T15:09:07.84Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ac/699889100536f1b63779646291e74eefa818087a0974eb271314d850f5dc/cuda_bindings-13.0.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:512d0d803a5e47a8a42d5a34ce0932802bf72fe952fdb11ac798715a35c6e5cb", size = 11910447, upload-time = "2025-10-21T15:09:09.942Z" }, + { url = "https://files.pythonhosted.org/packages/8c/f9/a2f5910aaf21f4cd43f456ea80f47f1424eece5b8f063dac1980304b8ef0/cuda_bindings-13.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:dd83e8d79587e265b82d3e589ba6b061770537443dfb1bb4a74f755c8b13f62b", size = 11211659, upload-time = "2025-10-21T15:09:12.639Z" }, + { url = "https://files.pythonhosted.org/packages/11/67/9656e003f18c5b32e1a2496998b24f4355ec978c5f3639b0eb9f6d0ff83f/cuda_bindings-13.0.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c859e326c776a47e66c50386a10c84fe34291eb6e711610c9fd7cc27d446334f", size = 11522409, upload-time = "2025-10-21T15:09:14.674Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/a83379caa7c1bed4195e704c24467a6c07fe8e29c7055ccd4f00c5702363/cuda_bindings-13.0.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e675dbd009fb5e66d63fd13a8ff35f849120f01bcc4dafadbced3004605c3588", size = 11903148, upload-time = "2025-10-21T15:09:16.918Z" }, + { url = "https://files.pythonhosted.org/packages/7c/e0/ff1eeda06364df8c750843432ac6efb33a06df38261f0a1ceee59bb7dac2/cuda_bindings-13.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:193762306b6032c00a141fc38bcef92c6fb4d332fd2d6a550c7f950e7fd8acd8", size = 11543153, upload-time = "2025-10-21T15:09:19.252Z" }, + { url = "https://files.pythonhosted.org/packages/e8/99/0042dc5e98e3364480b1aaabc0f5c150d037825b264bba35ac7a883e46ee/cuda_bindings-13.0.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7c7e6e89cdfc9b34f16a065cc6ad6c4bab19ce5dcef8da3ace8ad10bda899fa0", size = 11594384, upload-time = "2025-10-21T15:09:21.938Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c4/a931a90ce763bd7d587e18e73e4ce246b8547c78247c4f50ee24efc0e984/cuda_bindings-13.0.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e93866465e7ff4b7ebdf711cf9cd680499cd875f992058c68be08d4775ac233d", size = 11920899, upload-time = "2025-10-21T15:09:26.306Z" }, + { url = "https://files.pythonhosted.org/packages/14/3e/5725b2e5b9ac22bf19a50ec5f7611301ab6111c98ccf1b6b125fdaa71550/cuda_bindings-13.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bd2364bc49925837ce18dda259c3a36e539977ca0297799a54891cae1d5213f5", size = 11160621, upload-time = "2025-10-21T15:09:28.7Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2c/ec611e27ba48a9056f3b0610c5e27727e539f3905356cfe07acea18e772c/cuda_bindings-13.0.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed06ef3507bd0aefb0da367e3d15676a8c7443bd68a88f298562d60b41078c20", size = 11521928, upload-time = "2025-10-21T15:09:30.714Z" }, + { url = "https://files.pythonhosted.org/packages/d4/2e/02cebf281ef5201b6bb9ea193b1a4d26e6233c46571cfb04c4a7dede12b9/cuda_bindings-13.0.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3ab845487ca2c14accdcb393a559a3070469ea4b591d05e6ef439471f47f3e24", size = 11902749, upload-time = "2025-10-21T15:09:32.688Z" }, + { url = "https://files.pythonhosted.org/packages/36/d2/088c28751f54df7a251259ef3f99d34c428e12653f15db02fd62a96247af/cuda_bindings-13.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:aaa0934e16aa20ec10fbb1ecc53a6961b8d1c06a970fe05cc6ee7d2a805a090f", size = 11697137, upload-time = "2025-10-21T15:09:35.232Z" }, +] + +[[package]] +name = "cuda-pathfinder" +version = "1.5.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/c8/26f2e4aae92f11522a96043892ba39a90eac610d5242523aa863212bc1c7/cuda_pathfinder-1.5.5-py3-none-any.whl", hash = "sha256:0228c023f95d1480f143ef5c8922d27a2ab052087a942e81dc289c9eb8f91689", size = 51671, upload-time = "2026-05-27T01:21:25.413Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/aa/12037145b7a56eaa5b29b41872f7a21b538e807e13f32c4d3c46e59be084/debugpy-1.8.21.tar.gz", hash = "sha256:a3c53278e84c94e11bd87c53970ec391d1a67396c8b22609fcac576520e611a6", size = 1697577, upload-time = "2026-06-01T19:30:35.156Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/f3/6b1d4c71f4cbb5360009f928934a03b42906f28fc7b3f7f35f04e58acead/debugpy-1.8.21-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:8eeab7b5462f683452c57c0126aaa5ec4e974ddb705f39ba87dff8818c8e08f9", size = 2113873, upload-time = "2026-06-01T19:30:37.148Z" }, + { url = "https://files.pythonhosted.org/packages/1c/f2/17c3bf91cebc173bfbf5734cd2669723d0a35c0cf9d2fd2124546efeae83/debugpy-1.8.21-cp310-cp310-manylinux_2_34_x86_64.whl", hash = "sha256:0fddfdc130ac6d8bfc0415b0409822fa901c8f310e5c945ac5653a0352532344", size = 3004715, upload-time = "2026-06-01T19:30:38.888Z" }, + { url = "https://files.pythonhosted.org/packages/5a/22/1f8efd80c7b5909e760f9cfd0c9e8681d2d35d532f7c0a40760cd4da4a19/debugpy-1.8.21-cp310-cp310-win32.whl", hash = "sha256:72b5d676c4cbfac3bac5bb01c138a4656e843f93f03ce2a5f4e394ad49fbee73", size = 5303455, upload-time = "2026-06-01T19:30:40.52Z" }, + { url = "https://files.pythonhosted.org/packages/da/ce/54c79abd6cccef92fa7b43d97e3acafedf4d645557267ece05e948b5e4b8/debugpy-1.8.21-cp310-cp310-win_amd64.whl", hash = "sha256:a7fe47fd23da57b9e0bec3f4a8ee65a2dc55782455ed7f2141d75ab5d2eaeef5", size = 5331751, upload-time = "2026-06-01T19:30:42.146Z" }, + { url = "https://files.pythonhosted.org/packages/89/fb/cbf306d6e07a313a91e7171a98669054502840931432c227cfd505ee367f/debugpy-1.8.21-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:da456226c7b4c69e35dbe35dcee6623d912000a77816db7856a41af1c72a0264", size = 2203120, upload-time = "2026-06-01T19:30:43.964Z" }, + { url = "https://files.pythonhosted.org/packages/aa/57/aa739bd4ad2cbf96aeb1b20b56918ddd5ae4c28b68709bfcd327f02123ee/debugpy-1.8.21-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:f68b891688e61bdc08b8d364d919ff0051e0b94657b39dcd027bc3173edb7cdc", size = 3059958, upload-time = "2026-06-01T19:30:45.622Z" }, + { url = "https://files.pythonhosted.org/packages/a8/31/453d2c9a23d133fe2c8ec7ca1d816ded52a913487fe3ffef7c01b4b706af/debugpy-1.8.21-cp311-cp311-win32.whl", hash = "sha256:f843a8b08c2edeaf9b1582eed4f25441af21a297c22ff16bf76a662557aa9c9e", size = 5236515, upload-time = "2026-06-01T19:30:47.461Z" }, + { url = "https://files.pythonhosted.org/packages/60/94/6660de2f2d7bf388f229335ba4637646eebabdbf38564cb439a95a9193c9/debugpy-1.8.21-cp311-cp311-win_amd64.whl", hash = "sha256:84c564d8cc701d41843b29a92814c1f1bef6798724ca9d675c284ad9f6a547d7", size = 5256138, upload-time = "2026-06-01T19:30:49.113Z" }, + { url = "https://files.pythonhosted.org/packages/a2/df/bf625547431a9cadc9f4cbfeda38866e2b17f6aed147b625377e87834449/debugpy-1.8.21-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:9f96713896f39c3dff0ee841f47320c3f2983d33c341e009361bb0ebc79adc4e", size = 2483609, upload-time = "2026-06-01T19:30:50.794Z" }, + { url = "https://files.pythonhosted.org/packages/bf/09/59324b903599031ff9faaec1758292409f6561a0ec2492fe4b703327705a/debugpy-1.8.21-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:c193d474f0a211191f2b4449d2d06157c689013035bd952f3b617e0ef422b176", size = 3968900, upload-time = "2026-06-01T19:30:52.341Z" }, + { url = "https://files.pythonhosted.org/packages/14/cd/27f65b805d7fe005c44e1a36b9183ecdfbcdbf9d3e721a5115d461ecc7ee/debugpy-1.8.21-cp312-cp312-win32.whl", hash = "sha256:4743373c1cac7f9e74a1b9915bf1dbe0e900eca657ffb170ae07ac8363205ae9", size = 5336340, upload-time = "2026-06-01T19:30:54.047Z" }, + { url = "https://files.pythonhosted.org/packages/77/1d/c84e30c0c674184948b66f076ab271c01d940618a2824c23cd035a27bc20/debugpy-1.8.21-cp312-cp312-win_amd64.whl", hash = "sha256:bd7ba9dd3daa7c2f942c6ca8d4695a16bf9ac16b63615261c7982bc74f7ed20c", size = 5374751, upload-time = "2026-06-01T19:30:55.891Z" }, + { url = "https://files.pythonhosted.org/packages/77/6b/d817e1f8cc77aa055d37fba092e0febfdff40fe652d8d53d4cd7a86ad98d/debugpy-1.8.21-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:13678151fc401e2d68c9880b91e28714f797d40422994572b24560ef80910a88", size = 2477398, upload-time = "2026-06-01T19:30:57.644Z" }, + { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" }, + { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3d/f4bbb323a548bfab2af3d6b4ffd9bf22636e55956a1285d317a1de643aad/debugpy-1.8.21-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9bb2a685287a2ac9b181cde89edcec64845cb51de7faaa75badb9a698bc24782", size = 2477209, upload-time = "2026-06-01T19:31:04.157Z" }, + { url = "https://files.pythonhosted.org/packages/8c/2d/6e7ec524984a1702777868de49a4c53202bddac2a432a76a093469587750/debugpy-1.8.21-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:3d6922439bf33fd38a3e2c447869ebc7b97da5cd3d329ff1ef9bc06c4903437e", size = 3927115, upload-time = "2026-06-01T19:31:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/97/47/d1aa6d64005a98a9144647d99306b419396f9ad7bf1d73c119e17a81fb4d/debugpy-1.8.21-cp314-cp314-win32.whl", hash = "sha256:15d4963bd5ffa48f0da0947fd06757fa7621945048a14ad7705431566d3c0e7c", size = 5336724, upload-time = "2026-06-01T19:31:07.711Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/b905b90d163af11878c1af8abafa4a25206335e112e284e413454543a6da/debugpy-1.8.21-cp314-cp314-win_amd64.whl", hash = "sha256:fe0744a12353406de0ae8ccff0d0a4a666f00801a3db8fd04e7a5f761cd520e8", size = 5373803, upload-time = "2026-06-01T19:31:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" }, +] + +[[package]] +name = "decorator" +version = "5.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/60/8b/32f9823da46cde7df2087faa08cd98d01b908f8dcab982cdba9c84e85355/decorator-5.3.1.tar.gz", hash = "sha256:4cbcdd55a6efadb9dbea26b858f4fb3264567b52d69ca0d25b721b553f60ea82", size = 58084, upload-time = "2026-05-18T06:03:28.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/7f/798705f5296a58ca505d600456748d1be48078eac8a7050d8a98bc9edb89/decorator-5.3.1-py3-none-any.whl", hash = "sha256:f47fe6fdbd2edd623ecfe36875d37aba411624e2670dd395dddae1358689bb3c", size = 10365, upload-time = "2026-05-18T06:03:26.517Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "distlib" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/46/8d/873e9252ea2c0e0c857884e0a2899ec43ade132345df1925ef24cbe64f18/distlib-0.4.2.tar.gz", hash = "sha256:baeb401c90f27acd15c4861ae0847d1e731c27ac3dbf4210643ba61fa1e813db", size = 614914, upload-time = "2026-06-08T16:24:15.439Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/60/aa891c893821d4d127292ed66c6940d1d715894bd5a0ce048056bc641773/distlib-0.4.2-py2.py3-none-any.whl", hash = "sha256:ca4cb11e5d746b5ec13c199cbf19ae27a241f89702b54e153a74332955446067", size = 470510, upload-time = "2026-06-08T16:24:13.208Z" }, +] + +[[package]] +name = "docutils" +version = "0.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/330ea8d383eb2ce973df34d1239b3b21e91cd8c865d21ff82902d952f91f/docutils-0.19.tar.gz", hash = "sha256:33995a6753c30b7f577febfc2c50411fec6aac7f7ffeb7c4cfe5991072dcf9e6", size = 2056383, upload-time = "2022-07-05T20:17:31.045Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/69/e391bd51bc08ed9141ecd899a0ddb61ab6465309f1eb470905c0c8868081/docutils-0.19-py3-none-any.whl", hash = "sha256:5e1de4d849fee02c63b040a4a3fd567f4ab104defd8a5511fbbc24a8a017efbc", size = 570472, upload-time = "2022-07-05T20:17:26.388Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "execnet" +version = "2.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" }, +] + +[[package]] +name = "filelock" +version = "3.29.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/f9/f38573ed5844586db374d085911740a501ccfa373b455fc9413f09f85237/filelock-3.29.1.tar.gz", hash = "sha256:d97e6b1b9757569626c58caa07dc4beb1613f4a2938b1e8cc81afca398906c9e", size = 59335, upload-time = "2026-06-03T15:19:04.053Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/a0/614c5fe402fd88951df45f4dda2fa3b4e17a99ecd92340771929169b3b95/filelock-3.29.1-py3-none-any.whl", hash = "sha256:85199dfd706869641b72b2e8955d5416a4b2b7dc4b0e8e6d97b4cc1299a6983b", size = 40750, upload-time = "2026-06-03T15:19:02.959Z" }, +] + +[[package]] +name = "fonttools" +version = "4.63.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/c9/4141c90a90db20f807c7e10bfd689fe53eb8f7f4caff58ee4d4dfe46919f/fonttools-4.63.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e3297a6a4059b4acc3a1e9a8b04741f240a80044eef08ebd32e8b5bcdddce75b", size = 2884632, upload-time = "2026-05-14T12:02:38.56Z" }, + { url = "https://files.pythonhosted.org/packages/b8/46/ad12b5c10eae602d7ef814b02afa08aacbf89da917fed5b071282b7eadc2/fonttools-4.63.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b1cd75a03ad8cb5bc40c90bfde68c0c47de423aa19e5c0f362b43520645eea94", size = 2429441, upload-time = "2026-05-14T12:02:41.162Z" }, + { url = "https://files.pythonhosted.org/packages/90/8f/bdca24a84c81d56fffed052229cdcff368f6e05882e526f4558891481f65/fonttools-4.63.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0425b277a59cff3d80ca42162a8de360f318438a2ac83570842a678d826d579", size = 4946346, upload-time = "2026-05-14T12:02:43.41Z" }, + { url = "https://files.pythonhosted.org/packages/04/59/a639c0e136441ee91a65b56fdf89e5d075927e7a09c559d1b0f5276577db/fonttools-4.63.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d7e5c9973aa04c95650c96e5f5ad865fbf42d62079163ecfab1e01cbc2504c22", size = 4903184, upload-time = "2026-05-14T12:02:45.742Z" }, + { url = "https://files.pythonhosted.org/packages/e6/53/91b7e0cb45b536f3da1b29ba8cbab89f27e8b986809e0b1982303a3f4eca/fonttools-4.63.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cb014d58140a38135f16064c74c652ed57aa0b75cbf8bb59cac821f7edb5334e", size = 4922967, upload-time = "2026-05-14T12:02:48.386Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b7/87439bf44e6b97c5538cd29d0b7e366a5b8ce2cc132a4134fb67fa3f2fa2/fonttools-4.63.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:032038247a96c1690f9f31e377c389383c902531b085aa4e4dabd6f57f870e69", size = 5042799, upload-time = "2026-05-14T12:02:50.424Z" }, + { url = "https://files.pythonhosted.org/packages/ad/7c/8b96c3263b89ef99cded544c0f0636686f85dbd3c211c4dceef0231fca23/fonttools-4.63.0-cp310-cp310-win32.whl", hash = "sha256:a8b33a82979e0a6a34ff435cc81317be1f95ec1ebb7a3a2d1c8a6a54f02ae44e", size = 1519704, upload-time = "2026-05-14T12:02:52.523Z" }, + { url = "https://files.pythonhosted.org/packages/e5/4d/2c2f0069970b6907de8fb5b05c5c0193cc22f717df151d1c7aef1c738f58/fonttools-4.63.0-cp310-cp310-win_amd64.whl", hash = "sha256:0c18358a155d75034911c5ee397a5b44cd19dd325dbb8b35fb60bf421d6a72ac", size = 1568666, upload-time = "2026-05-14T12:02:54.917Z" }, + { url = "https://files.pythonhosted.org/packages/75/2b/a7f1545bdf5da69c4bda0cea2a5781f0ad2a6623e0277267672db43c5fe6/fonttools-4.63.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2b8ae05d9eacf6081414d759c0a352769ac28ce31280d6bb8e77b03f9e3c449f", size = 2881793, upload-time = "2026-05-14T12:02:56.645Z" }, + { url = "https://files.pythonhosted.org/packages/49/50/965308c703f085f225db2886813b27e015b8b3438c350b22dd65b52c2a2c/fonttools-4.63.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:79cdc9f567aec74a72918fd060283911406750cbc9fd28c1316023deb6ce31a9", size = 2428130, upload-time = "2026-05-14T12:02:58.891Z" }, + { url = "https://files.pythonhosted.org/packages/d8/38/6937fbd7f2dc3a6b48725851bc2c15ec949b9af14d9bbcb5fe83cdf9bdf9/fonttools-4.63.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c14b4fd138c4bafcca294765c547914e1aa431ae1ca94ab99d8db08c958bd3b", size = 5111952, upload-time = "2026-05-14T12:03:01.263Z" }, + { url = "https://files.pythonhosted.org/packages/0b/43/a81f20050a3115b57d62c8e781446949512eac36690dc384ccea65ff4cc1/fonttools-4.63.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76ac49f929aecaf82d83250b8347e099d7aecba0f4726c1d9b6df3b8bb5fe18", size = 5082308, upload-time = "2026-05-14T12:03:03.211Z" }, + { url = "https://files.pythonhosted.org/packages/67/00/cdd9d4944ca6ae280d01e69cc37bde3bf663630b837a6fc6d2cd65d80e0e/fonttools-4.63.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dcf076a4474fe0d7367e5bbf5b052c7284fa1feca729c04176ce513521afd8a0", size = 5087932, upload-time = "2026-05-14T12:03:05.147Z" }, + { url = "https://files.pythonhosted.org/packages/f5/f1/0aa0dbea778c75adbef223c42019fd47d22262b905974d62d829545d485f/fonttools-4.63.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7dd683fef0663e9f0f45cf541d788d24caa3ec9db50796b588e1757d8b3bc007", size = 5213271, upload-time = "2026-05-14T12:03:07.238Z" }, + { url = "https://files.pythonhosted.org/packages/a8/99/253e4056e1f0e67b9390125a154b73b5eb73ad521bece95c004858fdeec2/fonttools-4.63.0-cp311-cp311-win32.whl", hash = "sha256:afefc1ed0a59785a7fb06ea7e1678e849c193e1e387db783579bc7b3056fcfcb", size = 2304473, upload-time = "2026-05-14T12:03:09.271Z" }, + { url = "https://files.pythonhosted.org/packages/08/60/defa5e69641db890a63be281f41345f4c33b157824eaf0b9fad3e08b0dcb/fonttools-4.63.0-cp311-cp311-win_amd64.whl", hash = "sha256:063e08bd17bd5a90127a14123de0d6a952dbc847695fd98b63c043d58057f90c", size = 2356389, upload-time = "2026-05-14T12:03:11.53Z" }, + { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" }, + { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" }, + { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" }, + { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" }, + { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8d/d8fec3dcde2963f8c908fb315e5ff2cd0ac34f82394bbbf73a2aa5145ce3/fonttools-4.63.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cd7e9857e5e63738b9d9fd707bc1f59c8b09e5177726d23664db393c59bb08bd", size = 2876062, upload-time = "2026-05-14T12:03:32.554Z" }, + { url = "https://files.pythonhosted.org/packages/ef/71/d935dc54e4ff121bfdd11e08702db63a7e6f25af21d8a3d7b7212df53641/fonttools-4.63.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c2a2a42198b696a6f48fad91709afb55176e66a5e566131219dba372fb7f8c59", size = 2424594, upload-time = "2026-05-14T12:03:34.86Z" }, + { url = "https://files.pythonhosted.org/packages/8e/40/e76320afa1df918e146155ef239b1719ee266092e96f5423bfd075affba1/fonttools-4.63.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e874792a8212b44583ea02189d9e693906b2f78b261f372f95d6c563210ac1d", size = 5024840, upload-time = "2026-05-14T12:03:36.745Z" }, + { url = "https://files.pythonhosted.org/packages/ce/36/0b805d8c485f872f65a509cbe3b58a5d0d17bee855333b54a150c79d3061/fonttools-4.63.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22135da48a348785c5e2d5d2d9d6bec5ed44adacbaeb9db12d9493bf6c6bfa68", size = 4975801, upload-time = "2026-05-14T12:03:38.833Z" }, + { url = "https://files.pythonhosted.org/packages/c8/26/2cee03d0aa083ab022da5c07aff9ed3f689da1defb81ad6917c9627896da/fonttools-4.63.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccf41f2efdf56994d22d73bef4ced1052161958169428d06ba9724ea9e9a64be", size = 4965009, upload-time = "2026-05-14T12:03:41.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/48/cc4b66d9058c0d0982c833fad10127c4b0e9324606aafa41382295ca4102/fonttools-4.63.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9ced0bd02ac751dd6319b0da88aaef24414e3b0dbc32bb4f24944821a3741a27", size = 5105892, upload-time = "2026-05-14T12:03:43.525Z" }, + { url = "https://files.pythonhosted.org/packages/d8/1f/a98a30a814b9ddef3a2e706025f90b9e0bc94890e6cb15254bc86547d11a/fonttools-4.63.0-cp313-cp313-win32.whl", hash = "sha256:85be818f5506e8a7753153def2c9550178f0ecae6a47b5e0e8dbb23f7cc90380", size = 2291313, upload-time = "2026-05-14T12:03:45.594Z" }, + { url = "https://files.pythonhosted.org/packages/92/46/5177b01f3b4abfdd4409f31cca4ab279c9343a26efbe9ec78c97fc612e02/fonttools-4.63.0-cp313-cp313-win_amd64.whl", hash = "sha256:ba04cb5891d4c0c21b6da95eda8d7b090021508a294fff33464fc7d241e0856b", size = 2342299, upload-time = "2026-05-14T12:03:47.414Z" }, + { url = "https://files.pythonhosted.org/packages/27/d2/23d25e3f247b328be58d04a4c9f894178a0d1eda7d42867cfb388adaf416/fonttools-4.63.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fd1e3094f42d806d3d7c79162fc59e5910fcbe3a7360c385b8da969bc4493745", size = 2875338, upload-time = "2026-05-14T12:03:50.052Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/7dfa0c761cb3b2964e2a84c4dc986c926a87de0cb9fb60d5b28ded3f2914/fonttools-4.63.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6e528da43bc3791085f8cb6141b1d13e459226790240340fcbb4625649238b03", size = 2422661, upload-time = "2026-05-14T12:03:52.154Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/64cfa18a7a1621d17b7f4502b2b0ed8a135a90c3db51ea590ee99043e76b/fonttools-4.63.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b2248c5decb223562f7902ff6325077a073f608ee8e33e88ad88db734eb9f49", size = 5010526, upload-time = "2026-05-14T12:03:54.647Z" }, + { url = "https://files.pythonhosted.org/packages/36/e1/a8933a72c45a87177fbde2696e0d0755c8c9062f8c077a961c6215fa27b1/fonttools-4.63.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:308f957cdeaf8abe4e5f2f124902ef405448af92c90f80e302a3b771c2e6116b", size = 4923946, upload-time = "2026-05-14T12:03:56.984Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/872e6e233b8c5e8b41413796ff18b7fe479661bd40147e071b450dfad7a1/fonttools-4.63.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bf00f21eb5fb721dbaf73d1e9da6d02a1af7768f2ebcf9798be98beab8ba90f6", size = 4962489, upload-time = "2026-05-14T12:03:59.443Z" }, + { url = "https://files.pythonhosted.org/packages/30/c4/83c24f2ec38b90cfda84bf4b1a1f49df80e84a1db4e7ac6e0d41bf23bc39/fonttools-4.63.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c1aaa4b9c75798400ac043ce04d74e7830376c85095a5a6ed7cba2f17a266bf4", size = 5071870, upload-time = "2026-05-14T12:04:02.122Z" }, + { url = "https://files.pythonhosted.org/packages/de/40/3ae22b60ff1d41ce0bd044b31238cdc72cef99f28b976f1e128ebd618c9b/fonttools-4.63.0-cp314-cp314-win32.whl", hash = "sha256:22693918177bd9ceabec4736d338045f357769416fc6b0b2508eefef75b08616", size = 2295026, upload-time = "2026-05-14T12:04:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d4/98078064ccc76b45cb0f6c002452011e93c4bd26f6850344f0951cc1fe89/fonttools-4.63.0-cp314-cp314-win_amd64.whl", hash = "sha256:7d782fac32985914c351556f68ac0855391572bcd87de50e05970d3cd4c96fc5", size = 2347454, upload-time = "2026-05-14T12:04:06.752Z" }, + { url = "https://files.pythonhosted.org/packages/49/4e/652d1580c5f4e39f7d103b0c793e4773129ad633dce4addd0cf4dfebde02/fonttools-4.63.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6db5140a60a5d731d21ec076745b40a310607731b0a565b50776393188649001", size = 2958152, upload-time = "2026-05-14T12:04:08.706Z" }, + { url = "https://files.pythonhosted.org/packages/0e/55/ad864c9a9b219f552eb46b32cd7906c466e5a578ba0c3abfcc0fe7413eb6/fonttools-4.63.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d76edbff9014094dbf03bd2d074709dfa6ec7aba13d838c937a2b33d2d6a86e", size = 2460809, upload-time = "2026-05-14T12:04:10.783Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/0aa8db70f18cf52e49b4ed5ecec68547f981160bf5ded3b5aed6faa0a6f9/fonttools-4.63.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0eac00b9118c3c2f87d272e45341871c5b3066baa3c86897fa634a7c3fb59096", size = 5148649, upload-time = "2026-05-14T12:04:12.747Z" }, + { url = "https://files.pythonhosted.org/packages/7f/63/18e4369c25043096f1048e0c9915951adc4f842bd81c6b18155824d6fa99/fonttools-4.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51394295f1a51de8b5f30bdb1e1b9a4231536c7064ef5c6e211eec19fa36036f", size = 4932147, upload-time = "2026-05-14T12:04:14.806Z" }, + { url = "https://files.pythonhosted.org/packages/a1/3f/67f3eac2ffd8a98446c5022f8ed3864eac878a5ff7af8df4c8286dba16cc/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9e12f105d2b6342c559c298afb674006bb2893afc7102dcf8a1b55b0486b4e40", size = 5027237, upload-time = "2026-05-14T12:04:17.675Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ba/4e6214cb38a7b04779e97bb7636de9a5c7f20af7018d03dee0b64c08510a/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:796f27556dbe094c4824f75ca85267e4df776c79036c8441469a4df37038c196", size = 5053933, upload-time = "2026-05-14T12:04:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/34/3b/214dcc19ee31d3d38fb5ad2755c11ef0514e5dc300bbaf41c0b69f393799/fonttools-4.63.0-cp314-cp314t-win32.whl", hash = "sha256:948428a275741f0b64b113c955425a953314f4b9ab9997f73a72c83e68e569c8", size = 2359326, upload-time = "2026-05-14T12:04:24.22Z" }, + { url = "https://files.pythonhosted.org/packages/dd/1e/3ff1a9b523058c2eeb6a9d50f5574e2a738200d0d94107d5bc4105e8da3f/fonttools-4.63.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6d4741eb179121cab9eea4cb2393d24492373a260d7945006358c08cfbf45419", size = 2425829, upload-time = "2026-05-14T12:04:26.829Z" }, + { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" }, +] + +[[package]] +name = "fsspec" +version = "2026.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d5/8d/1c51c094345df128ca4a990d633fe1a0ff28726c9e6b3c41ba65087bba1d/fsspec-2026.4.0.tar.gz", hash = "sha256:301d8ac70ae90ef3ad05dcf94d6c3754a097f9b5fe4667d2787aa359ec7df7e4", size = 312760, upload-time = "2026-04-29T20:42:38.635Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/0c/043d5e551459da400957a1395e0febbf771446ff34291afcbe3d8be2a279/fsspec-2026.4.0-py3-none-any.whl", hash = "sha256:11ef7bb35dab8a394fde6e608221d5cf3e8499401c249bebaeaad760a1a8dec2", size = 203402, upload-time = "2026-04-29T20:42:36.842Z" }, +] + +[[package]] +name = "greenlet" +version = "3.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/6e/802acd792aebb2256fbbee8cacf2727faaeb6f240ac11008f09eae4414bc/greenlet-3.5.1.tar.gz", hash = "sha256:5a56aeb7d5d9cc4b3a735efb5095bd4b4f6f0e4f93e5ca876d0e2315137b7829", size = 197356, upload-time = "2026-05-20T15:05:03.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/21/117c8710abb7f146d804a124c07eb5964a60b90d02b72452885aecc18efa/greenlet-3.5.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:7eacb17a9d41538a2bc4912eba5ef13823c83cb69e4d141d0813debe7163187f", size = 283510, upload-time = "2026-05-20T13:12:26.475Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f7/6762a56fa5f6c2295c449c6524e10ce481e381c994cc44d9d03aef0700fb/greenlet-3.5.1-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e5cc9606aa5f4e0bde0d3bd502b44f743864c3ffa5cfa1011b1e30f5aa02366f", size = 599696, upload-time = "2026-05-20T14:00:02.906Z" }, + { url = "https://files.pythonhosted.org/packages/0f/05/85a511e68ee109aff0aa00b4b497806091dd2d82ce209e49c6e801bd5d92/greenlet-3.5.1-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c3d35f87c7253b715d13d679e0783d845910144f282cb939fe1ba4ac8616269c", size = 612618, upload-time = "2026-05-20T14:05:39.202Z" }, + { url = "https://files.pythonhosted.org/packages/2e/19/60df45065b2981ff894fdd51e7c99a3a4b107412822b083d88d5d528f663/greenlet-3.5.1-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:00929c98ec525fd9bf075875d8c5f6a983a90906cdf78a66e6de2d8e466c2a19", size = 619237, upload-time = "2026-05-20T14:09:06.421Z" }, + { url = "https://files.pythonhosted.org/packages/89/b8/8b83d18ae07c46c019617f35afd7b47aab7f9b4fbb12fc637d681e10bdd8/greenlet-3.5.1-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:540dae7b956209af4d70a3be35927b4055f617763771e5e84a5255bea934d2f5", size = 612947, upload-time = "2026-05-20T13:14:23.469Z" }, + { url = "https://files.pythonhosted.org/packages/26/9a/4ba4c2bc9d9df5f41bb8943fb7bb11e440352e6b9c2e36716b6e85f8b82d/greenlet-3.5.1-cp310-cp310-manylinux_2_39_riscv64.whl", hash = "sha256:001775efe7b8e758861294c7a27c28af87f3f3f1c20468a2bc618c45b346c061", size = 415653, upload-time = "2026-05-20T14:01:36.999Z" }, + { url = "https://files.pythonhosted.org/packages/5d/14/ad1f9fc9b82384c010212464a3702bd911f95dab2f1180bc6fbcfb1f958c/greenlet-3.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed8cdb691169715a9a492844a83246f090182247d1a5031dc78a403f68ba1e97", size = 1571425, upload-time = "2026-05-20T14:02:22.671Z" }, + { url = "https://files.pythonhosted.org/packages/46/1c/43b8203cf10f4292c9e3d270e9e5f5ade79115a0a0ca5ea6f1be5f8915a7/greenlet-3.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9d59e840387076a51016777a9328b3f2c427c6f9208a6e958bad251be50a648d", size = 1638688, upload-time = "2026-05-20T13:14:30.026Z" }, + { url = "https://files.pythonhosted.org/packages/ac/6e/0344b1e99f58f71715456e46492101fd2daa408957b8186ade0a4b515da7/greenlet-3.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:b9152fca4a6466e114aaec745ae61cba739903a109754a9d4e1262f01e9259b1", size = 237763, upload-time = "2026-05-20T13:11:35.659Z" }, + { url = "https://files.pythonhosted.org/packages/42/3c/ff890b466eaba2b0f5e6bdfff025f8c75f41b8ffdc3dbc3d24ad261e764a/greenlet-3.5.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:73f78f9b9f0a5c06e5c946ba1e8e36f5114923b6be109ee618c54f079c3ea14f", size = 284764, upload-time = "2026-05-20T13:09:10.204Z" }, + { url = "https://files.pythonhosted.org/packages/81/0e/5e5457be3d256918f6a4756f073548a3f0190836e2cc94aa6d0d617a940b/greenlet-3.5.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0cbed8bb44e23c5b199f888f4e4ce096b45ad9f25ff74a7ad0213875e936bb2", size = 603479, upload-time = "2026-05-20T14:00:04.757Z" }, + { url = "https://files.pythonhosted.org/packages/6d/e1/f89a21d58d308298e6f275f13a1b472ed96c680b601a371b08be6a725989/greenlet-3.5.1-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a203a8bd0acb0701653d3bbb26e404854a68674139ed5cbb778830f42b09bb33", size = 615495, upload-time = "2026-05-20T14:05:40.87Z" }, + { url = "https://files.pythonhosted.org/packages/2c/f2/8fd452fd81adb9ec79c8275c1375702ab0fd6bee4952da12eaa09b9508d8/greenlet-3.5.1-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ebeb75c81211f5c702576cf81f315e77e23cfdb2c7c6fcb9dd143e6de35c360", size = 623515, upload-time = "2026-05-20T14:09:07.853Z" }, + { url = "https://files.pythonhosted.org/packages/75/de/af6cef182862d2ccd6975440d21c9058a77c3f9b469abf94e322dfd2e0e3/greenlet-3.5.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a271fcd66c74615cda6a964fda3f304267a12e50a084472218a39bb0376f563", size = 614754, upload-time = "2026-05-20T13:14:24.947Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bc/c318aa9f3ffc77320fddcee3d892be957b42e2ff947198d9450b004f3a38/greenlet-3.5.1-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:017a544f0385d441e88714160d089d6900ef46c9eff9d99b6715a5ef2d127747", size = 418439, upload-time = "2026-05-20T14:01:38.446Z" }, + { url = "https://files.pythonhosted.org/packages/1a/c6/50e520283a9f19388a7326b05f9e8637e566003475eacaadad04f558c68d/greenlet-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ded7b068c7c31c1a8657d4fd42d886b3e051ae29f88b80c5ff9d502257b0f071", size = 1574097, upload-time = "2026-05-20T14:02:24.003Z" }, + { url = "https://files.pythonhosted.org/packages/21/1c/13abd1f4860d987fa5e1170a01930d6e6cd40d328de487a3c9fdaff0ffd0/greenlet-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d0932b81d72f552ded9d810d00021b64d89f2195a91ce115b893f943b7a4ab3c", size = 1641058, upload-time = "2026-05-20T13:14:31.83Z" }, + { url = "https://files.pythonhosted.org/packages/f5/56/5f332b7705545eac2dc01b4e9254d24a793f2656d55d5cc6b94ee59d22ae/greenlet-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:88e300d136eac057b2397aa1cfd7328b4c87c7eb66a09c7bc6a1292234db474e", size = 238089, upload-time = "2026-05-20T13:14:03.229Z" }, + { url = "https://files.pythonhosted.org/packages/d9/a9/a3c2fa886c5b94863fb0e61b3bc14610b7aa94cf4f17f8741b11708305fc/greenlet-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:cc6ab7e555c8a112ad3a76e368e86e12a2754bcae1652a5602e133ec7b635523", size = 234989, upload-time = "2026-05-20T13:08:27.715Z" }, + { url = "https://files.pythonhosted.org/packages/c4/37/4549f149c9797c21b32c2683c33522af22522099de128b2406672526d005/greenlet-3.5.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:fa4f98af3a528f0c3fd592a26df7f376f93329c8f4d987f6bb979057af8bf5e2", size = 286220, upload-time = "2026-05-20T13:07:28.463Z" }, + { url = "https://files.pythonhosted.org/packages/38/ff/a4f436709716965eaab9f36ea7b906c8a927fbe32fb1372a2071d964f6b1/greenlet-3.5.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffea73584b216150eab159b6d12348fb253e68757974de1e2c40d8a318ac89ed", size = 601585, upload-time = "2026-05-20T14:00:06.141Z" }, + { url = "https://files.pythonhosted.org/packages/65/ad/54bc3fcee3ad368a61b19b67d88117f7a8c29727bf71fffdeda81fbd946e/greenlet-3.5.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1072b4f9edcc1e192d9283a66a3e68d6b84c561de33a83d7858beb9ba1effe10", size = 614215, upload-time = "2026-05-20T14:05:42.675Z" }, + { url = "https://files.pythonhosted.org/packages/7c/6c/de5b1b388cd2d9fbdfeab324863daba37d54e6e233ddbefd70b385a8c591/greenlet-3.5.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:89101bfd5011e069be974903cb3a4e4523845e4ece2d62dcd8d358933c0ef249", size = 620094, upload-time = "2026-05-20T14:09:09.18Z" }, + { url = "https://files.pythonhosted.org/packages/40/69/b91cda0647df839483201545913514c2827ebea5e5ccdf931842763bc127/greenlet-3.5.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:add5217d68b31130f0beca584d7fef4878327d2e31642b66618a14eef312b63b", size = 611358, upload-time = "2026-05-20T13:14:26.37Z" }, + { url = "https://files.pythonhosted.org/packages/4a/43/1204baffab8a6476464795a7ccf394a3248d4f22c9f87173a15b36b6d971/greenlet-3.5.1-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:e6cd99ea59dd5d89f0c956606571d79bfe6f68c9eb7f4a4083a41a7f1587edee", size = 422782, upload-time = "2026-05-20T14:01:39.597Z" }, + { url = "https://files.pythonhosted.org/packages/59/90/3cf77e080350cd02fa307bb2abf05df48f4482c240275bbd2c203ba8bb1c/greenlet-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a5ea42a752d47a145eae922b605cd1634665ac3d5ec1e72402d5048e8d60d207", size = 1570475, upload-time = "2026-05-20T14:02:25.29Z" }, + { url = "https://files.pythonhosted.org/packages/65/2c/18cece62045e74598c3c393f70dce4a63f56222015ba29a5d4eeb04f764c/greenlet-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5551170cf4f5ff5623e9af81323751979fee2c731e2287b61f73cd27257b823", size = 1635625, upload-time = "2026-05-20T13:14:34.027Z" }, + { url = "https://files.pythonhosted.org/packages/30/f5/310d104ddf41eb5a70f4c268d22508dfb0c3c8e86fec152be34d0d2ed819/greenlet-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3c8bb982ad117d29478ef8f5533e97df21f1e2befd17a299257b0c96d1371c0b", size = 238791, upload-time = "2026-05-20T13:10:39.018Z" }, + { url = "https://files.pythonhosted.org/packages/62/90/ceca11f504cd23a8047a3dea31919adc48df9b626dd0c13f0d858734fdfd/greenlet-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:80eb4b04dadc4e67df3fae179a32c4706a3f495bc7f22fc8a81115d5f5512188", size = 235580, upload-time = "2026-05-20T13:08:45.056Z" }, + { url = "https://files.pythonhosted.org/packages/27/69/7f7e5372d998b81001899b1c0823c957aa413ba0f2662e65821611cc31e4/greenlet-3.5.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:51518ff74664078fc51bffcc6fc529b0df5ae58da192691cee765d45ce944a2b", size = 285060, upload-time = "2026-05-20T13:08:51.899Z" }, + { url = "https://files.pythonhosted.org/packages/b1/bf/387f9b6b865fd2ae0d0be09e0004827295a01b71be76ed350dd1e28a91a4/greenlet-3.5.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ffdb3c0bb002c99cd8f298957e046c3dbf6006b5b7cdf11a4e19194624a0a0a", size = 604370, upload-time = "2026-05-20T14:00:07.492Z" }, + { url = "https://files.pythonhosted.org/packages/32/f5/169ce3d4e4c67291bd18f8cbe0299c9f3e45102c7f1fb3c14780c93e4532/greenlet-3.5.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7715a5a2c3378ba602c3a440558261e13a820bb53a82693aacd7b7f6d964e283", size = 616987, upload-time = "2026-05-20T14:05:44.237Z" }, + { url = "https://files.pythonhosted.org/packages/19/ba/c24110c55dffa55aa6e1d98b45310da33801aeba7686ff0190fe5d46fd32/greenlet-3.5.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d40a890035c0058cadbdc4af7569800fd28a0e527a0fdbb7b5f9418f176846ce", size = 622911, upload-time = "2026-05-20T14:09:10.598Z" }, + { url = "https://files.pythonhosted.org/packages/ee/e5/7f2e41d5273be07e77560d61ea4e56485b4d6c316d2a84518c62d1364061/greenlet-3.5.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc71ff466927a201b08305acac451ebe1aedfcea002f62f1f2f2ac2ac1e6a135", size = 613911, upload-time = "2026-05-20T13:14:27.539Z" }, + { url = "https://files.pythonhosted.org/packages/ec/7b/d20db2e8a5ad6c038702f3179b136f93f0a3d1a21a0c0777f3e470cdf4b2/greenlet-3.5.1-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:67821bb03e4e98664490edb787ff6af501194c29bbee0f5c1dfdcf1dc3d9d436", size = 425228, upload-time = "2026-05-20T14:01:40.837Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a4/fbdc67579b73615a1f91615e814303cc71e06128f7baaba87be79b8fb90c/greenlet-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cd443683db272ebaaca03af98c0b063ab30db70ea8a31a1559f35e3f7b744ccd", size = 1570689, upload-time = "2026-05-20T14:02:27.225Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b4/77abbe35078be39718a46cd49caf16bceb35662f97a34101dca28aa98e47/greenlet-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:089fff7a6ce8d9316d1f65ebc00273a56be258c1725b32b94de90a3a979557e1", size = 1635602, upload-time = "2026-05-20T13:14:36.344Z" }, + { url = "https://files.pythonhosted.org/packages/37/f7/129f27ca700845b8ee8ca88ce7f43435a1239c2eddb7677fc938822762cf/greenlet-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:110a1ca7b49b014b097f6078272c3f4ed31af45b254de5228b79adba879f6af9", size = 238683, upload-time = "2026-05-20T13:11:50.57Z" }, + { url = "https://files.pythonhosted.org/packages/6d/5c/a485a36e87df8d8fd0632ee01511244f5156a20ed3746cc6599340326395/greenlet-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f16ba1efc0715b680a18b8123d90dad887c6112ae3555b4b5c32c149540c6b4e", size = 235499, upload-time = "2026-05-20T13:12:42.028Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cb/c62454606daf5640369c94d8a9dd540599b1bfc090e2d2180cb77f4038d2/greenlet-3.5.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8ab31c9de8651a2facdd5c5bb0011f2380dd1a7af78ce2adf4b56095294fc07", size = 285579, upload-time = "2026-05-20T13:08:56.396Z" }, + { url = "https://files.pythonhosted.org/packages/ec/71/c4270398c2eba968a6071af1dfbdcaeee6ec1c24bc8b435b8cc452700da6/greenlet-3.5.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e300185139abc337ade480c327183adf42a875ac7181bfe66d7d4efea31fbea", size = 651106, upload-time = "2026-05-20T14:00:09.448Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ab/71e34b78a44ec271fb5f550c17bc46d301ddc5953890d935f270b0dcdb5a/greenlet-3.5.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7ffdb990dcaa0234cf9845aead5df2e3c3a8b6507d409274dd87e0d5ab05ffc2", size = 663478, upload-time = "2026-05-20T14:05:45.88Z" }, + { url = "https://files.pythonhosted.org/packages/c6/2d/2d80842910da44f78c286532d084b8a5c3717c844ae80ceb3858738ae89a/greenlet-3.5.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c09df69dc1712d131332054a858a3e5cca400967fa3a672e2324fbb0971448c", size = 667767, upload-time = "2026-05-20T14:09:12.15Z" }, + { url = "https://files.pythonhosted.org/packages/77/96/4efd6fa5c62c85426a0c19077a586258ebc3a2a146ff2493e4312a697a22/greenlet-3.5.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2f82b3597e9d83b63408affed0b48fd0f54935edac4302237b9a837be0dae33c", size = 660800, upload-time = "2026-05-20T13:14:29.129Z" }, + { url = "https://files.pythonhosted.org/packages/e9/d3/dad2eecedfbb1ed7050a20dcfae40c1442b74bc7423608be2c7e03ee7133/greenlet-3.5.1-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:a4764e0bfc6a4d114c865b32520805c16a990ef5f286a514413b05d5ecd6a23d", size = 470786, upload-time = "2026-05-20T14:01:42.064Z" }, + { url = "https://files.pythonhosted.org/packages/7a/e0/6c71401a25cac7000261304e866a2f2cc04dc74810d40e2f118aa4799495/greenlet-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c0141e37414c10164e702b8fb1473304221ad98f71600850c6ef7ff4880feba0", size = 1617518, upload-time = "2026-05-20T14:02:28.662Z" }, + { url = "https://files.pythonhosted.org/packages/41/26/c5c06643e8c0af9e7bf18e16cb51d0ab7625155f0392e1c9015d66d556cd/greenlet-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:50ae25a67bea74ea41fb14b960bc532df73eb713417b2d61892dced82fe8d3bc", size = 1681593, upload-time = "2026-05-20T13:14:39.417Z" }, + { url = "https://files.pythonhosted.org/packages/8a/bd/e11a108317485075e68af9d23039619b86b28130c3b50d227d42edece64b/greenlet-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:8a17c42330e261299766b75ac1ea32caa437a9453c8f65d16a13140db378ecd3", size = 239800, upload-time = "2026-05-20T13:09:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/47/f8/8e8e8417b7bf28639a5a56356ef934d0375e1d0c70a57e04d7701e870ffe/greenlet-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:7b5f5fae05b8ac6d176a61b60c394a8cbdc2b5b91b81793066e68745cf165e54", size = 236862, upload-time = "2026-05-20T13:09:10.498Z" }, + { url = "https://files.pythonhosted.org/packages/90/12/41bf27fde4d3605d3773ae57751eda182b8be2f5398011c041173b1d9534/greenlet-3.5.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:ea8da1e900d758d078810d4255d8c6aa572181896a31ec79d779eb79c3adc9ad", size = 293637, upload-time = "2026-05-20T13:12:35.529Z" }, + { url = "https://files.pythonhosted.org/packages/44/44/ba14b23e9757707050c2f397d305bbcae62e5d7cad122f8b6baec5ae4a1f/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a19570c52a21420dcbc94e661994bc325c0b5b11304540fed514586da5dc8f2e", size = 650840, upload-time = "2026-05-20T14:00:11.079Z" }, + { url = "https://files.pythonhosted.org/packages/a8/37/5ddc2b686a6844f91abecef43411842426da2e1573f60b49ecf2547f4ae1/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3d955c89b75eeca4723d7cc14135f393cd47c32e2a6cb4a8e4c6e760a26b0986", size = 656416, upload-time = "2026-05-20T14:05:47.118Z" }, + { url = "https://files.pythonhosted.org/packages/8c/46/5987dcd1a2570ba84f3b187536b2ca3ae97613387e57f5cfa99df068fe5e/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea37d5a157eb9493820d3792ac4ece28619a394391d2b9f2f78057d396ff0f0f", size = 656607, upload-time = "2026-05-20T14:09:13.949Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f0/d17510297c35a2992712f0bf84de3779749999f7d3d63aa1f09db7c62dbe/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2daaaebd1a5aa88c49045b6baf9310b3263796bd88db713edf37cf53e7bb4e", size = 654397, upload-time = "2026-05-20T13:14:30.696Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c1/6da0a9ddcc29d7e51ef14883fa3dc1e53b3f4ffba00582106c7bf55da1d8/greenlet-3.5.1-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:8d8a23250ea3ec7b36de8fa4b541e9e2db3ee82915cc060ab0631609ad8b28de", size = 488287, upload-time = "2026-05-20T14:01:43.143Z" }, + { url = "https://files.pythonhosted.org/packages/37/eb/147387705bb89092645b012586e7273cb5ed3c90ef7eaf3a69173eaf0209/greenlet-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3bfbd69cc349e43bf3a8ae1c85548ff0718efc887615c2db16c3833d7b0b072d", size = 1614469, upload-time = "2026-05-20T14:02:30.192Z" }, + { url = "https://files.pythonhosted.org/packages/a6/4e/37ee0da7732b7aa9896f17e15579a9df34b9fcb9dd494f0adfa749af6623/greenlet-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4378720dd888136c27215a0214d32a4d37c3852765d45bc37aad0623423cfd78", size = 1675115, upload-time = "2026-05-20T13:14:40.972Z" }, + { url = "https://files.pythonhosted.org/packages/57/f3/97dfcf4a6eb5077f8a672234216fb5923eb89f2cab7081cb10b2cf75b605/greenlet-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:45718441607f9325d948db98cbc691276059316d0358c188c246da4e1d4d23d2", size = 245246, upload-time = "2026-05-20T13:12:22.646Z" }, +] + +[[package]] +name = "groundwork-sphinx-theme" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/9d/304bfacefd0ef853c48af60aee35c096dd392ef4b340d336a59a7b8c953b/groundwork-sphinx-theme-1.1.1.tar.gz", hash = "sha256:5f1217bf34daba5fcd93e8a2a04ef5a6c2b144ec43754aec7ce14de501e23fe4", size = 26423, upload-time = "2019-11-25T05:24:22.842Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/e3/7c1b4e2d62d89229c9df5b90f2195b36758dab8a7f00f0710a90d0f414cc/groundwork_sphinx_theme-1.1.1-py2.py3-none-any.whl", hash = "sha256:b4796989ce3cd6d5b5a3c7ebe52a8c9cf848110e9f12c2c88e2b3c0e4e8f0e24", size = 26875, upload-time = "2019-11-25T05:24:25.253Z" }, +] + +[[package]] +name = "id" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/04/c2156091427636080787aac190019dc64096e56a23b7364d3c1764ee3a06/id-1.6.1.tar.gz", hash = "sha256:d0732d624fb46fd4e7bc4e5152f00214450953b9e772c182c1c22964def1a069", size = 18088, upload-time = "2026-02-04T16:19:41.26Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/77/de194443bf38daed9452139e960c632b0ef9f9a5dd9ce605fdf18ca9f1b1/id-1.6.1-py3-none-any.whl", hash = "sha256:f5ec41ed2629a508f5d0988eda142e190c9c6da971100612c4de9ad9f9b237ca", size = 14689, upload-time = "2026-02-04T16:19:40.051Z" }, +] + +[[package]] +name = "identify" +version = "2.6.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/63/51723b5f116cc04b061cb6f5a561790abf249d25931d515cd375e063e0f4/identify-2.6.19.tar.gz", hash = "sha256:6be5020c38fcb07da56c53733538a3081ea5aa70d36a156f83044bfbf9173842", size = 99567, upload-time = "2026-04-17T18:39:50.265Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/84/d9273cd09688070a6523c4aee4663a8538721b2b755c4962aafae0011e72/identify-2.6.19-py2.py3-none-any.whl", hash = "sha256:20e6a87f786f768c092a721ad107fc9df0eb89347be9396cadf3f4abbd1fb78a", size = 99397, upload-time = "2026-04-17T18:39:49.221Z" }, +] + +[[package]] +name = "idna" +version = "3.18" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" }, +] + +[[package]] +name = "imagesize" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/e6/7bf14eeb8f8b7251141944835abd42eb20a658d89084b7e1f3e5fe394090/imagesize-2.0.0.tar.gz", hash = "sha256:8e8358c4a05c304f1fccf7ff96f036e7243a189e9e42e90851993c558cfe9ee3", size = 1773045, upload-time = "2026-03-03T14:18:29.941Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/53/fb7122b71361a0d121b669dcf3d31244ef75badbbb724af388948de543e2/imagesize-2.0.0-py2.py3-none-any.whl", hash = "sha256:5667c5bbb57ab3f1fa4bc366f4fbc971db3d5ed011fd2715fd8001f782718d96", size = 9441, upload-time = "2026-03-03T14:18:27.892Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "9.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/3d/2d244233ac4f76e38533cfcb2991c9eb4c7bf688ae0a036d30725b8faafe/importlib_metadata-9.0.0-py3-none-any.whl", hash = "sha256:2d21d1cc5a017bd0559e36150c21c830ab1dc304dedd1b7ea85d20f45ef3edd7", size = 27789, upload-time = "2026-03-20T06:42:55.665Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "ipykernel" +version = "6.31.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython", version = "8.39.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "ipython", version = "9.14.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a5/1d/d5ba6edbfe6fae4c3105bca3a9c889563cc752c7f2de45e333164c7f4846/ipykernel-6.31.0.tar.gz", hash = "sha256:2372ce8bc1ff4f34e58cafed3a0feb2194b91fc7cad0fc72e79e47b45ee9e8f6", size = 167493, upload-time = "2025-10-20T11:42:39.948Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/d8/502954a4ec0efcf264f99b65b41c3c54e65a647d9f0d6f62cd02227d242c/ipykernel-6.31.0-py3-none-any.whl", hash = "sha256:abe5386f6ced727a70e0eb0cf1da801fa7c5fa6ff82147747d5a0406cd8c94af", size = 117003, upload-time = "2025-10-20T11:42:37.502Z" }, +] + +[[package]] +name = "ipython" +version = "8.39.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +dependencies = [ + { name = "colorama", marker = "(python_full_version < '3.11' and sys_platform == 'win32') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "decorator", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jedi", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "matplotlib-inline", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pexpect", marker = "(python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "prompt-toolkit", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pygments", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "stack-data", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "traitlets", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/18/f8598d287006885e7136451fdea0755af4ebcbfe342836f24deefaed1164/ipython-8.39.0.tar.gz", hash = "sha256:4110ae96012c379b8b6db898a07e186c40a2a1ef5d57a7fa83166047d9da7624", size = 5513971, upload-time = "2026-03-27T10:02:13.94Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/56/4cc7fc9e9e3f38fd324f24f8afe0ad8bb5fa41283f37f1aaf9de0612c968/ipython-8.39.0-py3-none-any.whl", hash = "sha256:bb3c51c4fa8148ab1dea07a79584d1c854e234ea44aa1283bcb37bc75054651f", size = 831849, upload-time = "2026-03-27T10:02:07.846Z" }, +] + +[[package]] +name = "ipython" +version = "9.14.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +dependencies = [ + { name = "colorama", marker = "(python_full_version >= '3.11' and sys_platform == 'win32') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "decorator", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jedi", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "matplotlib-inline", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pexpect", marker = "(python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "prompt-toolkit", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "psutil", marker = "(python_full_version >= '3.11' and sys_platform != 'emscripten') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pygments", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "stack-data", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "traitlets", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "python_full_version == '3.11.*' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e2/23/3a27530575643c8bb7bfc757a28e2e7ef80092afbf59a2bc5716320b6602/ipython-9.14.1.tar.gz", hash = "sha256:f913bf74df06d458e46ced84ca506c23797590d594b236fe60b14df213291e7b", size = 4433457, upload-time = "2026-06-05T08:12:34.921Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/22/58818a63eaf8982b67632b1bc20585c811611b15a8da19d6012323dc76a5/ipython-9.14.1-py3-none-any.whl", hash = "sha256:5d4a9ecaa3b10e6e5f269dd0948bdb58ca9cb851899cd23e07c320d3eb11613c", size = 627770, upload-time = "2026-06-05T08:12:33.045Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" }, +] + +[[package]] +name = "jaraco-context" +version = "6.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "backports-tarfile", marker = "python_full_version < '3.12' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" }, +] + +[[package]] +name = "jaraco-functools" +version = "4.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/cf/ea4ef2920830dea3f5ab2ea4da6fb67724e6dca80ee2553788c3607243d0/jaraco_functools-4.5.0.tar.gz", hash = "sha256:3bb5665ea4a020cf78a7040e89154c77edadb3ca74f366479669c5999aa70b03", size = 20272, upload-time = "2026-05-15T21:34:10.025Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/9a/982e48afcffcd727a9144506720ffd4224b6b7e355c98641866f38b7c043/jaraco_functools-4.5.0-py3-none-any.whl", hash = "sha256:79ce39246eddbde4b3a03b77ea5f0f7878dc669b166a66cf3fa8e266aa3fa2f4", size = 10594, upload-time = "2026-05-15T21:34:08.595Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py", version = "0.30.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "rpds-py", version = "2026.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "jupyter-cache" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "click" }, + { name = "importlib-metadata" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "pyyaml" }, + { name = "sqlalchemy" }, + { name = "tabulate" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/f7/3627358075f183956e8c4974603232b03afd4ddc7baf72c2bc9fff522291/jupyter_cache-1.0.1.tar.gz", hash = "sha256:16e808eb19e3fb67a223db906e131ea6e01f03aa27f49a7214ce6a5fec186fb9", size = 32048, upload-time = "2024-11-15T16:03:55.322Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/6b/67b87da9d36bff9df7d0efbd1a325fa372a43be7158effaf43ed7b22341d/jupyter_cache-1.0.1-py3-none-any.whl", hash = "sha256:9c3cafd825ba7da8b5830485343091143dff903e4d8c69db9349b728b140abf6", size = 33907, upload-time = "2024-11-15T16:03:54.021Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/dc/5512503b088997c2250b8bf18258fba9d9ce5ead641183700960d3c9d342/jupyter_client-8.9.1.tar.gz", hash = "sha256:a58f730dd9e728ba16ba1d62ebccf7ffe1ebbdbce4e95cfae941b7321ae1f4fa", size = 359256, upload-time = "2026-06-09T13:15:01.033Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/6f/56d39bf385c5c27988aebaf0c18a2a17e960575740100973511018bd904e/jupyter_client-8.9.1-py3-none-any.whl", hash = "sha256:0b7a295bc46e8751e9adae84781f726c851c1d911bd793edc4a3bde942e3da81", size = 109828, upload-time = "2026-06-09T13:14:58.835Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, +] + +[[package]] +name = "karma-sphinx-theme" +version = "0.0.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/38/25be66e776ee0d088d19a0b3d1abc58020cf8cb88d921e8b72d1c25ae641/karma_sphinx_theme-0.0.8.tar.gz", hash = "sha256:5a95f91818b458bd5bdf62690828361a369a222f0721cd0e1eb2ea29056e8c27", size = 96101, upload-time = "2018-06-20T00:03:29.073Z" } + +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.12' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "secretstorage", marker = "sys_platform == 'linux' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/f8/06549565caa026e540b7e7bab5c5a90eb7ca986015f4c48dace243cd24d9/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:32cc0a5365239a6ea0c6ed461e8838d053b57e397443c0ca894dcc8e388d4374", size = 122802, upload-time = "2026-03-09T13:12:37.515Z" }, + { url = "https://files.pythonhosted.org/packages/84/eb/8476a0818850c563ff343ea7c9c05dcdcbd689a38e01aa31657df01f91fa/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cc0b66c1eec9021353a4b4483afb12dfd50e3669ffbb9152d6842eb34c7e29fd", size = 66216, upload-time = "2026-03-09T13:12:38.812Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c4/f9c8a6b4c21aed4198566e45923512986d6cef530e7263b3a5f823546561/kiwisolver-1.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:86e0287879f75621ae85197b0877ed2f8b7aa57b511c7331dce2eb6f4de7d476", size = 63917, upload-time = "2026-03-09T13:12:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/f1/0e/ba4ae25d03722f64de8b2c13e80d82ab537a06b30fc7065183c6439357e3/kiwisolver-1.5.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:62f59da443c4f4849f73a51a193b1d9d258dcad0c41bc4d1b8fb2bcc04bfeb22", size = 1628776, upload-time = "2026-03-09T13:12:41.976Z" }, + { url = "https://files.pythonhosted.org/packages/8a/e4/3f43a011bc8a0860d1c96f84d32fa87439d3feedf66e672fef03bf5e8bac/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9190426b7aa26c5229501fa297b8d0653cfd3f5a36f7990c264e157cbf886b3b", size = 1228164, upload-time = "2026-03-09T13:12:44.002Z" }, + { url = "https://files.pythonhosted.org/packages/4b/34/3a901559a1e0c218404f9a61a93be82d45cb8f44453ba43088644980f033/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c8277104ded0a51e699c8c3aff63ce2c56d4ed5519a5f73e0fd7057f959a2b9e", size = 1246656, upload-time = "2026-03-09T13:12:45.557Z" }, + { url = "https://files.pythonhosted.org/packages/87/9e/f78c466ea20527822b95ad38f141f2de1dcd7f23fb8716b002b0d91bbe59/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8f9baf6f0a6e7571c45c8863010b45e837c3ee1c2c77fcd6ef423be91b21fedb", size = 1295562, upload-time = "2026-03-09T13:12:47.562Z" }, + { url = "https://files.pythonhosted.org/packages/0a/66/fd0e4a612e3a286c24e6d6f3a5428d11258ed1909bc530ba3b59807fd980/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cff8e5383db4989311f99e814feeb90c4723eb4edca425b9d5d9c3fefcdd9537", size = 2178473, upload-time = "2026-03-09T13:12:50.254Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8e/6cac929e0049539e5ee25c1ee937556f379ba5204840d03008363ced662d/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ebae99ed6764f2b5771c522477b311be313e8841d2e0376db2b10922daebbba4", size = 2274035, upload-time = "2026-03-09T13:12:51.785Z" }, + { url = "https://files.pythonhosted.org/packages/ca/d3/9d0c18f1b52ea8074b792452cf17f1f5a56bd0302a85191f405cfbf9da16/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:d5cd5189fc2b6a538b75ae45433140c4823463918f7b1617c31e68b085c0022c", size = 2443217, upload-time = "2026-03-09T13:12:53.329Z" }, + { url = "https://files.pythonhosted.org/packages/45/2a/6e19368803a038b2a90857bf4ee9e3c7b667216d045866bf22d3439fd75e/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f42c23db5d1521218a3276bb08666dcb662896a0be7347cba864eca45ff64ede", size = 2249196, upload-time = "2026-03-09T13:12:55.057Z" }, + { url = "https://files.pythonhosted.org/packages/75/2b/3f641dfcbe72e222175d626bacf2f72c3b34312afec949dd1c50afa400f5/kiwisolver-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:94eff26096eb5395136634622515b234ecb6c9979824c1f5004c6e3c3c85ccd2", size = 73389, upload-time = "2026-03-09T13:12:56.496Z" }, + { url = "https://files.pythonhosted.org/packages/da/88/299b137b9e0025d8982e03d2d52c123b0a2b159e84b0ef1501ef446339cf/kiwisolver-1.5.0-cp310-cp310-win_arm64.whl", hash = "sha256:dd952e03bfbb096cfe2dd35cd9e00f269969b67536cb4370994afc20ff2d0875", size = 64782, upload-time = "2026-03-09T13:12:57.609Z" }, + { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" }, + { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" }, + { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" }, + { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" }, + { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" }, + { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" }, + { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, + { url = "https://files.pythonhosted.org/packages/17/6f/6fd4f690a40c2582fa34b97d2678f718acf3706b91d270c65ecb455d0a06/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:295d9ffe712caa9f8a3081de8d32fc60191b4b51c76f02f951fd8407253528f4", size = 59606, upload-time = "2026-03-09T13:15:40.81Z" }, + { url = "https://files.pythonhosted.org/packages/82/a0/2355d5e3b338f13ce63f361abb181e3b6ea5fffdb73f739b3e80efa76159/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:51e8c4084897de9f05898c2c2a39af6318044ae969d46ff7a34ed3f96274adca", size = 57537, upload-time = "2026-03-09T13:15:42.071Z" }, + { url = "https://files.pythonhosted.org/packages/c8/b9/1d50e610ecadebe205b71d6728fd224ce0e0ca6aba7b9cbe1da049203ac5/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b83af57bdddef03c01a9138034c6ff03181a3028d9a1003b301eb1a55e161a3f", size = 79888, upload-time = "2026-03-09T13:15:43.317Z" }, + { url = "https://files.pythonhosted.org/packages/cd/ee/b85ffcd75afed0357d74f0e6fc02a4507da441165de1ca4760b9f496390d/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf4679a3d71012a7c2bf360e5cd878fbd5e4fcac0896b56393dec239d81529ed", size = 77584, upload-time = "2026-03-09T13:15:44.605Z" }, + { url = "https://files.pythonhosted.org/packages/6b/dd/644d0dde6010a8583b4cd66dd41c5f83f5325464d15c4f490b3340ab73b4/kiwisolver-1.5.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:41024ed50e44ab1a60d3fe0a9d15a4ccc9f5f2b1d814ff283c8d01134d5b81bc", size = 73390, upload-time = "2026-03-09T13:15:45.832Z" }, + { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" }, + { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" }, + { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" }, +] + +[[package]] +name = "latexcodec" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/27/dd/4270b2c5e2ee49316c3859e62293bd2ea8e382339d63ab7bbe9f39c0ec3b/latexcodec-3.0.1.tar.gz", hash = "sha256:e78a6911cd72f9dec35031c6ec23584de6842bfbc4610a9678868d14cdfb0357", size = 31222, upload-time = "2025-06-17T18:47:34.051Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/40/23569737873cc9637fd488606347e9dd92b9fa37ba4fcda1f98ee5219a97/latexcodec-3.0.1-py3-none-any.whl", hash = "sha256:a9eb8200bff693f0437a69581f7579eb6bca25c4193515c09900ce76451e452e", size = 18532, upload-time = "2025-06-17T18:47:30.726Z" }, +] + +[[package]] +name = "librt" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/40/08/9e7f6b5d2b5bed6ad055cdd5925f192bb403a51280f86b56554d9d0699a2/librt-0.11.0.tar.gz", hash = "sha256:075dc3ef4458a278e0195cbf6ac9d38808d9b906c5a6c7f7f79c3888276a3fb1", size = 200139, upload-time = "2026-05-10T18:17:25.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/10/37fd9e9ba96cb0bd742dfb20fc3d082e54bdbec759d7300df927f360ef07/librt-0.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6e94ebfcfa2d5e9926d6c3b9aa4617ffc42a845b4321fb84021b872358c82a0f", size = 141706, upload-time = "2026-05-10T18:15:16.129Z" }, + { url = "https://files.pythonhosted.org/packages/cf/72/1b1466f358e4a0b728051f69bc27e67b432c6eaa2e05b88db49d3785ae0d/librt-0.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ae627397a2f351560440d872d6f7c8dbb4072e57868e7b2fc5b8b430fe489d45", size = 142605, upload-time = "2026-05-10T18:15:18.148Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/ed26dd2f6bc9a0baf48306433e579e8d354d70b2bcb78134ed950a5d0e1e/librt-0.11.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc329359321b67d24efdf4bc69012b0597001649544db662c001db5a0184794c", size = 476555, upload-time = "2026-05-10T18:15:19.569Z" }, + { url = "https://files.pythonhosted.org/packages/66/fe/11891191c0e0a3fd617724e891f6e67a71a7658974a892b9a9a97fdb2977/librt-0.11.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:7e82e642ab0f7608ce2fe53d76ca2280a9ee33a1b06556142c7c6fe80a86fc33", size = 468434, upload-time = "2026-05-10T18:15:20.87Z" }, + { url = "https://files.pythonhosted.org/packages/6f/50/5ec949d7f9ce1a07af903aa3e13abb98b717923bdead6e719b2f824ccc07/librt-0.11.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:88145c15c67731d54283d135b03244028c750cc9edc334a96a4f5950ebdb2884", size = 496918, upload-time = "2026-05-10T18:15:22.616Z" }, + { url = "https://files.pythonhosted.org/packages/ea/c4/177336c7524e34875a38bf668e88b193a6723a4eb4045d07f74df6e1506c/librt-0.11.0-cp310-cp310-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9d36a51b3d93320b686588e27123f4995804dbf1bce81df78c02fc3c6eea9280", size = 490334, upload-time = "2026-05-10T18:15:24.2Z" }, + { url = "https://files.pythonhosted.org/packages/13/1f/da3112f7569eda3b49f9a2629bae1fe059812b6085df16c885f6454dff49/librt-0.11.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d00f3ac06a2a8b246327f11e186a53a100a4d5c7ed52346367e5ec751d51586c", size = 511287, upload-time = "2026-05-10T18:15:26.226Z" }, + { url = "https://files.pythonhosted.org/packages/fa/94/03fec301522e172d105581431223be56b27594ff46440ebfbb658a3735d5/librt-0.11.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:461bbceede621f1ffb8839755f8663e886087ee7af16294cab7fb4d782c62eeb", size = 517202, upload-time = "2026-05-10T18:15:27.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/6e/339f6e5a7b413ce014f1917a756dae630fe59cc99f34153205b1cb540901/librt-0.11.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:0cad8a4d6a8ff03c9b76f9414caccd78e7cfbc8a2e12fa334d8e1d9932753783", size = 497517, upload-time = "2026-05-10T18:15:29.614Z" }, + { url = "https://files.pythonhosted.org/packages/cd/43/acdd5ce317cb46e8253ca9bfbdb8b12e68a24d745949336a7f3d5fb79ba0/librt-0.11.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f37aa505b3cf60701562eddb32df74b12a9e380c207fd8b06dd157a943ac7ea0", size = 538878, upload-time = "2026-05-10T18:15:30.928Z" }, + { url = "https://files.pythonhosted.org/packages/29/b5/7a25bb12e3172839f647f196b3e988318b7bb1ca7501732a225c4dce2ec0/librt-0.11.0-cp310-cp310-win32.whl", hash = "sha256:94663a21534637f0e787ec2a2a756022df6e5b7b2335a5cdd7d8e33d68a2af89", size = 100070, upload-time = "2026-05-10T18:15:32.551Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0d/ebbcf4d77999c02c937b05d2b90ff4cd4dcc7e9a365ba132329ac1fe7a0f/librt-0.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:dec7db73758c2b54953fd8b7fe348c45188fe26b39ee18446196edd08453a5d4", size = 117918, upload-time = "2026-05-10T18:15:33.678Z" }, + { url = "https://files.pythonhosted.org/packages/fe/87/2bf31fe17587b29e3f93ec31421e2b1e1c3e349b8bf6c7c313dbad1d5340/librt-0.11.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:93d95bd45b7d58343d8b90d904450a545144eec19a002511163426f8ab1fae29", size = 141092, upload-time = "2026-05-10T18:15:34.795Z" }, + { url = "https://files.pythonhosted.org/packages/cf/08/5c5bf772920b7ebac6e32bc91a643e0ab3870199c0b542356d3baa83970a/librt-0.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ee278c769a713638cdacd4c0436d72156e75df3ebc0166ab2b9dc43acc386c9", size = 142035, upload-time = "2026-05-10T18:15:36.242Z" }, + { url = "https://files.pythonhosted.org/packages/06/20/662a03d254e5b000d838e8b345d83303ddb768c080fd488e40634c0fa66b/librt-0.11.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f230cb1cbc9faaa616f9a678f530ebcf186e414b6bcbd88b960e4ba1b92428d5", size = 475022, upload-time = "2026-05-10T18:15:37.56Z" }, + { url = "https://files.pythonhosted.org/packages/de/f3/aa81523e45184c6ec23dc7f63263362ec55f80a09d424c012359ecbe7e35/librt-0.11.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5d63c855d86938d9de93e265c9bd8c705b51ec494de5738340ee93767a686e4b", size = 467273, upload-time = "2026-05-10T18:15:39.182Z" }, + { url = "https://files.pythonhosted.org/packages/6b/6f/59c74b560ca8853834d5501d589c8a2519f4184f273a085ffd0f37a1cc47/librt-0.11.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:993f028be9e96a08d31df3479ac80d99be374d17f3b78e4796b3fd3c913d4e89", size = 497083, upload-time = "2026-05-10T18:15:40.634Z" }, + { url = "https://files.pythonhosted.org/packages/fe/7b/5aa4d2c9600a719401160bf7055417df0b2a47439b9d88286ce45e56b65f/librt-0.11.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:258d73a0aa66a055e65b2e4d1b8cdb23b9d132c5bb915d9547d804fcaed116cc", size = 489139, upload-time = "2026-05-10T18:15:41.934Z" }, + { url = "https://files.pythonhosted.org/packages/d6/31/9143803d7da6856a69153785768c4936864430eec0fd9461c3ea527d9922/librt-0.11.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0827efe7854718f04aaddf6496e96960a956e676fe1d0f04eb41511fd8ad06d5", size = 508442, upload-time = "2026-05-10T18:15:43.206Z" }, + { url = "https://files.pythonhosted.org/packages/2f/5a/bce08184488426bda4ccc2c4964ac048c8f68ae89bd7120082eef4233cfd/librt-0.11.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7753e57d6e12d019c0d8786f1c09c709f4c3fcc57c3887b24e36e6c06ec938b7", size = 514230, upload-time = "2026-05-10T18:15:44.761Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/bb5e213d254b7505a0e658da199d8ab719086632ce09eef311ab27976523/librt-0.11.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:11bd19822431cc21af9f27374e7ae2e58103c7d98bda823536a6c47f6bb2bb3d", size = 494231, upload-time = "2026-05-10T18:15:46.308Z" }, + { url = "https://files.pythonhosted.org/packages/9d/fb/541cdad5b1ab1300398c74c4c9a497b88e5074c21b1244c8f49731d3a284/librt-0.11.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:22bdf239b219d3993761a148ffa134b19e52e9989c84f845d5d7b71d70a17412", size = 537585, upload-time = "2026-05-10T18:15:47.629Z" }, + { url = "https://files.pythonhosted.org/packages/8f/f2/464bb69295c320cb06bddb4f14a4ec67934ee14b2bffb12b19fb7ab287ba/librt-0.11.0-cp311-cp311-win32.whl", hash = "sha256:46c60b61e308eb535fbd6fa622b1ee1bb2815691c1ad9c98bf7b84952ec3bc8d", size = 100509, upload-time = "2026-05-10T18:15:49.157Z" }, + { url = "https://files.pythonhosted.org/packages/6d/e7/a17ee1788f9e4fbf548c19f4afa07c92089b9e24fef6cb2410863781ef4c/librt-0.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:902e546ff044f579ff1c953ff5fce97b636fe9e3943996b2177710c6ef076f73", size = 118628, upload-time = "2026-05-10T18:15:50.345Z" }, + { url = "https://files.pythonhosted.org/packages/cc/c7/6c766214f9f9903bcfcfbef97d807af8d8f5aa3502d247858ab17582d212/librt-0.11.0-cp311-cp311-win_arm64.whl", hash = "sha256:65ac3bc20f78aa0ee5ae84baa68917f89fef4af63e941084dd019a0d0e749f0c", size = 103122, upload-time = "2026-05-10T18:15:52.068Z" }, + { url = "https://files.pythonhosted.org/packages/8b/d0/07c77e067f0838949b43bd89232c29d72efebb9d2801a9750184eb706b71/librt-0.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b87504f1690a23b9a2cca841191a04f83895d4fc2dd04df91d82b1a04ca2ad46", size = 144147, upload-time = "2026-05-10T18:15:53.227Z" }, + { url = "https://files.pythonhosted.org/packages/7a/24/8493538fa4f62f982686398a5b8f68008138a75086abdea19ade64bf4255/librt-0.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40071fc5fe0ce8daa6de616702314a01e1250711682b0523d6ab8d4525910cb3", size = 143614, upload-time = "2026-05-10T18:15:54.657Z" }, + { url = "https://files.pythonhosted.org/packages/ff/1e/f8bad050810d9171f34a1648ed910e56814c2ba61639f2bd53c6377ae24b/librt-0.11.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:137e79445c896a0ea7b265f52d23954e05b64222ee1af69e2cb34219067cbb67", size = 485538, upload-time = "2026-05-10T18:15:56.117Z" }, + { url = "https://files.pythonhosted.org/packages/c0/fe/3594ebfbaf03084ba4b120c9ba5c3183fd938a48725e9bbe6ff0a5159ad8/librt-0.11.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:cca6644054e78746d8d4ef238681f9c34ff8b584fe6b988ecebb8db3b15e622a", size = 479623, upload-time = "2026-05-10T18:15:57.544Z" }, + { url = "https://files.pythonhosted.org/packages/b0/da/5d1876984b3746c85dbd219dbfcb73c85f54ee263fd32e5b2a632ec14571/librt-0.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5b0eea49f5562861ee8d757a32ef7d559c1d35be2aaaa1ec28941d74c9ffc8a", size = 513082, upload-time = "2026-05-10T18:15:58.805Z" }, + { url = "https://files.pythonhosted.org/packages/19/6e/55bdf5d5ca00c3e18430690bf2c953d8d3ffd3c337418173d33dec985dc9/librt-0.11.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0d1029d7e1ae1a7e647ed6fb5df8c4ce2dffefb7a9f5fd1376a4554d96dac09f", size = 508105, upload-time = "2026-05-10T18:16:00.2Z" }, + { url = "https://files.pythonhosted.org/packages/07/10/f1f23a7c595ee90ece4d35c851e5d104b1311a887ed1b4ac4c35bbd13da8/librt-0.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bc3ce6b33c5828d9e80592011a5c584cb2ce86edbc4088405f70da47dc1d1b3b", size = 522268, upload-time = "2026-05-10T18:16:01.708Z" }, + { url = "https://files.pythonhosted.org/packages/b6/02/5720f5697a7f54b78b3aefbe20df3a48cedcff1276618c4aa481177942ed/librt-0.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:936c5995f3514a42111f20099397d8177c79b4d7e70961e396c6f5a0a3566766", size = 527348, upload-time = "2026-05-10T18:16:03.496Z" }, + { url = "https://files.pythonhosted.org/packages/50/db/b4a47c6f91db4ff76348a0b3dd0cc65e090a078b765a810a62ff9434c3d3/librt-0.11.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9bc0ca6ad9381cbe8e4aa6e5726e4c80c78115a6e9723c599ed1d73e092bc49d", size = 516294, upload-time = "2026-05-10T18:16:05.173Z" }, + { url = "https://files.pythonhosted.org/packages/9e/58/9384b2f4eb1ed1d273d40948a7c5c4b2360213b402ef3be4641c06299f9c/librt-0.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:070aa8c26c0a74774317a72df8851facc7f0f012a5b406557ac56992d92e1ec8", size = 553608, upload-time = "2026-05-10T18:16:06.839Z" }, + { url = "https://files.pythonhosted.org/packages/21/7b/5aa8848a7c6a9278c79375146da1812e695754ceec5f005e6043461a7315/librt-0.11.0-cp312-cp312-win32.whl", hash = "sha256:6bf14feb84b05ae945277395451998c89c54d0def4070eb5c08de544930b245a", size = 101879, upload-time = "2026-05-10T18:16:08.103Z" }, + { url = "https://files.pythonhosted.org/packages/37/33/8a745436944947575b584231750a41417de1a38cf6a2e9251d1065651c09/librt-0.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:75672f0bc524ede266287d532d7923dbce94c7514ad07627bac3d0c6d92cc4d9", size = 119831, upload-time = "2026-05-10T18:16:09.174Z" }, + { url = "https://files.pythonhosted.org/packages/59/67/a6739ac96e28b7855808bdb0370e250606104a859750d209e5a0716fe7ab/librt-0.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:2f10cf143e4a9bb0f4f5af568a00df94a2d69ef41c2579584454bb0fe5cc642c", size = 103470, upload-time = "2026-05-10T18:16:10.369Z" }, + { url = "https://files.pythonhosted.org/packages/82/61/e59168d4d0bf2bf90f4f0caf7a001bfc60254c3af4586013b04dc3ef517b/librt-0.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:78dc31f7fdfe9c9d0eb0e8f42d139db230e826415bbcabd9f0e9faaaee909894", size = 144119, upload-time = "2026-05-10T18:16:11.771Z" }, + { url = "https://files.pythonhosted.org/packages/61/fd/caa1d60b12f7dd79ccea23054e06eeaebe266a5f52c40a6b651069200ce5/librt-0.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fa475675db22290c3158e1d42326d0f5a65f04f44a0e68c3630a25b53560fb9c", size = 143565, upload-time = "2026-05-10T18:16:13.334Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a9/dc744f5c2b4978d48db970be29f22716d3413d28b14ad99740817315cf2c/librt-0.11.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:621db29691044bdeda22e789e482e1b0f3a985d90e3426c9c6d17606416205ea", size = 485395, upload-time = "2026-05-10T18:16:14.729Z" }, + { url = "https://files.pythonhosted.org/packages/8f/21/7f8e97a1e4dae952a5a95948f6f8507a173bc1e669f54340bba6ca1ca31b/librt-0.11.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a9010e2ed5b3a9e158c5fd966b3ab7e834bb3d3aacc8f66c91dd4b57a3799230", size = 479383, upload-time = "2026-05-10T18:16:16.321Z" }, + { url = "https://files.pythonhosted.org/packages/a6/6d/d8ee9c114bebf2c50e29ec2aa940826fccb62a645c3e4c18760987d0e16d/librt-0.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c39513d8b7477a2e1ed8c43fc21c524e8d5a0f8d4e8b7b074dbdbe7820a08e2", size = 513010, upload-time = "2026-05-10T18:16:17.647Z" }, + { url = "https://files.pythonhosted.org/packages/f0/43/0b5708af2bd30a46400e72ba6bdaa8f066f15fb9a688527e34220e8d6c06/librt-0.11.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7aef3cf1d5af86e770ab04bfd993dfc4ae8b8c17f66fb77dd4a7d50de7bbb1a3", size = 508433, upload-time = "2026-05-10T18:16:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/4a/50/356187247d09013490481033183b3532b58acf8028bcb34b2b56a375c9b2/librt-0.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:557183ddc36babe46b27dd60facbd5adb4492181a5be887587d57cda6e092f21", size = 522595, upload-time = "2026-05-10T18:16:20.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/e7/c6ac4240899c7f3248079d5a9900debe0dadb3fdeaf856684c987105ba47/librt-0.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:83d3e1f72bd42f6c5c0b7daec530c3f829bd02db42c70b8ddf0c2d90a2459930", size = 527255, upload-time = "2026-05-10T18:16:22.352Z" }, + { url = "https://files.pythonhosted.org/packages/eb/b5/a81322dbeedeeaf9c1ee6f001734d28a09d8383ac9e6779bc24bbd0743c6/librt-0.11.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:4ce1f21fbe589bc1afd7872dece84fb0e1144f794a288e58a10d2c54a55c43be", size = 516847, upload-time = "2026-05-10T18:16:23.627Z" }, + { url = "https://files.pythonhosted.org/packages/ae/66/6e6323787d592b55204a42595ff1102da5115601b53a7e9ddebc889a6da5/librt-0.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b09f7044ea2b64c9da42fd3d335666518cfd1c6e8a182c95da73d0214b41e", size = 553920, upload-time = "2026-05-10T18:16:25.025Z" }, + { url = "https://files.pythonhosted.org/packages/9c/21/623f8ca230857102066d9ca8c6c1734995908c4d0d1bee7bb2ef0021cb33/librt-0.11.0-cp313-cp313-win32.whl", hash = "sha256:78fddc31cd4d3caa897ad5d31f856b1faadc9474021ad6cb182b9018793e254e", size = 101898, upload-time = "2026-05-10T18:16:26.649Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1d/b4ebd44dd723f768469007515cb92251e0ae286c94c140f374801140fa74/librt-0.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ca8aa88751a775870b764e93bad5135385f563cb8dcee399abf034ea4d3cb47", size = 119812, upload-time = "2026-05-10T18:16:27.859Z" }, + { url = "https://files.pythonhosted.org/packages/3b/e4/b2f4ca7965ca373b491cdb4bc25cdb30c1649ca81a8782056a83850292a9/librt-0.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:96f044bb325fd9cf1a723015638c219e9143f0dfbc0ca54c565df2b7fc748b44", size = 103448, upload-time = "2026-05-10T18:16:29.066Z" }, + { url = "https://files.pythonhosted.org/packages/29/eb/dbce197da4e227779e56b5735f2decc3eb36e55a1cdbf1bd65d6639d76c1/librt-0.11.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4a017a95e5837dc15a8c5661d60e05daa96b90908b1aa6b7acdf443cd25c8ebd", size = 143345, upload-time = "2026-05-10T18:16:30.674Z" }, + { url = "https://files.pythonhosted.org/packages/76/a3/254bebd0c11c8ba684018efb8006ff22e466abce445215cca6c778e7d9de/librt-0.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b1ecbd9819deccc39b7542bf4d2a740d8a620694d39989e58661d3763458f8d4", size = 143131, upload-time = "2026-05-10T18:16:32.037Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3f/f77d6122d21ac7bf6ae8a7dfced1bd2a7ac545d3273ebdcaf8042f6d619f/librt-0.11.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7da327dacd7be8f8ec36547373550744a3cc0e536d54665cd83f8bcd961200e8", size = 477024, upload-time = "2026-05-10T18:16:33.493Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0a/2c996dadebaa7d9bbbd43ef2d4f3e66b6da545f838a41694ef6172cebec8/librt-0.11.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0dc56b1f8d06e60db362cc3fdae206681817f86ce4725d34511473487f12a34b", size = 474221, upload-time = "2026-05-10T18:16:34.864Z" }, + { url = "https://files.pythonhosted.org/packages/0a/7e/f5d92af8486b8272c23b3e686b46ff72d89c8169585eb61eef01a2ac7147/librt-0.11.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05fb8fb2ab90e21c8d12ea240d744ad514da9baf381ebfa70d91d20d21713175", size = 505174, upload-time = "2026-05-10T18:16:36.705Z" }, + { url = "https://files.pythonhosted.org/packages/af/1a/cb0734fe86398eb33193ab753b7326255c74cac5eb09e76b9b16536e7adb/librt-0.11.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cae74872be221df4374d10fec61f93ed1513b9546ea84f2c0bf73ab3e9bd0b03", size = 497216, upload-time = "2026-05-10T18:16:38.418Z" }, + { url = "https://files.pythonhosted.org/packages/18/06/094820f91558b66e29943c0ec41c9914f460f48dd51fc503c3101e10842d/librt-0.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:32bcc918c0148eb7e3d57385125bac7e5f9e4359d05f07448b09f6f778c2f31c", size = 513921, upload-time = "2026-05-10T18:16:39.848Z" }, + { url = "https://files.pythonhosted.org/packages/0b/c2/00de9018871a282f530cacb457d5ec0428f6ac7e6fedde9aff7468d9fb04/librt-0.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:f9743fc99135d5f78d2454435615f6dec0473ca507c26ce9d92b10b562a280d3", size = 520850, upload-time = "2026-05-10T18:16:41.471Z" }, + { url = "https://files.pythonhosted.org/packages/51/9d/64631832348fd1834fb3a61b996434edddaaf25a31d03b0a76273159d2cf/librt-0.11.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5ba067f4aadae8fda802d91d2124c90c42195ff32d9161d3549e6d05cfe26f96", size = 504237, upload-time = "2026-05-10T18:16:43.15Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ec/ae5525eb16edc827a044e7bb8777a455ff95d4bca9379e7e6bddd7383647/librt-0.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:de3bf945454d032f9e390b85c4072e0a0570bf825421c8be0e71209fa65e1abe", size = 546261, upload-time = "2026-05-10T18:16:44.408Z" }, + { url = "https://files.pythonhosted.org/packages/5a/09/adce371f27ca039411da9659f7430fcc2ba6cd0c7b3e4467a0f091be7fa9/librt-0.11.0-cp314-cp314-win32.whl", hash = "sha256:d2277a05f6dcb9fd13db9566aac4fabd68c3ea1ea46ee5567d4eef8efa495a2f", size = 96965, upload-time = "2026-05-10T18:16:46.039Z" }, + { url = "https://files.pythonhosted.org/packages/d6/ee/8ac720d98548f173c7ce2e632a7ca94673f74cacd5c8162a84af5b35958a/librt-0.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:ab73e8db5e3f564d812c1f5c3a175930a5f9bc96ccb5e3b22a34d7858b401cf7", size = 115151, upload-time = "2026-05-10T18:16:47.133Z" }, + { url = "https://files.pythonhosted.org/packages/94/20/c900cf14efeb09b6bef2b2dff20779f73464b97fd58d1c6bccc379588ae3/librt-0.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:aea3caa317752e3a466fa8af45d91ee0ea8c7fdd96e42b0a8dd9b76a7931eba1", size = 98850, upload-time = "2026-05-10T18:16:48.597Z" }, + { url = "https://files.pythonhosted.org/packages/0c/71/944bfe4b64e12abffcd3c15e1cce07f72f3d55655083786285f4dedeb532/librt-0.11.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d1b36540d7aaf9b9101b3a6f376c8d8e9f7a9aec93ed05918f2c69d493ffef72", size = 151138, upload-time = "2026-05-10T18:16:49.839Z" }, + { url = "https://files.pythonhosted.org/packages/b6/10/99e64a5c86989357fda078c8143c533389585f6473b7439172dd8f3b3b2d/librt-0.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:efbb343ab2ce3540f4ecbe6315d677ed70f37cd9a72b1e58066c918ca83acbaa", size = 151976, upload-time = "2026-05-10T18:16:51.062Z" }, + { url = "https://files.pythonhosted.org/packages/21/31/5072ad880946d83e5ea4147d6d018c78eefce85b77819b19bdd0ee229435/librt-0.11.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0dd688aab3f7914d3e6e5e3554978e0383312fb8e771d84be008a35b9ee548", size = 557927, upload-time = "2026-05-10T18:16:52.632Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8d/70b5fb7cfbab60edbe7381614ab985da58e144fbf465c86d44c95f43cdca/librt-0.11.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:f5fb36b8c6c63fdcbb1d526d94c0d1331610d43f4118cc1beb4efef4f3faacb2", size = 539698, upload-time = "2026-05-10T18:16:53.934Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a3/ba3495a0b3edbd24a4cae0d1d3c64f39a9fc45d06e812101289b50c1a619/librt-0.11.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a9a237d13addb93715b6fee74023d5ee3469b53fce527626c0e088aa585805f", size = 577162, upload-time = "2026-05-10T18:16:55.589Z" }, + { url = "https://files.pythonhosted.org/packages/f7/db/36e25fb81f99937ff1b96612a1dc9fd66f039cb9cc3aee12c01fac31aab9/librt-0.11.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5ddd17bd87b2c56ddd60e546a7984a2e64c4e8eab92fb4cf3830a48ad5469d51", size = 566494, upload-time = "2026-05-10T18:16:56.975Z" }, + { url = "https://files.pythonhosted.org/packages/33/0d/3f622b47f0b013eeb9cf4cc07ae9bfe378d832a4eec998b2b209fe84244d/librt-0.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd43992b4473d42f12ff9e68326079f0696d9d4e6000e8f39a0238d482ba6ee2", size = 596858, upload-time = "2026-05-10T18:16:58.374Z" }, + { url = "https://files.pythonhosted.org/packages/a9/02/71b90bc93039c46a2000651f6ad60122b114c8f54c4ad306e0e96f5b75ad/librt-0.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:f8e3e8056dd674e279741485e2e512d6e9a751c7455809d0114e6ebf8d781085", size = 590318, upload-time = "2026-05-10T18:16:59.676Z" }, + { url = "https://files.pythonhosted.org/packages/04/04/418cb3f75621e2b761fb1ab0f017f4d70a1a72a6e7c74ee4f7e8d198c2f3/librt-0.11.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c1f708d8ae9c56cf38a903c44297243d2ec83fd82b396b977e0144a3e76217e3", size = 575115, upload-time = "2026-05-10T18:17:01.007Z" }, + { url = "https://files.pythonhosted.org/packages/cc/2c/5a2183ac58dd911f26b5d7e7d7d8f1d87fcecdddd99d6c12169a258ff62c/librt-0.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0add982e0e7b9fc14cf4b33789d5f13f66581889b88c2f58099f6ce8f92617bd", size = 617918, upload-time = "2026-05-10T18:17:02.682Z" }, + { url = "https://files.pythonhosted.org/packages/15/1f/dc6771a52592a4451be6effa200cbfc9cec61e4393d3033d81a9d307961d/librt-0.11.0-cp314-cp314t-win32.whl", hash = "sha256:2b481d846ac894c4e8403c5fd0e87c5d11d6499e404b474602508a224ff531c8", size = 103562, upload-time = "2026-05-10T18:17:03.99Z" }, + { url = "https://files.pythonhosted.org/packages/62/4a/7d1415567027286a75ba1093ec4aca11f073e0f559c530cf3e0a757ad55c/librt-0.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:28edb433edde181112a908c78907af28f964eabc15f4dd16c9d66c834302677c", size = 124327, upload-time = "2026-05-10T18:17:05.465Z" }, + { url = "https://files.pythonhosted.org/packages/ce/62/b40b382fa0c66fee1478073eb8db352a4a6beda4a1adccf1df911d8c289c/librt-0.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dee008f20b542e3cd162ba338a7f9ec0f6d23d395f66fe8aeeec3c9d067ea253", size = 102572, upload-time = "2026-05-10T18:17:06.809Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" }, + { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" }, + { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" }, + { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" }, + { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" }, + { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" }, + { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" }, + { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" }, + { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" }, + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/6f/340b04986e67aac6f66c5145ce68bf72c64bed30f92c8913499a6e6b8f99/matplotlib-3.10.9-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77210dce9cb8153dffc967efaae990543392563d5a376d4dd8539bebcb0ed217", size = 8296625, upload-time = "2026-04-24T00:11:43.376Z" }, + { url = "https://files.pythonhosted.org/packages/bb/2f/127081eb83162053ebb9678ceac64220b93a663e0167432566e9c7c82aab/matplotlib-3.10.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1e7698ac9868428e84d2c967424803b2472ff7167d9d6590d4204ed775343c3b", size = 8188790, upload-time = "2026-04-24T00:11:46.556Z" }, + { url = "https://files.pythonhosted.org/packages/fc/b7/d8bcec2626c35f96972bff656299fef4578113ea6193c8fdad324710410c/matplotlib-3.10.9-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1aa972116abb4c9d201bf245620b433726cb6856f3bef6a78f776a00f5c92d37", size = 8769389, upload-time = "2026-04-24T00:11:48.959Z" }, + { url = "https://files.pythonhosted.org/packages/12/49/b78e214a527ea732033b7f4d37f7afb504d74ba9d134bd47938230dfb8b1/matplotlib-3.10.9-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae2f11957b27ce53497dd4d7b235c4d4f1faf383dfb39d0c5beb833bff883294", size = 9589657, upload-time = "2026-04-24T00:11:51.915Z" }, + { url = "https://files.pythonhosted.org/packages/5f/15/5246f7b43beae19c74dfee651d58d6cc8112e06f77adb4e88cc04f2e3a23/matplotlib-3.10.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b049278ddce116aaa1c1377ebf58adea909132dfce0281cf7e3a1ea9fc2e2c65", size = 9651983, upload-time = "2026-04-24T00:11:54.766Z" }, + { url = "https://files.pythonhosted.org/packages/75/77/5acecfe672ba0fa1b8c0454f69ce155d1e6fc5852fa7206bf9afaf767121/matplotlib-3.10.9-cp310-cp310-win_amd64.whl", hash = "sha256:82834c3c292d24d3a8aae77cd2d20019de69d692a34a970e4fdb8d33e2ea3dda", size = 8199701, upload-time = "2026-04-24T00:11:58.389Z" }, + { url = "https://files.pythonhosted.org/packages/4c/8c/290f021104741fea63769c31494f5324c0cd249bf536a65a4350767b1f22/matplotlib-3.10.9-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:68cfdcede415f7c8f5577b03303dd94526cdb6d11036cecdc205e08733b2d2bb", size = 8306860, upload-time = "2026-04-24T00:12:01.207Z" }, + { url = "https://files.pythonhosted.org/packages/51/18/325cd32ece1120d1da51cc4e4294c6580190699490183fc2fe8cb6d61ec5/matplotlib-3.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfca0129678bd56379db26c52b5d77ed7de314c047492fbdc763aa7501710cfb", size = 8199254, upload-time = "2026-04-24T00:12:04.239Z" }, + { url = "https://files.pythonhosted.org/packages/79/db/e28c1b83e3680740aa78925f5fb2ae4d16207207419ad75ea9fe604f8676/matplotlib-3.10.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e436d155fa8a3399dc62683f8f5d0e2e50d25d0144a73edd73f82eec8f4abfb", size = 8777092, upload-time = "2026-04-24T00:12:06.793Z" }, + { url = "https://files.pythonhosted.org/packages/55/fa/3ce7adfe9ba101748f465211660d9c6374c876b671bdb8c2bb6d347e8b94/matplotlib-3.10.9-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56fc0bd271b00025c6edfdc7c2dcd247372c8e1544971d62e1dc7c17367e8bf9", size = 9595691, upload-time = "2026-04-24T00:12:09.706Z" }, + { url = "https://files.pythonhosted.org/packages/36/c4/6960a76686ed668f2c60f84e9799ba4c0d56abdb36b1577b60c1d061d1ec/matplotlib-3.10.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5a6104ed666402ba5106d7f36e0e0cdca4e8d7fa4d39708ca88019e2835a2eb", size = 9659771, upload-time = "2026-04-24T00:12:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0d/271aace3342157c64700c9ff4c59c7b392f3dbab393692e8db6fbe7ab96c/matplotlib-3.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:d730e984eddf56974c3e72b6129c7ca462ac38dc624338f4b0b23eb23ecba00f", size = 8205112, upload-time = "2026-04-24T00:12:15.773Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ee/cb57ad4754f3e7b9174ce6ce66d9205fb827067e48a9f58ac09d7e7d6b77/matplotlib-3.10.9-cp311-cp311-win_arm64.whl", hash = "sha256:51bf0ddbdc598e060d46c16b5590708f81a1624cefbaaf62f6a81bf9285b8c80", size = 8132310, upload-time = "2026-04-24T00:12:18.645Z" }, + { url = "https://files.pythonhosted.org/packages/35/c6/5581e26c72233ebb2a2a6fed2d24fb7c66b4700120b813f51b0555acf0b6/matplotlib-3.10.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0c3c28d9fbcc1fe7a03be236d73430cf6409c41fb2383a7ac52fe932b072cb1", size = 8319908, upload-time = "2026-04-24T00:12:21.323Z" }, + { url = "https://files.pythonhosted.org/packages/b7/18/4880dd762e40cd360c1bf06e890c5a97b997e91cb324602b1a19950ad5ce/matplotlib-3.10.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cb28c2bd769aa3e98322c6ab09854cbcc52ab69d2759d681bba3e327b2b320", size = 8216016, upload-time = "2026-04-24T00:12:23.4Z" }, + { url = "https://files.pythonhosted.org/packages/32/91/d024616abdba99e83120e07a20658976f6a343646710760c4a51df126029/matplotlib-3.10.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ae20801130378b82d647ff5047c07316295b68dc054ca6b3c13519d0ea624285", size = 8789336, upload-time = "2026-04-24T00:12:26.096Z" }, + { url = "https://files.pythonhosted.org/packages/5c/04/030a2f61ef2158f5e4c259487a92ac877732499fb33d871585d89e03c42d/matplotlib-3.10.9-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c63ebcd8b4b169eb2f5c200552ae6b8be8999a005b6b507ed76fb8d7d674fe2", size = 9604602, upload-time = "2026-04-24T00:12:29.052Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c2/541e4d09d87bb6b5830fc28b4c887a9a8cf4e1c6cee698a8c05552ae2003/matplotlib-3.10.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d75d11c949914165976c621b2324f9ef162af7ebf4b057ddf95dd1dba7e5edcf", size = 9670966, upload-time = "2026-04-24T00:12:32.131Z" }, + { url = "https://files.pythonhosted.org/packages/04/a1/4571fc46e7702de8d0c2dc54ad1b2f8e29328dea3ee90831181f7353d93c/matplotlib-3.10.9-cp312-cp312-win_amd64.whl", hash = "sha256:d091f9d758b34aaaaa6331d13574bf01891d903b3dec59bfff458ef7551de5d6", size = 8217462, upload-time = "2026-04-24T00:12:35.226Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d0/2269edb12aa30c13c8bcc9382892e39943ce1d28aab4ec296e0381798e81/matplotlib-3.10.9-cp312-cp312-win_arm64.whl", hash = "sha256:10cc5ce06d10231c36f40e875f3c7e8050362a4ee8f0ee5d29a6b3277d57bb42", size = 8136688, upload-time = "2026-04-24T00:12:37.442Z" }, + { url = "https://files.pythonhosted.org/packages/aa/d3/8d4f6afbecb49fc04e060a57c0fce39ea51cc163a6bd87303ccd698e4fa6/matplotlib-3.10.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b580440f1ff81a0e34122051a3dfabb7e4b7f9e380629929bde0eff9af72165f", size = 8320331, upload-time = "2026-04-24T00:12:39.688Z" }, + { url = "https://files.pythonhosted.org/packages/63/d9/9e14bc7564bf92d5ffa801ae5fac819ce74b925dfb55e3ebde61a3bbad3e/matplotlib-3.10.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b1b745c489cd1a77a0dc1120a05dc87af9798faebc913601feb8c73d89bf2d1e", size = 8216461, upload-time = "2026-04-24T00:12:42.494Z" }, + { url = "https://files.pythonhosted.org/packages/8a/17/4402d0d14ccf1dfc70932600b68097fbbf9c898a4871d2cbbe79c7801a32/matplotlib-3.10.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8f3bcac1ca5ed000a6f4337d47ba67dfddf37ed6a46c15fd7f014997f7bf865f", size = 8790091, upload-time = "2026-04-24T00:12:44.789Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0b/322aeec06dd9b91411f92028b37d447342770a24392aa4813e317064dad5/matplotlib-3.10.9-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a8d66a55def891c33147ba3ba9bfcabf0b526a43764c818acbb4525e5ed0838", size = 9605027, upload-time = "2026-04-24T00:12:47.583Z" }, + { url = "https://files.pythonhosted.org/packages/74/88/5f13482f55e7b00bcfc09838b093c2456e1379978d2a146844aae05350ad/matplotlib-3.10.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d843374407c4017a6403b59c6c81606773d136f3259d5b6da3131bc814542cc2", size = 9671269, upload-time = "2026-04-24T00:12:50.878Z" }, + { url = "https://files.pythonhosted.org/packages/c5/e0/0840fd2f93da988ec660b8ad1984abe9f25d2aed22a5e394ff1c68c88307/matplotlib-3.10.9-cp313-cp313-win_amd64.whl", hash = "sha256:f4399f64b3e94cd500195490972ae1ee81170df1636fa15364d157d5bdd7b921", size = 8217588, upload-time = "2026-04-24T00:12:53.784Z" }, + { url = "https://files.pythonhosted.org/packages/47/b9/d706d06dd605c49b9f83a2aed8c13e3e5db70697d7a80b7e3d7915de6b17/matplotlib-3.10.9-cp313-cp313-win_arm64.whl", hash = "sha256:ba7b3b8ef09eab7df0e86e9ae086faa433efbfbdb46afcb3aa16aabf779469a8", size = 8136913, upload-time = "2026-04-24T00:12:56.501Z" }, + { url = "https://files.pythonhosted.org/packages/9b/45/6e32d96978264c8ca8c4b1010adb955a1a49cfaf314e212bbc8908f04a61/matplotlib-3.10.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:09218df8a93712bd6ea133e83a153c755448cf7868316c531cffcc43f69d1cc9", size = 8368019, upload-time = "2026-04-24T00:12:58.896Z" }, + { url = "https://files.pythonhosted.org/packages/86/0a/c8e3d3bba245f0f7fc424937f8ff7ef77291a36af3edb97ccd78aa93d84f/matplotlib-3.10.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:82368699727bfb7b0182e1aa13082e3c08e092fa1a25d3e1fd92405bff96f6d4", size = 8264645, upload-time = "2026-04-24T00:13:01.406Z" }, + { url = "https://files.pythonhosted.org/packages/3d/aa/5bf5a14fe4fed73a4209a155606f8096ff797aad89c6c35179026571133e/matplotlib-3.10.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3225f4e1edcb8c86c884ddf79ebe20ecd0a67d30188f279897554ccd8fded4dc", size = 8802194, upload-time = "2026-04-24T00:13:03.702Z" }, + { url = "https://files.pythonhosted.org/packages/dd/5e/b4be852d6bba6fd15893fadf91ff26ae49cb91aac789e95dde9d342e664f/matplotlib-3.10.9-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de2445a0c6690d21b7eb6ce071cebad6d40a2e9bdf10d039074a96ba19797b99", size = 9622684, upload-time = "2026-04-24T00:13:06.647Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/ed428c971139112ef730f62770654d609467346d09d4b62617e1afd68a5a/matplotlib-3.10.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b2b9516251cb89ff618d757daec0e2ed1bf21248013844a853d87ef85ab3081d", size = 9680790, upload-time = "2026-04-24T00:13:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/e7/09/052e884aaf2b985c63cb79f715f1d5b6a3eaa7de78f6a52b9dbc077d5b53/matplotlib-3.10.9-cp313-cp313t-win_amd64.whl", hash = "sha256:e9fae004b941b23ff2edcf1567a857ed77bafc8086ffa258190462328434faf8", size = 8287571, upload-time = "2026-04-24T00:13:13.087Z" }, + { url = "https://files.pythonhosted.org/packages/f4/38/ae27288e788c35a4250491422f3db7750366fc8c97d6f36fbdecfc1f5518/matplotlib-3.10.9-cp313-cp313t-win_arm64.whl", hash = "sha256:6b63d9c7c769b88ab81e10dc86e4e0607cf56817b9f9e6cf24b2a5f1693b8e38", size = 8188292, upload-time = "2026-04-24T00:13:15.546Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e6/3bd8afd04949f02eabc1c17115ea5255e19cacd4d06fc5abdde4eeb0052c/matplotlib-3.10.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:172db52c9e683f5d12eaf57f0f54834190e12581fe1cc2a19595a8f5acb4e77d", size = 8321276, upload-time = "2026-04-24T00:13:18.318Z" }, + { url = "https://files.pythonhosted.org/packages/41/86/86231232fff41c9f8e4a1a7d7a597d349a02527109c3af7d618366122139/matplotlib-3.10.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97e35e8d39ccc85859095e01a53847432ba9a53ddf7986f7a54a11b73d0e143f", size = 8218218, upload-time = "2026-04-24T00:13:20.974Z" }, + { url = "https://files.pythonhosted.org/packages/85/8f/becc9722cafc64f5d2eb0b7c1bf5f585271c618a45dbd8fabeb021f898b6/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aba1615dabe83188e19d4f75a253c6a08423e04c1425e64039f800050a69de6b", size = 9608145, upload-time = "2026-04-24T00:13:23.228Z" }, + { url = "https://files.pythonhosted.org/packages/32/5d/f7e914f7d9325abff4057cee62c0fa70263683189f774473cbfb534cd13b/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34cf8167e023ad956c15f36302911d5406bd99a9862c1a8499ea6f7c0e015dc2", size = 9885085, upload-time = "2026-04-24T00:13:25.849Z" }, + { url = "https://files.pythonhosted.org/packages/a5/fd/fa69f2221534e80cc5772ac2b7d222011a2acafc2ec7216d5dd174c864ae/matplotlib-3.10.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:59476c6d29d612b8e9bb6ce8c5b631be6ba8f9e3a2421f22a02b192c7dd28716", size = 9672358, upload-time = "2026-04-24T00:13:28.906Z" }, + { url = "https://files.pythonhosted.org/packages/ab/1a/5a4f747a8b271cbb024946d2dd3c913ab5032ba430626f8c3528ada96b4b/matplotlib-3.10.9-cp314-cp314-win_amd64.whl", hash = "sha256:336b9acc64d309063126edcdaca00db9373af3c476bb94388fe9c5a53ad13e6f", size = 8349970, upload-time = "2026-04-24T00:13:31.904Z" }, + { url = "https://files.pythonhosted.org/packages/64/dc/95d60ecaefe30680a154b52ea96ab4b0dab547f1fd6aa12f5fb655e89cae/matplotlib-3.10.9-cp314-cp314-win_arm64.whl", hash = "sha256:2dc9477819ffd78ad12a20df1d9d6a6bd4fec6aaa9072681465fddca052f1456", size = 8272785, upload-time = "2026-04-24T00:13:34.511Z" }, + { url = "https://files.pythonhosted.org/packages/70/a0/005d68bc8b8418300ce6591f18586910a8526806e2ab663933d9f20a41e9/matplotlib-3.10.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:da4e09638420548f31c354032a6250e473c68e5a4e96899b4844cf39ddea23fe", size = 8367999, upload-time = "2026-04-24T00:13:36.962Z" }, + { url = "https://files.pythonhosted.org/packages/22/05/1236cc9290be70b2498af20ca348add76e3fffe7f67b477db5133a84f3ea/matplotlib-3.10.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:345f6f68ecc8da0ca56fad2ea08fde1a115eda530079eca185d50a7bc3e146c6", size = 8264543, upload-time = "2026-04-24T00:13:39.851Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c2/071f5a5ff6c5bd63aaaf2f45c811d9bf2ced94bde188d9e1a519e21d0cba/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4edcfbd8565339aa62f1cd4012f7180926fdbe71850f7b0d3c379c175cd6b66c", size = 9622800, upload-time = "2026-04-24T00:13:42.296Z" }, + { url = "https://files.pythonhosted.org/packages/95/57/da7d1f10a85624b9e7db68e069dd94e58dc41dbf9463c5921632ecbe3661/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6be157fe17fc37cb95ac1d7374cf717ce9259616edec911a78d9d26dae8522d4", size = 9888561, upload-time = "2026-04-24T00:13:45.026Z" }, + { url = "https://files.pythonhosted.org/packages/67/b2/ef8d6bb59b0edb6c16c968b70f548aa13b54348972def5aa6ac85df67145/matplotlib-3.10.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4e42042d54db34fda4e95a7bd3e5789c2a995d2dad3eb8850232ee534092fbbf", size = 9680884, upload-time = "2026-04-24T00:13:48.066Z" }, + { url = "https://files.pythonhosted.org/packages/61/1c/d21bfeb9931881ebe96bcfcff27c7ae4b160ae0ec291a714c42641a56d75/matplotlib-3.10.9-cp314-cp314t-win_amd64.whl", hash = "sha256:c27df8b3848f32a83d1767566595e43cfaa4460380974da06f4279a7ec143c39", size = 8432333, upload-time = "2026-04-24T00:13:51.008Z" }, + { url = "https://files.pythonhosted.org/packages/78/23/92493c3e6e1b635ccfff146f7b99e674808787915420373ac399283764c2/matplotlib-3.10.9-cp314-cp314t-win_arm64.whl", hash = "sha256:a49f1eadc84ca85fd72fa4e89e70e61bf86452df6f971af04b12c60761a0772c", size = 8324785, upload-time = "2026-04-24T00:13:53.633Z" }, + { url = "https://files.pythonhosted.org/packages/2c/2b/0e92ad0ac446633f928a1563db4aa8add407e1924faf0ded5b95b35afb27/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1872fb212a05b729e649754a72d5da61d03e0554d76e80303b6f83d1d2c0552b", size = 8293058, upload-time = "2026-04-24T00:13:56.339Z" }, + { url = "https://files.pythonhosted.org/packages/4b/23/74682fd369f5299ceda438fea2a0662e6383b85c9383fb9cdfcf04713e07/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:985f2238880e2e69093f588f5fe2e46771747febf0649f3cf7f7b7480875317f", size = 8186627, upload-time = "2026-04-24T00:13:58.623Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e8/368aab88f3c4cd8992800f31abfe0670c3e47540ba20a97e9fdbcde594b3/matplotlib-3.10.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6640f75af2c6148293caa0a2b39dd806a492dd66c8a8b04035813e33d0fd2585", size = 8764117, upload-time = "2026-04-24T00:14:01.684Z" }, + { url = "https://files.pythonhosted.org/packages/63/e2/9f66ca6a651a52abfe0d4964ce01439ed34f3f1e119de10ff3a07f403043/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:42fb814efabe95c06c1994d8ab5a8385f43a249e23badd3ba931d4308e5bca20", size = 8304420, upload-time = "2026-04-24T00:14:04.57Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e8/467c03568218792906aa87b5e7bb379b605e056ed0c74fe00c051786d925/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f76e640a5268850bfda54b5131b1b1941cc685e42c5fa98ed9f2d64038308cba", size = 8197981, upload-time = "2026-04-24T00:14:07.233Z" }, + { url = "https://files.pythonhosted.org/packages/6f/87/afead29192170917537934c6aff4b008c805fff7b1ccea0c79120d96beda/matplotlib-3.10.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3fc0364dfbe1d07f6d15c5ebd0c5bf89e126916e5a8667dd4a7a6e84c36653d4", size = 8774002, upload-time = "2026-04-24T00:14:09.816Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, +] + +[[package]] +name = "mdit-py-plugins" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/59/fc/f8d0863f8862f25602c0404d75568e89fb6b4109804645e5cdfb1be5cf56/mdit_py_plugins-0.6.1.tar.gz", hash = "sha256:a2bca0f039f39dbd35fb74ae1b5f998608c437463371f0ff7f49a19a17a114d0", size = 56114, upload-time = "2026-05-13T09:03:38.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/69/6da5581c6a7fede7dc261bf4e67d6adca4196f176b43288b55b3db395b6e/mdit_py_plugins-0.6.1-py3-none-any.whl", hash = "sha256:214c82fb2ac524472ab6a5bcab1de80f73b50443e187f401bfd77efbc7c6481d", size = 66663, upload-time = "2026-05-13T09:03:37.76Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "mistune" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/84/620cc3f7e3adf6f5067e10f4dbae71295d8f9e16d5d3f9ef97c40f2f592c/mistune-3.2.1.tar.gz", hash = "sha256:7c8e5501d38bac1582e067e46c8343f17d57ea1aaa735823f3aba1fd59c88a28", size = 98003, upload-time = "2026-05-03T14:33:22.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/7f/a946aa4f8752b37102b41e64dca18a1976ac705c3a0d1dfe74d820a02552/mistune-3.2.1-py3-none-any.whl", hash = "sha256:78cdb0ba5e938053ccf63651b352508d2efa9411dc8810bfb05f2dc5140c0048", size = 53749, upload-time = "2026-05-03T14:33:20.551Z" }, +] + +[[package]] +name = "more-itertools" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/f4da6f02cdffe04d6362210b807146a26044c88d839208aec273bb0d9184/more_itertools-11.1.0.tar.gz", hash = "sha256:48e8f4d9e7e5878571ecf6f2b4e57634f93cd474cc8cfbd2376f2d11b396e30d", size = 145772, upload-time = "2026-05-22T14:14:29.909Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/3d/1087453384dbde46a8c7f9356eead2c58be8a7bf156bca40243377c85715/more_itertools-11.1.0-py3-none-any.whl", hash = "sha256:4b65538ae22f6fed0ce4874efd317463a7489796a0939fa66824dd542125a192", size = 72226, upload-time = "2026-05-22T14:14:28.824Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "mypy" +version = "1.20.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "librt", marker = "platform_python_implementation != 'PyPy' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/af/e3d4b3e9ec91a0ff9aabfdb38692952acf49bbb899c2e4c29acb3a6da3ae/mypy-1.20.2.tar.gz", hash = "sha256:e8222c26daaafd9e8626dec58ae36029f82585890589576f769a650dd20fd665", size = 3817349, upload-time = "2026-04-21T17:12:28.473Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/97/ce2502df2cecf2ef997b6c6527c4a223b92feb9e7b790cdc8dcd683f3a8a/mypy-1.20.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cf5a4db6dca263010e2c7bff081c89383c72d187ba2cf4c44759aac970e2f0c4", size = 14457059, upload-time = "2026-04-21T17:06:14.935Z" }, + { url = "https://files.pythonhosted.org/packages/c9/34/417ee60b822cc80c0f3dc9f495ad7fd8dbb8d8b2cf4baf22d4046d25d01d/mypy-1.20.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7b0e817b518bff7facd7f85ea05b643ad8bdcce684cf29784987b0a7c8e1f997", size = 13346816, upload-time = "2026-04-21T17:10:41.433Z" }, + { url = "https://files.pythonhosted.org/packages/4a/85/e20951978702df58379d0bcc2e8f7ccdca4e78cd7dc66dd3ddbf9b29d517/mypy-1.20.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97d7b9a485b40f8ca425460e89bf1da2814625b2da627c0dcc6aa46c92631d14", size = 13772593, upload-time = "2026-04-21T17:08:11.24Z" }, + { url = "https://files.pythonhosted.org/packages/63/a5/5441a13259ec516c56fd5de0fd96a69a9590ae6c5e5d3e5174aa84b97973/mypy-1.20.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e1c12f6d2db3d78b909b5f77513c11eb7f2dd2782b96a3ab6dffc7d44575c99", size = 14656635, upload-time = "2026-04-21T17:09:54.042Z" }, + { url = "https://files.pythonhosted.org/packages/3b/51/b89c69157c5e1f19fd125a65d991166a26906e7902f026f00feebbcfa2b9/mypy-1.20.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:89dce27e142d25ffbc154c1819383b69f2e9234dc4ed4766f42e0e8cb264ab5c", size = 14943278, upload-time = "2026-04-21T17:09:15.599Z" }, + { url = "https://files.pythonhosted.org/packages/e9/44/6b0eeecfe96d7cce1d71c66b8e03cb304aa70ec11f1955dc1d6b46aca3c3/mypy-1.20.2-cp310-cp310-win_amd64.whl", hash = "sha256:f376e37f9bf2a946872fc5fd1199c99310748e3c26c7a26683f13f8bdb756cbd", size = 10851915, upload-time = "2026-04-21T17:06:03.5Z" }, + { url = "https://files.pythonhosted.org/packages/3c/36/6593dc88545d75fb96416184be5392da5e2a8e8c2802a8597913e16ae25c/mypy-1.20.2-cp310-cp310-win_arm64.whl", hash = "sha256:6e2b469efd811707bc530fd1effef0f5d6eebcb7fe376affae69025da4b979a2", size = 9786676, upload-time = "2026-04-21T17:07:02.035Z" }, + { url = "https://files.pythonhosted.org/packages/1f/4d/9ebeae211caccbdaddde7ed5e31dfcf57faac66be9b11deb1dc6526c8078/mypy-1.20.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4077797a273e56e8843d001e9dfe4ba10e33323d6ade647ff260e5cd97d9758c", size = 14371307, upload-time = "2026-04-21T17:08:56.442Z" }, + { url = "https://files.pythonhosted.org/packages/95/d7/93473d34b61f04fac1aecc01368485c89c5c4af7a4b9a0cab5d77d04b63f/mypy-1.20.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cdecf62abcc4292500d7858aeae87a1f8f1150f4c4dd08fb0b336ee79b2a6df3", size = 13258917, upload-time = "2026-04-21T17:05:50.978Z" }, + { url = "https://files.pythonhosted.org/packages/e2/30/3dd903e8bafb7b5f7bf87fcd58f8382086dea2aa19f0a7b357f21f63071b/mypy-1.20.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c566c3a88b6ece59b3d70f65bedef17304f48eb52ff040a6a18214e1917b3254", size = 13700516, upload-time = "2026-04-21T17:11:33.161Z" }, + { url = "https://files.pythonhosted.org/packages/07/05/c61a140aba4c729ac7bc99ae26fc627c78a6e08f5b9dd319244ea71a3d7e/mypy-1.20.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0deb80d062b2479f2c87ae568f89845afc71d11bc41b04179e58165fd9f31e98", size = 14562889, upload-time = "2026-04-21T17:05:27.674Z" }, + { url = "https://files.pythonhosted.org/packages/fd/87/da78243742ffa8a36d98c3010f0d829f93d5da4e6786f1a1a6f2ad616502/mypy-1.20.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bba9ad231e92a3e424b3e56b65aa17704993425bba97e302c832f9466bb85bac", size = 14803844, upload-time = "2026-04-21T17:10:06.2Z" }, + { url = "https://files.pythonhosted.org/packages/37/52/10a1ddf91b40f843943a3c6db51e2df59c9e237f29d355e95eaab427461f/mypy-1.20.2-cp311-cp311-win_amd64.whl", hash = "sha256:baf593f2765fa3a6b1ef95807dbaa3d25b594f6a52adcc506a6b9cb115e1be67", size = 10846300, upload-time = "2026-04-21T17:12:23.886Z" }, + { url = "https://files.pythonhosted.org/packages/20/02/f9a4415b664c53bd34d6709be59da303abcae986dc4ac847b402edb6fa1e/mypy-1.20.2-cp311-cp311-win_arm64.whl", hash = "sha256:20175a1c0f49863946ec20b7f63255768058ac4f07d2b9ded6a6b46cfb5a9100", size = 9779498, upload-time = "2026-04-21T17:09:23.695Z" }, + { url = "https://files.pythonhosted.org/packages/71/4e/7560e4528db9e9b147e4c0f22660466bf30a0a1fe3d63d1b9d3b0fd354ee/mypy-1.20.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4dbfcf869f6b0517f70cf0030ba6ea1d6645e132337a7d5204a18d8d5636c02b", size = 14539393, upload-time = "2026-04-21T17:07:12.52Z" }, + { url = "https://files.pythonhosted.org/packages/32/d9/34a5efed8124f5a9234f55ac6a4ced4201e2c5b81e1109c49ad23190ec8c/mypy-1.20.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4b6481b228d072315b053210b01ac320e1be243dc17f9e5887ef167f23f5fae4", size = 13361642, upload-time = "2026-04-21T17:06:53.742Z" }, + { url = "https://files.pythonhosted.org/packages/d1/14/eb377acf78c03c92d566a1510cda8137348215b5335085ef662ab82ecd3a/mypy-1.20.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34397cdced6b90b836e38182076049fdb41424322e0b0728c946b0939ebdf9f6", size = 13740347, upload-time = "2026-04-21T17:12:04.73Z" }, + { url = "https://files.pythonhosted.org/packages/b9/94/7e4634a32b641aa1c112422eed1bbece61ee16205f674190e8b536f884de/mypy-1.20.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5da6976f20cae27059ea8d0c86e7cef3de720e04c4bb9ee18e3690fdb792066", size = 14734042, upload-time = "2026-04-21T17:07:43.16Z" }, + { url = "https://files.pythonhosted.org/packages/7a/f3/f7e62395cb7f434541b4491a01149a4439e28ace4c0c632bbf5431e92d1f/mypy-1.20.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:56908d7e08318d39f85b1f0c6cfd47b0cac1a130da677630dac0de3e0623e102", size = 14964958, upload-time = "2026-04-21T17:11:00.665Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0d/47e3c3a0ec2a876e35aeac365df3cac7776c36bbd4ed18cc521e1b9d255b/mypy-1.20.2-cp312-cp312-win_amd64.whl", hash = "sha256:d52ad8d78522da1d308789df651ee5379088e77c76cb1994858d40a426b343b9", size = 10911340, upload-time = "2026-04-21T17:10:49.179Z" }, + { url = "https://files.pythonhosted.org/packages/d6/b2/6c852d72e0ea8b01f49da817fb52539993cde327e7d010e0103dc12d0dac/mypy-1.20.2-cp312-cp312-win_arm64.whl", hash = "sha256:785b08db19c9f214dc37d65f7c165d19a30fcecb48abfa30f31b01b5acaabb58", size = 9833947, upload-time = "2026-04-21T17:09:05.267Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c4/b93812d3a192c9bcf5df405bd2f30277cd0e48106a14d1023c7f6ed6e39b/mypy-1.20.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:edfbfca868cdd6bd8d974a60f8a3682f5565d3f5c99b327640cedd24c4264026", size = 14524670, upload-time = "2026-04-21T17:10:30.737Z" }, + { url = "https://files.pythonhosted.org/packages/f3/47/42c122501bff18eaf1e8f457f5c017933452d8acdc52918a9f59f6812955/mypy-1.20.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e2877a02380adfcdbc69071a0f74d6e9dbbf593c0dc9d174e1f223ffd5281943", size = 13336218, upload-time = "2026-04-21T17:08:44.069Z" }, + { url = "https://files.pythonhosted.org/packages/92/8f/75bbc92f41725fbd585fb17b440b1119b576105df1013622983e18640a93/mypy-1.20.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7488448de6007cd5177c6cea0517ac33b4c0f5ee9b5e9f2be51ce75511a85517", size = 13724906, upload-time = "2026-04-21T17:08:01.02Z" }, + { url = "https://files.pythonhosted.org/packages/a1/32/4c49da27a606167391ff0c39aa955707a00edc500572e562f7c36c08a71f/mypy-1.20.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bb9c2fa06887e21d6a3a868762acb82aec34e2c6fd0174064f27c93ede68ad15", size = 14726046, upload-time = "2026-04-21T17:11:22.354Z" }, + { url = "https://files.pythonhosted.org/packages/7f/fc/4e354a1bd70216359deb0c9c54847ee6b32ef78dfb09f5131ff99b494078/mypy-1.20.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9d56a78b646f2e3daa865bc70cd5ec5a46c50045801ca8ff17a0c43abc97e3ee", size = 14955587, upload-time = "2026-04-21T17:12:16.033Z" }, + { url = "https://files.pythonhosted.org/packages/62/b2/c0f2056e9eb8f08c62cafd9715e4584b89132bdc832fcf85d27d07b5f3e5/mypy-1.20.2-cp313-cp313-win_amd64.whl", hash = "sha256:2a4102b03bb7481d9a91a6da8d174740c9c8c4401024684b9ca3b7cc5e49852f", size = 10922681, upload-time = "2026-04-21T17:06:35.842Z" }, + { url = "https://files.pythonhosted.org/packages/e5/14/065e333721f05de8ef683d0aa804c23026bcc287446b61cac657b902ccac/mypy-1.20.2-cp313-cp313-win_arm64.whl", hash = "sha256:a95a9248b0c6fd933a442c03c3b113c3b61320086b88e2c444676d3fd1ca3330", size = 9830560, upload-time = "2026-04-21T17:07:51.023Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d1/b4ec96b0ecc620a4443570c6e95c867903428cfcde4206518eafdd5880c3/mypy-1.20.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:419413398fe250aae057fd2fe50166b61077083c9b82754c341cf4fd73038f30", size = 14524561, upload-time = "2026-04-21T17:06:27.325Z" }, + { url = "https://files.pythonhosted.org/packages/3a/63/d2c2ff4fa66bc49477d32dfa26e8a167ba803ea6a69c5efb416036909d30/mypy-1.20.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e73c07f23009962885c197ccb9b41356a30cc0e5a1d0c2ea8fd8fb1362d7f924", size = 13363883, upload-time = "2026-04-21T17:11:11.239Z" }, + { url = "https://files.pythonhosted.org/packages/2a/56/983916806bf4eddeaaa2c9230903c3669c6718552a921154e1c5182c701f/mypy-1.20.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c64e5973df366b747646fc98da921f9d6eba9716d57d1db94a83c026a08e0fb", size = 13742945, upload-time = "2026-04-21T17:08:34.181Z" }, + { url = "https://files.pythonhosted.org/packages/19/65/0cd9285ab010ee8214c83d67c6b49417c40d86ce46f1aa109457b5a9b8d7/mypy-1.20.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a65aa591af023864fd08a97da9974e919452cfe19cb146c8a5dc692626445dc", size = 14706163, upload-time = "2026-04-21T17:05:15.51Z" }, + { url = "https://files.pythonhosted.org/packages/94/97/48ff3b297cafcc94d185243a9190836fb1b01c1b0918fff64e941e973cc9/mypy-1.20.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4fef51b01e638974a6e69885687e9bd40c8d1e09a6cd291cca0619625cf1f558", size = 14938677, upload-time = "2026-04-21T17:05:39.562Z" }, + { url = "https://files.pythonhosted.org/packages/fd/a1/1b4233d255bdd0b38a1f284feeb1c143ca508c19184964e22f8d837ec851/mypy-1.20.2-cp314-cp314-win_amd64.whl", hash = "sha256:913485a03f1bcf5d279409a9d2b9ed565c151f61c09f29991e5faa14033da4c8", size = 11089322, upload-time = "2026-04-21T17:06:44.29Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/ce7ee2ba36aeb954ba50f18fa25d9c1188578654b97d02a66a15b6f09531/mypy-1.20.2-cp314-cp314-win_arm64.whl", hash = "sha256:c3bae4f855d965b5453784300c12ffc63a548304ac7f99e55d4dc7c898673aa3", size = 10017775, upload-time = "2026-04-21T17:07:20.732Z" }, + { url = "https://files.pythonhosted.org/packages/4e/a1/9d93a7d0b5859af0ead82b4888b46df6c8797e1bc5e1e262a08518c6d48e/mypy-1.20.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2de3dcea53babc1c3237a19002bc3d228ce1833278f093b8d619e06e7cc79609", size = 15549002, upload-time = "2026-04-21T17:08:23.107Z" }, + { url = "https://files.pythonhosted.org/packages/00/d2/09a6a10ee1bf0008f6c144d9676f2ca6a12512151b4e0ad0ff6c4fac5337/mypy-1.20.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:52b176444e2e5054dfcbcb8c75b0b719865c96247b37407184bbfca5c353f2c2", size = 14401942, upload-time = "2026-04-21T17:07:31.837Z" }, + { url = "https://files.pythonhosted.org/packages/57/da/9594b75c3c019e805250bed3583bdf4443ff9e6ef08f97e39ae308cb06f2/mypy-1.20.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:688c3312e5dadb573a2c69c82af3a298d43ecf9e6d264e0f95df960b5f6ac19c", size = 15041649, upload-time = "2026-04-21T17:09:34.653Z" }, + { url = "https://files.pythonhosted.org/packages/97/77/f75a65c278e6e8eba2071f7f5a90481891053ecc39878cc444634d892abe/mypy-1.20.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29752dbbf8cc53f89f6ac096d363314333045c257c9c75cbd189ca2de0455744", size = 15864588, upload-time = "2026-04-21T17:11:44.936Z" }, + { url = "https://files.pythonhosted.org/packages/d7/46/1a4e1c66e96c1a3246ddf5403d122ac9b0a8d2b7e65730b9d6533ba7a6d3/mypy-1.20.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:803203d2b6ea644982c644895c2f78b28d0e208bba7b27d9b921e0ec5eb207c6", size = 16093956, upload-time = "2026-04-21T17:10:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/5a/2c/78a8851264dec38cd736ca5b8bc9380674df0dd0be7792f538916157716c/mypy-1.20.2-cp314-cp314t-win_amd64.whl", hash = "sha256:9bcb8aa397ff0093c824182fd76a935a9ba7ad097fcbef80ae89bf6c1731d8ec", size = 12568661, upload-time = "2026-04-21T17:11:54.473Z" }, + { url = "https://files.pythonhosted.org/packages/83/01/cd7318aa03493322ce275a0e14f4f52b8896335e4e79d4fb8153a7ad2b77/mypy-1.20.2-cp314-cp314t-win_arm64.whl", hash = "sha256:e061b58443f1736f8a37c48978d7ab581636d6ab03e3d4f99e3fa90463bb9382", size = 10389240, upload-time = "2026-04-21T17:09:42.719Z" }, + { url = "https://files.pythonhosted.org/packages/28/9a/f23c163e25b11074188251b0b5a0342625fc1cdb6af604757174fa9acc9b/mypy-1.20.2-py3-none-any.whl", hash = "sha256:a94c5a76ab46c5e6257c7972b6c8cff0574201ca7dc05647e33e795d78680563", size = 2637314, upload-time = "2026-04-21T17:05:54.5Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "myst-nb" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata" }, + { name = "ipykernel" }, + { name = "ipython", version = "8.39.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "ipython", version = "9.14.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jupyter-cache" }, + { name = "myst-parser" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "pyyaml" }, + { name = "sphinx" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/b4/ff1abeea67e8cfe0a8c033389f6d1d8b0bfecfd611befb5cbdeab884fce6/myst_nb-1.4.0.tar.gz", hash = "sha256:c145598de62446a6fd009773dd071a40d3b76106ace780de1abdfc6961f614c2", size = 82285, upload-time = "2026-03-02T21:14:56.95Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/93/0a378b48488879a1d925b42a804edfc6e0cd0ef854220f2dce738a46e7e9/myst_nb-1.4.0-py3-none-any.whl", hash = "sha256:0e2c86e7d3b82c3aa51383f82d6268f7714f3b772c23a796ab09538a8e68b4e4", size = 82555, upload-time = "2026-03-02T21:14:55.652Z" }, +] + +[[package]] +name = "myst-parser" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "jinja2" }, + { name = "markdown-it-py" }, + { name = "mdit-py-plugins" }, + { name = "pyyaml" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/64/e2f13dac02f599980798c01156393b781aec983b52a6e4057ee58f07c43a/myst_parser-3.0.1.tar.gz", hash = "sha256:88f0cb406cb363b077d176b51c476f62d60604d68a8dcdf4832e080441301a87", size = 92392, upload-time = "2024-04-28T20:22:42.116Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/de/21aa8394f16add8f7427f0a1326ccd2b3a2a8a3245c9252bc5ac034c6155/myst_parser-3.0.1-py3-none-any.whl", hash = "sha256:6457aaa33a5d474aca678b8ead9b3dc298e89c68e67012e73146ea6fd54babf1", size = 83163, upload-time = "2024-04-28T20:22:39.985Z" }, +] + +[[package]] +name = "nbclient" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", hash = "sha256:04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a", size = 62535, upload-time = "2026-06-05T07:52:41.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/c9/94d73e5a01c5b926c3fa2496e97d7a8dc28ed5a77c0b2ed712f1a62e6694/nbclient-0.11.0-py3-none-any.whl", hash = "sha256:ef7fa0d59d6e1d41103933d8a445a18d5de860ca6b613b87b8574accdb3c2895", size = 25288, upload-time = "2026-06-05T07:52:40.115Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/f8/bb0a9d5f46819c821dc1f004aa2cc29b1d91453297dbf5ff20470f00f193/nbconvert-7.17.1-py3-none-any.whl", hash = "sha256:aa85c087b435e7bf1ffd03319f658e285f2b89eccab33bc1ba7025495ab3e7c8", size = 261927, upload-time = "2026-04-08T00:44:12.845Z" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + +[[package]] +name = "nbmake" +version = "1.5.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "pygments" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/9a/aae201cee5639e1d562b3843af8fd9f8d018bb323e776a2b973bdd5fc64b/nbmake-1.5.5.tar.gz", hash = "sha256:239dc868ea13a7c049746e2aba2c229bd0f6cdbc6bfa1d22f4c88638aa4c5f5c", size = 85929, upload-time = "2024-12-23T18:33:46.774Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/be/b257e12f9710819fde40adc972578bee6b72c5992da1bc8369bef2597756/nbmake-1.5.5-py3-none-any.whl", hash = "sha256:c6fbe6e48b60cacac14af40b38bf338a3b88f47f085c54ac5b8639ff0babaf4b", size = 12818, upload-time = "2024-12-23T18:33:44.566Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "networkx" +version = "3.4.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" }, +] + +[[package]] +name = "networkx" +version = "3.6.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, +] + +[[package]] +name = "nh3" +version = "0.3.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9c/5f/1d19bdc7d27238e37f3672cdc02cb77c56a4a86d140cd4f4f23c90df6e16/nh3-0.3.5.tar.gz", hash = "sha256:45855e14ff056064fec77133bfcf7cd691838168e5e17bbef075394954dc9dc8", size = 20743, upload-time = "2026-04-25T10:44:16.066Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/b0/8587ac42a9627ab88e7e221601f1dfccbf4db80b2a29222ea63266dc9abc/nh3-0.3.5-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:23a312224875f72cd16bde417f49071451877e29ef646a60e50fcb69407cc18a", size = 1420126, upload-time = "2026-04-25T10:43:39.834Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1b/1dbc4d0c43f12e8c1784ede17eaee6f061d4fbe5505757c65c49b2ceab95/nh3-0.3.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:387abd011e81959d5a35151a11350a0795c6edeb53ebfa02d2e882dc01299263", size = 793943, upload-time = "2026-04-25T10:43:41.363Z" }, + { url = "https://files.pythonhosted.org/packages/47/9f/d6758d7a14ee964bf439cc35ae4fa24a763a93399c8ef6f22bd11d532d29/nh3-0.3.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:48f45e3e914be93a596431aa143dedf1582557bf41a58153c296048d6e3798c9", size = 841150, upload-time = "2026-04-25T10:43:43.007Z" }, + { url = "https://files.pythonhosted.org/packages/b6/36/d5d1ae8374612c98f390e1ea7c610fa6c9716259a03bbf4d15b269f40073/nh3-0.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0a09f51806fd51b4fedbf9ea2b61fef388f19aef0d62fe51199d41648be14588", size = 1008415, upload-time = "2026-04-25T10:43:44.324Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8f/d13a9c3fd2d9c131a2a281737380e9379eb0f8c33fea24c2b923aaafbb15/nh3-0.3.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:c357f1d042c67f135a5e6babb2b0e3b9d9224ff4a3543240f597767b01384ffd", size = 1092706, upload-time = "2026-04-25T10:43:45.653Z" }, + { url = "https://files.pythonhosted.org/packages/bb/57/2f3add7f8680fcc896afa6a675cb2bab09982853ee8af40bad621f6b61c4/nh3-0.3.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:38748140bf76383ab7ce2dce0ad4cb663855d8fbc9098f7f3483673d09616a17", size = 1048346, upload-time = "2026-04-25T10:43:46.974Z" }, + { url = "https://files.pythonhosted.org/packages/c1/c3/2f9e4ffa82863074d1361bfe949bc46393d91b3411579dfbbd090b24cac5/nh3-0.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:84bdeb082544fbcb77a12c034dd77d7da0556fdc0727b787eb6214b958c15e29", size = 1029038, upload-time = "2026-04-25T10:43:48.569Z" }, + { url = "https://files.pythonhosted.org/packages/e8/10/2804deb3f3315184c9cae41702e293c87524b5a21f766b07d7fe3ffbcfbb/nh3-0.3.5-cp314-cp314t-win32.whl", hash = "sha256:c3aae321f67ae66cff2a627115f106a377d4475d10b0e13d97959a13486b9a88", size = 603263, upload-time = "2026-04-25T10:43:49.851Z" }, + { url = "https://files.pythonhosted.org/packages/eb/a2/f6685248b49f7548fc9a8c335ab3a52f68610b72e8a61576447151e4e2e6/nh3-0.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c88605d8d468f7fc1b31e06129bc91d6c96f6c621776c9b504a0da9beac9df5f", size = 616866, upload-time = "2026-04-25T10:43:51.005Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b6/d8c9018635d4acfefde6b68470daa510eed715a350cbaa2f928ba0609f81/nh3-0.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:72c5bdedec27fa33de6a5326346ea8aa3fe54f6ac294d54c4b204fb66a9f1e79", size = 602566, upload-time = "2026-04-25T10:43:52.283Z" }, + { url = "https://files.pythonhosted.org/packages/85/30/d162e99746a2fb1d98bb0ef23af3e201b156cf09f7de867c7390c8fe1c06/nh3-0.3.5-cp38-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:3bb854485c9b33e5bb143ff3e49e577073bc6bc320f0ff8fc316dd89c0d3c101", size = 1442393, upload-time = "2026-04-25T10:43:53.556Z" }, + { url = "https://files.pythonhosted.org/packages/25/8c/072120d506978ab053e1732d0efa7c86cb478fee0ee098fda0ac0d31cb34/nh3-0.3.5-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50d401ab2d8e86d59e2126e3ab2a2f45840c405842b626d9a51624b3a33b6878", size = 837722, upload-time = "2026-04-25T10:43:55.073Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/d4e06e28c5ad1c4b065f89737d02631bd49f1660b6ebcf17a87ffcd201da/nh3-0.3.5-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:acfd354e61accbe4c74f8017c6e397a776916dfe47c48643cf7fd84ade826f93", size = 822872, upload-time = "2026-04-25T10:43:56.581Z" }, + { url = "https://files.pythonhosted.org/packages/0a/62/50659255213f241ec5797ae7427464c969397373e83b3659372b341ae869/nh3-0.3.5-cp38-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:52d877980d7ca01dc3baf3936bf844828bc6f332962227a684ed79c18cce14c3", size = 1100031, upload-time = "2026-04-25T10:43:58.098Z" }, + { url = "https://files.pythonhosted.org/packages/00/7a/a12ae77593b2fcf3be25df7bc1c01967d0de448bdb4b6c7ec80fe4f5a74f/nh3-0.3.5-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:207c01801d3e9bb8ec08f08689346bdd30ce15b8bf60013a925d08b5388962a4", size = 1057669, upload-time = "2026-04-25T10:43:59.328Z" }, + { url = "https://files.pythonhosted.org/packages/2d/71/5647dc04c0233192a3956fc91708822b21403a06508cacf78083c68e7bf0/nh3-0.3.5-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea232933394d1d58bf7c4bb348dc4660eae6604e1ae81cd2ba6d9ed80d390f3b", size = 914795, upload-time = "2026-04-25T10:44:00.52Z" }, + { url = "https://files.pythonhosted.org/packages/1b/0e/bf298920729f216adcb002acf7ea01b90842603d2e4e2ce9b900d9ee8fab/nh3-0.3.5-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe3a787dc76b50de6bee54ef242f26c41dfe47654428e3e94f0fae5bb6dd2cc1", size = 806976, upload-time = "2026-04-25T10:44:01.743Z" }, + { url = "https://files.pythonhosted.org/packages/85/01/26761e1dc2b848e65a62c19e5d39ad446283287cd4afddc89f364ab86bc9/nh3-0.3.5-cp38-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:488928988caad25ba14b1eb5bc74e25e21f3b5e40341d956f3ce4a8bc19460dc", size = 834904, upload-time = "2026-04-25T10:44:03.454Z" }, + { url = "https://files.pythonhosted.org/packages/33/53/0766113e679540ac1edc1b82b1295aecd321eeb75d6fead70109a838b6ee/nh3-0.3.5-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2c069570b06aa848457713ad7af4a9905691291548c4466a9ad78ee95808382b", size = 857159, upload-time = "2026-04-25T10:44:05.003Z" }, + { url = "https://files.pythonhosted.org/packages/58/36/734d353dfaf292fed574b8b3092f0ef79dc6404f3879f7faaa61a4701fad/nh3-0.3.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:eeedc90ed8c42c327e8e10e621ccfa314fc6cce35d5929f4297ff1cdb89667c4", size = 1018600, upload-time = "2026-04-25T10:44:06.18Z" }, + { url = "https://files.pythonhosted.org/packages/6b/aa/d9c59c1b49669fcb7bababa55df82385f029ad5c2651f583c3a1141cfdd1/nh3-0.3.5-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:de8e8621853b6470fe928c684ee0d3f39ea8086cebafe4c416486488dea7b68d", size = 1103530, upload-time = "2026-04-25T10:44:07.68Z" }, + { url = "https://files.pythonhosted.org/packages/90/b0/cdd210bfb8d9d43fb02fc3c868336b9955934d8e15e66eb1d15a147b8af0/nh3-0.3.5-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:6ea58cc44d274c643b83547ca9654a0b1a817609b160601356f76a2b744c49ad", size = 1061754, upload-time = "2026-04-25T10:44:09.362Z" }, + { url = "https://files.pythonhosted.org/packages/ce/cb/7a39e72e668c8445bdd95e494b3e21cfdddc68329be8ea3522c8befb46c4/nh3-0.3.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e49c9b564e6bcb03ecd2f057213df9a0de15a95812ac9db9600b590db23d3ae9", size = 1040938, upload-time = "2026-04-25T10:44:10.775Z" }, + { url = "https://files.pythonhosted.org/packages/af/4c/fc2f9ed208a3801a319f59b5fea03cdc20cf3bd8af14be930d3a8de01224/nh3-0.3.5-cp38-abi3-win32.whl", hash = "sha256:559e4c73b689e9a7aa97ac9760b1bc488038d7c1a575aa4ab5a0e19ee9630c0f", size = 611445, upload-time = "2026-04-25T10:44:12.317Z" }, + { url = "https://files.pythonhosted.org/packages/db/1a/e4c9b5e2ae13e6092c9ec16d8ca30646cb01fcdea245f36c5b08fd21fbd5/nh3-0.3.5-cp38-abi3-win_amd64.whl", hash = "sha256:45e6a65dc88a300a2e3502cb9c8e6d1d6b831d6fba7470643333609c6aab1f30", size = 626502, upload-time = "2026-04-25T10:44:13.682Z" }, + { url = "https://files.pythonhosted.org/packages/80/7c/19cd0671d1ba2762fb388fc149697d20d0568ccfeef833b11280a619e526/nh3-0.3.5-cp38-abi3-win_arm64.whl", hash = "sha256:8f85285700a18e9f3fc5bff41fe573fa84f81542ef13b48a89f9fecca0474d3b", size = 611069, upload-time = "2026-04-25T10:44:14.934Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" }, + { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" }, + { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" }, + { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" }, + { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" }, + { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" }, + { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" }, + { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" }, + { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" }, + { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" }, + { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" }, + { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" }, + { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" }, + { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" }, + { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" }, + { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" }, + { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" }, + { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" }, + { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" }, + { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" }, + { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" }, + { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" }, + { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" }, + { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" }, + { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" }, + { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" }, + { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" }, + { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" }, + { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" }, + { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" }, + { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" }, + { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" }, + { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" }, + { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" }, + { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" }, + { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" }, + { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" }, + { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" }, + { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" }, + { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" }, + { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" }, + { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" }, + { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" }, + { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" }, + { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" }, + { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" }, + { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" }, + { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" }, + { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" }, + { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" }, + { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" }, +] + +[[package]] +name = "nvidia-cublas" +version = "13.1.0.3" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/a5/fce49e2ae977e0ccc084e5adafceb4f0ac0c8333cb6863501618a7277f67/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c86fc7f7ae36d7528288c5d88098edcb7b02c633d262e7ddbb86b0ad91be5df2", size = 542851226, upload-time = "2025-10-09T08:59:04.818Z" }, + { url = "https://files.pythonhosted.org/packages/e7/44/423ac00af4dd95a5aeb27207e2c0d9b7118702149bf4704c3ddb55bb7429/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:ee8722c1f0145ab246bccb9e452153b5e0515fd094c3678df50b2a0888b8b171", size = 423133236, upload-time = "2025-10-09T08:59:32.536Z" }, + { url = "https://files.pythonhosted.org/packages/10/f5/f50bc3f5c2bb57ab8f5b4d78bc1146b57810d42cb8fcb28cbe2e14050376/nvidia_cublas-13.1.0.3-py3-none-win_amd64.whl", hash = "sha256:2a3b94a37def342471c59fad7856caee4926809a72dd5270155d6a31b5b277be", size = 404355960, upload-time = "2025-10-09T09:07:00.987Z" }, +] + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.8.4.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/29/99/db44d685f0e257ff0e213ade1964fc459b4a690a73293220e98feb3307cf/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b86f6dd8935884615a0683b663891d43781b819ac4f2ba2b0c9604676af346d0", size = 590537124, upload-time = "2025-03-07T01:43:53.556Z" }, + { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" }, + { url = "https://files.pythonhosted.org/packages/70/61/7d7b3c70186fb651d0fbd35b01dbfc8e755f69fd58f817f3d0f642df20c3/nvidia_cublas_cu12-12.8.4.1-py3-none-win_amd64.whl", hash = "sha256:47e9b82132fa8d2b4944e708049229601448aaad7e6f296f630f2d1a32de35af", size = 567544208, upload-time = "2025-03-07T01:53:30.535Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti" +version = "13.0.85" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/2a/80353b103fc20ce05ef51e928daed4b6015db4aaa9162ed0997090fe2250/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:796bd679890ee55fb14a94629b698b6db54bcfd833d391d5e94017dd9d7d3151", size = 10310827, upload-time = "2025-09-04T08:26:42.012Z" }, + { url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8", size = 10715597, upload-time = "2025-09-04T08:26:51.312Z" }, + { url = "https://files.pythonhosted.org/packages/ad/df/b74b10025c1205695c5676373f2edd3e87a7202cc62ead0dfbc373b0f6ea/nvidia_cuda_cupti-13.0.85-py3-none-win_amd64.whl", hash = "sha256:683f58d301548deeefcb8f6fac1b8d907691b9d8b18eccab417f51e362102f00", size = 7736776, upload-time = "2025-09-04T08:38:08.38Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/1f/b3bd73445e5cb342727fd24fe1f7b748f690b460acadc27ea22f904502c8/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4412396548808ddfed3f17a467b104ba7751e6b58678a4b840675c56d21cf7ed", size = 9533318, upload-time = "2025-03-07T01:40:10.421Z" }, + { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" }, + { url = "https://files.pythonhosted.org/packages/41/bc/83f5426095d93694ae39fe1311431b5d5a9bb82e48bf0dd8e19be2765942/nvidia_cuda_cupti_cu12-12.8.90-py3-none-win_amd64.whl", hash = "sha256:bb479dcdf7e6d4f8b0b01b115260399bf34154a1a2e9fe11c85c517d87efd98e", size = 7015759, upload-time = "2025-03-07T01:51:11.355Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc" +version = "13.0.88" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575", size = 90215200, upload-time = "2025-09-04T08:28:44.204Z" }, + { url = "https://files.pythonhosted.org/packages/b7/dc/6bb80850e0b7edd6588d560758f17e0550893a1feaf436807d64d2da040f/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d27f20a0ca67a4bb34268a5e951033496c5b74870b868bacd046b1b8e0c3267b", size = 43015449, upload-time = "2025-09-04T08:28:20.239Z" }, + { url = "https://files.pythonhosted.org/packages/4a/af/345fedb9f4c76c84ab4fa445b36bd4048a4d9db60e6bc76b4f913ff4b852/nvidia_cuda_nvrtc-13.0.88-py3-none-win_amd64.whl", hash = "sha256:6bcd4e7f8e205cbe644f5a98f2f799bef9556fefc89dd786e79a16312ce49872", size = 76807835, upload-time = "2025-09-04T08:39:15.274Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.8.93" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d1/e50d0acaab360482034b84b6e27ee83c6738f7d32182b987f9c7a4e32962/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc1fec1e1637854b4c0a65fb9a8346b51dd9ee69e61ebaccc82058441f15bce8", size = 43106076, upload-time = "2025-03-07T01:41:59.817Z" }, + { url = "https://files.pythonhosted.org/packages/45/51/52a3d84baa2136cc8df15500ad731d74d3a1114d4c123e043cb608d4a32b/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-win_amd64.whl", hash = "sha256:7a4b6b2904850fe78e0bd179c4b655c404d4bb799ef03ddc60804247099ae909", size = 73586838, upload-time = "2025-03-07T01:52:13.483Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime" +version = "13.0.96" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/4f/17d7b9b8e285199c58ce28e31b5c5bbaa4d8271af06a89b6405258245de2/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef9bcbe90493a2b9d810e43d249adb3d02e98dd30200d86607d8d02687c43f55", size = 2261060, upload-time = "2025-10-09T08:55:15.78Z" }, + { url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548", size = 2243632, upload-time = "2025-10-09T08:55:36.117Z" }, + { url = "https://files.pythonhosted.org/packages/b7/94/6b867483bec07da24ffa32736c79fabb94ef3a7af4d787a9d4a974868576/nvidia_cuda_runtime-13.0.96-py3-none-win_amd64.whl", hash = "sha256:f79298c8a098cec150a597c8eba58ecdab96e3bdc4b9bc4f9983635031740492", size = 2927037, upload-time = "2025-10-09T09:04:23.782Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/75/f865a3b236e4647605ea34cc450900854ba123834a5f1598e160b9530c3a/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:52bf7bbee900262ffefe5e9d5a2a69a30d97e2bc5bb6cc866688caa976966e3d", size = 965265, upload-time = "2025-03-07T01:39:43.533Z" }, + { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" }, + { url = "https://files.pythonhosted.org/packages/30/a5/a515b7600ad361ea14bfa13fb4d6687abf500adc270f19e89849c0590492/nvidia_cuda_runtime_cu12-12.8.90-py3-none-win_amd64.whl", hash = "sha256:c0c6027f01505bfed6c3b21ec546f69c687689aad5f1a377554bc6ca4aa993a8", size = 944318, upload-time = "2025-03-07T01:51:01.794Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu12" +version = "9.10.2.21" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/41/e79269ce215c857c935fd86bcfe91a451a584dfc27f1e068f568b9ad1ab7/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c9132cc3f8958447b4910a1720036d9eff5928cc3179b0a51fb6d167c6cc87d8", size = 705026878, upload-time = "2025-06-06T21:52:51.348Z" }, + { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" }, + { url = "https://files.pythonhosted.org/packages/3d/90/0bd6e586701b3a890fd38aa71c387dab4883d619d6e5ad912ccbd05bfd67/nvidia_cudnn_cu12-9.10.2.21-py3-none-win_amd64.whl", hash = "sha256:c6288de7d63e6cf62988f0923f96dc339cea362decb1bf5b3141883392a7d65e", size = 692992268, upload-time = "2025-06-06T21:55:18.114Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu13" +version = "9.15.1.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/93/b3c9db2c35d6183361333d2dcfea50e094c012d012c8a4d7effbfb53ef62/nvidia_cudnn_cu13-9.15.1.9-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:44cd2ec83c3ef62a7357614bd02ce7f3dac35ffcbb04ad20999e730741f0ba17", size = 415636241, upload-time = "2025-11-12T20:22:26.582Z" }, + { url = "https://files.pythonhosted.org/packages/0c/d0/90f98fc55c48a7d8f5ad0a03a6321acc1a7024bdd550d96b3547a04ea6b4/nvidia_cudnn_cu13-9.15.1.9-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:ebc9a647918df0d7298d67cfaf41579fd4c78ead9aba246f5ad9414d61b9ec4c", size = 351298418, upload-time = "2025-11-12T20:23:21.455Z" }, + { url = "https://files.pythonhosted.org/packages/01/e4/f899b1cd1b3be20e8a5065fba3670d492f634da07eba5e09425bc96647be/nvidia_cudnn_cu13-9.15.1.9-py3-none-win_amd64.whl", hash = "sha256:e99068ca372b9791483759705ff79545e6e0ab5fe6352772e084cc6d1a419ab6", size = 336136012, upload-time = "2025-11-12T20:24:43.179Z" }, +] + +[[package]] +name = "nvidia-cufft" +version = "12.0.0.61" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3", size = 214085489, upload-time = "2025-09-04T08:31:56.044Z" }, + { url = "https://files.pythonhosted.org/packages/85/b2/f8af21a2ed1beed337a6a02c5a28aeb85441f4d578ec3d529543c775ea4b/nvidia_cufft-12.0.0.61-py3-none-win_amd64.whl", hash = "sha256:2abce5b39d2f5ae12730fb7e5db6696533e36c26e2d3e8fd1750bdd2853364eb", size = 213342123, upload-time = "2025-09-04T08:40:51.145Z" }, +] + +[[package]] +name = "nvidia-cufft-cu12" +version = "11.3.3.83" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/bc/7771846d3a0272026c416fbb7e5f4c1f146d6d80704534d0b187dd6f4800/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:848ef7224d6305cdb2a4df928759dca7b1201874787083b6e7550dd6765ce69a", size = 193109211, upload-time = "2025-03-07T01:44:56.873Z" }, + { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" }, + { url = "https://files.pythonhosted.org/packages/7d/ec/ce1629f1e478bb5ccd208986b5f9e0316a78538dd6ab1d0484f012f8e2a1/nvidia_cufft_cu12-11.3.3.83-py3-none-win_amd64.whl", hash = "sha256:7a64a98ef2a7c47f905aaf8931b69a3a43f27c55530c698bb2ed7c75c0b42cb7", size = 192216559, upload-time = "2025-03-07T01:53:57.106Z" }, +] + +[[package]] +name = "nvidia-cufile" +version = "1.15.1.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44", size = 1223672, upload-time = "2025-09-04T08:32:22.779Z" }, + { url = "https://files.pythonhosted.org/packages/ab/73/cc4a14c9813a8a0d509417cf5f4bdaba76e924d58beb9864f5a7baceefbf/nvidia_cufile-1.15.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:bdc0deedc61f548bddf7733bdc216456c2fdb101d020e1ab4b88d232d5e2f6d1", size = 1136992, upload-time = "2025-09-04T08:32:14.119Z" }, +] + +[[package]] +name = "nvidia-cufile-cu12" +version = "1.13.1.3" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" }, + { url = "https://files.pythonhosted.org/packages/1e/f5/5607710447a6fe9fd9b3283956fceeee8a06cda1d2f56ce31371f595db2a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:4beb6d4cce47c1a0f1013d72e02b0994730359e17801d395bdcbf20cfb3bb00a", size = 1120705, upload-time = "2025-03-07T01:45:41.434Z" }, +] + +[[package]] +name = "nvidia-curand" +version = "10.4.0.35" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/72/7c2ae24fb6b63a32e6ae5d241cc65263ea18d08802aaae087d9f013335a2/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:133df5a7509c3e292aaa2b477afd0194f06ce4ea24d714d616ff36439cee349a", size = 61962106, upload-time = "2025-08-04T10:21:41.128Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc", size = 59544258, upload-time = "2025-08-04T10:22:03.992Z" }, + { url = "https://files.pythonhosted.org/packages/99/27/72103153b1ffc00e09fdc40ac970235343dcd1ea8bd762e84d2d73219ffa/nvidia_curand-10.4.0.35-py3-none-win_amd64.whl", hash = "sha256:65b1710aa6961d326b411e314b374290904c5ddf41dc3f766ebc3f1d7d4ca69f", size = 55242481, upload-time = "2025-08-04T10:30:41.831Z" }, +] + +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.9.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/5e/92aa15eca622a388b80fbf8375d4760738df6285b1e92c43d37390a33a9a/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:dfab99248034673b779bc6decafdc3404a8a6f502462201f2f31f11354204acd", size = 63625754, upload-time = "2025-03-07T01:46:10.735Z" }, + { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" }, + { url = "https://files.pythonhosted.org/packages/b9/75/70c05b2f3ed5be3bb30b7102b6eb78e100da4bbf6944fd6725c012831cab/nvidia_curand_cu12-10.3.9.90-py3-none-win_amd64.whl", hash = "sha256:f149a8ca457277da854f89cf282d6ef43176861926c7ac85b2a0fbd237c587ec", size = 62765309, upload-time = "2025-03-07T01:54:20.478Z" }, +] + +[[package]] +name = "nvidia-cusolver" +version = "12.0.4.66" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparse", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112", size = 200941980, upload-time = "2025-09-04T08:33:22.767Z" }, + { url = "https://files.pythonhosted.org/packages/99/ef/332a0101260ca78a1daef046bf0b06199e8ed4dac1d2aa698289c358169c/nvidia_cusolver-12.0.4.66-py3-none-win_amd64.whl", hash = "sha256:16515bd33a8e76bb54d024cfa068fa68d30e80fc34b9e1090813ea9362e0cb65", size = 193551444, upload-time = "2025-09-04T08:41:46.813Z" }, +] + +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.7.3.90" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparse-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/32/f7cd6ce8a7690544d084ea21c26e910a97e077c9b7f07bf5de623ee19981/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:db9ed69dbef9715071232caa9b69c52ac7de3a95773c2db65bdba85916e4e5c0", size = 267229841, upload-time = "2025-03-07T01:46:54.356Z" }, + { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" }, + { url = "https://files.pythonhosted.org/packages/13/c0/76ca8551b8a84146ffa189fec81c26d04adba4bc0dbe09cd6e6fd9b7de04/nvidia_cusolver_cu12-11.7.3.90-py3-none-win_amd64.whl", hash = "sha256:4a550db115fcabc4d495eb7d39ac8b58d4ab5d8e63274d3754df1c0ad6a22d34", size = 256720438, upload-time = "2025-03-07T01:54:39.898Z" }, +] + +[[package]] +name = "nvidia-cusparse" +version = "12.6.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" }, + { url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b", size = 145942937, upload-time = "2025-09-04T08:33:58.029Z" }, + { url = "https://files.pythonhosted.org/packages/02/b0/b043d6f3480f102f885cf87fc3ffd3edcb5e23b855025a50e2ef4d059185/nvidia_cusparse-12.6.3.3-py3-none-win_amd64.whl", hash = "sha256:cbcf42feb737bd7ec15b4c0a63e62351886bd3f975027b8815d7f720a2b5ea79", size = 143783033, upload-time = "2025-09-04T08:42:12.391Z" }, +] + +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.5.8.93" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f7/cd777c4109681367721b00a106f491e0d0d15cfa1fd59672ce580ce42a97/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b6c161cb130be1a07a27ea6923df8141f3c295852f4b260c65f18f3e0a091dc", size = 288117129, upload-time = "2025-03-07T01:47:40.407Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" }, + { url = "https://files.pythonhosted.org/packages/62/07/f3b2ad63f8e3d257a599f422ae34eb565e70c41031aecefa3d18b62cabd1/nvidia_cusparse_cu12-12.5.8.93-py3-none-win_amd64.whl", hash = "sha256:9a33604331cb2cac199f2e7f5104dfbb8a5a898c367a53dfda9ff2acb6b6b4dd", size = 284937404, upload-time = "2025-03-07T01:55:07.742Z" }, +] + +[[package]] +name = "nvidia-cusparselt-cu12" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/b9/598f6ff36faaece4b3c50d26f50e38661499ff34346f00e057760b35cc9d/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8878dce784d0fac90131b6817b607e803c36e629ba34dc5b433471382196b6a5", size = 283835557, upload-time = "2025-02-26T00:16:54.265Z" }, + { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" }, + { url = "https://files.pythonhosted.org/packages/2f/d8/a6b0d0d0c2435e9310f3e2bb0d9c9dd4c33daef86aa5f30b3681defd37ea/nvidia_cusparselt_cu12-0.7.1-py3-none-win_amd64.whl", hash = "sha256:f67fbb5831940ec829c9117b7f33807db9f9678dc2a617fbe781cac17b4e1075", size = 271020911, upload-time = "2025-02-26T00:14:47.204Z" }, +] + +[[package]] +name = "nvidia-cusparselt-cu13" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/10/8dcd1175260706a2fc92a16a52e306b71d4c1ea0b0cc4a9484183399818a/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:400c6ed1cf6780fc6efedd64ec9f1345871767e6a1a0a552a1ea0578117ea77c", size = 220791277, upload-time = "2025-08-13T19:22:40.982Z" }, + { url = "https://files.pythonhosted.org/packages/fd/53/43b0d71f4e702fa9733f8b4571fdca50a8813f1e450b656c239beff12315/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:25e30a8a7323935d4ad0340b95a0b69926eee755767e8e0b1cf8dd85b197d3fd", size = 169884119, upload-time = "2025-08-13T19:23:41.967Z" }, + { url = "https://files.pythonhosted.org/packages/57/de/8f0578928b9b1246d7b1324db0528e6b9f9fb54496a49f40bf71f09f1a27/nvidia_cusparselt_cu13-0.8.0-py3-none-win_amd64.whl", hash = "sha256:e80212ed7b1afc97102fbb2b5c82487aa73f6a0edfa6d26c5a152593e520bb8f", size = 156459710, upload-time = "2025-08-13T19:24:18.043Z" }, +] + +[[package]] +name = "nvidia-nccl-cu12" +version = "2.27.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/1c/857979db0ef194ca5e21478a0612bcdbbe59458d7694361882279947b349/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:31432ad4d1fb1004eb0c56203dc9bc2178a1ba69d1d9e02d64a6938ab5e40e7a", size = 322400625, upload-time = "2025-06-26T04:11:04.496Z" }, + { url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457", size = 322348229, upload-time = "2025-06-26T04:11:28.385Z" }, +] + +[[package]] +name = "nvidia-nccl-cu13" +version = "2.28.9" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/55/1920646a2e43ffd4fc958536b276197ed740e9e0c54105b4bb3521591fc7/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:01c873ba1626b54caa12272ed228dc5b2781545e0ae8ba3f432a8ef1c6d78643", size = 196561677, upload-time = "2025-11-18T05:49:03.45Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b4/878fefaad5b2bcc6fcf8d474a25e3e3774bc5133e4b58adff4d0bca238bc/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:e4553a30f34195f3fa1da02a6da3d6337d28f2003943aa0a3d247bbc25fefc42", size = 196493177, upload-time = "2025-11-18T05:49:17.677Z" }, +] + +[[package]] +name = "nvidia-nvjitlink" +version = "13.0.88" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/7a/123e033aaff487c77107195fa5a2b8686795ca537935a24efae476c41f05/nvidia_nvjitlink-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:13a74f429e23b921c1109976abefacc69835f2f433ebd323d3946e11d804e47b", size = 40713933, upload-time = "2025-09-04T08:35:43.553Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2c/93c5250e64df4f894f1cbb397c6fd71f79813f9fd79d7cd61de3f97b3c2d/nvidia_nvjitlink-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e931536ccc7d467a98ba1d8b89ff7fa7f1fa3b13f2b0069118cd7f47bff07d0c", size = 38768748, upload-time = "2025-09-04T08:35:20.008Z" }, + { url = "https://files.pythonhosted.org/packages/e4/01/07530b0e37546231052e30234540289c42eaffa486f1a34a87fed340157b/nvidia_nvjitlink-13.0.88-py3-none-win_amd64.whl", hash = "sha256:634e96e3da9ef845ae744097a1f289238ecf946ce0b82e93cdce14b9782e682f", size = 36035115, upload-time = "2025-09-04T08:43:03.001Z" }, +] + +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.8.93" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" }, + { url = "https://files.pythonhosted.org/packages/2a/a2/8cee5da30d13430e87bf99bb33455d2724d0a4a9cb5d7926d80ccb96d008/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:adccd7161ace7261e01bb91e44e88da350895c270d23f744f0820c818b7229e7", size = 38386204, upload-time = "2025-03-07T01:49:43.612Z" }, + { url = "https://files.pythonhosted.org/packages/ed/d7/34f02dad2e30c31b10a51f6b04e025e5dd60e5f936af9045a9b858a05383/nvidia_nvjitlink_cu12-12.8.93-py3-none-win_amd64.whl", hash = "sha256:bd93fbeeee850917903583587f4fc3a4eafa022e34572251368238ab5e6bd67f", size = 268553710, upload-time = "2025-03-07T01:56:24.13Z" }, +] + +[[package]] +name = "nvidia-nvshmem-cu12" +version = "3.4.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/6a/03aa43cc9bd3ad91553a88b5f6fb25ed6a3752ae86ce2180221962bc2aa5/nvidia_nvshmem_cu12-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0b48363fc6964dede448029434c6abed6c5e37f823cb43c3bcde7ecfc0457e15", size = 138936938, upload-time = "2025-09-06T00:32:05.589Z" }, + { url = "https://files.pythonhosted.org/packages/b5/09/6ea3ea725f82e1e76684f0708bbedd871fc96da89945adeba65c3835a64c/nvidia_nvshmem_cu12-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:042f2500f24c021db8a06c5eec2539027d57460e1c1a762055a6554f72c369bd", size = 139103095, upload-time = "2025-09-06T00:32:31.266Z" }, +] + +[[package]] +name = "nvidia-nvshmem-cu13" +version = "3.4.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/0f/05cc9c720236dcd2db9c1ab97fff629e96821be2e63103569da0c9b72f19/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dc2a197f38e5d0376ad52cd1a2a3617d3cdc150fd5966f4aee9bcebb1d68fe9", size = 60215947, upload-time = "2025-09-06T00:32:20.022Z" }, + { url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80", size = 60412546, upload-time = "2025-09-06T00:32:41.564Z" }, +] + +[[package]] +name = "nvidia-nvtx" +version = "13.0.85" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4", size = 148047, upload-time = "2025-09-04T08:29:01.761Z" }, + { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" }, + { url = "https://files.pythonhosted.org/packages/d2/50/0e2220f8620a177de994211186ffc5bfa9f2ce1e1282797f8f90096f9f88/nvidia_nvtx-13.0.85-py3-none-win_amd64.whl", hash = "sha256:d66ea44254dd3c6eacc300047af6e1288d2269dd072b417e0adffbf479e18519", size = 137066, upload-time = "2025-09-04T08:39:25.649Z" }, +] + +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/c0/1b303feea90d296f6176f32a2a70b5ef230f9bdeb3a72bddb0dc922dc137/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d7ad891da111ebafbf7e015d34879f7112832fc239ff0d7d776b6cb685274615", size = 91161, upload-time = "2025-03-07T01:42:23.922Z" }, + { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" }, + { url = "https://files.pythonhosted.org/packages/9f/99/4c9c0c329bf9fc125008c3b54c7c94c0023518d06fc025ae36431375e1fe/nvidia_nvtx_cu12-12.8.90-py3-none-win_amd64.whl", hash = "sha256:619c8304aedc69f02ea82dd244541a83c3d9d40993381b3b590f1adaed3db41e", size = 56492, upload-time = "2025-03-07T01:52:24.69Z" }, +] + +[[package]] +name = "packaging" +version = "26.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + +[[package]] +name = "pathspec" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/aa/d0b28e1c811cd4d5f5c2bfe2e022292bd255ae5744a3b9ac7d6c8f72dd75/pillow-12.2.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:a4e8f36e677d3336f35089648c8955c51c6d386a13cf6ee9c189c5f5bd713a9f", size = 5354355, upload-time = "2026-04-01T14:42:15.402Z" }, + { url = "https://files.pythonhosted.org/packages/27/8e/1d5b39b8ae2bd7650d0c7b6abb9602d16043ead9ebbfef4bc4047454da2a/pillow-12.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e589959f10d9824d39b350472b92f0ce3b443c0a3442ebf41c40cb8361c5b97", size = 4695871, upload-time = "2026-04-01T14:42:18.234Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c5/dcb7a6ca6b7d3be41a76958e90018d56c8462166b3ef223150360850c8da/pillow-12.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a52edc8bfff4429aaabdf4d9ee0daadbbf8562364f940937b941f87a4290f5ff", size = 6269734, upload-time = "2026-04-01T14:42:20.608Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f1/aa1bb13b2f4eba914e9637893c73f2af8e48d7d4023b9d3750d4c5eb2d0c/pillow-12.2.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:975385f4776fafde056abb318f612ef6285b10a1f12b8570f3647ad0d74b48ec", size = 8076080, upload-time = "2026-04-01T14:42:23.095Z" }, + { url = "https://files.pythonhosted.org/packages/a1/2a/8c79d6a53169937784604a8ae8d77e45888c41537f7f6f65ed1f407fe66d/pillow-12.2.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd9c0c7a0c681a347b3194c500cb1e6ca9cab053ea4d82a5cf45b6b754560136", size = 6382236, upload-time = "2026-04-01T14:42:25.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/42/bbcb6051030e1e421d103ce7a8ecadf837aa2f39b8f82ef1a8d37c3d4ebc/pillow-12.2.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:88d387ff40b3ff7c274947ed3125dedf5262ec6919d83946753b5f3d7c67ea4c", size = 7070220, upload-time = "2026-04-01T14:42:28.68Z" }, + { url = "https://files.pythonhosted.org/packages/3f/e1/c2a7d6dd8cfa6b231227da096fd2d58754bab3603b9d73bf609d3c18b64f/pillow-12.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:51c4167c34b0d8ba05b547a3bb23578d0ba17b80a5593f93bd8ecb123dd336a3", size = 6493124, upload-time = "2026-04-01T14:42:31.579Z" }, + { url = "https://files.pythonhosted.org/packages/5f/41/7c8617da5d32e1d2f026e509484fdb6f3ad7efaef1749a0c1928adbb099e/pillow-12.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:34c0d99ecccea270c04882cb3b86e7b57296079c9a4aff88cb3b33563d95afaa", size = 7194324, upload-time = "2026-04-01T14:42:34.615Z" }, + { url = "https://files.pythonhosted.org/packages/2d/de/a777627e19fd6d62f84070ee1521adde5eeda4855b5cf60fe0b149118bca/pillow-12.2.0-cp310-cp310-win32.whl", hash = "sha256:b85f66ae9eb53e860a873b858b789217ba505e5e405a24b85c0464822fe88032", size = 6376363, upload-time = "2026-04-01T14:42:37.19Z" }, + { url = "https://files.pythonhosted.org/packages/e7/34/fc4cb5204896465842767b96d250c08410f01f2f28afc43b257de842eed5/pillow-12.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:673aa32138f3e7531ccdbca7b3901dba9b70940a19ccecc6a37c77d5fdeb05b5", size = 7083523, upload-time = "2026-04-01T14:42:39.62Z" }, + { url = "https://files.pythonhosted.org/packages/2d/a0/32852d36bc7709f14dc3f64f929a275e958ad8c19a6deba9610d458e28b3/pillow-12.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:3e080565d8d7c671db5802eedfb438e5565ffa40115216eabb8cd52d0ecce024", size = 2463318, upload-time = "2026-04-01T14:42:42.063Z" }, + { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, + { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, + { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, + { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, + { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, +] + +[[package]] +name = "pip" +version = "26.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/91/47e7d486260f618783899587af63ccf7980fb60245c3e63dd4571c6b57ad/pip-26.1.2.tar.gz", hash = "sha256:f49cd134c61cf2fd75e0ce2676db03e4054504a5a4986d00f8299ae632dc4605", size = 1840799, upload-time = "2026-05-31T17:33:58.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/95/6b5cb3461ea5673ba0995989746db58eb18b91b54dbf331e72f569540946/pip-26.1.2-py3-none-any.whl", hash = "sha256:382ff9f685ee3bc25864f820aa50505825f10f5458ffff07e30a6d96e5715cab", size = 1813144, upload-time = "2026-05-31T17:33:56.772Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/47/e4501f49c178ae1d9f4a75073fda4204f52647993f075a9db4d14930e0c5/platformdirs-4.10.0.tar.gz", hash = "sha256:31e761a6a0ca04faf7353ea759bdba55652be214725111e5aac52dfa29d4bef7", size = 31224, upload-time = "2026-05-28T03:32:53.587Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/e6/cd9575ac904136b3cbf7aa7ee819ef86eedb7274e46f230e94ea4342e729/platformdirs-4.10.0-py3-none-any.whl", hash = "sha256:fb516cdb12eb0d857d0cd85a7c57cea4d060bee4578d6cf5a14dfdf8cbf8784a", size = 22743, upload-time = "2026-05-28T03:32:52.175Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pre-commit" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8e/22/2de9408ac81acbb8a7d05d4cc064a152ccf33b3d480ebe0cd292153db239/pre_commit-4.6.0.tar.gz", hash = "sha256:718d2208cef53fdc38206e40524a6d4d9576d103eb16f0fec11c875e7716e9d9", size = 198525, upload-time = "2026-04-21T20:31:41.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/6e/4b28b62ecb6aae56769c34a8ff1d661473ec1e9519e2d5f8b2c150086b26/pre_commit-4.6.0-py2.py3-none-any.whl", hash = "sha256:e2cf246f7299edcabcf15f9b0571fdce06058527f0a06535068a86d38089f29b", size = 226472, upload-time = "2026-04-21T20:31:40.092Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pybtex" +version = "0.26.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "latexcodec" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4d/f5/f30da9c93f0fa6d619332b2f69597219b625f35780473a05164a9981fd9a/pybtex-0.26.1.tar.gz", hash = "sha256:2e5543bea424e60e9e42eef70bff597be48649d8f68ba061a7a092b2477d5464", size = 692991, upload-time = "2026-04-03T13:05:39.014Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/f6/775eb92e865b28cdb4ad1f2bed7a5446197516f76b58a950faa3be3fd08d/pybtex-0.26.1-py3-none-any.whl", hash = "sha256:e26c0412cc54f5f21b2a6d9d175762a2d2af9ccf3a8f651cdb89ec035db77aa1", size = 126134, upload-time = "2026-04-03T13:05:40.623Z" }, +] + +[[package]] +name = "pybtex-docutils" +version = "1.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "pybtex" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7e/84/796ea94d26188a853660f81bded39f8de4cfe595130aef0dea1088705a11/pybtex-docutils-1.0.3.tar.gz", hash = "sha256:3a7ebdf92b593e00e8c1c538aa9a20bca5d92d84231124715acc964d51d93c6b", size = 18348, upload-time = "2023-08-22T18:47:54.833Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/b1/ce1f4596211efb5410e178a803f08e59b20bedb66837dcf41e21c54f9ec1/pybtex_docutils-1.0.3-py3-none-any.whl", hash = "sha256:8fd290d2ae48e32fcb54d86b0efb8d573198653c7e2447d5bec5847095f430b9", size = 6385, upload-time = "2023-08-22T06:43:20.513Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + +[[package]] +name = "pyproject-hooks" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" }, +] + +[[package]] +name = "pytest" +version = "8.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" }, +] + +[[package]] +name = "pytest-cov" +version = "6.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", extra = ["toml"] }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/30/4c/f883ab8f0daad69f47efdf95f55a66b51a8b939c430dadce0611508d9e99/pytest_cov-6.3.0.tar.gz", hash = "sha256:35c580e7800f87ce892e687461166e1ac2bcb8fb9e13aea79032518d6e503ff2", size = 70398, upload-time = "2025-09-06T15:40:14.361Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/b4/bb7263e12aade3842b938bc5c6958cae79c5ee18992f9b9349019579da0f/pytest_cov-6.3.0-py3-none-any.whl", hash = "sha256:440db28156d2468cafc0415b4f8e50856a0d11faefa38f30906048fe490f1749", size = 25115, upload-time = "2025-09-06T15:40:12.44Z" }, +] + +[[package]] +name = "pytest-json-report" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "pytest-metadata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4f/d3/765dae9712fcd68d820338908c1337e077d5fdadccd5cacf95b9b0bea278/pytest-json-report-1.5.0.tar.gz", hash = "sha256:2dde3c647851a19b5f3700729e8310a6e66efb2077d674f27ddea3d34dc615de", size = 21241, upload-time = "2022-03-15T21:03:10.2Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/35/d07400c715bf8a88aa0c1ee9c9eb6050ca7fe5b39981f0eea773feeb0681/pytest_json_report-1.5.0-py3-none-any.whl", hash = "sha256:9897b68c910b12a2e48dd849f9a284b2c79a732a8a9cb398452ddd23d3c8c325", size = 13222, upload-time = "2022-03-15T21:03:08.65Z" }, +] + +[[package]] +name = "pytest-metadata" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/85/8c969f8bec4e559f8f2b958a15229a35495f5b4ce499f6b865eac54b878d/pytest_metadata-3.1.1.tar.gz", hash = "sha256:d2a29b0355fbc03f168aa96d41ff88b1a3b44a3b02acbe491801c98a048017c8", size = 9952, upload-time = "2024-02-12T19:38:44.887Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/43/7e7b2ec865caa92f67b8f0e9231a798d102724ca4c0e1f414316be1c1ef2/pytest_metadata-3.1.1-py3-none-any.whl", hash = "sha256:c8e0844db684ee1c798cfa38908d20d67d0463ecb6137c72e91f418558dd5f4b", size = 11428, upload-time = "2024-02-12T19:38:42.531Z" }, +] + +[[package]] +name = "pytest-timeout" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/82/4c9ecabab13363e72d880f2fb504c5f750433b2b6f16e99f4ec21ada284c/pytest_timeout-2.4.0.tar.gz", hash = "sha256:7e68e90b01f9eff71332b25001f85c75495fc4e3a836701876183c4bcfd0540a", size = 17973, upload-time = "2025-05-05T19:44:34.99Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/b6/3127540ecdf1464a00e5a01ee60a1b09175f6913f0644ac748494d9c4b21/pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2", size = 14382, upload-time = "2025-05-05T19:44:33.502Z" }, +] + +[[package]] +name = "pytest-xdist" +version = "3.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "execnet" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "python-discovery" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "platformdirs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/12/38c1a0b1e64806780c9563e3fc9f6e472251839662587cfbe9bfaf2ae10a/python_discovery-1.4.0.tar.gz", hash = "sha256:eb8bc7daad3c226c147e45bb4e970a1feb1bf4048ee178e6db59e197b8010ce3", size = 68455, upload-time = "2026-05-28T01:15:37.639Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/8d/3d316429f65029532bb1e28ff77b797d86b5ac3915bb44ca4e19aa283d43/python_discovery-1.4.0-py3-none-any.whl", hash = "sha256:26ed78d703e234879a66244c7d4114563fb13ec5cd30a2d1357e5fb4850782da", size = 33217, upload-time = "2026-05-28T01:15:36.573Z" }, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/b9/52aa9ec2867528b54f1e60846728d8b4d84726630874fee3a91e66c7df81/pyzmq-27.1.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:508e23ec9bc44c0005c4946ea013d9317ae00ac67778bd47519fdf5a0e930ff4", size = 1329850, upload-time = "2025-09-08T23:07:26.274Z" }, + { url = "https://files.pythonhosted.org/packages/99/64/5653e7b7425b169f994835a2b2abf9486264401fdef18df91ddae47ce2cc/pyzmq-27.1.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:507b6f430bdcf0ee48c0d30e734ea89ce5567fd7b8a0f0044a369c176aa44556", size = 906380, upload-time = "2025-09-08T23:07:29.78Z" }, + { url = "https://files.pythonhosted.org/packages/73/78/7d713284dbe022f6440e391bd1f3c48d9185673878034cfb3939cdf333b2/pyzmq-27.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf7b38f9fd7b81cb6d9391b2946382c8237fd814075c6aa9c3b746d53076023b", size = 666421, upload-time = "2025-09-08T23:07:31.263Z" }, + { url = "https://files.pythonhosted.org/packages/30/76/8f099f9d6482450428b17c4d6b241281af7ce6a9de8149ca8c1c649f6792/pyzmq-27.1.0-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03ff0b279b40d687691a6217c12242ee71f0fba28bf8626ff50e3ef0f4410e1e", size = 854149, upload-time = "2025-09-08T23:07:33.17Z" }, + { url = "https://files.pythonhosted.org/packages/59/f0/37fbfff06c68016019043897e4c969ceab18bde46cd2aca89821fcf4fb2e/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:677e744fee605753eac48198b15a2124016c009a11056f93807000ab11ce6526", size = 1655070, upload-time = "2025-09-08T23:07:35.205Z" }, + { url = "https://files.pythonhosted.org/packages/47/14/7254be73f7a8edc3587609554fcaa7bfd30649bf89cd260e4487ca70fdaa/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd2fec2b13137416a1c5648b7009499bcc8fea78154cd888855fa32514f3dad1", size = 2033441, upload-time = "2025-09-08T23:07:37.432Z" }, + { url = "https://files.pythonhosted.org/packages/22/dc/49f2be26c6f86f347e796a4d99b19167fc94503f0af3fd010ad262158822/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:08e90bb4b57603b84eab1d0ca05b3bbb10f60c1839dc471fc1c9e1507bef3386", size = 1891529, upload-time = "2025-09-08T23:07:39.047Z" }, + { url = "https://files.pythonhosted.org/packages/a3/3e/154fb963ae25be70c0064ce97776c937ecc7d8b0259f22858154a9999769/pyzmq-27.1.0-cp310-cp310-win32.whl", hash = "sha256:a5b42d7a0658b515319148875fcb782bbf118dd41c671b62dae33666c2213bda", size = 567276, upload-time = "2025-09-08T23:07:40.695Z" }, + { url = "https://files.pythonhosted.org/packages/62/b2/f4ab56c8c595abcb26b2be5fd9fa9e6899c1e5ad54964e93ae8bb35482be/pyzmq-27.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:c0bb87227430ee3aefcc0ade2088100e528d5d3298a0a715a64f3d04c60ba02f", size = 632208, upload-time = "2025-09-08T23:07:42.298Z" }, + { url = "https://files.pythonhosted.org/packages/3b/e3/be2cc7ab8332bdac0522fdb64c17b1b6241a795bee02e0196636ec5beb79/pyzmq-27.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:9a916f76c2ab8d045b19f2286851a38e9ac94ea91faf65bd64735924522a8b32", size = 559766, upload-time = "2025-09-08T23:07:43.869Z" }, + { url = "https://files.pythonhosted.org/packages/06/5d/305323ba86b284e6fcb0d842d6adaa2999035f70f8c38a9b6d21ad28c3d4/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86", size = 1333328, upload-time = "2025-09-08T23:07:45.946Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a0/fc7e78a23748ad5443ac3275943457e8452da67fda347e05260261108cbc/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581", size = 908803, upload-time = "2025-09-08T23:07:47.551Z" }, + { url = "https://files.pythonhosted.org/packages/7e/22/37d15eb05f3bdfa4abea6f6d96eb3bb58585fbd3e4e0ded4e743bc650c97/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f", size = 668836, upload-time = "2025-09-08T23:07:49.436Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c4/2a6fe5111a01005fc7af3878259ce17684fabb8852815eda6225620f3c59/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e", size = 857038, upload-time = "2025-09-08T23:07:51.234Z" }, + { url = "https://files.pythonhosted.org/packages/cb/eb/bfdcb41d0db9cd233d6fb22dc131583774135505ada800ebf14dfb0a7c40/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e", size = 1657531, upload-time = "2025-09-08T23:07:52.795Z" }, + { url = "https://files.pythonhosted.org/packages/ab/21/e3180ca269ed4a0de5c34417dfe71a8ae80421198be83ee619a8a485b0c7/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2", size = 2034786, upload-time = "2025-09-08T23:07:55.047Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b1/5e21d0b517434b7f33588ff76c177c5a167858cc38ef740608898cd329f2/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394", size = 1894220, upload-time = "2025-09-08T23:07:57.172Z" }, + { url = "https://files.pythonhosted.org/packages/03/f2/44913a6ff6941905efc24a1acf3d3cb6146b636c546c7406c38c49c403d4/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f", size = 567155, upload-time = "2025-09-08T23:07:59.05Z" }, + { url = "https://files.pythonhosted.org/packages/23/6d/d8d92a0eb270a925c9b4dd039c0b4dc10abc2fcbc48331788824ef113935/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97", size = 633428, upload-time = "2025-09-08T23:08:00.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/14/01afebc96c5abbbd713ecfc7469cfb1bc801c819a74ed5c9fad9a48801cb/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07", size = 559497, upload-time = "2025-09-08T23:08:02.15Z" }, + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, + { url = "https://files.pythonhosted.org/packages/f3/81/a65e71c1552f74dec9dff91d95bafb6e0d33338a8dfefbc88aa562a20c92/pyzmq-27.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c17e03cbc9312bee223864f1a2b13a99522e0dc9f7c5df0177cd45210ac286e6", size = 836266, upload-time = "2025-09-08T23:09:40.048Z" }, + { url = "https://files.pythonhosted.org/packages/58/ed/0202ca350f4f2b69faa95c6d931e3c05c3a397c184cacb84cb4f8f42f287/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f328d01128373cb6763823b2b4e7f73bdf767834268c565151eacb3b7a392f90", size = 800206, upload-time = "2025-09-08T23:09:41.902Z" }, + { url = "https://files.pythonhosted.org/packages/47/42/1ff831fa87fe8f0a840ddb399054ca0009605d820e2b44ea43114f5459f4/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c1790386614232e1b3a40a958454bdd42c6d1811837b15ddbb052a032a43f62", size = 567747, upload-time = "2025-09-08T23:09:43.741Z" }, + { url = "https://files.pythonhosted.org/packages/d1/db/5c4d6807434751e3f21231bee98109aa57b9b9b55e058e450d0aef59b70f/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:448f9cb54eb0cee4732b46584f2710c8bc178b0e5371d9e4fc8125201e413a74", size = 747371, upload-time = "2025-09-08T23:09:45.575Z" }, + { url = "https://files.pythonhosted.org/packages/26/af/78ce193dbf03567eb8c0dc30e3df2b9e56f12a670bf7eb20f9fb532c7e8a/pyzmq-27.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:05b12f2d32112bf8c95ef2e74ec4f1d4beb01f8b5e703b38537f8849f92cb9ba", size = 544862, upload-time = "2025-09-08T23:09:47.448Z" }, + { url = "https://files.pythonhosted.org/packages/4c/c6/c4dcdecdbaa70969ee1fdced6d7b8f60cfabe64d25361f27ac4665a70620/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066", size = 836265, upload-time = "2025-09-08T23:09:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/3e/79/f38c92eeaeb03a2ccc2ba9866f0439593bb08c5e3b714ac1d553e5c96e25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604", size = 800208, upload-time = "2025-09-08T23:09:51.073Z" }, + { url = "https://files.pythonhosted.org/packages/49/0e/3f0d0d335c6b3abb9b7b723776d0b21fa7f3a6c819a0db6097059aada160/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c", size = 567747, upload-time = "2025-09-08T23:09:52.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cf/f2b3784d536250ffd4be70e049f3b60981235d70c6e8ce7e3ef21e1adb25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271", size = 747371, upload-time = "2025-09-08T23:09:54.563Z" }, + { url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" }, +] + +[[package]] +name = "readme-renderer" +version = "43.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "nh3" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fe/b5/536c775084d239df6345dccf9b043419c7e3308bc31be4c7882196abc62e/readme_renderer-43.0.tar.gz", hash = "sha256:1818dd28140813509eeed8d62687f7cd4f7bad90d4db586001c5dc09d4fde311", size = 31768, upload-time = "2024-02-26T16:10:59.415Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/be/3ea20dc38b9db08387cf97997a85a7d51527ea2057d71118feb0aa8afa55/readme_renderer-43.0-py3-none-any.whl", hash = "sha256:19db308d86ecd60e5affa3b2a98f017af384678c63c88e5d4556a380e674f3f9", size = 13301, upload-time = "2024-02-26T16:10:57.945Z" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py", version = "0.30.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "rpds-py", version = "2026.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "python_full_version < '3.13' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "requests-toolbelt" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" }, +] + +[[package]] +name = "rfc3986" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/40/1520d68bfa07ab5a6f065a186815fb6610c86fe957bc065754e47f7b0840/rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c", size = 49026, upload-time = "2022-01-10T00:52:30.832Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", size = 31326, upload-time = "2022-01-10T00:52:29.594Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "rpds-py" +version = "0.30.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288", size = 370490, upload-time = "2025-11-30T20:21:33.256Z" }, + { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00", size = 359751, upload-time = "2025-11-30T20:21:34.591Z" }, + { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6", size = 389696, upload-time = "2025-11-30T20:21:36.122Z" }, + { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7", size = 403136, upload-time = "2025-11-30T20:21:37.728Z" }, + { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324", size = 524699, upload-time = "2025-11-30T20:21:38.92Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df", size = 412022, upload-time = "2025-11-30T20:21:40.407Z" }, + { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3", size = 390522, upload-time = "2025-11-30T20:21:42.17Z" }, + { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221", size = 404579, upload-time = "2025-11-30T20:21:43.769Z" }, + { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7", size = 421305, upload-time = "2025-11-30T20:21:44.994Z" }, + { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff", size = 572503, upload-time = "2025-11-30T20:21:46.91Z" }, + { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7", size = 598322, upload-time = "2025-11-30T20:21:48.709Z" }, + { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139", size = 560792, upload-time = "2025-11-30T20:21:50.024Z" }, + { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464", size = 221901, upload-time = "2025-11-30T20:21:51.32Z" }, + { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169", size = 235823, upload-time = "2025-11-30T20:21:52.505Z" }, + { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" }, + { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" }, + { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" }, + { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" }, + { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" }, + { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" }, + { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" }, + { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" }, + { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" }, + { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" }, + { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" }, + { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" }, + { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" }, + { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" }, + { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" }, + { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" }, + { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" }, + { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" }, + { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" }, + { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" }, + { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" }, + { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" }, + { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" }, + { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" }, + { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" }, + { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" }, + { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" }, + { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" }, + { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" }, + { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" }, + { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" }, + { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" }, + { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" }, + { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" }, + { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" }, + { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" }, + { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" }, + { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" }, + { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" }, + { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" }, + { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" }, + { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" }, + { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" }, + { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" }, + { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" }, + { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" }, + { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" }, + { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" }, + { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" }, + { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" }, + { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" }, + { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" }, + { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" }, + { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" }, + { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" }, + { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" }, + { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" }, + { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" }, + { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" }, + { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" }, + { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" }, + { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" }, + { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" }, + { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" }, + { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" }, + { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" }, + { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" }, + { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" }, + { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" }, + { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" }, + { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" }, + { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" }, + { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" }, +] + +[[package]] +name = "rpds-py" +version = "2026.5.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/43/25a8dcd3feedd735039a8f0b5b7e3b118232b5eae288c4fd9ab200d41094/rpds_py-2026.5.1.tar.gz", hash = "sha256:07b24fea40541e28570e5b795a4a38fbdcd12550c06bd0748005ecc8116ca256", size = 64459, upload-time = "2026-05-28T12:02:13.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/a0/acf8b6fc20bfdcd3a45bd3f57680fb198e157b7e997b9123b10763798bd2/rpds_py-2026.5.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3397a5ed7174dc2786bb214030232fc36fe8e5584fec43a9952cc542b1a12036", size = 355609, upload-time = "2026-05-28T11:58:50.78Z" }, + { url = "https://files.pythonhosted.org/packages/b6/95/f8203fd997484b1690a6869cd0e503b6c3c6be55b0ecc36d1a491fe742f0/rpds_py-2026.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:99ab6ba7bfa2cb0f96a04e3652355bf04e3f51aceb1e943b8541dab7ba4828cc", size = 348460, upload-time = "2026-05-28T11:58:52.374Z" }, + { url = "https://files.pythonhosted.org/packages/33/8c/b47326ad2f0be545a5e5c1a55937a12afaea7d392ba2837bb9680f57e6c9/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0efbe45632665e53e3db8fe1e5692db58fc5cb9bab4459d570b83efefe11164", size = 381031, upload-time = "2026-05-28T11:58:53.775Z" }, + { url = "https://files.pythonhosted.org/packages/22/0b/e83bbd97ffac6f6389b605cd4e1c8ac5761dc7e977769c9255d8c5adb7bd/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:01d17b29c0c23d82b1f4751147ec49cf451f1fc2554eb9ef5f957e55d2656ead", size = 387121, upload-time = "2026-05-28T11:58:55.243Z" }, + { url = "https://files.pythonhosted.org/packages/fd/0e/d285d1bc8864245919c61e1ca82263e4a66d337759c3a4cef72766ff9afc/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7559f72b94ae52659086c595dfa017cde03155f7832071d30959049052cb3ece", size = 501026, upload-time = "2026-05-28T11:58:56.788Z" }, + { url = "https://files.pythonhosted.org/packages/86/06/ccb2109a1e543437b5e43816f2b43b9554cc6783145528a4e3711e05c011/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e25b7088f9ccbfc0dfcaa52bf969300ca229e10ecf758974ebcbb080a4b37bb", size = 391865, upload-time = "2026-05-28T11:58:58.298Z" }, + { url = "https://files.pythonhosted.org/packages/3d/33/237173db1cfef10105b3839a24de00eb8d2a523711add4632447cdf0aedd/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:613fc4ee9eaef26dc5840666214dd6fbcebcf32f46e76f4abc473059f4e13dda", size = 378012, upload-time = "2026-05-28T11:58:59.589Z" }, + { url = "https://files.pythonhosted.org/packages/97/64/1eae54e34d5161f9969295e80bd6b62a55f2b6ac5f2a5b60d02c2140e758/rpds_py-2026.5.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:85264a90ff4c05c1568dd65f5921c837614b67c60358fb4c17df3b7f2e90690a", size = 391111, upload-time = "2026-05-28T11:59:01.104Z" }, + { url = "https://files.pythonhosted.org/packages/d8/34/5bb334a5a0f65d77869217c4654f34c78a7d11b93938a3c076a2edeafc52/rpds_py-2026.5.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe71bca7d547acb17027c7fd1624ff8aae623499c498d3e7011182c4de5c25e0", size = 409225, upload-time = "2026-05-28T11:59:02.433Z" }, + { url = "https://files.pythonhosted.org/packages/16/0f/007ec21283b5b040b4ec3bd95e0402591e22bfa7d5c93dfe01c465c2d2d7/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05fa4f41f37ec97c9c260441a940450a192f78d774d2b097eee1379f1e1246a", size = 556487, upload-time = "2026-05-28T11:59:04.012Z" }, + { url = "https://files.pythonhosted.org/packages/ff/10/5437c94508169b6b22d8418fef7a66e9ffb5f3b9e9c94460f2eedafe06ff/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df1d2a1996755b24b9ecee92cb4d36c28f86f464a6a173349c26bab41e94b8c2", size = 620798, upload-time = "2026-05-28T11:59:05.485Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d5/9937dce4d6bda74157b954e7d1460db05a22f5929dccfeeba1ed27a93df0/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8895840ac4809e5f60c88fd07617cd71326e73d6e5a8aa783c5c0f7c24985de2", size = 584053, upload-time = "2026-05-28T11:59:06.837Z" }, + { url = "https://files.pythonhosted.org/packages/6c/31/750617dd0ae1752471bf43f9e41d263398fae7cde7849d23b8574a70e617/rpds_py-2026.5.1-cp311-cp311-win32.whl", hash = "sha256:3684a59b158a7683aaeb8e25352e9a9dd2122cec78f2d8530266e4f91b4c7b3f", size = 214390, upload-time = "2026-05-28T11:59:08.402Z" }, + { url = "https://files.pythonhosted.org/packages/3c/bb/3dcab0e1d9516303f2eb672a5d6f62eca5a69e2886301e9c8c54b520c39b/rpds_py-2026.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:7bd530e6a530bb3ea892f194fafa455f3516ac25ecf7143fd33c09be62b0470a", size = 231097, upload-time = "2026-05-28T11:59:09.786Z" }, + { url = "https://files.pythonhosted.org/packages/49/d6/c6bbf5cb1cf12b9732df8074b57f6ef8341ba884c95d40632ae8bddb44e4/rpds_py-2026.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:0a5ae4dbe43c1076983b72616496919872ae7bbe7a1e21cc48336bc3154d130b", size = 226361, upload-time = "2026-05-28T11:59:11.079Z" }, + { url = "https://files.pythonhosted.org/packages/d4/e7/a78582dc57caa592dcc7d4fb69b61390561e908eb3d2f5df5928a8e354c0/rpds_py-2026.5.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3abe24a66e57adcfa645d718063a5fa5103ecc71ddbf26d78af8f9368018ff1d", size = 353040, upload-time = "2026-05-28T11:59:12.531Z" }, + { url = "https://files.pythonhosted.org/packages/a3/43/35e3f136343aef451e545ce8c38d36c2f93c0ed88703db8b64ba2b205c68/rpds_py-2026.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58b1d94308ddf0b1982f61f2eb54bf92997c9ece8a8093ef014250f4a517906c", size = 345775, upload-time = "2026-05-28T11:59:13.827Z" }, + { url = "https://files.pythonhosted.org/packages/20/e1/0f2160c5982d3157734d5cb3ed63d8b2d583a73c9864f77b666449f32cf8/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fa92420128dadce7f54bd73ba1825a273e9268fe9e35dbf7e6362890efa4e08", size = 376329, upload-time = "2026-05-28T11:59:15.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/11/ee0ba42aff83bf4effdbc576673c6be64c5e173978c3f6d537e94482f77d/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ca653c6546386227cd9800d1bef6a348099acf8db4250341da6d90f663d6dfcb", size = 383539, upload-time = "2026-05-28T11:59:16.665Z" }, + { url = "https://files.pythonhosted.org/packages/11/df/d94aa6a499d4ac40afe2d7620f2c597fd3c0f182e854ad7cf3f596a81cb6/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66c93681c4729e4e3ecba31b8179fae083ff3118841672835140338b4b9867c1", size = 494674, upload-time = "2026-05-28T11:59:17.991Z" }, + { url = "https://files.pythonhosted.org/packages/1f/75/33d30f43bb2f458de11979486a591b1bf6e5651765ed1704c6197c2dc773/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40ff257542e04796880e011e15cd4dc21c2599975df2aaa8f2c8495ca574e1a5", size = 389268, upload-time = "2026-05-28T11:59:19.434Z" }, + { url = "https://files.pythonhosted.org/packages/f4/1e/2c9096fc19d5fd084b0184ca2b651e659aa0a37e6fdbecf6ece47f147fe1/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6825cc329b290e93c5f6a9be2393118a763f6ccf6abd83704e0c102ca583644", size = 376280, upload-time = "2026-05-28T11:59:21Z" }, + { url = "https://files.pythonhosted.org/packages/b9/e5/61ec9f8be8211ea7f48448195549e4aaf02004083475493b0e137702ecb2/rpds_py-2026.5.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:de42116e69cb53b911cc34aee5ab98f36c597b822545045d49e938818b99e5e4", size = 387233, upload-time = "2026-05-28T11:59:22.454Z" }, + { url = "https://files.pythonhosted.org/packages/0d/ca/bcec1005c4f4a234f92a29078631fee49206c7265ccae966f18fd332e80e/rpds_py-2026.5.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c0f920015df2a504bebaba6d4c31ccf3fcf942f92655c086da30b671aad19aa6", size = 405009, upload-time = "2026-05-28T11:59:23.845Z" }, + { url = "https://files.pythonhosted.org/packages/72/e6/4d5718c5cf26c522dc7c9999e238da1e77380b81d0c5d1df11e271ddfeb1/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0408a24e44feb919423dc6d9da677cb5cddb894d2ca9e763967d156d9c60fab4", size = 553113, upload-time = "2026-05-28T11:59:25.184Z" }, + { url = "https://files.pythonhosted.org/packages/d4/25/2ee807bdb3e1f0b7eddf7782acd5665a8b5205a331a7d7244a52c4812fd9/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cea68bcd53467561ae2f96a6bdad1544299ba97b5b0ddcd5ac3d376e5c781c24", size = 618838, upload-time = "2026-05-28T11:59:26.749Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c1/7d4c26f167f8c41501cc073d30ee22082b16ce358cf5b00ec97cbc7804ea/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4be8b1d2a705cc37d08256004e1d07de143fa0075c8e85a3df020b776f62b732", size = 582436, upload-time = "2026-05-28T11:59:28.11Z" }, + { url = "https://files.pythonhosted.org/packages/04/1d/9d12b0a337bab46f4769f8857f4007e3b2d639e14f9a44a0efe157696e64/rpds_py-2026.5.1-cp312-cp312-win32.whl", hash = "sha256:6736718bd4fc49cbcb538ba30516fdbef161522acefb739657d48b97bd864fed", size = 212734, upload-time = "2026-05-28T11:59:29.689Z" }, + { url = "https://files.pythonhosted.org/packages/c5/93/e4116f2de7f56bc7406a76033dc501811ddeb22b7f056b92d632871ebb0c/rpds_py-2026.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:0a7d1eec967df0e9b22614a5e177622e0c89611d03727fa0cb48e45028907870", size = 229045, upload-time = "2026-05-28T11:59:31.033Z" }, + { url = "https://files.pythonhosted.org/packages/cb/53/6c3419d85eb2ec5938a37627c585b42d76a63bb731d6e42ed4b079ebf486/rpds_py-2026.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:1841d067089e117142d79b98aa0df2f08b52f2ecc1819dd2700636c0db74a473", size = 223967, upload-time = "2026-05-28T11:59:32.318Z" }, + { url = "https://files.pythonhosted.org/packages/6c/32/14c961ad295f490eb0849ada8b79683e93a59b9de3afdd983eaf55fa6867/rpds_py-2026.5.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:efef4ac29c6ff495531eb17ee705b62841ecaa291b7c7077e848ea03e237164d", size = 352787, upload-time = "2026-05-28T11:59:33.655Z" }, + { url = "https://files.pythonhosted.org/packages/ca/bb/d1b85117967c11191441a7274ae616c65d93901d082c588f89a50a8da5ae/rpds_py-2026.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c39f5b67a8a2e67179ada2a954227d670fe65fa9098457f698f56ddf248709b3", size = 345179, upload-time = "2026-05-28T11:59:35Z" }, + { url = "https://files.pythonhosted.org/packages/7c/46/d84105f062e626a1b233f863907288a4708c2d833b8b4c6fb2764bc080c0/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5c30f3f04eef4fbd362226a6f31d7c8895ca4fbb6e0b790f6890a98d8da8559", size = 376173, upload-time = "2026-05-28T11:59:36.43Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ae/469d7959ce5b1201e1de135dc735b86db3b35dd0d1734f6a44246d5f061c/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:277f6c82f0580848796c7ecc8a7173aa3bfb928e4ff831261c2f60a81dc270db", size = 383162, upload-time = "2026-05-28T11:59:37.995Z" }, + { url = "https://files.pythonhosted.org/packages/dc/a2/57853d31a1116a561aa072794602ad3f6341e18d70a8523f1bd5b9fc1e5a/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:63c2c4c213f1a4e3f3de28ecab029dbdee976324e729c0d7a55211be72576b02", size = 495093, upload-time = "2026-05-28T11:59:39.453Z" }, + { url = "https://files.pythonhosted.org/packages/99/63/3a8eabcad9314b7daf5c65f451d2c33d989235cd8a5762186cf2c3f5a4f8/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3350ec808fb538fe71a1f94dfaa0e29c598dfad805ce49f0caec5ae3183c652b", size = 389829, upload-time = "2026-05-28T11:59:40.896Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/05678d97fc25e2622df14dc530fb82023174ecfff6733991ed0d78f167bd/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1b964e3ab599e718dc46c018d104b1ebc007cbc6567d827c94a687fca56d77e", size = 374786, upload-time = "2026-05-28T11:59:42.626Z" }, + { url = "https://files.pythonhosted.org/packages/88/d1/8c90b6431e80a3b91b284a5c7c8c0c4f9c006444d90477a740d6e0f9c694/rpds_py-2026.5.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:19cb09fab7b7fc96b2a6e28f2e34b72a3705ff27b37edb77455316e5d3f3dc9b", size = 386920, upload-time = "2026-05-28T11:59:44.124Z" }, + { url = "https://files.pythonhosted.org/packages/ff/99/4638f672ab356682d633ee0da9255f5b67ce6efd0b85eb94ad3e255e65a5/rpds_py-2026.5.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:abe76bcdba31e576cb83eeb8797aa0d882b738fef6dc65d0601fc753806a5b46", size = 405059, upload-time = "2026-05-28T11:59:47.177Z" }, + { url = "https://files.pythonhosted.org/packages/66/3f/3546524b6eb4cc2e1f363a3d638fa52f6c24faae3500c25fb488b02f1740/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8bff7073db3899158fff55ebf57b113a67030af26f80a18978f9f0aa60250ddf", size = 553030, upload-time = "2026-05-28T11:59:48.603Z" }, + { url = "https://files.pythonhosted.org/packages/c6/c3/7b3388c796fcf471bd17194242d4dc1a7608567c0fa422bcc1c5e79f9c1e/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8ba264fa49be666cd9cc56bf34ec7002fb3d27a4aee5bcb4d43d0d18feb1bb6f", size = 618975, upload-time = "2026-05-28T11:59:50.314Z" }, + { url = "https://files.pythonhosted.org/packages/61/1e/a3cb07f2795075d1d88efddae2f541359fde5f08c81ee114c29c2949c90a/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4860b603ddda0475a8885499b3729e90229d480105b42651962a5397d995fa89", size = 581178, upload-time = "2026-05-28T11:59:51.673Z" }, + { url = "https://files.pythonhosted.org/packages/a1/74/e758c03a5ef46f04c37f2651a2893db846d569ba8a7bca469d4b58939bcd/rpds_py-2026.5.1-cp313-cp313-win32.whl", hash = "sha256:7944270ae71383f6e2657dd7d5ce4eeb4ac2d0059a6738f0510583d462ab4842", size = 212481, upload-time = "2026-05-28T11:59:53.148Z" }, + { url = "https://files.pythonhosted.org/packages/70/ec/a2aca432db9c7359b40fa393eeeaa0d166c2f70175be956e75fa24197c44/rpds_py-2026.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:88647f43a73c4e01be19b04ceef0c8d3a1958153604d13c773becd8016f2a0cf", size = 228519, upload-time = "2026-05-28T11:59:54.505Z" }, + { url = "https://files.pythonhosted.org/packages/29/60/a73bfdd45b096574556acf303bbd9fa9eed36ca8a818b514e2a5d5fe2b9d/rpds_py-2026.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:453895624ecf7db7063b1004e44037522bbaef9ff6a945e59bc71662d7a03abd", size = 223446, upload-time = "2026-05-28T11:59:56.081Z" }, + { url = "https://files.pythonhosted.org/packages/18/e2/408105fd611823f00882aea810f3989a30d26b1bab8b6beb20f98c724e0e/rpds_py-2026.5.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:b4e4bc98639ec915f512fde3aa7a95e0041d95d9c3cc86eea841fa63cb1e8600", size = 355287, upload-time = "2026-05-28T11:59:57.448Z" }, + { url = "https://files.pythonhosted.org/packages/8d/58/5c4a43436843c90d0f6d19f82c200c80e3843ca9fa07b237623327f6d384/rpds_py-2026.5.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cacedb7a6e167680acba45ad5716e89067d225dc80da0d7040cae8c81d4572fa", size = 347033, upload-time = "2026-05-28T11:59:58.881Z" }, + { url = "https://files.pythonhosted.org/packages/fb/c2/1a71acdacaf4e259b10278fb87b039ded3cf80041bcd89dd8a3ea702ded6/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68700371c5d7ae1412862ddfa719090925c93ecf351c566d66f09d04b136ea00", size = 376891, upload-time = "2026-05-28T12:00:00.516Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c8/535f3d9b65addd8e28aa87b83c6e526799c3717a88273db8ea795beeef7a/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:296c799becfa849c779c8725494fe9ed94959ed886787df4364b058465bad7f0", size = 385646, upload-time = "2026-05-28T12:00:02.394Z" }, + { url = "https://files.pythonhosted.org/packages/1c/91/dc033f313345c354ade914dbe73cdb90b615a4409ea02430d5356794f3d8/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d3858b908218ee108d0bbfb2095ccc237648053c9bf98affad7cb079acaf1d97", size = 498830, upload-time = "2026-05-28T12:00:04.189Z" }, + { url = "https://files.pythonhosted.org/packages/27/fc/90fcbea459dbb8ddc18a2e0fd1de9412b48bc84ffff2db771cf714bacfd6/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4fb8d2e7cb2f850b169806d61d1b991738acec96500a75c30f49caf064ce7cef", size = 392830, upload-time = "2026-05-28T12:00:05.797Z" }, + { url = "https://files.pythonhosted.org/packages/b2/1d/46cd11a228c9750684a798d98f878be6f614aa762438da7378f035e79e35/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27b74c10ed6a8f190f4287f53bcfea348b92a84a9c9f70d30183d1e6172d580d", size = 379613, upload-time = "2026-05-28T12:00:07.433Z" }, + { url = "https://files.pythonhosted.org/packages/24/4a/d9b0c6af3a1de03eb93741bbe8be2bdce84d8fda8224f3005451d86df389/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:b9a6528956191c48c52294a592dbd4a8386d7048bdb25c0efcb6b966466c6d83", size = 388183, upload-time = "2026-05-28T12:00:09.227Z" }, + { url = "https://files.pythonhosted.org/packages/c5/b4/db7aaabdda6d020afc87d981bcc2f57a434c7dec60ecfc2ab3dd50b20351/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:af03e34e860047bc7a352b842856fcf78798fbb81132cc98bd2f907ab4eb9cd2", size = 408578, upload-time = "2026-05-28T12:00:10.779Z" }, + { url = "https://files.pythonhosted.org/packages/08/d6/070f6a41cbb343e2ac4171859bf3f3623e0ab002f72619d6d505313ec2de/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fea6e836d10abbe191d557d33bd58bd5987725fe63aa1eefe557d230209855bd", size = 553573, upload-time = "2026-05-28T12:00:12.443Z" }, + { url = "https://files.pythonhosted.org/packages/75/ab/1a71ea3589c4345dac0a0518f0e6a031cb42689277851b683c46d27463a5/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:fc0c0f878ea770a0a8a462456c5ad36fc9fe6358e6b76fdadc7f17575e0b8bf1", size = 620861, upload-time = "2026-05-28T12:00:14.09Z" }, + { url = "https://files.pythonhosted.org/packages/8a/22/9bf80a56069c0c443fcfefac639a86a744550a2898817a6dfd3e26654924/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e0b360f316d966b048b085857630b3cc51f3db2f07b06f440eac8f695374d1e3", size = 585633, upload-time = "2026-05-28T12:00:15.66Z" }, + { url = "https://files.pythonhosted.org/packages/da/68/3b2c0a75c9e04125696f84ebdbbf304acf5a40b58ba4481cdb98a922c3ba/rpds_py-2026.5.1-cp313-cp313t-win32.whl", hash = "sha256:a2999883eedf72fdfb7520b92c7d4ec2572a71ff40239377aa604cc529eecafc", size = 210074, upload-time = "2026-05-28T12:00:17.291Z" }, + { url = "https://files.pythonhosted.org/packages/e7/8b/609157d5a25d37d4f29f92840ba531f416907c34ae5c5739dd21fc2bef98/rpds_py-2026.5.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e07be2a9d7122bd6e82dea89814ef8dc893feb1aae97fec1630f3263bbb30e55", size = 228635, upload-time = "2026-05-28T12:00:18.73Z" }, + { url = "https://files.pythonhosted.org/packages/d4/6f/19c1918a4b590d8de87e712e4abe4b3875771eff60216fb6153cf6665c68/rpds_py-2026.5.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:1f2c391c3059798093b65df23aca2cac150460ae9c630d99dec83d703d9485b9", size = 349756, upload-time = "2026-05-28T12:00:20.217Z" }, + { url = "https://files.pythonhosted.org/packages/e5/60/a06fe7da34eca79dacbf958a2ba0c6eea85bc2b29de20080bf40f72f66fa/rpds_py-2026.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:413b424f7c4ee65ab5e5be91f5731be0f8b41a1ee2b12dfe810d716312e95a78", size = 343831, upload-time = "2026-05-28T12:00:21.711Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ec/b2333b97b90e2a6ef6ca8ad386ee284968e74bcfe113b3f1a8d9036429a9/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c595a1d9255dce0599e13130d1440ab2506654f2b50294226ee06402f8fef63", size = 375127, upload-time = "2026-05-28T12:00:23.326Z" }, + { url = "https://files.pythonhosted.org/packages/14/7f/e00aae54067f2b488c4637961d5f58204d470795fc791085fa3f15060d2e/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1c27c5f6102eac8c03e7595a00827a53b271ba40a53b59ff8709170e0855ea4a", size = 379034, upload-time = "2026-05-28T12:00:24.89Z" }, + { url = "https://files.pythonhosted.org/packages/be/cc/423999bbb8ae8dc93c77fc1d5e984ade5eb89d237d3bb884ccfa72ae2890/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c7fcf61d44cacecaf3aea542b0e053db77972a4573e7ceda16fb2b399161195", size = 490823, upload-time = "2026-05-28T12:00:26.676Z" }, + { url = "https://files.pythonhosted.org/packages/0f/aa/c671bf660f12e68d3c52ff86c7066ed1372df5a0f4f2ff584e419b8207e7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2c817a189d4ee14290420e5ff051e4dd6baa13f3edf84685071dee07a6d538ee", size = 388144, upload-time = "2026-05-28T12:00:28.577Z" }, + { url = "https://files.pythonhosted.org/packages/19/c8/d63bb75b68afe77b229e3021c6031bcaf01da5db5b0e69d0d10f9ba679a7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21846aac0ed2e0589f38c12dc44e77bb64e494b771eadbcf169cba00566ba7ba", size = 371959, upload-time = "2026-05-28T12:00:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/82/35/c51122014d8274ff37dc606d60049c3db7d83da02b5b282511e5a906a9a6/rpds_py-2026.5.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b317c87a13f769a4e787819bd508aaa5d69aa09b0880de9af6d3a8a54571cdec", size = 383558, upload-time = "2026-05-28T12:00:31.764Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f9/2790cb99c136a5363acdeacf5c27c56f3de0d4118a1f48fca83404c99c89/rpds_py-2026.5.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce87129d9f2c14fa6c4a8601fb80eb4488c80d38a20cd13758ef11123e14995d", size = 402789, upload-time = "2026-05-28T12:00:33.247Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1b/e4fb584f8c75d35c38150ff6a332cda949e6f97acba1f4fd123b14ab56fe/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9cdddb6c1207d284d94fd1530adf57fbd797fe7c4b8704ba85f49414f2557e7d", size = 551405, upload-time = "2026-05-28T12:00:34.819Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f7/a6731b4216cb3793ea1af5391da240f5683dacc0d13e034fe5fc3503f240/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:4e237e139f94d3c036fd28eb9f564c99055476ff4ff05cd42be55ce349b5aa02", size = 616975, upload-time = "2026-05-28T12:00:36.268Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/2e051a81d95d8e63f4b35a1c463a87e8766bc3d083c067c5dfb6bf220747/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ed0954b524873214369184a9c82b0eaa45a3fbb9a798cd95b17e0d98499e7ea0", size = 578701, upload-time = "2026-05-28T12:00:37.82Z" }, + { url = "https://files.pythonhosted.org/packages/65/56/b5f6fdb2083e32bca8a8993d89e70db114b4756c9e2c38421328126689d2/rpds_py-2026.5.1-cp314-cp314-win32.whl", hash = "sha256:2d88621d6a7d4dfa633d21abe90f280bb205274e16b1d1e61c6ad4640b2453b7", size = 209806, upload-time = "2026-05-28T12:00:39.492Z" }, + { url = "https://files.pythonhosted.org/packages/fb/80/65a5aa96c155e611d1ed844e4e1f57f3e36b021f396d9f8585d756e6b90d/rpds_py-2026.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:cef8ac28d26f4dda3533060c20fbf80a325458fa9fd23ea72a73cdfa8e978838", size = 225985, upload-time = "2026-05-28T12:00:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/27/7c/ad185212e87b05f196daef92bc5f3caf07298eb47c295b5585c3dd3093ac/rpds_py-2026.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:eaaea962c68cdc68d4a533ba985ab8e9484277910bbfaa2ab3ef7732667bfed8", size = 221219, upload-time = "2026-05-28T12:00:43.15Z" }, + { url = "https://files.pythonhosted.org/packages/23/58/e14ae18759020334646b031e708ab4158d653a938822bfb7b95ef2e93aa3/rpds_py-2026.5.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:21942f52dbbd5f8758bf021213d28bd45c39e873e65e2407faf5f1846f5761ad", size = 352148, upload-time = "2026-05-28T12:00:44.638Z" }, + { url = "https://files.pythonhosted.org/packages/31/9b/5f4a1e2f960bca3ac5d052b139dd31eed97b259f9d909173821760d542e8/rpds_py-2026.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f414556f6e3958300ff941e40c9f97e3dc9774ddd1b3434c475d73dd354bbed3", size = 345196, upload-time = "2026-05-28T12:00:46.14Z" }, + { url = "https://files.pythonhosted.org/packages/1a/71/1d9574d6a2fa20ab60eaa55c7467f5aa20cbc770f341a05f09c0876f59e2/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ef1013a8625c74043210190b246f5b1551e09757c1f356c6e4160ef96c5bc081", size = 374981, upload-time = "2026-05-28T12:00:47.531Z" }, + { url = "https://files.pythonhosted.org/packages/0c/9a/37e99f4915a80aa71670263c1267f7ae0af95f53a3f61e6c3bdc016d4515/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cc68e231a77a5f0d774ae278a1f8e55c0456501820847c1e4efb3829f3441df6", size = 379961, upload-time = "2026-05-28T12:00:49.216Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ff/6e73f74b89d2e0715e0fc86b7dde893f9a61ae2f9b256ff3bdfe41ac4e94/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9baffb505aff33acc69b422a19f77806680f3c8632227d79f48de8a810d1c2c5", size = 495965, upload-time = "2026-05-28T12:00:51.111Z" }, + { url = "https://files.pythonhosted.org/packages/ea/e0/425faba25f59d74d4638b267f7c7a80e8649d2ef4db10a19b0c4a71e6e6f/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8d2f912928d426e8cfa396f7f3f8d29a59e6689c86dcca3c420730c1096322b", size = 389526, upload-time = "2026-05-28T12:00:52.77Z" }, + { url = "https://files.pythonhosted.org/packages/c6/76/7a41960e3fddae47fab43a28684d5da981401dffd88253de0944148654cb/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90f628283be835db980c941767d41c9a27b5239e54ba0a9c1335247e82406964", size = 376190, upload-time = "2026-05-28T12:00:54.215Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/5f38dc70824fc6951b51d35377e577a3a3a4c81a6769cc5a2de25ebe0ad1/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:1ebb2f0ab7e16132995a72de805170e0203df0c3dd22e1ef1cd1fdd90bd7a131", size = 383921, upload-time = "2026-05-28T12:00:55.673Z" }, + { url = "https://files.pythonhosted.org/packages/60/1a/d60a38caa1505f4b9483c3fbbde12c94e1079154f4f401a6da96f7e77621/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f3df3d16ded76f1f8c9cdebd0e1ea55fdf4c23b812de189814da7cf229c22a81", size = 404766, upload-time = "2026-05-28T12:00:57.518Z" }, + { url = "https://files.pythonhosted.org/packages/87/ff/602fd3f174d6425f0bce05ad0dfbec0e96b38d0f7d08a79af5aa20083885/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9af8905b8f854990e40d5206aa5ac58d9b0fe0b7f351ff2bb086c20f6c8c6a47", size = 551343, upload-time = "2026-05-28T12:00:58.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c1/1be13327acdbead3eca1fde03b6a34dbb011f1e864e217f0d32cc1779a7f/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:036a36a87fb1cd3b214d11c4b3c4f7d2ddad933625dca1c900b56a057c07740a", size = 618502, upload-time = "2026-05-28T12:01:00.656Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d7/afb49b49d7f2be8b7ba1a9f0977fa5168003437b93086726f066544e8351/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ae3853454fe9ef283a03c96c2d835d39e84b14643a9d62c82ef0fb87d702ca", size = 581916, upload-time = "2026-05-28T12:01:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/25/d1/dbef8c1f8a10f07beb62b5f054e20099fd9924b3ec001b8f0b6ac7813a85/rpds_py-2026.5.1-cp314-cp314t-win32.whl", hash = "sha256:6c3d771a46ec18b12af06ce36243a9a80b07a5d0515236332d90863ca8bb326a", size = 207855, upload-time = "2026-05-28T12:01:03.821Z" }, + { url = "https://files.pythonhosted.org/packages/2a/72/bfa4e61ab8e7dc1c8adf397e05e6cbdd4239357bd72b248d3de662f23915/rpds_py-2026.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c93c629be4636cf54337bd5f06c104d55e42ced54d681f6fe21ae510a65116f6", size = 225422, upload-time = "2026-05-28T12:01:05.194Z" }, + { url = "https://files.pythonhosted.org/packages/42/56/3fe0fb34820ff667be791b3a3c22b85e8bcba54e9c832f47438c191fa7be/rpds_py-2026.5.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:edf2765d84e42447f112ad877af8fe1db0089aaec5b28e88d6eab45e7fe99cea", size = 357151, upload-time = "2026-05-28T12:01:53.43Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f2/3eb9ccdb9f143b8c9b003978898cb497f942a324c077401e6b8834238e63/rpds_py-2026.5.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ad3773236e95f7f33991eb125224b7da66f206504d032a253a02da7e134519fb", size = 350195, upload-time = "2026-05-28T12:01:54.901Z" }, + { url = "https://files.pythonhosted.org/packages/a7/24/dbda232bc4f3ed732120692ab0d2c8402cb020516556d8bee622dcef2413/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a04df86b3f0fade39ec8fd0e0aab089b1da9fbd2b48df778a57ef96f5e7d38df", size = 381850, upload-time = "2026-05-28T12:01:56.601Z" }, + { url = "https://files.pythonhosted.org/packages/40/30/32e769839a358f78810c234f160f2cc21d1e4e47e1c0e0e0d535be5a0219/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6142dbd80c4df62a5d899f0d616d417f84e0bc8d32526c8e5589019d75d028a7", size = 387899, upload-time = "2026-05-28T12:01:58.212Z" }, + { url = "https://files.pythonhosted.org/packages/ab/86/ec84d243aadb3b34b71dd26a010d0930b2d284ff5fc9a69fec53810ee6fd/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0b35217adefe87f2fe4db7e9766cabe84744bfe9616d9667be18988928c7f2dc", size = 501618, upload-time = "2026-05-28T12:01:59.888Z" }, + { url = "https://files.pythonhosted.org/packages/74/25/b60e52686bbff777a64f9e4f4d3dd57980dc846913777177a2c92e4937aa/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b95d5e11fc712b752081183a55a244c03cd00570489edd7014d8899f8ceb8162", size = 394003, upload-time = "2026-05-28T12:02:01.482Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c7/b3a6a588cc2219510ef3f42e207483a93950bedd1e3a0fd4015c95cff9e5/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:141c9498daf2ace9eda35d2b0e376f9ea8b058d84f2aef4f96fccfd449a2f251", size = 379778, upload-time = "2026-05-28T12:02:03.197Z" }, + { url = "https://files.pythonhosted.org/packages/31/00/c7dba3fc8a3da8cb3f6db1eb3386be4d79c2e97c6890d20eb9ac66ae8c43/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:6f249f8b860a200ad35193af961183ebe9132710484e6f6ce0cf89fd83c63a9a", size = 392359, upload-time = "2026-05-28T12:02:04.817Z" }, + { url = "https://files.pythonhosted.org/packages/93/dd/472ba494c70753f93745992c99855bee0636daf74e6984e5e003f150316f/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e4abbf391a70be864920858bf360f4fb380577c9a0f732438a1996726e2c195b", size = 412820, upload-time = "2026-05-28T12:02:06.401Z" }, + { url = "https://files.pythonhosted.org/packages/1d/6f/93831a3bfe789542ed0c1d0d74b78b440f055d6dc3ea4640eba2d95e6e23/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:c74005a7bb87752acf351c93897ec63ad77a07a0da7ecad9c050e32e7286ba34", size = 557243, upload-time = "2026-05-28T12:02:08.013Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ff/0b3d604614ffc77522c6b288fdbce68957eb583da1002aa65ba38ac0ee40/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:8213afbe8a3a906fb9acb2014423fe3359ee783d0bf90995f70623a3217bfa6c", size = 623541, upload-time = "2026-05-28T12:02:09.661Z" }, + { url = "https://files.pythonhosted.org/packages/ea/ea/e7b0251441da9adfeaebcf29601d10f2a1455fcf0772fae9e7e19032bd96/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8c43a8a973270fd173bf48cdf80bbe66312421cba68d40845034f174f2389049", size = 586326, upload-time = "2026-05-28T12:02:11.47Z" }, +] + +[[package]] +name = "ruff" +version = "0.15.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/5f7ec371001337d8fa61701c186ff8b613ecac1651848c5950f4c4d5f2e9/ruff-0.15.16.tar.gz", hash = "sha256:d05e78d38c78caf020b03789e25106c93017db5a0cb6e2819885018c61343b78", size = 4714267, upload-time = "2026-06-04T16:33:09.974Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/42/53ef1c3953f157956db9bf7861e3bc50b9b887ce93300aa48cdba8336fe6/ruff-0.15.16-py3-none-linux_armv6l.whl", hash = "sha256:6ac3c0b3969cc6cf6b158c4e2f8f682acb58e7d700d8a44b65ecdc72d66ab0b2", size = 10709025, upload-time = "2026-06-04T16:32:51.935Z" }, + { url = "https://files.pythonhosted.org/packages/93/9a/a79159346f19134a956607754e57d8d128f7a4c00f4ad2f7514d224c172c/ruff-0.15.16-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:197c207ed75ffba54a0dec23db4aa939a27a3053073e085e0042433cbdc58e4a", size = 11063550, upload-time = "2026-06-04T16:32:42.24Z" }, + { url = "https://files.pythonhosted.org/packages/bc/72/3ce2ac000a5299ec238e01f51397b3b653c93b077d9b1bfe8715bb895f20/ruff-0.15.16-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3a39fec45ab316cc23e7558f23fea4a70403ddb5648ea9a4a3854a16973d0071", size = 10421345, upload-time = "2026-06-04T16:32:37.251Z" }, + { url = "https://files.pythonhosted.org/packages/b0/c2/cc7fad3ec9169373f5b6a18f1917b91080feec40c3f9658334a1d28e2f03/ruff-0.15.16-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba93191d79003116b95128c9d306e045200fdbd0bccb782b110f3cd1d4abc5cf", size = 10757217, upload-time = "2026-06-04T16:32:54.722Z" }, + { url = "https://files.pythonhosted.org/packages/69/d2/3474009eaa0a65b31fa7152a2fad5e2f050c640ceb1e6b02ee6922e94c82/ruff-0.15.16-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c6ee4b90520630120ef032aa5cc10db483852dff950e78b1d717e2993a61ac8d", size = 10507035, upload-time = "2026-06-04T16:33:05.343Z" }, + { url = "https://files.pythonhosted.org/packages/ca/81/b7ae6ccbd11f0c8dc3d5d67fc4be9b57ff57ca86ba56152021378e1277f2/ruff-0.15.16-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e4215bc938bc3c8215c1472c1aa437e310fee20cd427335fec9d7e609563628", size = 11255291, upload-time = "2026-06-04T16:32:49.49Z" }, + { url = "https://files.pythonhosted.org/packages/d9/e1/46e526f1a7cc90857ce6ddf25fbb77eb6568651ac38d71b033af07076dd5/ruff-0.15.16-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7c8d26be963b090f10e29abc8b3e74a2a321f6fa34e02424e30b5af89350ecbb", size = 12124922, upload-time = "2026-06-04T16:33:07.821Z" }, + { url = "https://files.pythonhosted.org/packages/1a/da/5c791b088b596b24d0deb967fa28ae02ad751a140c0b9ea81c5ab915d6c0/ruff-0.15.16-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f198cf4123602a2280ed46c307bcbafe41758d6fee5b456b6b6058ca1514b3b4", size = 11332186, upload-time = "2026-06-04T16:33:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/72/11/5da87abe20047c8962361473923ebb2f62b595250126aadfad8c20649c1e/ruff-0.15.16-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb27515fa6240fb586ae82b901a59e67d24acff86f2190b433dc542fe0435aeb", size = 11373541, upload-time = "2026-06-04T16:32:47.007Z" }, + { url = "https://files.pythonhosted.org/packages/fe/2a/8554754c23a854ae3fd6b507e36ad61ddb121e298c6d5d617dec94ed0f14/ruff-0.15.16-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a267c46ba1593fc26b8eecbea050b39d40c0b6bb7781ee11c90a02cd10032951", size = 11353014, upload-time = "2026-06-04T16:32:34.795Z" }, + { url = "https://files.pythonhosted.org/packages/62/25/62ea41529ec89f742ea3fed9cb1059c72877ec7cf9b9e99ac9cf3294d1d9/ruff-0.15.16-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:528c68f39a91498a8d50e91ff5985df3d105782bab49cc378e73ac26bff083e8", size = 10737467, upload-time = "2026-06-04T16:32:26.348Z" }, + { url = "https://files.pythonhosted.org/packages/90/17/334d3ad9de4d40f9dd58fdd09e35ce64553bb501e2f19a839e2fb6be14fc/ruff-0.15.16-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:7ed55c58950df60589a9a7a5d2f8fa5f54ebd287163be805adfe6ee95a9de123", size = 10521910, upload-time = "2026-06-04T16:32:32.54Z" }, + { url = "https://files.pythonhosted.org/packages/4d/bd/3ac7c6ae77a885c1004b3dda2446ea401768d24f851c14b4ad4b24f6639c/ruff-0.15.16-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d482feaf51512b50f9790ceb417a56a61dd1e9d9bf967662b9ed27c01b34f53a", size = 10979190, upload-time = "2026-06-04T16:32:57.492Z" }, + { url = "https://files.pythonhosted.org/packages/33/d7/609546e6a413c3f216fbf2a50c928f97c80939154f6a0503114094a86191/ruff-0.15.16-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:1e15bc8c94513dae2a40cc9ef07c94fdd4ecc9e29dabebeebe170f952322c9e3", size = 11477014, upload-time = "2026-06-04T16:32:44.687Z" }, + { url = "https://files.pythonhosted.org/packages/74/0d/f2cd247ad32633a5c36e97141a2c21b11c6279f7957bc2ff360b1e08fddd/ruff-0.15.16-py3-none-win32.whl", hash = "sha256:580378f7bd4aa25f72e74aa54948a9622f142b1e509521dd10902e886681cc1e", size = 10735541, upload-time = "2026-06-04T16:32:30.145Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9e/02e845ef151b1dee585e55c4739f8e1734ae1d9f1221dff65761c162208b/ruff-0.15.16-py3-none-win_amd64.whl", hash = "sha256:408256017284eddf98fff77b29aa4fb30f586042d535b2d9befc6512f400aaec", size = 11843403, upload-time = "2026-06-04T16:32:39.76Z" }, + { url = "https://files.pythonhosted.org/packages/15/19/016553f86f207450aebebc2b2b5088d086b901cc8186c02ac4284db3bd88/ruff-0.15.16-py3-none-win_arm64.whl", hash = "sha256:8cd61783afb39638a7133ef0d2dfb1e91277593962f81b5a8423eb0b888a6121", size = 11134555, upload-time = "2026-06-04T16:33:00.136Z" }, +] + +[[package]] +name = "secretstorage" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography", marker = "sys_platform != 'darwin' or extra != 'extra-13-torchpfaffian-cpu' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jeepney", marker = "sys_platform != 'darwin' or extra != 'extra-13-torchpfaffian-cpu' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" }, +] + +[[package]] +name = "setuptools" +version = "82.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4f/db/cfac1baf10650ab4d1c111714410d2fbb77ac5a616db26775db562c8fab2/setuptools-82.0.1.tar.gz", hash = "sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9", size = 1152316, upload-time = "2026-03-09T12:47:17.221Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl", hash = "sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb", size = 1006223, upload-time = "2026-03-09T12:47:15.026Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "snowballstemmer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/f8/0a71edf031f03c40db17503cb8ca78a69a171254e568e7db241b0ab57ea1/snowballstemmer-3.1.1.tar.gz", hash = "sha256:e07bbc54a0d798fe6010a12398422e62a8bfbba95c394fd0956ef58cb4d3e260", size = 123314, upload-time = "2026-06-03T00:56:40.194Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/07/2ebca9b11fb9be7340a818d8d6f63feaebb146be2c4afbd6061701d6df6e/snowballstemmer-3.1.1-py3-none-any.whl", hash = "sha256:7e207fa178741da09cdee59d3ecec3827ad5f92b1fc5c9ff3755b639f71f5752", size = 104164, upload-time = "2026-06-03T00:56:38.614Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/47/2c/0a5f6f8ee0d5589e48c7640213ed5175d52cf540a06725b628cc1a45d6ce/soupsieve-2.8.4.tar.gz", hash = "sha256:e121fd02e975c695e4e9e8774a5ee35d74714b59307868dcc5319ad2d9e3328e", size = 121110, upload-time = "2026-05-24T13:55:57.154Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/f5/0c41cb68dcae6b7de4fac4188a3a9589e21fb31df21ea3a2e888db95e6c9/soupsieve-2.8.4-py3-none-any.whl", hash = "sha256:e7e6b0769c8f51ed59acab6e994b00621096cfb1c640a7509295987388fbaf65", size = 37304, upload-time = "2026-05-24T13:55:55.406Z" }, +] + +[[package]] +name = "sphinx" +version = "6.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "alabaster" }, + { name = "babel" }, + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "docutils" }, + { name = "imagesize" }, + { name = "jinja2" }, + { name = "packaging" }, + { name = "pygments" }, + { name = "requests" }, + { name = "snowballstemmer" }, + { name = "sphinxcontrib-applehelp" }, + { name = "sphinxcontrib-devhelp" }, + { name = "sphinxcontrib-htmlhelp" }, + { name = "sphinxcontrib-jsmath" }, + { name = "sphinxcontrib-qthelp" }, + { name = "sphinxcontrib-serializinghtml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0f/6d/392defcc95ca48daf62aecb89550143e97a4651275e62a3d7755efe35a3a/Sphinx-6.2.1.tar.gz", hash = "sha256:6d56a34697bb749ffa0152feafc4b19836c755d90a7c59b72bc7dfd371b9cc6b", size = 6681092, upload-time = "2023-04-25T11:01:40.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/d8/45ba6097c39ba44d9f0e1462fb232e13ca4ddb5aea93a385dcfa964687da/sphinx-6.2.1-py3-none-any.whl", hash = "sha256:97787ff1fa3256a3eef9eda523a63dbf299f7b47e053cfcf684a1c2a8380c912", size = 3024615, upload-time = "2023-04-25T11:01:08.562Z" }, +] + +[[package]] +name = "sphinx-mdinclude" +version = "0.6.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "mistune" }, + { name = "pygments" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b6/a7/c9a7888bb2187fdb06955d71e75f6f266b7e179b356ac76138d160a5b7eb/sphinx_mdinclude-0.6.2.tar.gz", hash = "sha256:447462e82cb8be61404a2204227f920769eb923d2f57608e3325f3bb88286b4c", size = 65257, upload-time = "2024-08-03T19:07:37.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/3d/6b41fe1637cd53c4b10d56e0e6f396546f837973dabf9c4b2a1de44620ac/sphinx_mdinclude-0.6.2-py3-none-any.whl", hash = "sha256:648e78edb067c0e4bffc22943278d49d54a0714494743592032fa3ad82a86984", size = 16911, upload-time = "2024-08-03T19:07:30.406Z" }, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "sphinx" }, + { name = "sphinxcontrib-jquery" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/84/68/a1bfbf38c0f7bccc9b10bbf76b94606f64acb1552ae394f0b8285bfaea25/sphinx_rtd_theme-3.1.0.tar.gz", hash = "sha256:b44276f2c276e909239a4f6c955aa667aaafeb78597923b1c60babc76db78e4c", size = 7620915, upload-time = "2026-01-12T16:03:31.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/c7/b5c8015d823bfda1a346adb2c634a2101d50bb75d421eb6dcb31acd25ebc/sphinx_rtd_theme-3.1.0-py2.py3-none-any.whl", hash = "sha256:1785824ae8e6632060490f67cf3a72d404a85d2d9fc26bce3619944de5682b89", size = 7655617, upload-time = "2026-01-12T16:03:28.101Z" }, +] + +[[package]] +name = "sphinx-theme" +version = "1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/3e/72404596274be91bcf809bf502f4c06c96a78c9c4791f0bb3df0f44b08b8/sphinx_theme-1.0.tar.gz", hash = "sha256:6a763f2568bb320b9296a1694a2e29ad8341930fc54471b19a38b080e644f3a2", size = 3690298, upload-time = "2017-01-05T02:54:24.817Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/99/aa60497585a4fad7a6b46e9493e146217ef7080712aa6141f6903139b027/sphinx_theme-1.0-py2.py3-none-any.whl", hash = "sha256:42691f1fa370b719a9456a484e8d7573259d4d62cc06866885f3988eba9edb70", size = 5549882, upload-time = "2017-01-05T02:54:11.844Z" }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, +] + +[[package]] +name = "sphinxcontrib-bibtex" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "pybtex" }, + { name = "pybtex-docutils" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/54/94fbcd5eb0532eaa91580d09795c4b6c562b72d5638c2ed5b5cc31d2b1f8/sphinxcontrib-bibtex-2.5.0.tar.gz", hash = "sha256:71b42e5db0e2e284f243875326bf9936aa9a763282277d75048826fef5b00eaa", size = 113310, upload-time = "2022-08-22T13:16:46.025Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/17/3be04de2ed752996654895558db01a30d64759b2c7120e7692402b8d4e19/sphinxcontrib_bibtex-2.5.0-py3-none-any.whl", hash = "sha256:748f726eaca6efff7731012103417ef130ecdcc09501b4d0c54283bf5f059f76", size = 39752, upload-time = "2022-08-22T13:16:43.376Z" }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/de/f3/aa67467e051df70a6330fe7770894b3e4f09436dea6881ae0b4f3d87cad8/sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a", size = 122331, upload-time = "2023-03-14T15:01:01.944Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", size = 121104, upload-time = "2023-03-14T15:01:00.356Z" }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, +] + +[[package]] +name = "sqlalchemy" +version = "2.0.50" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/57/da/6fbf010c8ebb347679d0d100b22fe9ba5e13fd04046c5df7280d2f0bf706/sqlalchemy-2.0.50.tar.gz", hash = "sha256:af5607d11ef90fd6a5c0549fe0045dce1663d427426bcfb506dcb5346a85a3b9", size = 9907424, upload-time = "2026-05-24T19:20:04.018Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/a9/812a775bd8c1af0966d660238d005baf25e9bced1f038c8e71f00aa637a7/sqlalchemy-2.0.50-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7af6eeb84985bf840ba779018ff9424d61ff69b52e66b8789d3c8da7bf5341b2", size = 2161617, upload-time = "2026-05-24T20:00:00.761Z" }, + { url = "https://files.pythonhosted.org/packages/d5/74/5a6bc5496e9be8f740fbf80f9e6bd4ab965c8a80870eb07ab015e360957a/sqlalchemy-2.0.50-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0fe7822866f3a9fc5f3db21a290ce8961a53050115f05edf9402b6a5feb92a9f", size = 3244104, upload-time = "2026-05-24T20:07:38.158Z" }, + { url = "https://files.pythonhosted.org/packages/81/55/b260d8df2adc9bb0bf294f67b5f802ff0d84d99442b536b9efd0ea72d447/sqlalchemy-2.0.50-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8e1b0f6a4dcd9b4839e2320afb5df37a6981cbc20ff9c423ae11c5537bdbd21", size = 3243039, upload-time = "2026-05-24T20:14:23.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/6d/58714005cbf370f16c3f30d30324a43be10069efcfe764f7236a2e851947/sqlalchemy-2.0.50-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e195687f1af431c9515416288373b323b6eb599f774409814e89e9d603a56e39", size = 3195017, upload-time = "2026-05-24T20:07:40.086Z" }, + { url = "https://files.pythonhosted.org/packages/30/e8/67527fee039bd3e1a6ce3f03d2b62fd87ab9099c17052810d79496727b66/sqlalchemy-2.0.50-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ea1a8a2db4b2217d456c8d7a873bfc605f06fe3584d315264ea18c2a17585d0b", size = 3215308, upload-time = "2026-05-24T20:14:26.034Z" }, + { url = "https://files.pythonhosted.org/packages/94/b2/dd3155a6a6706cb89adecf5ee6e0512f7b0ee5cf3e6f4cde67d3c20ebfda/sqlalchemy-2.0.50-cp310-cp310-win32.whl", hash = "sha256:68b154b08088b4ec32bb4d2958bfbb50e57549f91a4cd3e7f928e3553ed69031", size = 2121637, upload-time = "2026-05-24T20:08:06.401Z" }, + { url = "https://files.pythonhosted.org/packages/93/a1/a09c463ee3e7764b5ce5bd19a7f0b6eefbde62e637439ab58498cdbd6b47/sqlalchemy-2.0.50-cp310-cp310-win_amd64.whl", hash = "sha256:66e374271ecb7101273f57af1a62446a953d327eec4f8089147de57c591bbacc", size = 2144673, upload-time = "2026-05-24T20:08:07.936Z" }, + { url = "https://files.pythonhosted.org/packages/b6/5d/3172686af1770e4de2805f919a51441085f589ddadf3dd76ec582f84f497/sqlalchemy-2.0.50-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1aa6e403663a9c43c8fef7ce4bdb4cf48bcd8d352e91deda2a99f963270bd508", size = 2161366, upload-time = "2026-05-24T20:00:02.061Z" }, + { url = "https://files.pythonhosted.org/packages/0f/90/e98dedea3c3e663a17afcd003a34ba45efdac2cea3b6f2e4585e2b1e2537/sqlalchemy-2.0.50-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51b637a84f9fa35ae1f9017e786cb142974a25305085e1b378b3647a67f65ad3", size = 3318926, upload-time = "2026-05-24T20:07:42.369Z" }, + { url = "https://files.pythonhosted.org/packages/3b/4f/501308c2babb62c11753ecb4ee88ba9eef019419a4d6cbf7cb13e2bad353/sqlalchemy-2.0.50-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2dab927761d9108550f0cf8e66ff21af56f907a0ce0a689793db615e2b55f62c", size = 3319199, upload-time = "2026-05-24T20:14:28.551Z" }, + { url = "https://files.pythonhosted.org/packages/ac/39/d88996c5e03ed6248c3a788d20f0b8d8b376b9f8a495e4bab9df7c72d2f8/sqlalchemy-2.0.50-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:545eae198d37bcf837a10ede3684e2af32458d6f35c597c35c2de7502dc38fc4", size = 3270301, upload-time = "2026-05-24T20:07:44.917Z" }, + { url = "https://files.pythonhosted.org/packages/42/1b/1ae0e65161b51cc43e5ca75430ef79d80e23b5042d645586c2c342c3b92e/sqlalchemy-2.0.50-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0fec460e18cdbb4c7773531122ce9a27e96c6ca17af3933941d94da475ad2c86", size = 3293465, upload-time = "2026-05-24T20:14:30.501Z" }, + { url = "https://files.pythonhosted.org/packages/83/29/17c0003f2c0dfa6d1b97672475707e3ec5980db09defd7fa20beb6833bbd/sqlalchemy-2.0.50-cp311-cp311-win32.whl", hash = "sha256:e6e814658818fd165e749e3d8490ef16cc7f379a118c37ada8b0589ffbaaac22", size = 2120694, upload-time = "2026-05-24T20:08:09.237Z" }, + { url = "https://files.pythonhosted.org/packages/c9/18/280d00654cc19d1fccf236fa5070f6dd04b84dde6f1b2e637bde0ff340a7/sqlalchemy-2.0.50-cp311-cp311-win_amd64.whl", hash = "sha256:1c5f858fe79c9f5d8fda065c06186356acb7f8df3cd52dbd5ee3f200e4b144f5", size = 2145315, upload-time = "2026-05-24T20:08:10.952Z" }, + { url = "https://files.pythonhosted.org/packages/be/b0/a9d19b43f38f878b1278bca5b00b909f7540d41494396dd2561f9ad0956d/sqlalchemy-2.0.50-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23ae23d8b9d344d30d0a92f06d45825024a5790f1c1dd4cf452636a50d3e58cb", size = 2159807, upload-time = "2026-05-24T19:27:53.086Z" }, + { url = "https://files.pythonhosted.org/packages/f5/2c/191dd58a248fd2cfd4780fa82c375c505e4ad98c8b522fa69ec492130d77/sqlalchemy-2.0.50-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:47b71b933e7b4ebad407c8fdfd70d2c4f08b78b3238bb30eebdd6eb32ca51b89", size = 3343358, upload-time = "2026-05-24T20:09:29.279Z" }, + { url = "https://files.pythonhosted.org/packages/8a/2b/514fce8a7df81cf5bad7ff7865de7ac0c5776a38cc043475c4703eb7fe8b/sqlalchemy-2.0.50-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:110fdac56ace278949f00de805edacbd6141e382d992f9ba28238b3a0827a600", size = 3357994, upload-time = "2026-05-24T20:17:13.495Z" }, + { url = "https://files.pythonhosted.org/packages/35/a6/a0e283f5494f92b0d77e319ff77e437b1ffe4a051ba67c81d53234825475/sqlalchemy-2.0.50-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0f5e4ac70e9e757f6b3e87c0491ff034442ecd8dfd36d041a50564c322dafc0e", size = 3289399, upload-time = "2026-05-24T20:09:32.239Z" }, + { url = "https://files.pythonhosted.org/packages/b7/96/1b07325ba71752d6a028b77d07bed1483ad545f794e8b1dc89b3ba3b3c68/sqlalchemy-2.0.50-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:724f3dcbe53dd0151e3cb5e7ec4ba4c620bede579caacd16275dc35ce06e8615", size = 3321216, upload-time = "2026-05-24T20:17:15.581Z" }, + { url = "https://files.pythonhosted.org/packages/ed/8e/bad6ed253e8a99edfc99af02f7173ec48a1d3ed1b9b35a1b8bc1700900cc/sqlalchemy-2.0.50-cp312-cp312-win32.whl", hash = "sha256:1208050441471d003b7c8cb4054fb084f185cf35ac3f0ea270803865bca9939a", size = 2119194, upload-time = "2026-05-24T19:50:04.943Z" }, + { url = "https://files.pythonhosted.org/packages/b6/2d/314a6690dda4b9cfc571eab1a63cf6fe6e1470aa3759ccda6aa016ee0f5a/sqlalchemy-2.0.50-cp312-cp312-win_amd64.whl", hash = "sha256:9d1af51558029a156a70986b7df88f042b3d158d7c8d8fb5072912d4b32d89c7", size = 2146186, upload-time = "2026-05-24T19:50:06.74Z" }, + { url = "https://files.pythonhosted.org/packages/0b/c4/c42356b527296e9862f67990efce31ef78b4cf69cd3f80873a528a060320/sqlalchemy-2.0.50-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:06a9210bdc5f4298cff0781087e2ff45683922252dacc452846373a58761f093", size = 2156697, upload-time = "2026-05-24T19:27:54.764Z" }, + { url = "https://files.pythonhosted.org/packages/60/a1/b1a70e3c4365ac7fe9e347f3710f19b562c866fb96d45e3c891588789a7b/sqlalchemy-2.0.50-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b53784972ade4f8174b9aa661f31a06f8a936d2cfdd602913ff3c6dd40ae873", size = 3284260, upload-time = "2026-05-24T20:09:34.195Z" }, + { url = "https://files.pythonhosted.org/packages/3f/4a/f3ac3caa19f263d57b0a47f8c91bbf56583dc2d3fc63acfbf644abb24fe0/sqlalchemy-2.0.50-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31648fa14460537e768a7303b078e4344d208e0d23e06867c1f376a227ed82db", size = 3302280, upload-time = "2026-05-24T20:17:17.825Z" }, + { url = "https://files.pythonhosted.org/packages/66/55/ccada3e3d62254587819749a0bc69f41173eb48a6e385d10e66d32a9c88e/sqlalchemy-2.0.50-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:03f4323c980ad0e918cc9e5369b015f759f4e534db5bbaf4dc36832c10d05064", size = 3231580, upload-time = "2026-05-24T20:09:36.406Z" }, + { url = "https://files.pythonhosted.org/packages/05/f6/6809349130a2de0e109e7f00fd7d431da9565b9b2868b32ee684754f672b/sqlalchemy-2.0.50-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2b9dcc43afef8ac157cd92fce96985d6b8b0cfbd3df4d666f66b4d55a75d202f", size = 3269375, upload-time = "2026-05-24T20:17:20.34Z" }, + { url = "https://files.pythonhosted.org/packages/48/84/278a811ef4e07be9c89dc5cdd7be833268509a66a68c4897cf585e67428f/sqlalchemy-2.0.50-cp313-cp313-win32.whl", hash = "sha256:60922d6599065ddca2c6f376b9aa2f41a6b85a271725e0909490bbc50b1998a5", size = 2117229, upload-time = "2026-05-24T19:50:08.215Z" }, + { url = "https://files.pythonhosted.org/packages/f6/1c/067cc6187ed32d2ec222fe6d2643acc1659a6d0659f8a7cbc5ad3ae83280/sqlalchemy-2.0.50-cp313-cp313-win_amd64.whl", hash = "sha256:287086e67275a212c4582d166a6fb03a65ccc5551d80866270ce0dd9f34eccd3", size = 2143126, upload-time = "2026-05-24T19:50:09.691Z" }, + { url = "https://files.pythonhosted.org/packages/df/32/10ac51b4be7cdecd7e93d069251c86dfbf70b7adbd7c67b48ccea6c49e1c/sqlalchemy-2.0.50-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c966932507a4d7d0a37314927dbfcd89720e3f37d2a1e3352e7ae7939fa8e8a0", size = 2158519, upload-time = "2026-05-24T19:27:56.472Z" }, + { url = "https://files.pythonhosted.org/packages/5a/76/e703d2f7681d7d66c4c891af3f07c7ccf4c76ad7f18351de035b5eda007a/sqlalchemy-2.0.50-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:faffef4bcc20a1892e65e155293d99d60855bbbc79250ab712819cfd56a8e6bb", size = 3282063, upload-time = "2026-05-24T20:09:38.57Z" }, + { url = "https://files.pythonhosted.org/packages/31/26/ef168b184a25701f9995e8fb7e503fafd7a99c1c77cda1bc1a26ea2ed486/sqlalchemy-2.0.50-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c206aec519a2e7bd08abbfb33436e325fd22c632d9c21a9047e376ce241646e", size = 3287069, upload-time = "2026-05-24T20:17:21.942Z" }, + { url = "https://files.pythonhosted.org/packages/c2/15/765acc2bc693bccc43ca4a95d5b69750da8aaf6db1b5c616536e087f8920/sqlalchemy-2.0.50-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bef4ac756363227ef6402a75fee025a4bc690f92328e825868939b3b3a446a6d", size = 3230453, upload-time = "2026-05-24T20:09:40.398Z" }, + { url = "https://files.pythonhosted.org/packages/63/61/08e03c3adbf5db0087a0b6816746fec8f3032fb2f7fc899a9bb9b2a48ce4/sqlalchemy-2.0.50-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:96fbee6b19c19cd1556c8bf9419447cf2ec149ffcab7ab64348c23e54ef8547f", size = 3252413, upload-time = "2026-05-24T20:17:24.067Z" }, + { url = "https://files.pythonhosted.org/packages/03/0c/370a1f2db38436c615e10134c8a37de3688e74084792380695f3f5083860/sqlalchemy-2.0.50-cp314-cp314-win32.whl", hash = "sha256:8f00e3eb43ba30eb1b238ee03a8a62309486d1321eda3328bb611e0340033ad8", size = 2120063, upload-time = "2026-05-24T19:50:11.08Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a0/fe92bb9817863bc13ba093bda931979a26cc2ca69f8e8f26d07add3d7c6f/sqlalchemy-2.0.50-cp314-cp314-win_amd64.whl", hash = "sha256:15708c613cd5005b7dffe1f66ee6a63ee8f5e46799f71c70ebad74178c676a39", size = 2145830, upload-time = "2026-05-24T19:50:12.452Z" }, + { url = "https://files.pythonhosted.org/packages/cc/ff/e5640a98a0b2f491eb8fde10fb6c773621a2e44340de231fafcc9370f4a9/sqlalchemy-2.0.50-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3699dac4be410e97049a1658e9480da9cde956594aa0f3aebc60b88f21c5ba70", size = 2178435, upload-time = "2026-05-24T19:42:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/b7/85/337116e186f1236375b5fb70c21cfac98e8e8ab0d3a47be838dc47a59e08/sqlalchemy-2.0.50-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f96233858e3df43932ac11589e22520da6e8aeb624b03fedfeebb0e8ea213086", size = 3566059, upload-time = "2026-05-24T20:01:20.848Z" }, + { url = "https://files.pythonhosted.org/packages/96/34/bb0e190e161c3c2c24314a65add57218be14a4a9486886b7f5047c1ff7c8/sqlalchemy-2.0.50-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c4e70c46fad30c3bcc6a4708bc0130a3173e11a5b25f0ea4a9d8911b450f1f52", size = 3535366, upload-time = "2026-05-24T20:03:56.768Z" }, + { url = "https://files.pythonhosted.org/packages/df/5a/a7f759f97e4fd499c5d4e4488c760d5a7fbecf3028b465a04274fcd52384/sqlalchemy-2.0.50-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1918a3cf564d16d95bca7301005f41ab2ad50b07cd3b9da50d3ed986db148d6a", size = 3474879, upload-time = "2026-05-24T20:01:23.058Z" }, + { url = "https://files.pythonhosted.org/packages/9d/d9/2907ea38eb60687d297bf9c39e5ee58053c87b57fe8a9cae97090cecbf10/sqlalchemy-2.0.50-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b00098cdbdbd38c7be3d568b0c9c3122b8c0ec62b911b57cd5e6e0254d60a76d", size = 3486117, upload-time = "2026-05-24T20:03:59.052Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e3/5aa06f167559f8c0bdae487e297d23ba548150ab016a3418265d617a4985/sqlalchemy-2.0.50-cp314-cp314t-win32.whl", hash = "sha256:1fbd55a969d7ac44a98e3dec75016074f809fa08f871585ace58dde110d1bf3e", size = 2150823, upload-time = "2026-05-24T20:08:58.644Z" }, + { url = "https://files.pythonhosted.org/packages/65/9b/112fb8f977582d7489d036e409e3723948bcf5320b3ac465f3c481bbe8f9/sqlalchemy-2.0.50-cp314-cp314t-win_amd64.whl", hash = "sha256:c5c3cdb753a9004183e1ccb634b41611654c989e61bc68617ce878e46d6f1e51", size = 2185794, upload-time = "2026-05-24T20:09:00.319Z" }, + { url = "https://files.pythonhosted.org/packages/d0/10/f7220e9b784d295d241c86ed99aeb537f92afcd469a64861f2717e9bb077/sqlalchemy-2.0.50-py3-none-any.whl", hash = "sha256:92064363517a3ff8212b5a93b8c62876579d8dfd1ca5b561335f30152d884fa9", size = 1943861, upload-time = "2026-05-24T19:59:01.119Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "tabulate" +version = "0.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", hash = "sha256:e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d", size = 91754, upload-time = "2026-03-04T18:55:34.402Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", hash = "sha256:f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3", size = 39814, upload-time = "2026-03-04T18:55:31.284Z" }, +] + +[[package]] +name = "tinycss2" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", hash = "sha256:d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957", size = 88195, upload-time = "2025-11-23T10:29:10.082Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", hash = "sha256:3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661", size = 28404, upload-time = "2025-11-23T10:29:08.676Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "torch" +version = "2.10.0" +source = { registry = "https://download.pytorch.org/whl/cpu" } +resolution-markers = [ + "python_full_version >= '3.12' and sys_platform == 'darwin'", + "python_full_version == '3.11.*' and sys_platform == 'darwin'", + "python_full_version < '3.11' and sys_platform == 'darwin'", +] +dependencies = [ + { name = "filelock", marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "fsspec", marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jinja2", marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "setuptools", marker = "(python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (python_full_version < '3.12' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.12' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.12' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "sympy", marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-1-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:4db72a4d257c45c3502f11764ee41460a87312fdc3dff47a8957812efe961725", upload-time = "2026-02-06T16:27:14Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-1-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:0826ac8e409551e12b2360ac18b4161a838cbd111933e694752f351191331d09", upload-time = "2026-02-06T16:27:14Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:7fbbf409143a4fe0812a40c0b46a436030a7e1d14fe8c5234dfbe44df47f617e", upload-time = "2026-02-06T16:27:14Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-1-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:b39cafff7229699f9d6e172cac74d85fd71b568268e439e08d9c540e54732a3e", upload-time = "2026-02-06T16:27:17Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-2-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:7417ef370d7c3969dd509dae8d5c7daeb945af335ab76dd38358ba30a91251c1", upload-time = "2026-02-10T19:55:42Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-2-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:90821a3194b8806d9fa9fdaa9308c1bc73df0c26808274b14129a97c99f35794", upload-time = "2026-02-10T19:55:42Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-2-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:358bd7125cbec6e692d60618a5eec7f55a51b29e3652a849fd42af021d818023", upload-time = "2026-02-10T19:55:42Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-2-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:470de4176007c2700735e003a830828a88d27129032a3add07291da07e2a94e8", upload-time = "2026-02-10T19:55:43Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:2d16abfce6c92584ceeb00c3b2665d5798424dd9ed235ea69b72e045cd53ae97", upload-time = "2026-01-23T15:09:55Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:4584ab167995c0479f6821e3dceaf199c8166c811d3adbba5d8eedbbfa6764fd", upload-time = "2026-01-23T15:09:55Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:45a1c5057629444aeb1c452c18298fa7f30f2f7aeadd4dc41f9d340980294407", upload-time = "2026-01-23T15:09:55Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:339e05502b6c839db40e88720cb700f5a3b50cda332284873e851772d41b2c1e", upload-time = "2026-01-23T15:09:57Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:840351da59cedb7bcbc51981880050813c19ef6b898a7fecf73a3afc71aff3fe", upload-time = "2026-01-23T15:09:59Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:c88b1129fd4e14f0f882963c6728315caae35d2f47374d17edeed1edc7697497", upload-time = "2026-01-23T15:09:59Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:f4bea7dc451267c028593751612ad559299589304e68df54ae7672427893ff2c", upload-time = "2026-01-23T15:10:01Z" }, +] + +[[package]] +name = "torch" +version = "2.10.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] +dependencies = [ + { name = "filelock", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130')" }, + { name = "fsspec", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130')" }, + { name = "jinja2", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "setuptools", marker = "(python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "sympy", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/30/bfebdd8ec77db9a79775121789992d6b3b75ee5494971294d7b4b7c999bc/torch-2.10.0-2-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:2b980edd8d7c0a68c4e951ee1856334a43193f98730d97408fbd148c1a933313", size = 79411457, upload-time = "2026-02-10T21:44:59.189Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8b/4b61d6e13f7108f36910df9ab4b58fd389cc2520d54d81b88660804aad99/torch-2.10.0-2-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:418997cb02d0a0f1497cf6a09f63166f9f5df9f3e16c8a716ab76a72127c714f", size = 79423467, upload-time = "2026-02-10T21:44:48.711Z" }, + { url = "https://files.pythonhosted.org/packages/d3/54/a2ba279afcca44bbd320d4e73675b282fcee3d81400ea1b53934efca6462/torch-2.10.0-2-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:13ec4add8c3faaed8d13e0574f5cd4a323c11655546f91fbe6afa77b57423574", size = 79498202, upload-time = "2026-02-10T21:44:52.603Z" }, + { url = "https://files.pythonhosted.org/packages/ec/23/2c9fe0c9c27f7f6cb865abcea8a4568f29f00acaeadfc6a37f6801f84cb4/torch-2.10.0-2-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:e521c9f030a3774ed770a9c011751fb47c4d12029a3d6522116e48431f2ff89e", size = 79498254, upload-time = "2026-02-10T21:44:44.095Z" }, + { url = "https://files.pythonhosted.org/packages/16/ee/efbd56687be60ef9af0c9c0ebe106964c07400eade5b0af8902a1d8cd58c/torch-2.10.0-3-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a1ff626b884f8c4e897c4c33782bdacdff842a165fee79817b1dd549fdda1321", size = 915510070, upload-time = "2026-03-11T14:16:39.386Z" }, + { url = "https://files.pythonhosted.org/packages/36/ab/7b562f1808d3f65414cd80a4f7d4bb00979d9355616c034c171249e1a303/torch-2.10.0-3-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:ac5bdcbb074384c66fa160c15b1ead77839e3fe7ed117d667249afce0acabfac", size = 915518691, upload-time = "2026-03-11T14:15:43.147Z" }, + { url = "https://files.pythonhosted.org/packages/b3/7a/abada41517ce0011775f0f4eacc79659bc9bc6c361e6bfe6f7052a6b9363/torch-2.10.0-3-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:98c01b8bb5e3240426dcde1446eed6f40c778091c8544767ef1168fc663a05a6", size = 915622781, upload-time = "2026-03-11T14:17:11.354Z" }, + { url = "https://files.pythonhosted.org/packages/ab/c6/4dfe238342ffdcec5aef1c96c457548762d33c40b45a1ab7033bb26d2ff2/torch-2.10.0-3-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:80b1b5bfe38eb0e9f5ff09f206dcac0a87aadd084230d4a36eea5ec5232c115b", size = 915627275, upload-time = "2026-03-11T14:16:11.325Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f0/72bf18847f58f877a6a8acf60614b14935e2f156d942483af1ffc081aea0/torch-2.10.0-3-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:46b3574d93a2a8134b3f5475cfb98e2eb46771794c57015f6ad1fb795ec25e49", size = 915523474, upload-time = "2026-03-11T14:17:44.422Z" }, + { url = "https://files.pythonhosted.org/packages/f4/39/590742415c3030551944edc2ddc273ea1fdfe8ffb2780992e824f1ebee98/torch-2.10.0-3-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:b1d5e2aba4eb7f8e87fbe04f86442887f9167a35f092afe4c237dfcaaef6e328", size = 915632474, upload-time = "2026-03-11T14:15:13.666Z" }, + { url = "https://files.pythonhosted.org/packages/b6/8e/34949484f764dde5b222b7fe3fede43e4a6f0da9d7f8c370bb617d629ee2/torch-2.10.0-3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:0228d20b06701c05a8f978357f657817a4a63984b0c90745def81c18aedfa591", size = 915523882, upload-time = "2026-03-11T14:14:46.311Z" }, + { url = "https://files.pythonhosted.org/packages/0c/1a/c61f36cfd446170ec27b3a4984f072fd06dab6b5d7ce27e11adb35d6c838/torch-2.10.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:5276fa790a666ee8becaffff8acb711922252521b28fbce5db7db5cf9cb2026d", size = 145992962, upload-time = "2026-01-21T16:24:14.04Z" }, + { url = "https://files.pythonhosted.org/packages/b5/60/6662535354191e2d1555296045b63e4279e5a9dbad49acf55a5d38655a39/torch-2.10.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:aaf663927bcd490ae971469a624c322202a2a1e68936eb952535ca4cd3b90444", size = 915599237, upload-time = "2026-01-21T16:23:25.497Z" }, + { url = "https://files.pythonhosted.org/packages/40/b8/66bbe96f0d79be2b5c697b2e0b187ed792a15c6c4b8904613454651db848/torch-2.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:a4be6a2a190b32ff5c8002a0977a25ea60e64f7ba46b1be37093c141d9c49aeb", size = 113720931, upload-time = "2026-01-21T16:24:23.743Z" }, + { url = "https://files.pythonhosted.org/packages/76/bb/d820f90e69cda6c8169b32a0c6a3ab7b17bf7990b8f2c680077c24a3c14c/torch-2.10.0-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:35e407430795c8d3edb07a1d711c41cc1f9eaddc8b2f1cc0a165a6767a8fb73d", size = 79411450, upload-time = "2026-01-21T16:25:30.692Z" }, + { url = "https://files.pythonhosted.org/packages/78/89/f5554b13ebd71e05c0b002f95148033e730d3f7067f67423026cc9c69410/torch-2.10.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:3282d9febd1e4e476630a099692b44fdc214ee9bf8ee5377732d9d9dfe5712e4", size = 145992610, upload-time = "2026-01-21T16:25:26.327Z" }, + { url = "https://files.pythonhosted.org/packages/ae/30/a3a2120621bf9c17779b169fc17e3dc29b230c29d0f8222f499f5e159aa8/torch-2.10.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a2f9edd8dbc99f62bc4dfb78af7bf89499bca3d753423ac1b4e06592e467b763", size = 915607863, upload-time = "2026-01-21T16:25:06.696Z" }, + { url = "https://files.pythonhosted.org/packages/6f/3d/c87b33c5f260a2a8ad68da7147e105f05868c281c63d65ed85aa4da98c66/torch-2.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:29b7009dba4b7a1c960260fc8ac85022c784250af43af9fb0ebafc9883782ebd", size = 113723116, upload-time = "2026-01-21T16:25:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/61/d8/15b9d9d3a6b0c01b883787bd056acbe5cc321090d4b216d3ea89a8fcfdf3/torch-2.10.0-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:b7bd80f3477b830dd166c707c5b0b82a898e7b16f59a7d9d42778dd058272e8b", size = 79423461, upload-time = "2026-01-21T16:24:50.266Z" }, + { url = "https://files.pythonhosted.org/packages/cc/af/758e242e9102e9988969b5e621d41f36b8f258bb4a099109b7a4b4b50ea4/torch-2.10.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:5fd4117d89ffd47e3dcc71e71a22efac24828ad781c7e46aaaf56bf7f2796acf", size = 145996088, upload-time = "2026-01-21T16:24:44.171Z" }, + { url = "https://files.pythonhosted.org/packages/23/8e/3c74db5e53bff7ed9e34c8123e6a8bfef718b2450c35eefab85bb4a7e270/torch-2.10.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:787124e7db3b379d4f1ed54dd12ae7c741c16a4d29b49c0226a89bea50923ffb", size = 915711952, upload-time = "2026-01-21T16:23:53.503Z" }, + { url = "https://files.pythonhosted.org/packages/6e/01/624c4324ca01f66ae4c7cd1b74eb16fb52596dce66dbe51eff95ef9e7a4c/torch-2.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:2c66c61f44c5f903046cc696d088e21062644cbe541c7f1c4eaae88b2ad23547", size = 113757972, upload-time = "2026-01-21T16:24:39.516Z" }, + { url = "https://files.pythonhosted.org/packages/c9/5c/dee910b87c4d5c0fcb41b50839ae04df87c1cfc663cf1b5fca7ea565eeaa/torch-2.10.0-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:6d3707a61863d1c4d6ebba7be4ca320f42b869ee657e9b2c21c736bf17000294", size = 79498198, upload-time = "2026-01-21T16:24:34.704Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6f/f2e91e34e3fcba2e3fc8d8f74e7d6c22e74e480bbd1db7bc8900fdf3e95c/torch-2.10.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:5c4d217b14741e40776dd7074d9006fd28b8a97ef5654db959d8635b2fe5f29b", size = 146004247, upload-time = "2026-01-21T16:24:29.335Z" }, + { url = "https://files.pythonhosted.org/packages/98/fb/5160261aeb5e1ee12ee95fe599d0541f7c976c3701d607d8fc29e623229f/torch-2.10.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6b71486353fce0f9714ca0c9ef1c850a2ae766b409808acd58e9678a3edb7738", size = 915716445, upload-time = "2026-01-21T16:22:45.353Z" }, + { url = "https://files.pythonhosted.org/packages/6a/16/502fb1b41e6d868e8deb5b0e3ae926bbb36dab8ceb0d1b769b266ad7b0c3/torch-2.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:c2ee399c644dc92ef7bc0d4f7e74b5360c37cdbe7c5ba11318dda49ffac2bc57", size = 113757050, upload-time = "2026-01-21T16:24:19.204Z" }, + { url = "https://files.pythonhosted.org/packages/1a/0b/39929b148f4824bc3ad6f9f72a29d4ad865bcf7ebfc2fa67584773e083d2/torch-2.10.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:3202429f58309b9fa96a614885eace4b7995729f44beb54d3e4a47773649d382", size = 79851305, upload-time = "2026-01-21T16:24:09.209Z" }, + { url = "https://files.pythonhosted.org/packages/d8/14/21fbce63bc452381ba5f74a2c0a959fdf5ad5803ccc0c654e752e0dbe91a/torch-2.10.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:aae1b29cd68e50a9397f5ee897b9c24742e9e306f88a807a27d617f07adb3bd8", size = 146005472, upload-time = "2026-01-21T16:22:29.022Z" }, + { url = "https://files.pythonhosted.org/packages/54/fd/b207d1c525cb570ef47f3e9f836b154685011fce11a2f444ba8a4084d042/torch-2.10.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6021db85958db2f07ec94e1bc77212721ba4920c12a18dc552d2ae36a3eb163f", size = 915612644, upload-time = "2026-01-21T16:21:47.019Z" }, + { url = "https://files.pythonhosted.org/packages/36/53/0197f868c75f1050b199fe58f9bf3bf3aecac9b4e85cc9c964383d745403/torch-2.10.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff43db38af76fda183156153983c9a096fc4c78d0cd1e07b14a2314c7f01c2c8", size = 113997015, upload-time = "2026-01-21T16:23:00.767Z" }, + { url = "https://files.pythonhosted.org/packages/0e/13/e76b4d9c160e89fff48bf16b449ea324bda84745d2ab30294c37c2434c0d/torch-2.10.0-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:cdf2a523d699b70d613243211ecaac14fe9c5df8a0b0a9c02add60fb2a413e0f", size = 79498248, upload-time = "2026-01-21T16:23:09.315Z" }, + { url = "https://files.pythonhosted.org/packages/4f/93/716b5ac0155f1be70ed81bacc21269c3ece8dba0c249b9994094110bfc51/torch-2.10.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:bf0d9ff448b0218e0433aeb198805192346c4fd659c852370d5cc245f602a06a", size = 79464992, upload-time = "2026-01-21T16:23:05.162Z" }, + { url = "https://files.pythonhosted.org/packages/69/2b/51e663ff190c9d16d4a8271203b71bc73a16aa7619b9f271a69b9d4a936b/torch-2.10.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:233aed0659a2503b831d8a67e9da66a62c996204c0bba4f4c442ccc0c68a3f60", size = 146018567, upload-time = "2026-01-21T16:22:23.393Z" }, + { url = "https://files.pythonhosted.org/packages/5e/cd/4b95ef7f293b927c283db0b136c42be91c8ec6845c44de0238c8c23bdc80/torch-2.10.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:682497e16bdfa6efeec8cde66531bc8d1fbbbb4d8788ec6173c089ed3cc2bfe5", size = 915721646, upload-time = "2026-01-21T16:21:16.983Z" }, + { url = "https://files.pythonhosted.org/packages/56/97/078a007208f8056d88ae43198833469e61a0a355abc0b070edd2c085eb9a/torch-2.10.0-cp314-cp314-win_amd64.whl", hash = "sha256:6528f13d2a8593a1a412ea07a99812495bec07e9224c28b2a25c0a30c7da025c", size = 113752373, upload-time = "2026-01-21T16:22:13.471Z" }, + { url = "https://files.pythonhosted.org/packages/d8/94/71994e7d0d5238393df9732fdab607e37e2b56d26a746cb59fdb415f8966/torch-2.10.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:f5ab4ba32383061be0fb74bda772d470140a12c1c3b58a0cfbf3dae94d164c28", size = 79850324, upload-time = "2026-01-21T16:22:09.494Z" }, + { url = "https://files.pythonhosted.org/packages/e2/65/1a05346b418ea8ccd10360eef4b3e0ce688fba544e76edec26913a8d0ee0/torch-2.10.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:716b01a176c2a5659c98f6b01bf868244abdd896526f1c692712ab36dbaf9b63", size = 146006482, upload-time = "2026-01-21T16:22:18.42Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b9/5f6f9d9e859fc3235f60578fa64f52c9c6e9b4327f0fe0defb6de5c0de31/torch-2.10.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:d8f5912ba938233f86361e891789595ff35ca4b4e2ac8fe3670895e5976731d6", size = 915613050, upload-time = "2026-01-21T16:20:49.035Z" }, + { url = "https://files.pythonhosted.org/packages/66/4d/35352043ee0eaffdeff154fad67cd4a31dbed7ff8e3be1cc4549717d6d51/torch-2.10.0-cp314-cp314t-win_amd64.whl", hash = "sha256:71283a373f0ee2c89e0f0d5f446039bdabe8dbc3c9ccf35f0f784908b0acd185", size = 113995816, upload-time = "2026-01-21T16:22:05.312Z" }, +] + +[[package]] +name = "torch" +version = "2.10.0+cpu" +source = { registry = "https://download.pytorch.org/whl/cpu" } +resolution-markers = [ + "python_full_version >= '3.12' and sys_platform != 'darwin'", + "python_full_version == '3.11.*' and sys_platform != 'darwin'", + "python_full_version < '3.11' and sys_platform != 'darwin'", +] +dependencies = [ + { name = "filelock", marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "fsspec", marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jinja2", marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "setuptools", marker = "(python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (python_full_version < '3.12' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.12' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.12' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "sympy", marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-linux_aarch64.whl", hash = "sha256:31ae44836c8b9bbd1a3943d29c7c7457709ddf7c6173aa34aefe9d2203e4c405", upload-time = "2026-01-23T15:10:02Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-linux_s390x.whl", hash = "sha256:beadc2a6a1785b09a46daad378de91ef274b8d3eea7af0bc2d017d97f115afdf", upload-time = "2026-01-23T15:10:03Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:d63ee6a80982fd73fe44bb70d97d2976e010312ff6db81d7bfb9167b06dd45b9", upload-time = "2026-01-23T15:10:05Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a280ffaea7b9c828e0c1b9b3bd502d9b6a649dc9416997b69b84544bd469f215", upload-time = "2026-01-23T15:10:07Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp310-cp310-win_amd64.whl", hash = "sha256:6c6f0df770144907092a0d067048d96ed4f278a6c840376d2ff0e27e7579b925", upload-time = "2026-01-23T15:10:09Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-linux_aarch64.whl", hash = "sha256:ce5c113d1f55f8c1f5af05047a24e50d11d293e0cbbb5bf7a75c6c761edd6eaa", upload-time = "2026-01-23T15:10:11Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-linux_s390x.whl", hash = "sha256:0e286fcf6ce0cc7b204396c9b4ea0d375f1f0c3e752f68ce3d3aeb265511db8c", upload-time = "2026-01-23T15:10:12Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:1cfcb9b1558c6e52dffd0d4effce83b13c5ae5d97338164c372048c21f9cfccb", upload-time = "2026-01-23T15:10:15Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:b7cb1ec66cefb90fd7b676eac72cfda3b8d4e4d0cacd7a531963bc2e0a9710ab", upload-time = "2026-01-23T15:10:15Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-win_amd64.whl", hash = "sha256:17a09465bab2aab8f0f273410297133d8d8fb6dd84dccbd252ca4a4f3a111847", upload-time = "2026-01-23T15:10:19Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp311-cp311-win_arm64.whl", hash = "sha256:c35c0de592941d4944698dbfa87271ab85d3370eca3b694943a2ab307ac34b3f", upload-time = "2026-01-23T15:10:20Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-linux_aarch64.whl", hash = "sha256:8de5a36371b775e2d4881ed12cc7f2de400b1ad3d728aa74a281f649f87c9b8c", upload-time = "2026-01-23T15:10:22Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-linux_s390x.whl", hash = "sha256:9accc30b56cb6756d4a9d04fcb8ebc0bb68c7d55c1ed31a8657397d316d31596", upload-time = "2026-01-23T15:10:24Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:179451716487f8cb09b56459667fa1f5c4c0946c1e75fbeae77cfc40a5768d87", upload-time = "2026-01-23T15:10:25Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ee40b8a4b4b2cf0670c6fd4f35a7ef23871af956fecb238fbf5da15a72650b1d", upload-time = "2026-01-23T15:10:27Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-win_amd64.whl", hash = "sha256:21cb5436978ef47c823b7a813ff0f8c2892e266cfe0f1d944879b5fba81bf4e1", upload-time = "2026-01-23T15:10:30Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp312-cp312-win_arm64.whl", hash = "sha256:3eaa727e6a73affa61564d86b9d03191df45c8650d0666bd3d57c8597ef61e78", upload-time = "2026-01-23T15:10:31Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-linux_aarch64.whl", hash = "sha256:fd215f3d0f681905c5b56b0630a3d666900a37fcc3ca5b937f95275c66f9fd9c", upload-time = "2026-01-23T15:10:34Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-linux_s390x.whl", hash = "sha256:170a0623108055be5199370335cf9b41ba6875b3cb6f086db4aee583331a4899", upload-time = "2026-01-23T15:10:35Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:e51994492cdb76edce29da88de3672a3022f9ef0ffd90345436948d4992be2c7", upload-time = "2026-01-23T15:10:37Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:8d316e5bf121f1eab1147e49ad0511a9d92e4c45cc357d1ab0bee440da71a095", upload-time = "2026-01-23T15:10:38Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-win_amd64.whl", hash = "sha256:b719da5af01b59126ac13eefd6ba3dd12d002dc0e8e79b8b365e55267a8189d3", upload-time = "2026-01-23T15:10:41Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313-win_arm64.whl", hash = "sha256:b67d91326e4ed9eccbd6b7d84ed7ffa43f93103aa3f0b24145f3001f3b11b714", upload-time = "2026-01-23T15:10:42Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-linux_aarch64.whl", hash = "sha256:5af75e5f49de21b0bdf7672bc27139bd285f9e8dbcabe2d617a2eb656514ac36", upload-time = "2026-01-23T15:10:44Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-linux_s390x.whl", hash = "sha256:ba51ef01a510baf8fff576174f702c47e1aa54389a9f1fba323bb1a5003ff0bf", upload-time = "2026-01-23T15:10:48Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:0fedcb1a77e8f2aaf7bfd21591bf6d1e0b207473268c9be16b17cb7783253969", upload-time = "2026-01-23T15:10:48Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:106dd1930cb30a4a337366ba3f9b25318ebf940f51fd46f789281dd9e736bdc4", upload-time = "2026-01-23T15:10:50Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp313-cp313t-win_amd64.whl", hash = "sha256:eb1bde1ce198f05c8770017de27e001d404499cf552aaaa014569eff56ca25c0", upload-time = "2026-01-23T15:10:50Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314-linux_aarch64.whl", hash = "sha256:ea2bcc9d1fca66974a71d4bf9a502539283f35d61fcab5a799b4e120846f1e02", upload-time = "2026-01-23T15:10:53Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314-linux_s390x.whl", hash = "sha256:f8294fd2fc6dd8f4435a891a0122307a043b14b21f0dac1bca63c85bfb59e586", upload-time = "2026-01-23T15:10:55Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:a28fdbcfa2fbacffec81300f24dd1bed2b0ccfdbed107a823cff12bc1db070f6", upload-time = "2026-01-23T15:10:56Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:aada8afc068add586464b2a55adb7cc9091eec55caf5320447204741cb6a0604", upload-time = "2026-01-23T15:10:58Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314-win_amd64.whl", hash = "sha256:2adc71fe471e98a608723bfc837f7e1929885ebb912c693597711e139c1cda41", upload-time = "2026-01-23T15:11:01Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314t-linux_aarch64.whl", hash = "sha256:9412bd37b70f5ebd1205242c4ba4cabae35a605947f2b30806d5c9b467936db9", upload-time = "2026-01-23T15:11:03Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314t-linux_s390x.whl", hash = "sha256:e71c476517c33e7db69825a9ff46c7f47a723ec4dac5b2481cff4246d1c632be", upload-time = "2026-01-23T15:11:04Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:23882f8d882460aca809882fc42f5e343bf07585274f929ced00177d1be1eb67", upload-time = "2026-01-23T15:11:07Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:4fcd8b4cc2ae20f2b7749fb275349c55432393868778c2d50a08e81d5ee5591e", upload-time = "2026-01-23T15:11:07Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.10.0%2Bcpu-cp314-cp314t-win_amd64.whl", hash = "sha256:ffc8da9a1341092d6a90cb5b1c1a33cd61abf0fb43f0cd88443c27fa372c26ae", upload-time = "2026-01-23T15:11:10Z" }, +] + +[[package]] +name = "torch" +version = "2.10.0+cu128" +source = { registry = "https://download.pytorch.org/whl/cu128" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] +dependencies = [ + { name = "cuda-bindings", version = "12.9.4", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "filelock", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "fsspec", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jinja2", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cuda-cupti-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cuda-nvrtc-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cuda-runtime-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cudnn-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cufft-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cufile-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-curand-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusolver-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparse-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparselt-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nccl-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvshmem-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvtx-cu12", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "setuptools", marker = "(python_full_version >= '3.12' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "sympy", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "triton", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:e186f57ef1de1aa877943259819468fc6f27efb583b4a91f9215ada7b7f4e6cc", upload-time = "2026-01-21T15:21:34Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:36368507b56eaa51acbd3c96ac8893bb9a86991ffcd0699fea3a1a74a2b8bdcb", upload-time = "2026-01-21T15:21:34Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp310-cp310-win_amd64.whl", hash = "sha256:14d2831b9292c3a9b0d80116451315a08ffe8db745d403d06000bc47165b1f9e", upload-time = "2026-01-21T15:21:34Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:85ed7944655ea6fd69377692e9cbfd7bba28d99696ceae79985e7caa99cf0a95", upload-time = "2026-01-21T15:21:36Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1d01ffaebf64715c0f507a39463149cb19e596ff702bd4bcf862601f2881dabc", upload-time = "2026-01-21T15:21:40Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp311-cp311-win_amd64.whl", hash = "sha256:3523fda6e2cfab2b04ae09b1424681358e508bb3faa11ceb67004113d5e7acad", upload-time = "2026-01-21T15:22:00Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:6f09cdf2415516be028ae82e6b985bcfc3eac37bc52ab401142689f6224516ca", upload-time = "2026-01-21T15:22:03Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:628e89bd5110ced7debee2a57c69959725b7fbc64eab81a39dd70e46c7e28ba5", upload-time = "2026-01-21T15:22:11Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp312-cp312-win_amd64.whl", hash = "sha256:fbde8f6a9ec8c76979a0d14df21c10b9e5cab6f0d106a73ca73e2179bc597cae", upload-time = "2026-01-21T15:22:17Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:bdbcc703382f948e951c063448c9406bf38ce66c41dd698d9e2733fcf96c037a", upload-time = "2026-01-21T15:22:29Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:7b4bd23ed63de97456fcc81c26fea9f02ee02ce1112111c4dac0d8cfe574b23e", upload-time = "2026-01-21T15:22:51Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp313-cp313-win_amd64.whl", hash = "sha256:4d1b0b49c54223c7c04050b49eac141d77b6edbc34aea1dfc74a6fdb661baa8c", upload-time = "2026-01-21T15:22:54Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:f1f8b840c64b645a4bc61a393db48effb9c92b2dc26c8373873911f0750d1ea7", upload-time = "2026-01-21T15:23:28Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:23f58258012bcf1c349cb22af387e33aadca7f83ea617b080e774eb41e4fe8ff", upload-time = "2026-01-21T15:23:31Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp313-cp313t-win_amd64.whl", hash = "sha256:01b216e097b17a5277cfb47c383cdcacf06abeadcb0daca0c76b59e72854c3b6", upload-time = "2026-01-21T15:23:53Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:c42377bc2607e3e1c60da71b792fb507c3938c87fd6edab8b21c59c91473c36d", upload-time = "2026-01-21T15:23:56Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:37d71feea068776855686a1512058df3f19f6f040a151f055aa746601678744f", upload-time = "2026-01-21T15:24:08Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp314-cp314-win_amd64.whl", hash = "sha256:c57017ca29e62271e362fdeee7d20070e254755a5148b30b553d8a10fc83c7ef", upload-time = "2026-01-21T15:24:10Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:777461f50b2daf77e4bdd8e2ad34bdfc5a993bf1bdf2ab9ef39f5edfe4e9c12b", upload-time = "2026-01-21T15:24:20Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7bcba6a7c5f0987a13298b1ca843155dcceceac758fa3c7ccd5c7af4059a1080", upload-time = "2026-01-21T15:24:44Z" }, + { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.10.0%2Bcu128-cp314-cp314t-win_amd64.whl", hash = "sha256:70d89143c956389d4806cb4e5fe0b1129fe0db280e1073288d17fa76c101cba4", upload-time = "2026-01-21T15:24:46Z" }, +] + +[[package]] +name = "torch" +version = "2.10.0+cu130" +source = { registry = "https://download.pytorch.org/whl/cu130" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] +dependencies = [ + { name = "cuda-bindings", version = "13.0.3", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "filelock", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "fsspec", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jinja2", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cuda-cupti", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cuda-nvrtc", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cuda-runtime", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cudnn-cu13", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cufft", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cufile", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-curand", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusolver", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparse", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparselt-cu13", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nccl-cu13", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvshmem-cu13", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvtx", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "setuptools", marker = "(python_full_version >= '3.12' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "sympy", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "triton", marker = "(sys_platform == 'linux' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "typing-extensions", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +wheels = [ + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:adfb2bca94f12a5baca6ccf9aa40d6c5b1259748ebb38938be670b07a24d4e15", upload-time = "2026-01-21T19:02:02Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:0f8566d1b3d8353b7f18d5a15375a00dae89d886bb7d01143bb394f475832286", upload-time = "2026-01-21T19:02:47Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp310-cp310-win_amd64.whl", hash = "sha256:0de43ec229a78a2e80ae8578252f9eb14f898457d1cf2be81c8c91a4108c6c79", upload-time = "2026-01-21T19:00:26Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:ea3239d544b2e569a8f47db5c7fa4fd42a2fe96aefb84bb1eda45ce213020fd2", upload-time = "2026-01-21T19:01:56Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:22cfa45e73f1e8c64f4012737987a727d01d152121b93d196b0ca22f39a3f8e3", upload-time = "2026-01-21T19:02:52Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp311-cp311-win_amd64.whl", hash = "sha256:218ae0f323d5ebe8f2770e46cbfb7bbff9af2c8d192d5187878d0964d43c8b71", upload-time = "2026-01-21T19:00:26Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:4fc8f67637f4c92b989a07d80ffe755e79a3510ca02ebf23ce66396fb277c88d", upload-time = "2026-01-21T19:01:36Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:858f0cbcc78d726fea9499eb3464faa98392fa093845a3262209bd226b7844d6", upload-time = "2026-01-21T19:02:22Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp312-cp312-win_amd64.whl", hash = "sha256:224649fa0ab181ec483cc368e3303dda1760e4ba31bea806b88979f855436aaa", upload-time = "2026-01-21T19:00:27Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:75780283308df9fede371eeda01e9607c8862a1803a2f2f31a08a2c0deaed342", upload-time = "2026-01-21T19:01:39Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:7e0d9922e9e91f780b2761a0c5ebac3c15c9740bab042e1b59149afa6d6474eb", upload-time = "2026-01-21T19:02:26Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp313-cp313-win_amd64.whl", hash = "sha256:48af94af745a9dd9b42be81ea15b56aba981666bcfe10394dceca6d9476a50fa", upload-time = "2026-01-21T19:00:27Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:46699da91f0367d8dfa1b606cb0352aaf190b5853f463010e75ff08f15a94e7d", upload-time = "2026-01-21T19:02:20Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:775d1fff07e302fb669d555a5005f781aa460aa80dff7a512e8e6e723f9def83", upload-time = "2026-01-21T19:02:42Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp313-cp313t-win_amd64.whl", hash = "sha256:b38e5b505b015903a51c2b3f12e50a9f152f92fe7e3992e79f504138cf90601d", upload-time = "2026-01-21T19:01:32Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:18f87ae628c02f095f2e97756e4fa249ceef6ed6e87d5a3c79b5338abf842511", upload-time = "2026-01-21T19:01:38Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:db5a61791b7da3c1aa5a496e64cd72dbd4ef3ef2cbb69680fd45dc255b0da2f3", upload-time = "2026-01-21T19:02:42Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp314-cp314-win_amd64.whl", hash = "sha256:dda35d473dd34cafa0668be176b9ad2cb69b1ff570d0336715a6541e89e27640", upload-time = "2026-01-21T19:00:26Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:7781235583ea06b214075c10fa95f83b9805f06af44efc6e9946808413cff94f", upload-time = "2026-01-21T19:01:59Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:526b737db11d632281795484ec729baae5f193a5a0d76a1f7d822f7897c8b4f5", upload-time = "2026-01-21T19:02:44Z" }, + { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp314-cp314t-win_amd64.whl", hash = "sha256:d5ea18790a18b660d655f6e75a8ca6e8d6298b55fc338f8c921764b94c886743", upload-time = "2026-01-21T19:01:35Z" }, +] + +[[package]] +name = "torchpfaffian" +version = "0.0.1" +source = { editable = "." } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "setuptools" }, + { name = "torch", version = "2.10.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130')" }, + { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "torch", version = "2.10.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" }, marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "torch", version = "2.10.0+cu130", source = { registry = "https://download.pytorch.org/whl/cu130" }, marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, +] + +[package.optional-dependencies] +cpu = [ + { name = "torch", version = "2.10.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +cu128 = [ + { name = "torch", version = "2.10.0+cu128", source = { registry = "https://download.pytorch.org/whl/cu128" } }, +] +cu130 = [ + { name = "torch", version = "2.10.0+cu130", source = { registry = "https://download.pytorch.org/whl/cu130" } }, +] + +[package.dev-dependencies] +dev = [ + { name = "build" }, + { name = "mypy" }, + { name = "nbmake" }, + { name = "pip" }, + { name = "pre-commit" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "pytest-json-report" }, + { name = "pytest-timeout" }, + { name = "pytest-xdist" }, + { name = "ruff" }, + { name = "twine" }, + { name = "wheel" }, +] +docs = [ + { name = "build" }, + { name = "docutils" }, + { name = "groundwork-sphinx-theme" }, + { name = "ipykernel" }, + { name = "karma-sphinx-theme" }, + { name = "matplotlib" }, + { name = "myst-nb" }, + { name = "nbconvert" }, + { name = "sphinx" }, + { name = "sphinx-mdinclude" }, + { name = "sphinx-rtd-theme" }, + { name = "sphinx-theme" }, + { name = "sphinxcontrib-bibtex" }, + { name = "twine" }, + { name = "wheel" }, +] + +[package.metadata] +requires-dist = [ + { name = "numpy", specifier = ">=1.23,<3.0.0" }, + { name = "setuptools", specifier = ">=80.10" }, + { name = "torch", specifier = ">=2.1,<3.0.0" }, + { name = "torch", marker = "extra == 'cpu'", specifier = ">=2.1.2,<3.0.0", index = "https://download.pytorch.org/whl/cpu", conflict = { package = "torchpfaffian", extra = "cpu" } }, + { name = "torch", marker = "extra == 'cu128'", specifier = ">=2.1.2,<3.0.0", index = "https://download.pytorch.org/whl/cu128", conflict = { package = "torchpfaffian", extra = "cu128" } }, + { name = "torch", marker = "extra == 'cu130'", specifier = ">=2.1.2,<3.0.0", index = "https://download.pytorch.org/whl/cu130", conflict = { package = "torchpfaffian", extra = "cu130" } }, +] +provides-extras = ["cpu", "cu128", "cu130"] + +[package.metadata.requires-dev] +dev = [ + { name = "build", specifier = ">=1.4,<2" }, + { name = "mypy", specifier = ">=1.15,<2" }, + { name = "nbmake", specifier = ">=1.5,<2" }, + { name = "pip", specifier = ">=25" }, + { name = "pre-commit", specifier = ">=4.5.1" }, + { name = "pytest", specifier = ">=8.4,<9" }, + { name = "pytest-cov", specifier = ">=6.1,<7" }, + { name = "pytest-json-report", specifier = ">=1.5,<2" }, + { name = "pytest-timeout", specifier = ">=2.4" }, + { name = "pytest-xdist", specifier = ">=3.7,<4" }, + { name = "ruff", specifier = ">=0.9,<1" }, + { name = "twine", specifier = ">=6.1,<7" }, + { name = "wheel", specifier = ">=0.45,<0.46" }, +] +docs = [ + { name = "build", specifier = ">=1.4,<2" }, + { name = "docutils", specifier = ">=0.18,<0.20" }, + { name = "groundwork-sphinx-theme", specifier = ">=1.1,<2" }, + { name = "ipykernel", specifier = ">=6.29,<7" }, + { name = "karma-sphinx-theme", specifier = ">=0.0.8,<0.0.9" }, + { name = "matplotlib", specifier = ">=3.8,<4" }, + { name = "myst-nb", specifier = ">=1.1,<2" }, + { name = "nbconvert", specifier = ">=7.16,<8" }, + { name = "sphinx", specifier = ">=6.2,<6.3" }, + { name = "sphinx-mdinclude", specifier = ">=0.6,<0.7" }, + { name = "sphinx-rtd-theme", specifier = ">=3.0,<4" }, + { name = "sphinx-theme", specifier = "~=1.0" }, + { name = "sphinxcontrib-bibtex", specifier = ">=2.5,<2.6" }, + { name = "twine", specifier = ">=6.1,<7" }, + { name = "wheel", specifier = ">=0.45,<0.46" }, +] + +[[package]] +name = "tornado" +version = "6.5.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/64/24/95ec527ad67b76d59299e5465b3935d05e4294b7e0290a3924b7487df30b/tornado-6.5.7.tar.gz", hash = "sha256:66c513a76cda70d53907bc27cf1447557699c2e95aa48ba27a442ff61c3ddfc2", size = 519252, upload-time = "2026-06-08T17:34:51.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/dc/c7043cab6fed8ae159fc1923ce829ada35c4dbd797d408a43858ffaf9639/tornado-6.5.7-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:148b2eb15c2c765a50796172c1e499649b35f30d2e3c3d3e15913cfa56bfb163", size = 448543, upload-time = "2026-06-08T17:34:38.052Z" }, + { url = "https://files.pythonhosted.org/packages/92/4f/090b1431e5a43df696feceffc268c5383cc079ecb5f08ce58f917109aafe/tornado-6.5.7-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9da38de27f1da3b78a966f0dae12b5a1ea9afe72ca805d84ff06508272ddf100", size = 446707, upload-time = "2026-06-08T17:34:39.594Z" }, + { url = "https://files.pythonhosted.org/packages/37/d8/ef374952fd5da67d4463122c2b8e5a96536ec10b4b339254c6dcde81d01c/tornado-6.5.7-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8d759e71906ee783f8867b93bf26a265743da4c1e2f4a018464c1ba019862972", size = 449774, upload-time = "2026-06-08T17:34:41.204Z" }, + { url = "https://files.pythonhosted.org/packages/35/37/d434c73f4c6e014b745b9b37085f34f40c022f007efff3d7fe65991899f3/tornado-6.5.7-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a46347a18f23fb92b396beebe0fb78f61dda0cc302445202c16203d8a18848b", size = 450745, upload-time = "2026-06-08T17:34:42.531Z" }, + { url = "https://files.pythonhosted.org/packages/b6/2b/56b9aff361d7f1ab728a805ec7d7ea835f8807afa9f5cc690ea0e630efb9/tornado-6.5.7-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7778b30bef919231265e91c69963ce0f49a1e9c07ac900bbe75b19ce2575ba92", size = 450578, upload-time = "2026-06-08T17:34:43.787Z" }, + { url = "https://files.pythonhosted.org/packages/02/30/a7444fb23aa76860a14198fab96ac79f1866b0a6e19e26c4381b0938e50f/tornado-6.5.7-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e726f0c75da7726eec023aa62751ff8878bd2737e34fbdd33b1ae5897d2200f5", size = 449985, upload-time = "2026-06-08T17:34:45.326Z" }, + { url = "https://files.pythonhosted.org/packages/5c/42/5f0e56c01e8d9d36f4e23f367b85ae6cae0c1ecddd5e6977d8388ad27488/tornado-6.5.7-cp39-abi3-win32.whl", hash = "sha256:f8de3bf12d3efdd0cbe7c8887868198f8a91415e3f29fcf258d9b8eb7b1d9ae4", size = 451047, upload-time = "2026-06-08T17:34:46.784Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a4/b393076ffb21b469eec5b328a0534cf03a3b90bfc6b1f09507cdd075d938/tornado-6.5.7-cp39-abi3-win_amd64.whl", hash = "sha256:de942f843533a039ef9fa3d9c88c7cd8a7c94553fb5ad0154270989b3d99a2c4", size = 451485, upload-time = "2026-06-08T17:34:48.248Z" }, + { url = "https://files.pythonhosted.org/packages/71/2e/7b1c769803121b809112cf9a00681c472eae1d80e32d7ec0e0bd61d0d0e1/tornado-6.5.7-cp39-abi3-win_arm64.whl", hash = "sha256:ff934fce95643af5f11efdae618eaa73d469dc588641e5c8d19295a0c65c4796", size = 450506, upload-time = "2026-06-08T17:34:49.702Z" }, +] + +[[package]] +name = "traitlets" +version = "5.15.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/a9/a2584b8313b89f94869ddb3c4074617a691de1812a614d2d50e32ca5a7a6/traitlets-5.15.1.tar.gz", hash = "sha256:7b1c07854fe25acb39e009bae49f11b79ff6cbb2f27999104e9110e7a6b53722", size = 163344, upload-time = "2026-06-03T12:26:06.181Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/8d/1080ee4c231f361b6ce4470d556c8c435b67c7e0753aaa641497ee92f88b/traitlets-5.15.1-py3-none-any.whl", hash = "sha256:770a53705f84b81ac107e83a1b3328ff2dae16094d8fc3cfc004e4b22dfd8e92", size = 85858, upload-time = "2026-06-03T12:26:04.395Z" }, +] + +[[package]] +name = "triton" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/ba/b1b04f4b291a3205d95ebd24465de0e5bf010a2df27a4e58a9b5f039d8f2/triton-3.6.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c723cfb12f6842a0ae94ac307dba7e7a44741d720a40cf0e270ed4a4e3be781", size = 175972180, upload-time = "2026-01-20T16:15:53.664Z" }, + { url = "https://files.pythonhosted.org/packages/8c/f7/f1c9d3424ab199ac53c2da567b859bcddbb9c9e7154805119f8bd95ec36f/triton-3.6.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a6550fae429e0667e397e5de64b332d1e5695b73650ee75a6146e2e902770bea", size = 188105201, upload-time = "2026-01-20T16:00:29.272Z" }, + { url = "https://files.pythonhosted.org/packages/0f/2c/96f92f3c60387e14cc45aed49487f3486f89ea27106c1b1376913c62abe4/triton-3.6.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49df5ef37379c0c2b5c0012286f80174fcf0e073e5ade1ca9a86c36814553651", size = 176081190, upload-time = "2026-01-20T16:16:00.523Z" }, + { url = "https://files.pythonhosted.org/packages/e0/12/b05ba554d2c623bffa59922b94b0775673de251f468a9609bc9e45de95e9/triton-3.6.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8e323d608e3a9bfcc2d9efcc90ceefb764a82b99dea12a86d643c72539ad5d3", size = 188214640, upload-time = "2026-01-20T16:00:35.869Z" }, + { url = "https://files.pythonhosted.org/packages/17/5d/08201db32823bdf77a0e2b9039540080b2e5c23a20706ddba942924ebcd6/triton-3.6.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:374f52c11a711fd062b4bfbb201fd9ac0a5febd28a96fb41b4a0f51dde3157f4", size = 176128243, upload-time = "2026-01-20T16:16:07.857Z" }, + { url = "https://files.pythonhosted.org/packages/ab/a8/cdf8b3e4c98132f965f88c2313a4b493266832ad47fb52f23d14d4f86bb5/triton-3.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74caf5e34b66d9f3a429af689c1c7128daba1d8208df60e81106b115c00d6fca", size = 188266850, upload-time = "2026-01-20T16:00:43.041Z" }, + { url = "https://files.pythonhosted.org/packages/3c/12/34d71b350e89a204c2c7777a9bba0dcf2f19a5bfdd70b57c4dbc5ffd7154/triton-3.6.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:448e02fe6dc898e9e5aa89cf0ee5c371e99df5aa5e8ad976a80b93334f3494fd", size = 176133521, upload-time = "2026-01-20T16:16:13.321Z" }, + { url = "https://files.pythonhosted.org/packages/f9/0b/37d991d8c130ce81a8728ae3c25b6e60935838e9be1b58791f5997b24a54/triton-3.6.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10c7f76c6e72d2ef08df639e3d0d30729112f47a56b0c81672edc05ee5116ac9", size = 188289450, upload-time = "2026-01-20T16:00:49.136Z" }, + { url = "https://files.pythonhosted.org/packages/ce/4e/41b0c8033b503fd3cfcd12392cdd256945026a91ff02452bef40ec34bee7/triton-3.6.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1722e172d34e32abc3eb7711d0025bb69d7959ebea84e3b7f7a341cd7ed694d6", size = 176276087, upload-time = "2026-01-20T16:16:18.989Z" }, + { url = "https://files.pythonhosted.org/packages/35/f8/9c66bfc55361ec6d0e4040a0337fb5924ceb23de4648b8a81ae9d33b2b38/triton-3.6.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d002e07d7180fd65e622134fbd980c9a3d4211fb85224b56a0a0efbd422ab72f", size = 188400296, upload-time = "2026-01-20T16:00:56.042Z" }, + { url = "https://files.pythonhosted.org/packages/49/55/5ecf0dcaa0f2fbbd4420f7ef227ee3cb172e91e5fede9d0ecaddc43363b4/triton-3.6.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef5523241e7d1abca00f1d240949eebdd7c673b005edbbce0aca95b8191f1d43", size = 176138577, upload-time = "2026-01-20T16:16:25.426Z" }, + { url = "https://files.pythonhosted.org/packages/df/3d/9e7eee57b37c80cec63322c0231bb6da3cfe535a91d7a4d64896fcb89357/triton-3.6.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a17a5d5985f0ac494ed8a8e54568f092f7057ef60e1b0fa09d3fd1512064e803", size = 188273063, upload-time = "2026-01-20T16:01:07.278Z" }, + { url = "https://files.pythonhosted.org/packages/48/db/56ee649cab5eaff4757541325aca81f52d02d4a7cd3506776cad2451e060/triton-3.6.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b3a97e8ed304dfa9bd23bb41ca04cdf6b2e617d5e782a8653d616037a5d537d", size = 176274804, upload-time = "2026-01-20T16:16:31.528Z" }, + { url = "https://files.pythonhosted.org/packages/f6/56/6113c23ff46c00aae423333eb58b3e60bdfe9179d542781955a5e1514cb3/triton-3.6.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:46bd1c1af4b6704e554cad2eeb3b0a6513a980d470ccfa63189737340c7746a7", size = 188397994, upload-time = "2026-01-20T16:01:14.236Z" }, +] + +[[package]] +name = "twine" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "id" }, + { name = "keyring", marker = "(platform_machine != 'ppc64le' and platform_machine != 's390x') or (platform_machine == 'ppc64le' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (platform_machine == 'ppc64le' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (platform_machine == 'ppc64le' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (platform_machine == 's390x' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (platform_machine == 's390x' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (platform_machine == 's390x' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "packaging" }, + { name = "readme-renderer" }, + { name = "requests" }, + { name = "requests-toolbelt" }, + { name = "rfc3986" }, + { name = "rich" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e0/a8/949edebe3a82774c1ec34f637f5dd82d1cf22c25e963b7d63771083bbee5/twine-6.2.0.tar.gz", hash = "sha256:e5ed0d2fd70c9959770dce51c8f39c8945c574e18173a7b81802dab51b4b75cf", size = 172262, upload-time = "2025-09-04T15:43:17.255Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/7a/882d99539b19b1490cac5d77c67338d126e4122c8276bf640e411650c830/twine-6.2.0-py3-none-any.whl", hash = "sha256:418ebf08ccda9a8caaebe414433b0ba5e25eb5e4a927667122fbe8f829f985d8", size = 42727, upload-time = "2025-09-04T15:43:15.994Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "virtualenv" +version = "21.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "platformdirs" }, + { name = "python-discovery" }, + { name = "typing-extensions", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/0d/4e93c8e6d1001a75763f87d8f5ecda8ebc7f4aa2153dddfaf4ae8892821a/virtualenv-21.4.2.tar.gz", hash = "sha256:38e6ee0a555615c0ea9da2ac7e9998fe8dc3b911dd33ad8eaad2020957653b0c", size = 7613326, upload-time = "2026-05-31T17:01:22.827Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/c4/557dc082be035381b85fdb2b74e21d3d21b57750b74f2b47a32f3a639ff9/virtualenv-21.4.2-py3-none-any.whl", hash = "sha256:854210ca524a1a4d0d744734f4acbc721c3ffe163b85bbf5d56d14d5ae2f0fae", size = 7594079, upload-time = "2026-05-31T17:01:20.735Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.8.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/b4/51fe890511f0f242d07cb1ebe6a5b6db417262b9d2568b460347c57d95cc/wcwidth-0.8.1.tar.gz", hash = "sha256:faf5b4a5366a72dc49cad48cdf21f52bdf63bdda995178e483ba247ff79089b9", size = 1466072, upload-time = "2026-06-08T05:57:23.146Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/6e/95b0e537de1f4d4301f76f944642c6da50d1511cc7b3d64dc418a66c7509/wcwidth-0.8.1-py3-none-any.whl", hash = "sha256:f453740b1e4a4f3291faa37944c555d71056c4da08d59809b307ef4feba695c8", size = 323092, upload-time = "2026-06-08T05:57:21.413Z" }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, +] + +[[package]] +name = "wheel" +version = "0.45.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8a/98/2d9906746cdc6a6ef809ae6338005b3f21bb568bea3165cfc6a243fdc25c/wheel-0.45.1.tar.gz", hash = "sha256:661e1abd9198507b1409a20c02106d9670b2576e916d58f520316666abca6729", size = 107545, upload-time = "2024-11-23T00:18:23.513Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/2c/87f3254fd8ffd29e4c02732eee68a83a1d3c346ae39bc6822dcbcb697f2b/wheel-0.45.1-py3-none-any.whl", hash = "sha256:708e7481cc80179af0e556bbf0cc00b8444c7321e2700b8d8580231d13017248", size = 72494, upload-time = "2024-11-23T00:18:21.207Z" }, +] + +[[package]] +name = "zipp" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/d8/eab98a517c14134c0b2eb4e2387bc5f457334293ec5d2dd3857ec2966802/zipp-4.1.0.tar.gz", hash = "sha256:4cb57381f544315db7688e976e922a2b18cdb513d21cc194eb42232ba2a3e602", size = 26214, upload-time = "2026-05-18T20:08:57.967Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/13/547360d81e6d88d58492968ffda9f9542854f11310ee556fef14260cc886/zipp-4.1.0-py3-none-any.whl", hash = "sha256:25ad4e16390cd314347dd8f1de67a2ac538ae658ed4ab9db16029c07c188e97f", size = 10238, upload-time = "2026-05-18T20:08:57.045Z" }, +] From 64b86998b374630c67115304e633dad51c8860d6 Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Wed, 10 Jun 2026 14:58:33 -0400 Subject: [PATCH 2/7] Add PfaffianParlettReid strategy and integrate with tests and benchmarks --- README.md | 22 ++ notebooks/strategies_benchmark.ipynb | 285 ++++++++++-------- src/torch_pfaffian/__init__.py | 42 ++- src/torch_pfaffian/strategies/__init__.py | 1 + .../strategies/pfaffian_parlett_reid.py | 94 ++++++ .../test_pfaffian_parlett_reid.py | 143 +++++++++ tests/test_torch_pfaffian.py | 54 +++- 7 files changed, 518 insertions(+), 123 deletions(-) create mode 100644 src/torch_pfaffian/strategies/pfaffian_parlett_reid.py create mode 100644 tests/test_strategies/test_pfaffian_parlett_reid.py diff --git a/README.md b/README.md index e2c9feb..587f923 100644 --- a/README.md +++ b/README.md @@ -45,6 +45,28 @@ Use the `cu128` or `cu130` extra instead of `cpu` to install a CUDA-enabled buil [.github/CONTRIBUTING.md](.github/CONTRIBUTING.md) for the full contribution workflow. +## Usage + +```python +import torch + +from torch_pfaffian import pfaffian + +# Any skew-symmetric matrix of shape (..., 2n, 2n). +matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]]) + +pf = pfaffian(matrix) # signed Pfaffian (default) +magnitude = pfaffian(matrix, sign=False) # |pf|, using the faster det-based path +``` + +`pfaffian()` selects a strategy from the input: `sign=True` (the default) returns the +**signed** Pfaffian via `PfaffianParlettReid`; `sign=False` returns the magnitude using a +determinant-based strategy (`PfaffianFDBPf` when gradients are needed, otherwise +`PfaffianDet`). The `optimize` argument (`"auto"`, `"time"`, `"memory"`) is reserved as a +tie-breaker for future strategies. For explicit strategy selection, use +`get_pfaffian_function(name)`. + + # Important Links - Documentation at [https://MatchCake.github.io/TorchPfaffian/](https://MatchCake.github.io/TorchPfaffian/). - Github at [https://github.com/MatchCake/TorchPfaffian/](https://github.com/MatchCake/TorchPfaffian/). diff --git a/notebooks/strategies_benchmark.ipynb b/notebooks/strategies_benchmark.ipynb index 3742965..01c8469 100644 --- a/notebooks/strategies_benchmark.ipynb +++ b/notebooks/strategies_benchmark.ipynb @@ -9,11 +9,12 @@ "\n", "This notebook benchmarks the available Pfaffian strategies in terms of **time** and **memory** for both the **forward** and **backward** passes.\n", "\n", - "Three strategies are compared:\n", + "Four strategies are compared:\n", "\n", "- `PfaffianFDBPf`: computes the Pfaffian from `sqrt(|det(A)|)` with a custom **analytic** backward. Valid for any skew-symmetric matrix.\n", "- `PfaffianBlockDet`: computes the Pfaffian from the determinant of the upper-right block, with a custom analytic backward.\n", "- `PfaffianDet`: a reference baseline that also computes `pf = sqrt(|det(A)|)` but differentiates straight through `det`/`sqrt` with **plain autograd** (no custom backward), to expose the cost of naive autodiff against the analytic backward of `PfaffianFDBPf`.\n", + "- `PfaffianParlettReid`: computes the **signed** Pfaffian via batched Parlett-Reid skew-tridiagonalization, with a custom analytic backward. Valid for any skew-symmetric matrix.\n", "\n", "Each strategy is invoked through `Strategy.apply(matrix)`.\n", "\n", @@ -49,10 +50,10 @@ "start_time": "2026-06-10T14:25:08.874486863Z" }, "execution": { - "iopub.execute_input": "2026-06-10T14:16:52.667639Z", - "iopub.status.busy": "2026-06-10T14:16:52.667294Z", - "iopub.status.idle": "2026-06-10T14:16:54.207116Z", - "shell.execute_reply": "2026-06-10T14:16:54.205473Z" + "iopub.execute_input": "2026-06-10T18:28:57.150290Z", + "iopub.status.busy": "2026-06-10T18:28:57.149845Z", + "iopub.status.idle": "2026-06-10T18:28:58.931824Z", + "shell.execute_reply": "2026-06-10T18:28:58.929314Z" } }, "outputs": [ @@ -78,8 +79,9 @@ "from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet\n", "from torch_pfaffian.strategies.pfaffian_det import PfaffianDet\n", "from torch_pfaffian.strategies.pfaffian_fdbpf import PfaffianFDBPf\n", + "from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid\n", "\n", - "strategies = [PfaffianFDBPf, PfaffianBlockDet, PfaffianDet]\n", + "strategies = [PfaffianFDBPf, PfaffianBlockDet, PfaffianDet, PfaffianParlettReid]\n", "\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "print(f\"Running benchmarks on device: {device}\")" @@ -105,10 +107,10 @@ "start_time": "2026-06-10T14:25:10.033292322Z" }, "execution": { - "iopub.execute_input": "2026-06-10T14:16:54.210625Z", - "iopub.status.busy": "2026-06-10T14:16:54.210309Z", - "iopub.status.idle": "2026-06-10T14:17:21.107161Z", - "shell.execute_reply": "2026-06-10T14:17:21.105779Z" + "iopub.execute_input": "2026-06-10T18:28:58.937516Z", + "iopub.status.busy": "2026-06-10T18:28:58.937064Z", + "iopub.status.idle": "2026-06-10T18:29:48.414060Z", + "shell.execute_reply": "2026-06-10T18:29:48.412091Z" } }, "outputs": [ @@ -124,116 +126,153 @@ "data": { "text/plain": [ "{'PfaffianFDBPf': {'dimension': [4, 8, 16, 32, 64],\n", - " 'forward_time_mean': [8.39531006931793e-05,\n", - " 8.420960039074998e-05,\n", - " 0.0048694635002902945,\n", - " 0.0038942812007007888,\n", - " 0.005135932300981949],\n", - " 'backward_time_mean': [0.00023082459956640377,\n", - " 0.005614171149136382,\n", - " 0.0037422726509248605,\n", - " 0.0035597407983004813,\n", - " 0.007134951999250916],\n", - " 'forward_memory_mean': [5578.0, 13622.0, 42042.4, 147885.2, 556360.8],\n", - " 'forward_backward_memory_mean': [51952.75,\n", - " 191664.4,\n", - " 741525.9,\n", - " 2922178.35,\n", - " 11609078.25],\n", - " 'forward_time_ci': [9.135929690982144e-06,\n", - " 3.2582327167016847e-06,\n", - " 0.0009277367240195104,\n", - " 0.0012259096343144602,\n", - " 0.0024523398701700883],\n", - " 'backward_time_ci': [1.66414058654275e-05,\n", - " 0.0011459601539736321,\n", - " 0.0012184828913370757,\n", - " 0.0010552649404508374,\n", - " 0.002653286676583563],\n", - " 'forward_memory_ci': [29.3318367720307,\n", - " 24.815081322708405,\n", - " 102.10139647068085,\n", - " 30.656304800154892,\n", - " 40.23282740303128],\n", - " 'forward_backward_memory_ci': [4.743538874367067,\n", - " 21.21989739545609,\n", - " 162.69658520403138,\n", - " 34.345881944220274,\n", - " 52.56864599840158]},\n", + " 'forward_time_mean': [8.19441003841348e-05,\n", + " 8.427420107182115e-05,\n", + " 0.0016809296004794306,\n", + " 0.0010581897498923355,\n", + " 0.005361456051832647],\n", + " 'backward_time_mean': [0.00023227104975376278,\n", + " 0.002127916499011917,\n", + " 0.0017952793492440832,\n", + " 0.0031126482488616604,\n", + " 0.012903559449114255],\n", + " 'forward_memory_mean': [5578.4, 13611.6, 41978.0, 147905.2, 555889.6],\n", + " 'forward_backward_memory_mean': [51983.55,\n", + " 191691.65,\n", + " 741398.7,\n", + " 2922157.3,\n", + " 11608700.75],\n", + " 'forward_time_ci': [8.464542021427269e-06,\n", + " 2.245680630823186e-06,\n", + " 0.0011291846833554554,\n", + " 0.0009377027147125496,\n", + " 0.0025269452616774653],\n", + " 'backward_time_ci': [1.4114582596917043e-05,\n", + " 0.0011233393513818512,\n", + " 0.0009505318621660702,\n", + " 0.0005768491523161676,\n", + " 0.002477009668380689],\n", + " 'forward_memory_ci': [22.753778892630926,\n", + " 25.03830604662005,\n", + " 31.004671159104564,\n", + " 28.73910075874074,\n", + " 798.6774049370949],\n", + " 'forward_backward_memory_ci': [31.201145522155706,\n", + " 49.78397461665328,\n", + " 24.91108095860787,\n", + " 34.73306401080888,\n", + " 827.1162461563606]},\n", " 'PfaffianBlockDet': {'dimension': [4, 8, 16, 32, 64],\n", - " 'forward_time_mean': [7.726129915681667e-05,\n", - " 7.922490076452959e-05,\n", - " 8.57123999594478e-05,\n", - " 0.0034056200998747953,\n", - " 0.0026923404508124803],\n", - " 'backward_time_mean': [0.00013435915170703083,\n", - " 0.0001344478991086362,\n", - " 0.00016380800007027575,\n", - " 0.0020619140501366927,\n", - " 0.00030570419985451733],\n", - " 'forward_memory_mean': [2748.0, 5211.6, 13258.0, 41630.8, 147519.2],\n", - " 'forward_backward_memory_mean': [19599.05,\n", - " 71313.3,\n", - " 274652.7,\n", - " 1091927.6,\n", - " 4345071.7],\n", - " 'forward_time_ci': [3.169456596676188e-06,\n", - " 2.4604736536371967e-06,\n", - " 2.3125298299448165e-06,\n", - " 0.0013217441709651864,\n", - " 0.0012497851096257763],\n", - " 'backward_time_ci': [3.1405466727071304e-06,\n", - " 4.261377559919364e-06,\n", - " 5.229660731091481e-06,\n", - " 0.0011858865161943775,\n", - " 0.00018241185806708765],\n", - " 'forward_memory_ci': [25.777422026179995,\n", - " 22.071778484609798,\n", - " 22.287644535647285,\n", - " 25.872,\n", - " 30.415286129112605],\n", - " 'forward_backward_memory_ci': [84.88650624773861,\n", - " 66.22060255651084,\n", - " 3213.0211251070227,\n", - " 29.615975830977654,\n", - " 39.7277365762723]},\n", + " 'forward_time_mean': [7.536524899478536e-05,\n", + " 8.168975000444334e-05,\n", + " 8.706895059731323e-05,\n", + " 0.001051657000061823,\n", + " 0.0030910207497072406],\n", + " 'backward_time_mean': [0.00013123170065227897,\n", + " 0.00012973640077689196,\n", + " 0.00016013219938031397,\n", + " 0.0010435719996166881,\n", + " 0.006324023650813615],\n", + " 'forward_memory_mean': [2723.6, 5214.8, 13266.4, 41611.2, 147645.6],\n", + " 'forward_backward_memory_mean': [19580.05,\n", + " 71333.8,\n", + " 274744.0,\n", + " 1091919.9,\n", + " 4345076.65],\n", + " 'forward_time_ci': [2.382963388476969e-06,\n", + " 4.810192209058244e-06,\n", + " 2.216715054514603e-06,\n", + " 0.000989355533860999,\n", + " 0.0012347897387763483],\n", + " 'backward_time_ci': [3.8262641104641806e-06,\n", + " 4.803255474678276e-06,\n", + " 5.5969639797145865e-06,\n", + " 0.0008838234319664965,\n", + " 0.003438753836210876],\n", + " 'forward_memory_ci': [17.786335713273353,\n", + " 20.86010780615025,\n", + " 49.00833444908819,\n", + " 23.016706353612392,\n", + " 204.44883327259737],\n", + " 'forward_backward_memory_ci': [85.67800683096168,\n", + " 23.59621336258493,\n", + " 3221.2393824776923,\n", + " 28.76135900456503,\n", + " 30.138708843227537]},\n", " 'PfaffianDet': {'dimension': [4, 8, 16, 32, 64],\n", - " 'forward_time_mean': [2.814660001604352e-05,\n", - " 3.418759915803093e-05,\n", - " 0.004134788549345103,\n", - " 0.002652941150518018,\n", - " 0.00029987425114086363],\n", - " 'backward_time_mean': [0.0001211243503348669,\n", - " 0.0001411523018759908,\n", - " 5.7608549832366406e-05,\n", - " 0.00020152409961156082,\n", - " 0.0013275362496642628],\n", - " 'forward_memory_mean': [5464.4, 13483.2, 41928.4, 147770.4, 556153.2],\n", - " 'forward_backward_memory_mean': [39437.6,\n", - " 143664.2,\n", - " 554873.8,\n", - " 2188320.6,\n", - " 8699278.2],\n", - " 'forward_time_ci': [1.2732541170077155e-06,\n", - " 1.207109827186109e-06,\n", - " 0.0013741837643709278,\n", - " 0.0012392837411897722,\n", - " 0.00019687483453382923],\n", - " 'backward_time_ci': [2.5277217525177566e-06,\n", - " 5.454397998524737e-06,\n", - " 3.565945106097614e-05,\n", - " 0.00010193383971478204,\n", - " 0.00023040019338968858],\n", - " 'forward_memory_ci': [45.91907264788897,\n", - " 16.69521850237682,\n", - " 96.97527751795408,\n", - " 35.6852606931327,\n", - " 52.39233383857443],\n", - " 'forward_backward_memory_ci': [34.74130008778419,\n", - " 29.6061432600878,\n", - " 34.246935795314904,\n", - " 22.767103951003282,\n", - " 46.1319567830325]}}" + " 'forward_time_mean': [2.7452500944491476e-05,\n", + " 3.323840064695105e-05,\n", + " 0.0030790316999627977,\n", + " 0.0011021415502909804,\n", + " 0.006700940999871818],\n", + " 'backward_time_mean': [0.00011822484812000767,\n", + " 0.00013786099952994846,\n", + " 7.422215057886205e-05,\n", + " 0.00021711385052185505,\n", + " 0.010118925800998112],\n", + " 'forward_memory_mean': [5474.4, 13592.0, 41974.4, 147907.6, 556191.6],\n", + " 'forward_backward_memory_mean': [39396.2,\n", + " 143663.4,\n", + " 554896.2,\n", + " 2188359.4,\n", + " 8699330.8],\n", + " 'forward_time_ci': [7.673390919607909e-07,\n", + " 6.508977938745037e-07,\n", + " 0.001357923285875625,\n", + " 0.0009910804802474268,\n", + " 0.002612952285009407],\n", + " 'backward_time_ci': [1.715318349795078e-06,\n", + " 2.787178566221051e-06,\n", + " 3.343727478213894e-05,\n", + " 5.718054199953334e-05,\n", + " 0.01537962685569311],\n", + " 'forward_memory_ci': [34.72965841891821,\n", + " 116.32493321906979,\n", + " 140.6037246313572,\n", + " 201.347302913987,\n", + " 48.86786225386945],\n", + " 'forward_backward_memory_ci': [20.986697260282213,\n", + " 36.11274280419732,\n", + " 26.498217234968443,\n", + " 24.186415047338144,\n", + " 56.134791883371875]},\n", + " 'PfaffianParlettReid': {'dimension': [4, 8, 16, 32, 64],\n", + " 'forward_time_mean': [0.00031870675047684927,\n", + " 0.000636430950180511,\n", + " 0.0012928810996527319,\n", + " 0.0029040752007858826,\n", + " 0.016739764450176154],\n", + " 'backward_time_mean': [0.00017804684939619618,\n", + " 0.00021267364973027726,\n", + " 0.0027132313498441363,\n", + " 0.001959291399543872,\n", + " 0.0029937632993096487],\n", + " 'forward_memory_mean': [20622.8, 122692.8, 765880.4, 5172721.2, 37501890.8],\n", + " 'forward_backward_memory_mean': [39608.05,\n", + " 197338.1,\n", + " 1060746.6,\n", + " 6354729.6,\n", + " 42229875.6],\n", + " 'forward_time_ci': [4.911558318167587e-06,\n", + " 8.587527833854176e-06,\n", + " 5.860907011414913e-06,\n", + " 2.5366709316864834e-05,\n", + " 0.010716846098876317],\n", + " 'backward_time_ci': [6.21511470335741e-06,\n", + " 1.0905227890774133e-05,\n", + " 0.0010337452666681617,\n", + " 0.0005962628235559577,\n", + " 0.0012720487914115043],\n", + " 'forward_memory_ci': [96.49907124069014,\n", + " 342.5005761974408,\n", + " 1175.5182089575374,\n", + " 3898.9206156280306,\n", + " 10989.713335854474],\n", + " 'forward_backward_memory_ci': [142.66021515917868,\n", + " 353.63072961137533,\n", + " 1498.4527544662792,\n", + " 3967.4019035878932,\n", + " 11436.580473705424]}}" ] }, "execution_count": 2, @@ -260,18 +299,24 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "e414240b2fc6064e", "metadata": { "ExecuteTime": { "end_time": "2026-06-10T14:25:48.810201185Z", "start_time": "2026-06-10T14:25:47.642776418Z" + }, + "execution": { + "iopub.execute_input": "2026-06-10T18:29:48.418076Z", + "iopub.status.busy": "2026-06-10T18:29:48.417741Z", + "iopub.status.idle": "2026-06-10T18:29:49.863382Z", + "shell.execute_reply": "2026-06-10T18:29:49.862404Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/src/torch_pfaffian/__init__.py b/src/torch_pfaffian/__init__.py index 53aa80b..7d79315 100644 --- a/src/torch_pfaffian/__init__.py +++ b/src/torch_pfaffian/__init__.py @@ -2,12 +2,15 @@ TorchPfaffian is a Python package for efficiently computing the Pfaffian of skew-symmetric matrices using PyTorch. """ +import importlib_metadata + __author__ = "Jérémie Gince" __email__ = "gincejeremie@gmail.com" __copyright__ = "Copyright 2024, Jérémie Gince" __license__ = "Apache 2.0" __url__ = "https://github.com/MatchCake/TorchPfaffian" -__version__ = "0.0.1-beta0" +__package__ = "torch_pfaffian" +__version__ = importlib_metadata.version(__package__) import warnings from collections.abc import Callable @@ -28,3 +31,40 @@ def get_pfaffian_function(name: str = PfaffianFDBPf.NAME) -> Callable[[torch.Ten if name not in pfaffian_strategy_map: raise ValueError(f"Unknown strategy name: {name}. Available strategies: {list(pfaffian_strategy_map.keys())}") return pfaffian_strategy_map[name].apply + + +_OPTIMIZE_CHOICES = ("auto", "time", "memory") + + +def pfaffian(matrix: torch.Tensor, *, sign: bool = True, optimize: str = "auto") -> torch.Tensor: + """ + Compute the Pfaffian of a skew-symmetric matrix, choosing a strategy from the input. + + The matrix has shape ``(..., 2n, 2n)`` and the result has shape ``(...,)``, sharing the + backend, dtype, and device of ``matrix``. + + Strategy selection (``optimize="auto"``): + + =========================== ====================== ================================================= + Condition Strategy Reason + =========================== ====================== ================================================= + ``sign=True`` (default) ``PfaffianParlettReid`` only general strategy that returns the sign + ``sign=False``, grad needed ``PfaffianFDBPf`` magnitude only; robust analytic backward (pinv) + ``sign=False``, no grad ``PfaffianDet`` cheapest: ``sqrt(|det|)`` only + =========================== ====================== ================================================= + + :param matrix: Skew-symmetric matrix of shape ``(..., 2n, 2n)``. + :param sign: When ``True`` (default) return the signed Pfaffian, otherwise its magnitude. + :param optimize: Optimization target, one of ``"auto"``, ``"time"``, ``"memory"``. Currently a + tie-breaker reserved for when more strategies are available; ``"auto"`` follows the table above. + :return: The Pfaffian of the input, of shape ``(...,)``. + :rtype: torch.Tensor + """ + if optimize not in _OPTIMIZE_CHOICES: + raise ValueError(f"Unknown optimize value: {optimize!r}. Choose from {_OPTIMIZE_CHOICES}.") + if sign: + return PfaffianParlettReid.apply(matrix) + grad_needed = matrix.requires_grad and torch.is_grad_enabled() + if grad_needed: + return PfaffianFDBPf.apply(matrix) + return PfaffianDet.apply(matrix) diff --git a/src/torch_pfaffian/strategies/__init__.py b/src/torch_pfaffian/strategies/__init__.py index 5df968c..a63ea23 100644 --- a/src/torch_pfaffian/strategies/__init__.py +++ b/src/torch_pfaffian/strategies/__init__.py @@ -5,4 +5,5 @@ from .pfaffian_block_det import PfaffianBlockDet from .pfaffian_det import PfaffianDet from .pfaffian_fdbpf import PfaffianFDBPf +from .pfaffian_parlett_reid import PfaffianParlettReid from .strategy import PfaffianStrategy diff --git a/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py b/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py new file mode 100644 index 0000000..7e54b68 --- /dev/null +++ b/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py @@ -0,0 +1,94 @@ +from typing import cast + +import torch + +from .strategy import PfaffianStrategy + + +class PfaffianParlettReid(PfaffianStrategy): + """ + Compute the signed Pfaffian of a skew-symmetric matrix with the Parlett-Reid algorithm. + + The forward performs a batched skew-tridiagonalization with partial pivoting: the batch is + processed together and only the ``n / 2`` column-elimination steps are sequential. The result + is the signed Pfaffian, unlike the determinant-based strategies which return only the magnitude. + The backward uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T``, a single matrix + inverse with no autograd graph over the elimination. + + The input is a skew-symmetric matrix of shape ``(..., 2n, 2n)``. + """ + + NAME = "PfaffianParlettReid" + + @staticmethod + def forward(matrix: torch.Tensor) -> torch.Tensor: + dimension = matrix.shape[-1] + if dimension % 2 != 0: + return torch.zeros(matrix.shape[:-2], dtype=matrix.dtype, device=matrix.device) + if dimension == 0: + return torch.ones(matrix.shape[:-2], dtype=matrix.dtype, device=matrix.device) + + working = matrix.reshape(-1, dimension, dimension).clone() # (batch, 2n, 2n) + batch = working.shape[0] + batch_index = torch.arange(batch, device=matrix.device) + sign = torch.ones(batch, dtype=matrix.dtype, device=matrix.device) + valid = torch.ones(batch, dtype=torch.bool, device=matrix.device) + epsilon = PfaffianStrategy.EPSILON + + for column in range(0, dimension - 2, 2): + sub_column = working[:, column + 2 :, column].abs() # (batch, 2n - column - 2) + pivot_relative = sub_column.argmax(dim=1) # (batch,) + pivot_row = pivot_relative + column + 2 # (batch,) + pivot_magnitude = sub_column.gather(1, pivot_relative[:, None]).squeeze(1) # (batch,) + pivot_condition = pivot_magnitude > working[:, column + 1, column].abs() # (batch,) + mask = pivot_condition[:, None] # (batch, 1) + + # Congruence swap of rows/columns column+1 <-> pivot_row where pivoting helps. + row_fixed = working[:, column + 1, :].clone() + row_pivot = working[batch_index, pivot_row, :].clone() + working[:, column + 1, :] = torch.where(mask, row_pivot, row_fixed) + working[batch_index, pivot_row, :] = torch.where(mask, row_fixed, row_pivot) + col_fixed = working[:, :, column + 1].clone() + col_pivot = working[batch_index, :, pivot_row].clone() + working[:, :, column + 1] = torch.where(mask, col_pivot, col_fixed) + working[batch_index, :, pivot_row] = torch.where(mask, col_fixed, col_pivot) + sign = sign * torch.where(pivot_condition, -torch.ones_like(sign), torch.ones_like(sign)) + + pivot_value = working[:, column + 1, column] # (batch,) + zero_pivot = pivot_value.abs() < epsilon + valid = valid & ~zero_pivot + safe_pivot = torch.where(zero_pivot, torch.ones_like(pivot_value), pivot_value) + tau = working[:, column + 2 :, column] / safe_pivot[:, None] # (batch, 2n - column - 2) + column_next = working[:, column + 2 :, column + 1] # (batch, 2n - column - 2) + update = torch.einsum("bi,bj->bij", tau, column_next) - torch.einsum("bi,bj->bij", column_next, tau) + working[:, column + 2 :, column + 2 :] = working[:, column + 2 :, column + 2 :] + update + working[:, column + 2 :, column] = 0 + working[:, column, column + 2 :] = 0 + working[:, column + 2 :, column + 1] = 0 + working[:, column + 1, column + 2 :] = 0 + + super_index = torch.arange(0, dimension, 2, device=matrix.device) + super_entries = working[:, super_index, super_index + 1] # (batch, n) + raw_pfaffian = sign * super_entries.prod(dim=1) # (batch,) + pfaffian = torch.where(valid, raw_pfaffian, torch.zeros_like(raw_pfaffian)) + return pfaffian.reshape(matrix.shape[:-2]) + + @staticmethod + def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch.Tensor) -> torch.Tensor | None: + r""" + Gradient of the signed Pfaffian with respect to the input matrix. + + .. math:: + \frac{\partial \text{pf}(A)}{\partial A_{ij}} = \frac{\text{pf}(A)}{2} (A^{-1})_{ji} + + :param ctx: Context holding the saved input matrix and the forward Pfaffian. + :param grad_output: Gradient of the output with respect to the loss. + :return: Gradient of the input matrix, or ``None`` when the input does not require grad. + :rtype: torch.Tensor | None + """ + matrix, pfaffian = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) + grad_matrix = None + if ctx.needs_input_grad[0]: + inverse = torch.linalg.inv(matrix) + grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pfaffian, inverse) + return grad_matrix diff --git a/tests/test_strategies/test_pfaffian_parlett_reid.py b/tests/test_strategies/test_pfaffian_parlett_reid.py new file mode 100644 index 0000000..c7ce62c --- /dev/null +++ b/tests/test_strategies/test_pfaffian_parlett_reid.py @@ -0,0 +1,143 @@ +import numpy as np +import pytest +import torch +from torch.autograd import gradcheck + +from tests.configs import ( + ATOL_APPROX_COMPARISON, + ATOL_MATRIX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_MATRIX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet +from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid + +_RNG = np.random.default_rng(TEST_SEED) +_HALF_SIZES = [1, 2, 3, 4] +_RANDOM_BLOCKS = [_RNG.random((size, size)) for size in _HALF_SIZES for _ in range(N_RANDOM_TESTS_PER_CASE)] + + +def _block_antidiagonal(block: np.ndarray) -> torch.Tensor: + # Skew matrix [[0, block], [-block^T, 0]]; PfaffianBlockDet gives its exact signed Pfaffian. + zero = np.zeros_like(block) + top = np.concatenate([zero, block], axis=-1) + bottom = np.concatenate([-np.einsum("...ij->...ji", block), zero], axis=-1) + return torch.tensor(np.concatenate([top, bottom], axis=-2)) + + +def _random_skew(dimension: int, rng: np.random.Generator) -> torch.Tensor: + upper = rng.random((dimension, dimension)) + skew = np.triu(upper, k=1) + return torch.tensor(skew - skew.T) + + +_GRADCHECK_DIMENSIONS = [2, 4, 6] + + +def _skew_from_parameters(parameters: torch.Tensor, dimension: int) -> torch.Tensor: + # Build a skew-symmetric A(theta) from the free strictly-upper-triangular entries so that + # gradcheck differentiates on the manifold where the Pfaffian is defined. + upper = torch.zeros(dimension, dimension, dtype=parameters.dtype) + indices = torch.triu_indices(dimension, dimension, offset=1) + upper = upper.index_put((indices[0], indices[1]), parameters) + return upper - upper.transpose(-1, -2) + + +class TestPfaffianParlettReid: + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_square_matches_determinant(self, block): + matrix = _block_antidiagonal(block) + pfaffian = PfaffianParlettReid.apply(matrix) + determinant = torch.linalg.det(matrix) + torch.testing.assert_close(pfaffian**2, determinant, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_sign_matches_block_det(self, block): + matrix = _block_antidiagonal(block) + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + PfaffianBlockDet.apply(matrix), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) + + def test_forward_two_by_two_is_signed(self): + matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + torch.tensor(-3.0, dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_supports_leading_batch_dims(self): + blocks = _RNG.random((2, 3, 4, 4)) + matrix = _block_antidiagonal(blocks) + pfaffian = PfaffianParlettReid.apply(matrix) + assert pfaffian.shape == matrix.shape[:-2] + torch.testing.assert_close( + pfaffian**2, torch.linalg.det(matrix), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) + def test_forward_preserves_dtype_and_device(self, dtype): + matrix = _random_skew(6, _RNG).to(dtype) + pfaffian = PfaffianParlettReid.apply(matrix) + assert pfaffian.dtype == dtype + assert pfaffian.device == matrix.device + + def test_forward_odd_dimension_is_zero(self): + matrix = _random_skew(5, _RNG) + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + torch.zeros((), dtype=matrix.dtype), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_empty_matrix_is_one(self): + matrix = torch.zeros((0, 0), dtype=torch.float64) + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + torch.ones((), dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_singular_matrix_is_zero(self): + # A skew matrix with a zero pivot column has Pfaffian 0. + matrix = torch.zeros((4, 4), dtype=torch.float64) + matrix[2, 3] = 1.0 + matrix[3, 2] = -1.0 + torch.testing.assert_close( + PfaffianParlettReid.apply(matrix), + torch.zeros((), dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + @pytest.mark.parametrize("dimension", _GRADCHECK_DIMENSIONS) + def test_backward_passes_gradcheck_on_skew_parameterization(self, dimension): + count = dimension * (dimension - 1) // 2 + parameters = torch.tensor(_RNG.random(count) + 0.5, dtype=torch.float64, requires_grad=True) + assert gradcheck( + lambda values: PfaffianParlettReid.apply(_skew_from_parameters(values, dimension)), + (parameters,), + eps=1e-6, + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) + + def test_backward_returns_none_when_input_does_not_require_grad(self): + matrix = _random_skew(4, _RNG) + pfaffian = PfaffianParlettReid.apply(matrix) + + class _Context: + saved_tensors = (matrix, pfaffian) + needs_input_grad = (False,) + + assert PfaffianParlettReid.backward(_Context(), torch.ones_like(pfaffian)) is None diff --git a/tests/test_torch_pfaffian.py b/tests/test_torch_pfaffian.py index dcbea59..a3f083f 100644 --- a/tests/test_torch_pfaffian.py +++ b/tests/test_torch_pfaffian.py @@ -1,8 +1,11 @@ +from unittest import mock + import pytest import torch -from torch_pfaffian import get_pfaffian_function, pfaffian_strategy_map -from torch_pfaffian.strategies import PfaffianDet, PfaffianFDBPf +import torch_pfaffian +from torch_pfaffian import get_pfaffian_function, pfaffian, pfaffian_strategy_map +from torch_pfaffian.strategies import PfaffianDet, PfaffianFDBPf, PfaffianParlettReid class TestTorchPfaffian: @@ -30,3 +33,50 @@ def test_get_pfaffian_function_is_case_and_whitespace_insensitive(self): def test_get_pfaffian_function_unknown_name_raises_value_error(self): with pytest.raises(ValueError, match="Unknown strategy name"): get_pfaffian_function("not_a_real_strategy") + + def test_parlett_reid_is_registered(self): + assert PfaffianParlettReid.NAME.lower().strip() in pfaffian_strategy_map + assert get_pfaffian_function(PfaffianParlettReid.NAME) == PfaffianParlettReid.apply + + @staticmethod + def _skew_matrix() -> torch.Tensor: + return torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + + def test_pfaffian_signed_by_default_matches_parlett_reid(self): + matrix = self._skew_matrix() + torch.testing.assert_close(pfaffian(matrix), PfaffianParlettReid.apply(matrix)) + assert pfaffian(matrix).item() < 0 # signed, not magnitude + + def test_pfaffian_sign_false_returns_magnitude(self): + matrix = self._skew_matrix() + torch.testing.assert_close(pfaffian(matrix, sign=False), PfaffianDet.apply(matrix)) + assert pfaffian(matrix, sign=False).item() > 0 + + def test_pfaffian_invalid_optimize_raises_value_error(self): + with pytest.raises(ValueError, match="optimize"): + pfaffian(self._skew_matrix(), optimize="fastest") + + def test_pfaffian_routes_sign_true_to_parlett_reid(self): + with mock.patch.object(torch_pfaffian, "PfaffianParlettReid") as fake: + fake.apply.return_value = torch.zeros(()) + pfaffian(self._skew_matrix(), sign=True) + fake.apply.assert_called_once() + + def test_pfaffian_routes_magnitude_no_grad_to_det(self): + with mock.patch.object(torch_pfaffian, "PfaffianDet") as fake: + fake.apply.return_value = torch.zeros(()) + pfaffian(self._skew_matrix(), sign=False) + fake.apply.assert_called_once() + + def test_pfaffian_routes_magnitude_with_grad_to_fdbpf(self): + matrix = self._skew_matrix().requires_grad_(True) + with mock.patch.object(torch_pfaffian, "PfaffianFDBPf") as fake: + fake.apply.return_value = torch.zeros((), requires_grad=True) + pfaffian(matrix, sign=False) + fake.apply.assert_called_once() + + def test_pfaffian_signed_backward_flows(self): + matrix = self._skew_matrix().requires_grad_(True) + pfaffian(matrix).backward() + assert matrix.grad is not None + assert matrix.grad.shape == matrix.shape From c66f9ced3cd41f6375113386473ff126f661cb52 Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Thu, 11 Jun 2026 08:05:50 -0400 Subject: [PATCH 3/7] Add Rust-accelerated Pfaffian strategy and update build configurations --- .github/workflows/build_dist.yml | 3 + .github/workflows/tests.yml | 8 + README.md | 25 +- archives/_pfaffian.py | 378 ------------------ archives/_test_pfaffian.py | 171 -------- archives/pfaffian_perm.py | 61 --- notebooks/_strategies_benchmark_helpers.py | 49 ++- notebooks/strategies_benchmark.ipynb | 280 ++----------- pyproject.toml | 33 +- requirements.txt | 10 +- rust/Cargo.lock | 323 +++++++++++++++ rust/Cargo.toml | 15 + rust/src/lib.rs | 164 ++++++++ setup.py | 40 -- src/torch_pfaffian/__init__.py | 70 ++-- src/torch_pfaffian/strategies/__init__.py | 5 + .../strategies/pfaffian_parlett_reid.py | 13 +- .../strategies/pfaffian_rust_parlett_reid.py | 66 +++ .../test_pfaffian_parlett_reid.py | 12 + .../test_pfaffian_rust_parlett_reid.py | 168 ++++++++ tests/test_torch_pfaffian.py | 53 ++- uv.lock | 42 +- 22 files changed, 1024 insertions(+), 965 deletions(-) delete mode 100644 archives/_pfaffian.py delete mode 100644 archives/_test_pfaffian.py delete mode 100644 archives/pfaffian_perm.py create mode 100644 rust/Cargo.lock create mode 100644 rust/Cargo.toml create mode 100644 rust/src/lib.rs delete mode 100644 setup.py create mode 100644 src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py create mode 100644 tests/test_strategies/test_pfaffian_rust_parlett_reid.py diff --git a/.github/workflows/build_dist.yml b/.github/workflows/build_dist.yml index 95fc29b..238b400 100644 --- a/.github/workflows/build_dist.yml +++ b/.github/workflows/build_dist.yml @@ -51,6 +51,9 @@ jobs: uv version ${{steps.version.outputs.new_tag}} uv lock + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + - name: Build dist run: | uv run python -m build --sdist --wheel --no-isolation --outdir dist/ . diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index cb599e5..e3936e8 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -37,6 +37,10 @@ jobs: run: | uv venv .venv uv sync --locked --dev --extra cpu + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + - name: Build native extension + run: uv run maturin develop -m rust/Cargo.toml - name: Test Linting run: | uv run ruff format --check src tests @@ -99,6 +103,10 @@ jobs: run: | uv venv .venv uv sync --locked --dev --extra cpu + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + - name: Build native extension + run: uv run maturin develop -m rust/Cargo.toml - name: Test Unittests with pytest run: | uv run pytest tests --session-timeout=600 diff --git a/README.md b/README.md index 587f923..b205141 100644 --- a/README.md +++ b/README.md @@ -44,6 +44,22 @@ uv sync --dev --extra cpu Use the `cu128` or `cu130` extra instead of `cpu` to install a CUDA-enabled build of PyTorch. See [.github/CONTRIBUTING.md](.github/CONTRIBUTING.md) for the full contribution workflow. +### Native acceleration (optional) + +A Rust-accelerated signed-Pfaffian strategy (`RustPfaffianParlettReid`) is available when the +package is built with its native extension. Building from source requires a Rust toolchain +(); the project builds with [maturin](https://www.maturin.rs): + +```bash +uv run maturin develop --release -m rust/Cargo.toml +``` + +Use `--release` for an optimized build: `maturin develop` compiles in debug mode by default, +which makes the Rust kernel much slower. Installing a prebuilt wheel (or `maturin build`) is already +optimized, so this only matters for local development builds. + +If the native extension is not present, the package still works using the pure-Python strategies. + ## Usage @@ -60,11 +76,10 @@ magnitude = pfaffian(matrix, sign=False) # |pf|, using the faster det-based pat ``` `pfaffian()` selects a strategy from the input: `sign=True` (the default) returns the -**signed** Pfaffian via `PfaffianParlettReid`; `sign=False` returns the magnitude using a -determinant-based strategy (`PfaffianFDBPf` when gradients are needed, otherwise -`PfaffianDet`). The `optimize` argument (`"auto"`, `"time"`, `"memory"`) is reserved as a -tie-breaker for future strategies. For explicit strategy selection, use -`get_pfaffian_function(name)`. +**signed** Pfaffian, using the native `RustPfaffianParlettReid` when the extension is built and +falling back to the pure-Python `PfaffianParlettReid` otherwise; `sign=False` returns the magnitude +using a determinant-based strategy (`PfaffianFDBPf` when gradients are needed, otherwise +`PfaffianDet`). For explicit strategy selection, use `get_pfaffian_function(name)`. # Important Links diff --git a/archives/_pfaffian.py b/archives/_pfaffian.py deleted file mode 100644 index 13b4aed..0000000 --- a/archives/_pfaffian.py +++ /dev/null @@ -1,378 +0,0 @@ -""" -TODO: This file is a temporary file to test the implementation of the `pfaffian` functions. - -This file will be deleted before the final submission. -It is used as a reference to implement the `pfaffian` functions. -""" - -import warnings -from typing import Literal, Optional, Union - -import numpy as np -import pennylane as qml -import tqdm - -from torch_pfaffian import Pfaffian - - -class TensorLike: - pass - - -def convert_and_cast_like(*args, **kwargs): - return qml.math.convert_like(*args, **kwargs) - - -def _pivot(__matrix, k, kp): - matrix = qml.math.ones_like(__matrix) * __matrix - matrix_shape = qml.math.shape(matrix) - indexes_to_pivot = np.arange(matrix_shape[0]) - if len(matrix_shape) == 2: - matrix[..., [kp, k + 1], k:] = matrix[..., [k + 1, kp], k:] - matrix[..., k:, [kp, k + 1]] = matrix[..., k:, [k + 1, kp]] - return matrix - - # interchange rows k+1 and kp - kp_sub_matrix = matrix[indexes_to_pivot, kp, k:] - temp = qml.math.ones_like(kp_sub_matrix) * kp_sub_matrix - matrix[indexes_to_pivot, kp, k:] = matrix[indexes_to_pivot, k + 1, k:] - matrix[indexes_to_pivot, k + 1, k:] = temp - - # Then interchange columns k+1 and kp - kp_sub_matrix = matrix[indexes_to_pivot, k:, kp] - temp = qml.math.ones_like(kp_sub_matrix) * kp_sub_matrix - matrix[indexes_to_pivot, k:, kp] = matrix[indexes_to_pivot, k:, k + 1] - matrix[indexes_to_pivot, k:, k + 1] = temp - return matrix - - -def _compute_gauss_vector(__matrix, k): - zero_like = convert_and_cast_like(0, __matrix) - tau_norm = __matrix[..., k, k + 1][..., None] - zero_mask = qml.math.isclose(tau_norm, zero_like) - tau = qml.math.where(zero_mask, zero_like, __matrix[..., k, k + 2 :] / tau_norm) - return tau - - -def _update_matrix_block_kp2_kp2(__matrix, k, tau): - add_matrix = qml.math.zeros_like(__matrix) - add_matrix[..., k + 2 :, k + 2 :] += qml.math.einsum( - "...i,...j->...ij", tau, __matrix[..., k + 2 :, k + 1] - ) - qml.math.einsum("...i,...j->...ij", __matrix[..., k + 2 :, k + 1], tau) - return __matrix + add_matrix - - -def batch_pfaffian_ltl( - __matrix: TensorLike, - overwrite_input: bool = False, - test_input: bool = False, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False, -) -> Union[float, complex, TensorLike]: - r""" - Compute the Pfaffian of a real or complex skew-symmetric - matrix A (A=-A^T). If overwrite_a=True, the matrix A - is overwritten in the process. This function uses - the Parlett-Reid algorithm. - - This code is adapted of the function `pfaffian_LTL` - from https://github.com/basnijholt/pfapack/blob/master/pfapack/pfaffian.py. - - :param __matrix: Matrix to compute the Pfaffian of - :type __matrix: TensorLike - :param overwrite_input: Whether to overwrite the input matrix - :type overwrite_input: bool - :param test_input: Whether to test the input matrix for skew-symmetry - :type test_input: bool - :param p_bar: Progress bar - :type p_bar: Optional[tqdm.tqdm] - :param show_progress: Whether to show progress bar. If no progress bar is provided, a new one is created - :type show_progress: bool - - :return: Pfaffian of the matrix - :rtype: Union[float, complex, TensorLike] - """ - if overwrite_input: - matrix = __matrix - else: - matrix = qml.math.ones_like(__matrix) * __matrix - shape = qml.math.shape(matrix) - n, m = shape[-2:] - p_bar = p_bar or tqdm.tqdm(range(0, n - 1, 2), disable=not show_progress) - - if test_input: - p_bar.set_description("Testing input matrix") - # Check if matrix is square - assert shape[-2] == shape[-1] > 0 - # Check if it's skew-symmetric - matrix_t = qml.math.einsum("...ij->...ji", matrix) - assert qml.math.allclose(matrix, -matrix_t) - - matrix = qml.math.cast(matrix, dtype=complex) - zero_like = convert_and_cast_like(0, matrix) - pfaffian_val = qml.math.convert_like(np.ones(shape[:-2], dtype=complex), matrix) - - # Quick return if possible - if n % 2 == 1: - p_bar.n = n // 2 - p_bar.set_description("Odd-sized matrix") - p_bar.close() - return pfaffian_val * zero_like * matrix[..., 0, 0] # 0.0 but with require grad if needed - - p_bar.set_description(f"Computing Pfaffian of {shape} matrix") - for k in p_bar: - # First, find the largest entry in A[k+1:,k] and permute it to A[k+1,k] - kp = k + 1 + qml.math.abs(matrix[..., k + 1 :, k]).argmax(-1) - kp1 = qml.math.convert_like(k + 1, kp) - - # Check if we need to pivot - pivot_condition = ~qml.math.isclose(kp, kp1) - # interchange rows and cols k+1 and kp (pivot if needed) - matrix = qml.math.where(pivot_condition[..., None, None], _pivot(matrix, k, kp), matrix) - # every interchange corresponds to a "-" in det(P) - pfaffian_val *= qml.math.where(pivot_condition, -1.0, 1.0) - - # if we encounter a zero on the super/subdiagonal, the Pfaffian is 0 - zero_ss_condition = qml.math.isclose(matrix[..., k + 1, k], zero_like) - pfaffian_val *= qml.math.where(zero_ss_condition, zero_like, matrix[..., k, k + 1]) - if qml.math.all(zero_ss_condition): - p_bar.n = n // 2 - p_bar.set_description("Pfaffian is zero") - p_bar.close() - return pfaffian_val - - if k + 2 < n: - tau = _compute_gauss_vector(matrix, k) - # Update the matrix block A(k+2:,k+2) - matrix = _update_matrix_block_kp2_kp2(matrix, k, tau) - - p_bar.set_description("Pfaffian computed") - p_bar.close() - return pfaffian_val - - -def batch_householder_complex(x: TensorLike): - """(v, tau, alpha) = householder_real(x) - - Compute a Householder transformation such that - (1-tau v v^T) x = alpha e_1 - where x and v a complex vectors, tau is 0 or 2, and - alpha a complex number (e_1 is the first unit vector) - """ - sigma = qml.math.einsum("...i,...i->...", qml.math.conjugate(x[..., 1:]), x[..., 1:]) - - # if sigma == 0: - # return qml.math.zeros_like(x), 0, x[..., 0] - # else: - norm_x = qml.math.sqrt(qml.math.conjugate(x[..., 0]) * x[..., 0] + sigma) - - v = qml.math.ones_like(x) * x - phase = qml.math.exp(1j * qml.math.arctan2(qml.math.imag(x[..., 0]), qml.math.real(x[..., 0]))) - v[..., 0] = v[..., 0] + phase * norm_x - - v_frobenius_norm = qml.math.einsum("...i,...i->...", qml.math.conjugate(v), v) ** 0.5 - v = v / v_frobenius_norm[..., None] - - tau = convert_and_cast_like(2.0 + 0.0j, x) - return v, tau, -phase * norm_x - - -def _eliminate_ith_column_householder(matrix, i, alpha): - """ - Eliminate the i-th column of the matrix using the Householder transformation. - Equivalent to: - - matrix[..., i + 1, i] = alpha - matrix[..., i, i + 1] = -alpha - matrix[..., i + 2:, i] = zero_like - matrix[..., i, i + 2:] = zero_like - - :param matrix: - :param i: - :param alpha: - :return: - """ - zero_like = convert_and_cast_like(0, matrix) - - where_mask = qml.math.cast(qml.math.zeros_like(matrix), dtype=bool) - where_mask[..., i + 1, i] = True - where_mask[..., i, i + 1] = True - where_mask[..., i + 2 :, i] = True - where_mask[..., i, i + 2 :] = True - - values = qml.math.zeros_like(matrix) - values[..., i + 1, i] = alpha - values[..., i, i + 1] = -alpha - values[..., i + 2 :, i] = zero_like - values[..., i, i + 2 :] = zero_like - - matrix = qml.math.where(where_mask, values, matrix) - return matrix - - -def _update_matrix_block_householder(matrix, i, v, tau): - """ - Update the matrix block A(i+1:N,i+1:N) using the Householder transformation. - Equivalent to: - - w = tau * A(i+1:N,i+1:N) @ v - A(i+1:N,i+1:N) -= 2 * v @ w^T - - :param matrix: - :param i: - :param v: - :param tau: - :return: - """ - w = tau * qml.math.einsum("...ij,...j->...i", matrix[..., i + 1 :, i + 1 :], qml.math.conjugate(v)) - values = qml.math.zeros_like(matrix) - values[..., i + 1 :, i + 1 :] += qml.math.einsum("...i,...j->...ij", v, w) - qml.math.einsum( - "...i,...j->...ij", w, v - ) - return matrix + values - - -def batch_pfaffian_householder( - __matrix: TensorLike, - overwrite_input: bool = False, - test_input: bool = False, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False, -): - """pfaffian(A, overwrite_a=False) - - Compute the Pfaffian of a real or complex skew-symmetric - matrix A (A=-A^T). If overwrite_a=True, the matrix A - is overwritten in the process. This function uses the - Householder tridiagonalization. - - Note that the function pfaffian_schur() can also be used in the - real case. That function does not make use of the skew-symmetry - and is only slightly slower than pfaffian_householder(). - """ - if overwrite_input: - matrix = __matrix - else: - matrix = qml.math.ones_like(__matrix) * __matrix - shape = qml.math.shape(matrix) - n, m = shape[-2:] - p_bar = p_bar or tqdm.tqdm(range(n - 2), disable=not show_progress) - - if test_input: - p_bar.set_description("Testing input matrix") - # Check if matrix is square - assert shape[-2] == shape[-1] > 0 - # Check if it's skew-symmetric - matrix_t = qml.math.einsum("...ij->...ji", matrix) - assert qml.math.allclose(matrix, -matrix_t) - - matrix = qml.math.cast(matrix, dtype=complex) - zero_like = convert_and_cast_like(0, matrix) - pfaffian_val = qml.math.convert_like(np.ones(shape[:-2], dtype=complex), matrix) - - # Quick return if possible - if n % 2 == 1: - p_bar.set_description("Odd-sized matrix") - p_bar.close() - return pfaffian_val * zero_like * matrix[..., 0, 0] # 0.0 but with require grad if needed - - p_bar.set_description(f"Computing Pfaffian of {shape} matrix") - for i in p_bar: - # Find a Householder vector to eliminate the i-th column - v, tau, alpha = batch_householder_complex(matrix[..., i + 1 :, i]) - matrix = _eliminate_ith_column_householder(matrix, i, alpha) - matrix = _update_matrix_block_householder(matrix, i, v, tau) - - pfaffian_val = pfaffian_val * qml.math.where(qml.math.isclose(tau, zero_like), 1, 1 - tau) - if i % 2 == 0: - pfaffian_val = pfaffian_val * -alpha - - pfaffian_val = pfaffian_val * matrix[..., n - 2, n - 1] - p_bar.set_description("Pfaffian computed") - p_bar.close() - return pfaffian_val - - -def pfaffian_by_det( - __matrix: TensorLike, p_bar: Optional[tqdm.tqdm] = None, show_progress: bool = False, epsilon: float = 1e-12 -): - shape = qml.math.shape(__matrix) - p_bar = p_bar or tqdm.tqdm(total=1, disable=not show_progress) - p_bar.set_description(f"Computing determinant of {shape} matrix") - backend = qml.math.get_interface(__matrix) - if backend in ["autograd", "numpy"]: - det = qml.math.linalg.det(__matrix) - pf = qml.math.sqrt(qml.math.abs(det) + epsilon) - elif backend == "torch": - pf = Pfaffian.apply(__matrix) - else: - det = qml.math.det(__matrix) - pf = qml.math.sqrt(qml.math.abs(det) + epsilon) - p_bar.set_description(f"Determinant of {shape} matrix computed") - p_bar.update() - p_bar.close() - return pf - - -def pfaffian( - __matrix: TensorLike, - overwrite_input: bool = False, - method: Literal["P", "H", "det", "bLTL", "bH"] = "bLTL", - epsilon: float = 1e-12, - p_bar: Optional[tqdm.tqdm] = None, - show_progress: bool = False, -) -> Union[float, complex, TensorLike]: - """pfaffian(A, overwrite_a=False, method='P') - - Compute the Pfaffian of a real or complex skew-symmetric - matrix A (A=-A^T). If overwrite_a=True, the matrix A - is overwritten in the process. This function uses - either the Parlett-Reid algorithm (method='P', default), - or the Householder tridiagonalization (method='H'). - - This code is adapted of the function `pfaffian` - from https://github.com/basnijholt/pfapack/blob/master/pfapack/pfaffian.py. - - :param __matrix: Matrix to compute the Pfaffian of - :type __matrix: TensorLike - :param overwrite_input: Whether to overwrite the input matrix - :type overwrite_input: bool - :param method: Method to use. 'P' for Parlett-Reid algorithm, 'H' for Householder tridiagonalization, - 'det' for determinant, 'bLTL' for batched Parlett-Reid algorithm - :type method: Literal["P", "H", "det", "bLTL"] - :param epsilon: Tolerance for the determinant method - :type epsilon: float - :param p_bar: Progress bar - :type p_bar: Optional[tqdm.tqdm] - :param show_progress: Whether to show progress bar. If no progress bar is provided, a new one is created - :type show_progress: bool - :return: Pfaffian of the matrix - :rtype: Union[float, complex, TensorLike] - """ - shape = qml.math.shape(__matrix) - assert shape[-2] == shape[-1] > 0, "Matrix must be square" - - if method == "P": - from pfapack.pfaffian import pfaffian - - warnings.warn( - "The method 'P' is not implemented yet. It is recommended to use the method 'det' instead.", - UserWarning, - ) - return pfaffian(__matrix, overwrite_input, method="P") - elif method == "H": - from pfapack.pfaffian import pfaffian_householder - - warnings.warn( - "The method 'H' is not implemented yet. It is recommended to use the method 'det' instead.", - UserWarning, - ) - return pfaffian_householder(__matrix, overwrite_input) - elif method == "det": - return pfaffian_by_det(__matrix, p_bar=p_bar, show_progress=show_progress, epsilon=epsilon) - elif method == "bLTL": - return batch_pfaffian_ltl(__matrix, overwrite_input, show_progress=show_progress, p_bar=p_bar) - elif method == "bH": - return batch_pfaffian_householder(__matrix, overwrite_input, show_progress=show_progress, p_bar=p_bar) - else: - raise ValueError(f"Invalid method. Got {method}, must be 'P', 'H', 'det', 'bLTL', or 'bH'.") diff --git a/archives/_test_pfaffian.py b/archives/_test_pfaffian.py deleted file mode 100644 index a320154..0000000 --- a/archives/_test_pfaffian.py +++ /dev/null @@ -1,171 +0,0 @@ -import numpy as np -import pytest - -from tests.configs import ( - ATOL_MATRIX_COMPARISON, - ATOL_SCALAR_COMPARISON, - N_RANDOM_TESTS_PER_CASE, - RTOL_MATRIX_COMPARISON, - RTOL_SCALAR_COMPARISON, - TEST_SEED, - set_seed, -) -from torch_pfaffian import utils - -set_seed(TEST_SEED) -MIN_MATRIX_SIZE = 2 -MAX_MATRIX_SIZE = 20 -BATCH_SIZE = 3 -RECOMMENDED_METHODS = ["det", "bLTL", "bH"] - - -def gen_skew_symmetric_matrix_and_det(n, batch_size=None): - if batch_size is None: - matrix = np.random.rand(n, n) - else: - matrix = np.random.rand(batch_size, n, n) - matrix = matrix - np.einsum("...ij->...ji", matrix) - return matrix, np.linalg.det(matrix) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=None) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_get_skew_symmetric_matrix_and_det(matrix, det): - try: - from pfapack.pfaffian import pfaffian - except ImportError: - pytest.skip("pfapack is not installed.") - pf = pfaffian(matrix) - np.testing.assert_allclose(pf**2, det, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det, mth", - [ - (*gen_skew_symmetric_matrix_and_det(i, batch_size=batch_size), mth) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - for mth in RECOMMENDED_METHODS - for batch_size in [None, BATCH_SIZE] - ], -) -def test_pfaffian_methods(matrix, det, mth): - pf = utils.pfaffian(matrix, method=mth) - np.testing.assert_allclose(pf**2, det, atol=10 * ATOL_SCALAR_COMPARISON, rtol=10 * RTOL_SCALAR_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_batch_pfaffian_ltl(matrix, det): - pf = utils._pfaffian.batch_pfaffian_ltl(matrix) - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_pfaffian_bltl(matrix, det): - pf = utils.pfaffian(matrix, method="bLTL") - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=batch_size) - for batch_size in [None, 1] - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_pfaffian_bltl_single_item(matrix, det): - pf = utils.pfaffian(matrix, method="bLTL") - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) - - -@pytest.mark.parametrize( - "n, batch_size, mth", - [ - (i, batch_size, mth) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1, 2) - for _ in range(N_RANDOM_TESTS_PER_CASE) - for mth in RECOMMENDED_METHODS - for batch_size in [None, BATCH_SIZE] - ], -) -def test_pfaffian_methods_grads(n, batch_size, mth): - try: - import torch - except ImportError: - pytest.skip("PyTorch is not installed.") - torch.autograd.set_detect_anomaly(True) - - if batch_size is None: - np_matrix = np.random.rand(n, n) - else: - np_matrix = np.random.rand(batch_size, n, n) - np_matrix = np_matrix - np.einsum("...ij->...ji", np_matrix) - torch_matrix = torch.from_numpy(np_matrix).requires_grad_() - det = torch.det(torch_matrix) - torch_loss = torch.sum(det) - torch_loss.backward() - true_grad = torch_matrix.grad - - matrix = torch.from_numpy(np_matrix).requires_grad_() - pf = utils.pfaffian(matrix, method=mth) - pred_det = torch.real(pf**2) - with torch.no_grad(): - np.testing.assert_allclose(pred_det, det, atol=10 * ATOL_SCALAR_COMPARISON, rtol=10 * RTOL_SCALAR_COMPARISON) - - pred_loss = torch.sum(pred_det) - pred_loss.backward() - pred_grad = matrix.grad - assert pred_grad is not None - if mth == "det": - np.testing.assert_allclose( - torch.abs(pred_grad), torch.abs(true_grad), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON - ) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=BATCH_SIZE) - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_pfaffian_bh(matrix, det): - pf = utils.pfaffian(matrix, method="bH") - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) - - -@pytest.mark.parametrize( - "matrix, det", - [ - gen_skew_symmetric_matrix_and_det(i, batch_size=batch_size) - for batch_size in [None, 1] - for i in range(MIN_MATRIX_SIZE, MAX_MATRIX_SIZE + 1) - for _ in range(N_RANDOM_TESTS_PER_CASE) - ], -) -def test_pfaffian_bltl_single_item(matrix, det): - pf = utils.pfaffian(matrix, method="bH") - np.testing.assert_allclose(pf**2, det, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) diff --git a/archives/pfaffian_perm.py b/archives/pfaffian_perm.py deleted file mode 100644 index fd4ce3c..0000000 --- a/archives/pfaffian_perm.py +++ /dev/null @@ -1,61 +0,0 @@ -import numpy as np -import torch - -from .strategy import PfaffianStrategy - - -class PfaffianPerm(PfaffianStrategy): - """ - This class implements the Pfaffian using the determinant of the matrix for the forward pass and the - derivative of the Pfaffian with respect to the input matrix for the backward pass. - """ - - NAME = "PfaffianPerm" - - @staticmethod - def forward(matrix: torch.Tensor): - _2n = matrix.shape[-1] - if _2n % 2 != 0: - return torch.zeros_like(matrix[..., 0, 0]) - _n = _2n // 2 - # Let P be the set of permutations, {i_1, i_2, ..., i_2n} with respect to {1, 2, ..., 2n}, such that - # i_1 < j_1 < i_2 < j_2 < ... < i_2n < j_2n and i_1 < i_2 < ... < i_2n - indexes = np.arange(_2n) - # _i must be all the vector of length n from indexes. It should look like a sliding windows of size n - _i_starting_idx = np.arange(_n - 1) - _i_matrix = indexes[_i_starting_idx[:, None] + np.arange(_n)] - _j_starting_idx = _i_starting_idx + 1 - _j_matrix = indexes[_j_starting_idx[:, None] + np.arange(_n)] - - # build a matrix of each permutation of i and j where j > i - ij_matrix = np.concatenate( - [ - np.concatenate([_i_matrix[i, :, None], _j_matrix[j, :, None]], axis=-1)[None, ...] - for i in range(_i_matrix.shape[0]) - for j in range(i, _j_matrix.shape[0]) - ], - axis=0, - ) - - pf_matrix = torch.prod(matrix[..., ij_matrix[..., 0], ij_matrix[..., 1]], dim=-1) - delta_ij = ij_matrix[..., 0, 1] - ij_matrix[..., 0, 0] - signs = torch.tensor((-1) ** delta_ij).to(pf_matrix.device) - pf = torch.sum(signs * pf_matrix, dim=-1) - return pf - - @staticmethod - def backward(ctx: torch.autograd.function.FunctionCtx, grad_output): - r""" - - ..math: - \frac{\partial \text{pf}(A)}{\partial A_{ij}} = \frac{\text{pf}(A)}{2} A^{-1}_{ji} - - :param ctx: Context - :param grad_output: Gradient of the output - :return: Gradient of the input - """ - matrix, pf = ctx.saved_tensors - grad_matrix = None - if ctx.needs_input_grad[0]: - grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pf, torch.linalg.pinv(matrix)) - return grad_matrix diff --git a/notebooks/_strategies_benchmark_helpers.py b/notebooks/_strategies_benchmark_helpers.py index e7557d0..7d9cedd 100644 --- a/notebooks/_strategies_benchmark_helpers.py +++ b/notebooks/_strategies_benchmark_helpers.py @@ -5,7 +5,9 @@ import numpy as np import torch from torch.profiler import ProfilerActivity, profile +from tqdm.auto import tqdm +from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet from torch_pfaffian.strategies.strategy import PfaffianStrategy Strategy = type[PfaffianStrategy] @@ -15,25 +17,45 @@ def make_block_antidiagonal( - n: int, batch_size: int, dtype: torch.dtype = torch.float64, device: str = "cpu" + n: int, batch_size: int, dtype: torch.dtype = torch.float32, device: str = "cpu" ) -> torch.Tensor: """ - Build a batch of block-antidiagonal skew matrices ``[[0, B], [-B^T, 0]]``. + Build a batch of block-antidiagonal skew matrices ``[[0, B], [-B^T, 0]]`` of dimension ``n``. - :param n: Half the matrix dimension; the result has shape ``(batch_size, 2n, 2n)``. + :param n: Matrix dimension (even); the result has shape ``(batch_size, n, n)``. :param batch_size: Number of matrices in the batch. :param dtype: Floating dtype of the matrices. :param device: Device on which to allocate the matrices. - :return: A tensor of shape ``(batch_size, 2n, 2n)``. + :return: A tensor of shape ``(batch_size, n, n)``. :rtype: torch.Tensor """ - block = torch.randn(batch_size, n, n, dtype=dtype, device=device) + half = n // 2 + block = torch.randn(batch_size, half, half, dtype=dtype, device=device) zero = torch.zeros_like(block) top = torch.cat([zero, block], dim=-1) bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) return torch.cat([top, bottom], dim=-2) +def make_random_skew(n: int, batch_size: int, dtype: torch.dtype = torch.float32, device: str = "cpu") -> torch.Tensor: + """ + Build a batch of general (dense) random skew-symmetric matrices of dimension ``n``. + + Unlike :func:`make_block_antidiagonal`, the result has no block structure, so it is a + representative input for the strategies that accept any skew-symmetric matrix (every strategy + except ``PfaffianBlockDet``, which only computes the true Pfaffian on block-antidiagonal inputs). + + :param n: Matrix dimension (even); the result has shape ``(batch_size, n, n)``. + :param batch_size: Number of matrices in the batch. + :param dtype: Floating dtype of the matrices. + :param device: Device on which to allocate the matrices. + :return: A tensor of shape ``(batch_size, n, n)``. + :rtype: torch.Tensor + """ + full = torch.randn(batch_size, n, n, dtype=dtype, device=device) + return full - full.transpose(-1, -2) + + def _synchronize(is_cuda: bool) -> None: if is_cuda: torch.cuda.synchronize() @@ -96,7 +118,7 @@ def benchmark_strategies( values are the across-seed mean and the half-width of the 95% confidence interval. :param strategies: The strategy classes to benchmark (each exposes ``NAME`` and ``apply``). - :param sizes_n: Half-dimensions to sweep; each yields matrices of dimension ``2n``. + :param sizes_n: Matrix dimensions to sweep (even integers); each yields ``n x n`` matrices. :param batch_size: Number of matrices per benchmarked batch. :param device: Device on which to run the benchmark. :param n_seeds: Number of random seeds used to build the confidence intervals. @@ -113,15 +135,20 @@ def benchmark_strategies( } for strategy in strategies } - + p_bar = tqdm(total=len(sizes_n) * len(strategies) * n_seeds, desc="Benchmarking strategies") for n in sizes_n: per_seed: dict[str, dict[str, list[float]]] = { strategy.NAME: {metric: [] for metric in METRICS} for strategy in strategies } for seed in range(n_seeds): torch.manual_seed(seed) - matrix = make_block_antidiagonal(n, batch_size, dtype=torch.float64, device=device) + # PfaffianBlockDet only returns the true Pfaffian on block-antidiagonal inputs; every other + # strategy is valid on any skew matrix, so benchmark those on a general random skew matrix. + block_matrix = make_block_antidiagonal(n, batch_size, dtype=torch.float32, device=device) + random_matrix = make_random_skew(n, batch_size, dtype=torch.float32, device=device) for strategy in strategies: + matrix = block_matrix if strategy is PfaffianBlockDet else random_matrix + p_bar.set_description(f"Benchmarking {strategy.NAME:^30} (n: {n:^5} | seed: {seed:^5})") forward_time = _median_time(lambda: _forward_call(strategy, matrix), is_cuda, n_repeats) full_time = _median_time(lambda: _forward_backward_call(strategy, matrix), is_cuda, n_repeats) record = per_seed[strategy.NAME] @@ -131,13 +158,15 @@ def benchmark_strategies( record["forward_backward_memory"].append( _peak_memory(lambda: _forward_backward_call(strategy, matrix), is_cuda) ) + p_bar.update(1) for strategy in strategies: - results[strategy.NAME]["dimension"].append(2 * n) + results[strategy.NAME]["dimension"].append(n) for metric in METRICS: values = np.asarray(per_seed[strategy.NAME][metric], dtype=float) results[strategy.NAME][f"{metric}_mean"].append(float(values.mean())) results[strategy.NAME][f"{metric}_ci"].append(_confidence_interval(values)) + p_bar.close() return results @@ -173,7 +202,7 @@ def plot_results( lower = np.clip(mean - ci, np.finfo(float).tiny, None) ax.fill_between(dimension, lower, mean + ci, alpha=0.2, color=line.get_color()) ax.set_title(title) - ax.set_xlabel("matrix dimension (2n)") + ax.set_xlabel("matrix dimension") ax.set_ylabel(ylabel) ax.set_xscale("log", base=2) ax.set_yscale("log") diff --git a/notebooks/strategies_benchmark.ipynb b/notebooks/strategies_benchmark.ipynb index 01c8469..66842f0 100644 --- a/notebooks/strategies_benchmark.ipynb +++ b/notebooks/strategies_benchmark.ipynb @@ -4,56 +4,22 @@ "cell_type": "markdown", "id": "56c973ab", "metadata": {}, - "source": [ - "# Benchmarking the Pfaffian strategies\n", - "\n", - "This notebook benchmarks the available Pfaffian strategies in terms of **time** and **memory** for both the **forward** and **backward** passes.\n", - "\n", - "Four strategies are compared:\n", - "\n", - "- `PfaffianFDBPf`: computes the Pfaffian from `sqrt(|det(A)|)` with a custom **analytic** backward. Valid for any skew-symmetric matrix.\n", - "- `PfaffianBlockDet`: computes the Pfaffian from the determinant of the upper-right block, with a custom analytic backward.\n", - "- `PfaffianDet`: a reference baseline that also computes `pf = sqrt(|det(A)|)` but differentiates straight through `det`/`sqrt` with **plain autograd** (no custom backward), to expose the cost of naive autodiff against the analytic backward of `PfaffianFDBPf`.\n", - "- `PfaffianParlettReid`: computes the **signed** Pfaffian via batched Parlett-Reid skew-tridiagonalization, with a custom analytic backward. Valid for any skew-symmetric matrix.\n", - "\n", - "Each strategy is invoked through `Strategy.apply(matrix)`.\n", - "\n", - "For each strategy and matrix size we report, **averaged over 20 random seeds with 95% confidence intervals**:\n", - "\n", - "- the median forward time,\n", - "- the median backward time,\n", - "- the forward peak memory,\n", - "- the forward + backward peak memory." - ] + "source": "# Benchmarking the Pfaffian strategies\n\nThis notebook benchmarks the available Pfaffian strategies in terms of **time** and **memory** for both the **forward** and **backward** passes.\n\nFive strategies are compared:\n\n- `PfaffianFDBPf`: computes the Pfaffian from `sqrt(|det(A)|)` with a custom **analytic** backward. Valid for any skew-symmetric matrix.\n- `PfaffianBlockDet`: computes the Pfaffian from the determinant of the upper-right block, with a custom analytic backward.\n- `PfaffianDet`: a reference baseline that also computes `pf = sqrt(|det(A)|)` but differentiates straight through `det`/`sqrt` with **plain autograd** (no custom backward), to expose the cost of naive autodiff against the analytic backward of `PfaffianFDBPf`.\n- `PfaffianParlettReid`: computes the **signed** Pfaffian via batched Parlett-Reid skew-tridiagonalization, with a custom analytic backward. Valid for any skew-symmetric matrix.\n- `RustPfaffianParlettReid`: the same signed Parlett-Reid forward implemented in Rust (PyO3), with the analytic PyTorch backward. Available when the native extension is built.\n\nEach strategy is invoked through `Strategy.apply(matrix)`.\n\nFor each strategy and matrix size we report, **averaged over 20 random seeds with 95% confidence intervals**:\n\n- the median forward time,\n- the median backward time,\n- the forward peak memory,\n- the forward + backward peak memory." }, { "cell_type": "markdown", "id": "55b95a09", "metadata": {}, - "source": [ - "## Validity note\n", - "\n", - "`PfaffianBlockDet`'s forward only returns the *true* Pfaffian for **block-antidiagonal** skew matrices of the form\n", - "\n", - "$$ A = \\begin{pmatrix} 0 & B \\\\ -B^{T} & 0 \\end{pmatrix}. $$\n", - "\n", - "To keep the comparison both **fair** and **numerically valid**, we benchmark *all* strategies on block-antidiagonal inputs. `PfaffianFDBPf` and `PfaffianDet` are valid on any skew matrix (including this form), so this input shape is a common ground on which all strategies compute the same quantity." - ] + "source": "## Validity note\n\n`PfaffianBlockDet`'s forward only returns the *true* Pfaffian for **block-antidiagonal** skew matrices of the form\n\n$$ A = \\begin{pmatrix} 0 & B \\\\ -B^{T} & 0 \\end{pmatrix}. $$\n\nSo when it is benchmarked, `PfaffianBlockDet` is fed block-antidiagonal inputs, the only shape on which it is valid. Every other strategy is valid on **any** skew-symmetric matrix, so those are benchmarked on **general (dense) random skew-symmetric matrices** — a representative, unstructured workload. Each strategy is therefore measured on an input it computes correctly." }, { "cell_type": "code", "execution_count": 1, - "id": "2305932f", + "id": "657871cca9161529", "metadata": { "ExecuteTime": { - "end_time": "2026-06-10T14:25:10.025490742Z", - "start_time": "2026-06-10T14:25:08.874486863Z" - }, - "execution": { - "iopub.execute_input": "2026-06-10T18:28:57.150290Z", - "iopub.status.busy": "2026-06-10T18:28:57.149845Z", - "iopub.status.idle": "2026-06-10T18:28:58.931824Z", - "shell.execute_reply": "2026-06-10T18:28:58.929314Z" + "end_time": "2026-06-11T11:54:45.638647773Z", + "start_time": "2026-06-11T11:54:44.418952207Z" } }, "outputs": [ @@ -63,6 +29,14 @@ "text": [ "Running benchmarks on device: cpu\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/local/USHERBROOKE/ginj2102/github/TorchPfaffian/.venv/lib/python3.14/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] } ], "source": [ @@ -76,12 +50,23 @@ "import torch\n", "from _strategies_benchmark_helpers import benchmark_strategies, plot_results\n", "\n", - "from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet\n", "from torch_pfaffian.strategies.pfaffian_det import PfaffianDet\n", "from torch_pfaffian.strategies.pfaffian_fdbpf import PfaffianFDBPf\n", "from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid\n", "\n", - "strategies = [PfaffianFDBPf, PfaffianBlockDet, PfaffianDet, PfaffianParlettReid]\n", + "try:\n", + " from torch_pfaffian.strategies.pfaffian_rust_parlett_reid import RustPfaffianParlettReid\n", + "except ImportError:\n", + " RustPfaffianParlettReid = None\n", + "\n", + "strategies = [\n", + " PfaffianFDBPf,\n", + " # PfaffianBlockDet,\n", + " PfaffianDet,\n", + " PfaffianParlettReid,\n", + "]\n", + "if RustPfaffianParlettReid is not None:\n", + " strategies.append(RustPfaffianParlettReid)\n", "\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "print(f\"Running benchmarks on device: {device}\")" @@ -94,23 +79,16 @@ "source": [ "## Running the benchmark\n", "\n", - "The benchmarking and plotting logic lives in `_strategies_benchmark_helpers.py` to keep this notebook focused on the narrative. `benchmark_strategies` sweeps the matrix dimension `2n` and, for every strategy, measures each metric once per seed across `n_seeds` seeds, returning the across-seed mean and the half-width of the 95% confidence interval." + "The benchmarking and plotting logic lives in `_strategies_benchmark_helpers.py` to keep this notebook focused on the narrative. `benchmark_strategies` sweeps the matrix dimension `n` and, for every strategy, measures each metric once per seed across `n_seeds` seeds, returning the across-seed mean and the half-width of the 95% confidence interval." ] }, { "cell_type": "code", - "execution_count": 2, - "id": "b6a3c6b4", + "execution_count": null, + "id": "6ace4294c6d4b34", "metadata": { "ExecuteTime": { - "end_time": "2026-06-10T14:25:22.671153790Z", - "start_time": "2026-06-10T14:25:10.033292322Z" - }, - "execution": { - "iopub.execute_input": "2026-06-10T18:28:58.937516Z", - "iopub.status.busy": "2026-06-10T18:28:58.937064Z", - "iopub.status.idle": "2026-06-10T18:29:48.414060Z", - "shell.execute_reply": "2026-06-10T18:29:48.412091Z" + "start_time": "2026-06-11T11:54:45.649903607Z" } }, "outputs": [ @@ -118,171 +96,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/local/USHERBROOKE/ginj2102/github/TorchPfaffian/.venv/lib/python3.14/site-packages/torch/profiler/profiler.py:217: UserWarning: Warning: Profiler clears events at the end of each cycle.Only events from the current cycle will be reported.To keep events across cycles, set acc_events=True.\n", - " _warn_once(\n" + "Benchmarking PfaffianFDBPf (n: 2 | seed: 0 ): 0%| | 0/640 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plot_results(results, strategies, batch_size, device=device)" ] @@ -333,18 +140,7 @@ "cell_type": "markdown", "id": "8e444db9", "metadata": {}, - "source": [ - "## Conclusions and caveats\n", - "\n", - "The figure above reports, as a function of the matrix dimension $2n$, the median forward time, the median backward time, the forward peak memory, and the combined forward + backward peak memory for every strategy, evaluated on block-antidiagonal skew matrices. Shaded bands are 95% confidence intervals over the 20 seeds (they are essentially invisible for memory, which is seed-independent for a fixed shape).\n", - "\n", - "**Memory-metric caveat.** The memory numbers depend on the device:\n", - "\n", - "- On **CUDA**, the reported value is a true peak obtained from `torch.cuda.reset_peak_memory_stats()` / `torch.cuda.max_memory_allocated()`.\n", - "- On **CPU** (the continuous-integration case), no equivalent peak counter exists, so we report the **allocated bytes** measured by `torch.profiler` instead. This is an aggregate of allocations rather than a strict instantaneous peak, so CPU and CUDA memory values are not directly comparable and the absolute CPU numbers should be read as a relative indicator across strategies and sizes.\n", - "\n", - "`PfaffianFDBPf` and `PfaffianDet` share the same forward (`sqrt(|det(A)|)`); their difference is the backward, so the backward panels highlight the analytic custom backward against plain autograd." - ] + "source": "## Conclusions and caveats\n\nThe figure above reports, as a function of the matrix dimension $n$, the median forward time, the median backward time, the forward peak memory, and the combined forward + backward peak memory for every strategy. The general-purpose strategies are evaluated on general random skew-symmetric matrices; `PfaffianBlockDet`, when included, is evaluated on block-antidiagonal skew matrices (the only inputs for which it is valid). Shaded bands are 95% confidence intervals over the random seeds (they are essentially invisible for memory, which is seed-independent for a fixed shape).\n\n**Memory-metric caveat.** The memory numbers depend on the device:\n\n- On **CUDA**, the reported value is a true peak obtained from `torch.cuda.reset_peak_memory_stats()` / `torch.cuda.max_memory_allocated()`.\n- On **CPU** (the continuous-integration case), no equivalent peak counter exists, so we report the **allocated bytes** measured by `torch.profiler` instead. This is an aggregate of allocations rather than a strict instantaneous peak, so CPU and CUDA memory values are not directly comparable and the absolute CPU numbers should be read as a relative indicator across strategies and sizes.\n\n`PfaffianFDBPf` and `PfaffianDet` share the same forward (`sqrt(|det(A)|)`); their difference is the backward, so the backward panels highlight the analytic custom backward against plain autograd." } ], "metadata": { diff --git a/pyproject.toml b/pyproject.toml index c789a1b..af00376 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,10 +19,9 @@ classifiers = [ ] dependencies = [ "numpy (>=1.23,<3.0.0)", - "setuptools (>=80.10)", "torch (>=2.1,<3.0.0)", ] -dynamic = ["readme"] +readme = "README.md" [project.urls] homepage = "https://github.com/MatchCake/TorchPfaffian" @@ -58,6 +57,8 @@ dev = [ "pytest-timeout>=2.4", "pip>=25", "pre-commit>=4.5.1", + "maturin>=1.0,<2", + "tqdm>=4.68.2", ] docs = [ "wheel>=0.45,<0.46", @@ -124,25 +125,15 @@ url = "https://download.pytorch.org/whl/cu130" explicit = true [build-system] -requires = [ - "setuptools>=57.0.0", - "wheel>=0.45.1,<0.46", - "build>=1.2.2.post1,<2", - "twine>=6.1.0,<7", -] -build-backend = "setuptools.build_meta" - -[tool.setuptools.dynamic] -readme = { file = "README.md", content-type = "text/markdown" } - -[tool.setuptools] -package-dir = { "" = "src" } - -[tool.setuptools.packages.find] -where = ["src"] - -[tool.setuptools.package-data] -torch_pfaffian = ["py.typed"] +requires = ["maturin>=1.0,<2"] +build-backend = "maturin" + +[tool.maturin] +python-source = "src" +manifest-path = "rust/Cargo.toml" +module-name = "torch_pfaffian._rust" +features = ["pyo3/extension-module"] +include = ["src/torch_pfaffian/py.typed"] [tool.coverage.report] exclude_also = [ diff --git a/requirements.txt b/requirements.txt index 7141f32..0218332 100644 --- a/requirements.txt +++ b/requirements.txt @@ -40,6 +40,7 @@ colorama==0.4.6 ; os_name == 'nt' or sys_platform == 'win32' # ipython # pytest # sphinx + # tqdm comm==0.2.3 # via ipykernel contourpy==1.3.2 ; python_full_version < '3.11' @@ -181,6 +182,7 @@ matplotlib-inline==0.2.2 # via # ipykernel # ipython +maturin==1.13.3 mdit-py-plugins==0.6.1 # via myst-parser mdurl==0.1.2 @@ -360,10 +362,8 @@ rpds-py==2026.5.1 ; python_full_version >= '3.11' ruff==0.15.16 secretstorage==3.5.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'linux' # via keyring -setuptools==82.0.1 - # via - # torch - # torchpfaffian +setuptools==82.0.1 ; python_full_version >= '3.12' + # via torch six==1.17.0 # via python-dateutil snowballstemmer==3.1.1 @@ -411,6 +411,7 @@ tomli==2.4.1 ; python_full_version <= '3.11' # via # build # coverage + # maturin # mypy # pytest torch==2.10.0 @@ -419,6 +420,7 @@ tornado==6.5.7 # via # ipykernel # jupyter-client +tqdm==4.68.2 traitlets==5.15.1 # via # ipykernel diff --git a/rust/Cargo.lock b/rust/Cargo.lock new file mode 100644 index 0000000..37519ad --- /dev/null +++ b/rust/Cargo.lock @@ -0,0 +1,323 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "crossbeam-deque" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" + +[[package]] +name = "either" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "indoc" +version = "2.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706" +dependencies = [ + "rustversion", +] + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "matrixmultiply" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08" +dependencies = [ + "autocfg", + "rawpointer", +] + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "ndarray" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841" +dependencies = [ + "matrixmultiply", + "num-complex", + "num-integer", + "num-traits", + "portable-atomic", + "portable-atomic-util", + "rawpointer", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "numpy" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b94caae805f998a07d33af06e6a3891e38556051b8045c615470a71590e13e78" +dependencies = [ + "libc", + "ndarray", + "num-complex", + "num-integer", + "num-traits", + "pyo3", + "rustc-hash", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "portable-atomic" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" + +[[package]] +name = "portable-atomic-util" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "pyo3" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872" +dependencies = [ + "cfg-if", + "indoc", + "libc", + "memoffset", + "once_cell", + "portable-atomic", + "pyo3-build-config", + "pyo3-ffi", + "pyo3-macros", + "unindent", +] + +[[package]] +name = "pyo3-build-config" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb" +dependencies = [ + "once_cell", + "target-lexicon", +] + +[[package]] +name = "pyo3-ffi" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d" +dependencies = [ + "libc", + "pyo3-build-config", +] + +[[package]] +name = "pyo3-macros" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da" +dependencies = [ + "proc-macro2", + "pyo3-macros-backend", + "quote", + "syn", +] + +[[package]] +name = "pyo3-macros-backend" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028" +dependencies = [ + "heck", + "proc-macro2", + "pyo3-build-config", + "quote", + "syn", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "rayon" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "rustc-hash" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "target-lexicon" +version = "0.12.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1" + +[[package]] +name = "torch_pfaffian_rust" +version = "0.0.1" +dependencies = [ + "ndarray", + "num-traits", + "numpy", + "pyo3", + "rayon", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unindent" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3" diff --git a/rust/Cargo.toml b/rust/Cargo.toml new file mode 100644 index 0000000..6b8deef --- /dev/null +++ b/rust/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "torch_pfaffian_rust" +version = "0.0.1" +edition = "2021" + +[lib] +name = "_rust" +crate-type = ["cdylib"] + +[dependencies] +pyo3 = { version = "0.23", features = ["abi3-py310", "extension-module"] } +numpy = "0.23" +ndarray = "0.16" +num-traits = "0.2" +rayon = "1" diff --git a/rust/src/lib.rs b/rust/src/lib.rs new file mode 100644 index 0000000..0fd6912 --- /dev/null +++ b/rust/src/lib.rs @@ -0,0 +1,164 @@ +use num_traits::Float; +use numpy::ndarray::{Array1, Array2, Axis}; +use numpy::{IntoPyArray, PyArray1, PyReadonlyArray3}; +use pyo3::prelude::*; +use rayon::prelude::*; + +const PIVOT_EPSILON: f64 = 1e-30; + +/// Batches with at least this many matrices are evaluated in parallel across threads; smaller +/// batches run serially to avoid thread-pool overhead. +const PARALLEL_BATCH_THRESHOLD: usize = 8; + +/// Signed Pfaffian of a single skew-symmetric matrix via Parlett-Reid elimination. +/// +/// Generic over the floating precision so the same algorithm serves ``f32`` and ``f64`` inputs. +/// The matrix is copied into a flat row-major buffer so the hot rank-2 Schur update runs over a +/// contiguous row slice, which the compiler can auto-vectorize (far cheaper than per-element +/// strided ndarray indexing). +fn pfaffian_one(matrix: Array2) -> T { + let dimension = matrix.nrows(); + if dimension % 2 == 1 { + return T::zero(); + } + if dimension == 0 { + return T::one(); + } + let mut data: Vec = matrix.iter().copied().collect(); // row-major, len dimension * dimension + let epsilon = T::from(PIVOT_EPSILON).unwrap(); + let mut sign = T::one(); + let mut column = 0usize; + while column + 2 < dimension { + // Partial pivoting: largest |data[row, column]| for row > column + 1. + let mut pivot_row = column + 2; + let mut best = data[(column + 2) * dimension + column].abs(); + for row in (column + 3)..dimension { + let candidate = data[row * dimension + column].abs(); + if candidate > best { + best = candidate; + pivot_row = row; + } + } + if best > data[(column + 1) * dimension + column].abs() { + // Congruence swap of rows then columns column+1 <-> pivot_row. + for index in 0..dimension { + data.swap((column + 1) * dimension + index, pivot_row * dimension + index); + } + for index in 0..dimension { + data.swap(index * dimension + (column + 1), index * dimension + pivot_row); + } + sign = -sign; + } + let pivot = data[(column + 1) * dimension + column]; + if pivot.abs() < epsilon { + return T::zero(); + } + // Rank-2 skew Schur-complement update on the trailing block, read from originals. + let base = column + 2; + let length = dimension - base; + let tau: Vec = (0..length).map(|k| data[(base + k) * dimension + column] / pivot).collect(); + let next: Vec = (0..length).map(|k| data[(base + k) * dimension + (column + 1)]).collect(); + for row_offset in 0..length { + let tau_row = tau[row_offset]; + let next_row = next[row_offset]; + let start = (base + row_offset) * dimension + base; + let row = &mut data[start..start + length]; + for column_offset in 0..length { + row[column_offset] = + row[column_offset] + tau_row * next[column_offset] - next_row * tau[column_offset]; + } + } + column += 2; + } + let mut pfaffian = sign; + let mut index = 0usize; + while index < dimension { + pfaffian = pfaffian * data[index * dimension + (index + 1)]; + index += 2; + } + pfaffian +} + +/// Signed Pfaffian of each owned matrix, computed in parallel across the batch above a threshold. +/// +/// The batch elements are independent, so they are mapped over rayon threads; the per-matrix +/// Parlett-Reid elimination itself stays sequential. The caller releases the GIL around this. +fn signed_pfaffian_owned(matrices: Vec>) -> Vec { + if matrices.len() >= PARALLEL_BATCH_THRESHOLD { + matrices.into_par_iter().map(pfaffian_one).collect() + } else { + matrices.into_iter().map(pfaffian_one).collect() + } +} + +/// Copy each ``(n, n)`` slice of a ``(batch, n, n)`` view into an owned matrix. +fn owned_matrices(matrix: &PyReadonlyArray3<'_, T>) -> Vec> { + let view = matrix.as_array(); + let batch = view.shape()[0]; + (0..batch).map(|index| view.index_axis(Axis(0), index).to_owned()).collect() +} + +/// Signed Pfaffian of a batch of ``float64`` skew-symmetric matrices, shape ``(batch, n, n)``. +#[pyfunction] +fn signed_pfaffian_f64<'py>(py: Python<'py>, matrix: PyReadonlyArray3<'py, f64>) -> Bound<'py, PyArray1> { + let matrices = owned_matrices(&matrix); + let results = py.allow_threads(|| signed_pfaffian_owned(matrices)); + Array1::from(results).into_pyarray(py) +} + +/// Signed Pfaffian of a batch of ``float32`` skew-symmetric matrices, shape ``(batch, n, n)``. +#[pyfunction] +fn signed_pfaffian_f32<'py>(py: Python<'py>, matrix: PyReadonlyArray3<'py, f32>) -> Bound<'py, PyArray1> { + let matrices = owned_matrices(&matrix); + let results = py.allow_threads(|| signed_pfaffian_owned(matrices)); + Array1::from(results).into_pyarray(py) +} + +#[pymodule] +fn _rust(module: &Bound<'_, PyModule>) -> PyResult<()> { + module.add_function(wrap_pyfunction!(signed_pfaffian_f64, module)?)?; + module.add_function(wrap_pyfunction!(signed_pfaffian_f32, module)?)?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::pfaffian_one; + use numpy::ndarray::array; + + #[test] + fn two_by_two_is_signed() { + // pf([[0, -3], [3, 0]]) = -3 + let m = array![[0.0_f64, -3.0], [3.0, 0.0]]; + assert!((pfaffian_one(m) - (-3.0)).abs() < 1e-12); + } + + #[test] + fn four_by_four_matches_pfaffian_formula() { + // For [[0,a,b,c],[-a,0,d,e],[-b,-d,0,f],[-c,-e,-f,0]], pf = a*f - b*e + c*d. + let (a, b, c, d, e, f) = (1.0_f64, 2.0, 3.0, 4.0, 5.0, 6.0); + let m = array![ + [0.0, a, b, c], + [-a, 0.0, d, e], + [-b, -d, 0.0, f], + [-c, -e, -f, 0.0] + ]; + let expected = a * f - b * e + c * d; // = 6 - 10 + 12 = 8 + assert!((pfaffian_one(m) - expected).abs() < 1e-9); + } + + #[test] + fn f32_two_by_two_is_signed() { + // Same algorithm in single precision. + let m = array![[0.0_f32, -3.0], [3.0, 0.0]]; + assert!((pfaffian_one(m) - (-3.0)).abs() < 1e-5); + } + + #[test] + fn odd_is_zero_and_empty_is_one() { + let odd = array![[0.0_f64, 1.0, 2.0], [-1.0, 0.0, 3.0], [-2.0, -3.0, 0.0]]; + assert_eq!(pfaffian_one(odd), 0.0); + let empty = numpy::ndarray::Array2::::zeros((0, 0)); + assert_eq!(pfaffian_one(empty), 1.0); + } +} diff --git a/setup.py b/setup.py deleted file mode 100644 index 53a465e..0000000 --- a/setup.py +++ /dev/null @@ -1,40 +0,0 @@ -import setuptools -from setuptools import setup - -setup( - name="TorchPfaffian", - long_description="file: README.md", - long_description_content_type="text/markdown", - package_dir={"": "src"}, - packages=setuptools.find_packages(where="src"), - python_requires=">=3.10", - classifiers=[ - "Development Status :: 3 - Alpha", - "Intended Audience :: Science/Research", - "License :: OSI Approved :: Apache Software License", - "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.10", - "Programming Language :: Python :: 3.11", - "Topic :: Scientific/Engineering", - "Topic :: Scientific/Engineering :: Artificial Intelligence", - "Topic :: Software Development :: Libraries :: Python Modules", - "Operating System :: OS Independent", - ], - project_urls={ - "Homepage": "https://github.com/MatchCake/TorchPfaffian", - "Source": "https://github.com/MatchCake/TorchPfaffian", - "Documentation": "https://MatchCake.github.io/TorchPfaffian", - }, -) - - -# build library -# setup.py sdist bdist_wheel -# With pyproject.toml -# python -m pip install --upgrade build -# python -m build - -# publish on PyPI -# twine check dist/* -# twine upload --repository-url https://test.pypi.org/legacy/ dist/* -# twine upload dist/* diff --git a/src/torch_pfaffian/__init__.py b/src/torch_pfaffian/__init__.py index 7d79315..c600127 100644 --- a/src/torch_pfaffian/__init__.py +++ b/src/torch_pfaffian/__init__.py @@ -10,7 +10,10 @@ __license__ = "Apache 2.0" __url__ = "https://github.com/MatchCake/TorchPfaffian" __package__ = "torch_pfaffian" -__version__ = importlib_metadata.version(__package__) +try: + __version__ = importlib_metadata.version(__package__) +except importlib_metadata.PackageNotFoundError: + __version__ = importlib_metadata.version("TorchPfaffian") import warnings from collections.abc import Callable @@ -33,38 +36,59 @@ def get_pfaffian_function(name: str = PfaffianFDBPf.NAME) -> Callable[[torch.Ten return pfaffian_strategy_map[name].apply -_OPTIMIZE_CHOICES = ("auto", "time", "memory") - - -def pfaffian(matrix: torch.Tensor, *, sign: bool = True, optimize: str = "auto") -> torch.Tensor: +def pfaffian(matrix: torch.Tensor, *, sign: bool = True, check_input: bool = False) -> torch.Tensor: """ - Compute the Pfaffian of a skew-symmetric matrix, choosing a strategy from the input. + Compute the Pfaffian of a skew-symmetric matrix, choosing the strategy from the input. The matrix has shape ``(..., 2n, 2n)`` and the result has shape ``(...,)``, sharing the backend, dtype, and device of ``matrix``. - Strategy selection (``optimize="auto"``): + Strategy selection: - =========================== ====================== ================================================= - Condition Strategy Reason - =========================== ====================== ================================================= - ``sign=True`` (default) ``PfaffianParlettReid`` only general strategy that returns the sign - ``sign=False``, grad needed ``PfaffianFDBPf`` magnitude only; robust analytic backward (pinv) - ``sign=False``, no grad ``PfaffianDet`` cheapest: ``sqrt(|det|)`` only - =========================== ====================== ================================================= + ============================= =========================== =============================================== + Condition Strategy Reason + ============================= =========================== =============================================== + ``sign=True``, Rust available ``RustPfaffianParlettReid`` fastest signed path (native Rust kernel) + ``sign=True``, Rust not built ``PfaffianParlettReid`` pure-Python signed fallback + ``sign=False``, grad needed ``PfaffianFDBPf`` magnitude only; robust analytic backward (pinv) + ``sign=False``, no grad ``PfaffianDet`` cheapest: ``sqrt(|det|)`` only + ============================= =========================== =============================================== + + The Pfaffian is only defined for skew-symmetric matrices; the strategies assume this and do not + check it. Pass ``check_input=True`` to validate the assumption. For large matrices the Pfaffian + can exceed the floating range and overflow to ``inf``; a ``RuntimeWarning`` is emitted when the + result is not finite. :param matrix: Skew-symmetric matrix of shape ``(..., 2n, 2n)``. :param sign: When ``True`` (default) return the signed Pfaffian, otherwise its magnitude. - :param optimize: Optimization target, one of ``"auto"``, ``"time"``, ``"memory"``. Currently a - tie-breaker reserved for when more strategies are available; ``"auto"`` follows the table above. + :param check_input: When ``True``, validate that ``matrix`` is square in its last two dimensions + and skew-symmetric (``A == -A^T``) before computing, raising ``ValueError`` otherwise. Off by + default (``False``) so trusted inputs pay nothing; the check is an O(n^2) comparison, cheap + relative to the O(n^3) Pfaffian. :return: The Pfaffian of the input, of shape ``(...,)``. :rtype: torch.Tensor """ - if optimize not in _OPTIMIZE_CHOICES: - raise ValueError(f"Unknown optimize value: {optimize!r}. Choose from {_OPTIMIZE_CHOICES}.") + if check_input: + if matrix.shape[-1] != matrix.shape[-2]: + raise ValueError(f"Expected a square matrix in the last two dimensions, got shape {tuple(matrix.shape)}.") + if not torch.allclose(matrix, -matrix.transpose(-1, -2)): + raise ValueError("Input matrix is not skew-symmetric (A != -A^T).") + if sign: - return PfaffianParlettReid.apply(matrix) - grad_needed = matrix.requires_grad and torch.is_grad_enabled() - if grad_needed: - return PfaffianFDBPf.apply(matrix) - return PfaffianDet.apply(matrix) + if RustPfaffianParlettReid is not None: + result = RustPfaffianParlettReid.apply(matrix) + else: + result = PfaffianParlettReid.apply(matrix) + elif matrix.requires_grad and torch.is_grad_enabled(): + result = PfaffianFDBPf.apply(matrix) + else: + result = PfaffianDet.apply(matrix) + + if not torch.isfinite(result).all(): + warnings.warn( + "Pfaffian is not finite (overflow to inf/nan): its magnitude exceeds the floating range " + "of the input dtype at this matrix dimension. Consider a higher-precision dtype.", + RuntimeWarning, + stacklevel=2, + ) + return result diff --git a/src/torch_pfaffian/strategies/__init__.py b/src/torch_pfaffian/strategies/__init__.py index a63ea23..d37d1d4 100644 --- a/src/torch_pfaffian/strategies/__init__.py +++ b/src/torch_pfaffian/strategies/__init__.py @@ -7,3 +7,8 @@ from .pfaffian_fdbpf import PfaffianFDBPf from .pfaffian_parlett_reid import PfaffianParlettReid from .strategy import PfaffianStrategy + +try: + from .pfaffian_rust_parlett_reid import RustPfaffianParlettReid +except ImportError: + RustPfaffianParlettReid = None diff --git a/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py b/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py index 7e54b68..740465d 100644 --- a/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py +++ b/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py @@ -12,8 +12,11 @@ class PfaffianParlettReid(PfaffianStrategy): The forward performs a batched skew-tridiagonalization with partial pivoting: the batch is processed together and only the ``n / 2`` column-elimination steps are sequential. The result is the signed Pfaffian, unlike the determinant-based strategies which return only the magnitude. - The backward uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T``, a single matrix - inverse with no autograd graph over the elimination. + The backward uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T`` via a single + pseudo-inverse, with no autograd graph over the elimination. It equals the inverse for invertible + inputs (the exact gradient) and returns a finite zero on singular inputs instead of raising. At an + exactly-singular input that zero is the analytic continuation, not the true derivative, but such + points are measure-zero. The input is a skew-symmetric matrix of shape ``(..., 2n, 2n)``. """ @@ -89,6 +92,10 @@ def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch. matrix, pfaffian = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) grad_matrix = None if ctx.needs_input_grad[0]: - inverse = torch.linalg.inv(matrix) + # Use pinv, not inv: identical to inv for invertible A (exact gradient), but on a + # singular A it returns a finite 0 (since pf = 0) instead of raising. That 0 is the + # analytic continuation, not the true derivative at the exactly-singular point; such + # points are measure-zero and the forward there is also 0, so this is acceptable. + inverse = torch.linalg.pinv(matrix) grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pfaffian, inverse) return grad_matrix diff --git a/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py b/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py new file mode 100644 index 0000000..2827bd4 --- /dev/null +++ b/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py @@ -0,0 +1,66 @@ +from typing import cast + +import torch + +from .. import _rust +from .strategy import PfaffianStrategy + + +class RustPfaffianParlettReid(PfaffianStrategy): + """ + Compute the signed Pfaffian with the Rust Parlett-Reid kernel. + + The forward moves the input to a contiguous CPU array and calls the compiled + ``torch_pfaffian._rust`` kernel at a precision chosen from the input dtype: ``float32`` inputs + use the single-precision kernel and every other floating dtype uses the double-precision kernel. + The result is cast back to the input dtype and device. The backward is the same closed form as + :class:`PfaffianParlettReid`, ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T``, computed in PyTorch. + CUDA inputs are evaluated on CPU for the forward; the backward inverse runs on the input device. + + The input is a skew-symmetric matrix of shape ``(..., n, n)``. + """ + + NAME = "RustPfaffianParlettReid" + + @staticmethod + def forward(matrix: torch.Tensor) -> torch.Tensor: + dimension = matrix.shape[-1] + if dimension % 2 != 0: + return torch.zeros(matrix.shape[:-2], dtype=matrix.dtype, device=matrix.device) + if dimension == 0: + return torch.ones(matrix.shape[:-2], dtype=matrix.dtype, device=matrix.device) + flat = matrix.reshape(-1, dimension, dimension) # (batch, n, n) + if matrix.dtype == torch.float32: + working_dtype = torch.float32 + kernel = _rust.signed_pfaffian_f32 + else: + working_dtype = torch.float64 + kernel = _rust.signed_pfaffian_f64 + array = flat.detach().to(working_dtype).cpu().contiguous().numpy() + result = kernel(array) # (batch,) in working_dtype + pfaffian = torch.from_numpy(result).to(dtype=matrix.dtype, device=matrix.device) + return pfaffian.reshape(matrix.shape[:-2]) + + @staticmethod + def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch.Tensor) -> torch.Tensor | None: + r""" + Gradient of the signed Pfaffian with respect to the input matrix. + + .. math:: + \frac{\partial \text{pf}(A)}{\partial A_{ij}} = \frac{\text{pf}(A)}{2} (A^{-1})_{ji} + + :param ctx: Context holding the saved input matrix and the forward Pfaffian. + :param grad_output: Gradient of the output with respect to the loss. + :return: Gradient of the input matrix, or ``None`` when the input does not require grad. + :rtype: torch.Tensor | None + """ + matrix, pfaffian = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) + grad_matrix = None + if ctx.needs_input_grad[0]: + # Use pinv, not inv: identical to inv for invertible A (exact gradient), but on a + # singular A it returns a finite 0 (since pf = 0) instead of raising. That 0 is the + # analytic continuation, not the true derivative at the exactly-singular point; such + # points are measure-zero and the forward there is also 0, so this is acceptable. + inverse = torch.linalg.pinv(matrix) + grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pfaffian, inverse) + return grad_matrix diff --git a/tests/test_strategies/test_pfaffian_parlett_reid.py b/tests/test_strategies/test_pfaffian_parlett_reid.py index c7ce62c..f30d908 100644 --- a/tests/test_strategies/test_pfaffian_parlett_reid.py +++ b/tests/test_strategies/test_pfaffian_parlett_reid.py @@ -132,6 +132,18 @@ def test_backward_passes_gradcheck_on_skew_parameterization(self, dimension): rtol=RTOL_APPROX_COMPARISON, ) + def test_backward_finite_on_singular_matrix(self): + # Singular skew matrix (pf=0): the guarantee is that backward is FINITE (no LinAlgError), + # which pinv provides over inv. The returned zero is the analytic continuation, not the true + # derivative at this exactly-singular point, so we only assert finiteness here. + matrix = torch.zeros((4, 4), dtype=torch.float64) + matrix[2, 3] = 1.0 + matrix[3, 2] = -1.0 + matrix.requires_grad_(True) + PfaffianParlettReid.apply(matrix).backward() + assert matrix.grad is not None + assert torch.isfinite(matrix.grad).all() + def test_backward_returns_none_when_input_does_not_require_grad(self): matrix = _random_skew(4, _RNG) pfaffian = PfaffianParlettReid.apply(matrix) diff --git a/tests/test_strategies/test_pfaffian_rust_parlett_reid.py b/tests/test_strategies/test_pfaffian_rust_parlett_reid.py new file mode 100644 index 0000000..6005a0e --- /dev/null +++ b/tests/test_strategies/test_pfaffian_rust_parlett_reid.py @@ -0,0 +1,168 @@ +import numpy as np +import pytest +import torch +from torch.autograd import gradcheck + +pytest.importorskip("torch_pfaffian._rust") + +from tests.configs import ( # noqa: E402 + ATOL_APPROX_COMPARISON, + ATOL_MATRIX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_MATRIX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid # noqa: E402 +from torch_pfaffian.strategies.pfaffian_rust_parlett_reid import RustPfaffianParlettReid # noqa: E402 + +_RNG = np.random.default_rng(TEST_SEED) +_HALF_SIZES = [1, 2, 3, 4] +_RANDOM_BLOCKS = [_RNG.random((size, size)) for size in _HALF_SIZES for _ in range(N_RANDOM_TESTS_PER_CASE)] +_GRADCHECK_DIMENSIONS = [2, 4, 6] + + +def _block_antidiagonal(block: np.ndarray) -> torch.Tensor: + zero = np.zeros_like(block) + top = np.concatenate([zero, block], axis=-1) + bottom = np.concatenate([-np.einsum("...ij->...ji", block), zero], axis=-1) + return torch.tensor(np.concatenate([top, bottom], axis=-2)) + + +def _random_skew(dimension: int, rng: np.random.Generator) -> torch.Tensor: + upper = rng.random((dimension, dimension)) + skew = np.triu(upper, k=1) + return torch.tensor(skew - skew.T) + + +def _skew_from_parameters(parameters: torch.Tensor, dimension: int) -> torch.Tensor: + upper = torch.zeros(dimension, dimension, dtype=parameters.dtype) + indices = torch.triu_indices(dimension, dimension, offset=1) + upper = upper.index_put((indices[0], indices[1]), parameters) + return upper - upper.transpose(-1, -2) + + +class TestRustPfaffianParlettReid: + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_matches_python_parlett_reid(self, block): + matrix = _block_antidiagonal(block) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + PfaffianParlettReid.apply(matrix), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) + + @pytest.mark.parametrize("block", _RANDOM_BLOCKS) + def test_forward_square_matches_determinant(self, block): + matrix = _block_antidiagonal(block) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix) ** 2, + torch.linalg.det(matrix), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) + + def test_forward_two_by_two_is_signed(self): + matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + torch.tensor(-3.0, dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_supports_leading_batch_dims(self): + matrix = _block_antidiagonal(_RNG.random((2, 3, 4, 4))) + pfaffian = RustPfaffianParlettReid.apply(matrix) + assert pfaffian.shape == matrix.shape[:-2] + torch.testing.assert_close( + pfaffian**2, torch.linalg.det(matrix), atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + + @pytest.mark.parametrize("dtype", [torch.float32, torch.float64]) + def test_forward_preserves_dtype_and_device(self, dtype): + matrix = _random_skew(6, _RNG).to(dtype) + pfaffian = RustPfaffianParlettReid.apply(matrix) + assert pfaffian.dtype == dtype + assert pfaffian.device == matrix.device + + def test_forward_float32_kernel_matches_float64(self): + # The float32 input must route to the single-precision Rust kernel and agree with the + # double-precision result within single-precision tolerance. + matrix_double = _block_antidiagonal(_RNG.random((3, 4, 4))) + matrix_single = matrix_double.to(torch.float32) + result_single = RustPfaffianParlettReid.apply(matrix_single) + result_double = RustPfaffianParlettReid.apply(matrix_double) + assert result_single.dtype == torch.float32 + torch.testing.assert_close( + result_single, + result_double.to(torch.float32), + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) + + def test_forward_odd_dimension_is_zero(self): + matrix = _random_skew(5, _RNG) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + torch.zeros((), dtype=matrix.dtype), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_empty_matrix_is_one(self): + matrix = torch.zeros((0, 0), dtype=torch.float64) + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + torch.ones((), dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_forward_singular_matrix_is_zero(self): + matrix = torch.zeros((4, 4), dtype=torch.float64) + matrix[2, 3] = 1.0 + matrix[3, 2] = -1.0 + torch.testing.assert_close( + RustPfaffianParlettReid.apply(matrix), + torch.zeros((), dtype=torch.float64), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + @pytest.mark.parametrize("dimension", _GRADCHECK_DIMENSIONS) + def test_backward_passes_gradcheck_on_skew_parameterization(self, dimension): + count = dimension * (dimension - 1) // 2 + parameters = torch.tensor(_RNG.random(count) + 0.5, dtype=torch.float64, requires_grad=True) + assert gradcheck( + lambda values: RustPfaffianParlettReid.apply(_skew_from_parameters(values, dimension)), + (parameters,), + eps=1e-6, + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) + + def test_backward_finite_on_singular_matrix(self): + # Singular skew matrix (pf=0): the guarantee is that backward is FINITE (no LinAlgError), + # which pinv provides over inv. The returned zero is the analytic continuation, not the true + # derivative at this exactly-singular point, so we only assert finiteness here. + matrix = torch.zeros((4, 4), dtype=torch.float64) + matrix[2, 3] = 1.0 + matrix[3, 2] = -1.0 + matrix.requires_grad_(True) + RustPfaffianParlettReid.apply(matrix).backward() + assert matrix.grad is not None + assert torch.isfinite(matrix.grad).all() + + def test_backward_returns_none_when_input_does_not_require_grad(self): + matrix = _random_skew(4, _RNG) + pfaffian = RustPfaffianParlettReid.apply(matrix) + + class _Context: + saved_tensors = (matrix, pfaffian) + needs_input_grad = (False,) + + assert RustPfaffianParlettReid.backward(_Context(), torch.ones_like(pfaffian)) is None diff --git a/tests/test_torch_pfaffian.py b/tests/test_torch_pfaffian.py index a3f083f..065f02a 100644 --- a/tests/test_torch_pfaffian.py +++ b/tests/test_torch_pfaffian.py @@ -9,6 +9,14 @@ class TestTorchPfaffian: + def test_rust_parlett_reid_registered_when_available(self): + pytest.importorskip("torch_pfaffian._rust") + from torch_pfaffian.strategies import RustPfaffianParlettReid + + assert RustPfaffianParlettReid is not None + assert RustPfaffianParlettReid.NAME.lower().strip() in pfaffian_strategy_map + assert get_pfaffian_function(RustPfaffianParlettReid.NAME) == RustPfaffianParlettReid.apply + def test_pfaffian_strategy_map_contains_registered_strategies(self): assert PfaffianFDBPf.NAME.lower().strip() in pfaffian_strategy_map assert PfaffianDet.NAME.lower().strip() in pfaffian_strategy_map @@ -52,12 +60,18 @@ def test_pfaffian_sign_false_returns_magnitude(self): torch.testing.assert_close(pfaffian(matrix, sign=False), PfaffianDet.apply(matrix)) assert pfaffian(matrix, sign=False).item() > 0 - def test_pfaffian_invalid_optimize_raises_value_error(self): - with pytest.raises(ValueError, match="optimize"): - pfaffian(self._skew_matrix(), optimize="fastest") + def test_pfaffian_routes_sign_true_to_rust_when_available(self): + pytest.importorskip("torch_pfaffian._rust") + with mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid") as fake: + fake.apply.return_value = torch.zeros(()) + pfaffian(self._skew_matrix(), sign=True) + fake.apply.assert_called_once() - def test_pfaffian_routes_sign_true_to_parlett_reid(self): - with mock.patch.object(torch_pfaffian, "PfaffianParlettReid") as fake: + def test_pfaffian_routes_sign_true_to_python_when_rust_unavailable(self): + with ( + mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid", None), + mock.patch.object(torch_pfaffian, "PfaffianParlettReid") as fake, + ): fake.apply.return_value = torch.zeros(()) pfaffian(self._skew_matrix(), sign=True) fake.apply.assert_called_once() @@ -80,3 +94,32 @@ def test_pfaffian_signed_backward_flows(self): pfaffian(matrix).backward() assert matrix.grad is not None assert matrix.grad.shape == matrix.shape + + def test_pfaffian_check_input_rejects_non_skew(self): + non_skew = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float64) + with pytest.raises(ValueError, match="skew-symmetric"): + pfaffian(non_skew, check_input=True) + + def test_pfaffian_check_input_rejects_non_square(self): + non_square = torch.zeros((2, 4), dtype=torch.float64) + with pytest.raises(ValueError, match="square"): + pfaffian(non_square, check_input=True) + + def test_pfaffian_check_input_accepts_skew_matrix(self): + matrix = self._skew_matrix() + torch.testing.assert_close(pfaffian(matrix, check_input=True), pfaffian(matrix)) + + def test_pfaffian_check_input_off_by_default_allows_non_skew(self): + non_skew = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float64) + pfaffian(non_skew) # no validation by default, so no error is raised + + def test_pfaffian_warns_when_result_overflows(self): + # A 4x4 block-antidiagonal with huge entries makes the Pfaffian overflow to inf. + block = torch.tensor([[1e200, 0.0], [0.0, 1e200]], dtype=torch.float64) + zero = torch.zeros_like(block) + top = torch.cat([zero, block], dim=-1) + bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) + matrix = torch.cat([top, bottom], dim=-2) + with pytest.warns(RuntimeWarning, match="not finite"): + result = pfaffian(matrix) + assert not torch.isfinite(result).all() diff --git a/uv.lock b/uv.lock index 55df965..3fa6a44 100644 --- a/uv.lock +++ b/uv.lock @@ -1793,6 +1793,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, ] +[[package]] +name = "maturin" +version = "1.13.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tomli", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/1c/612d23d33ec21b9ae7ece7b3f0dd5f9dfd57b4009e9d2938165869ebd6ae/maturin-1.13.3.tar.gz", hash = "sha256:771e1e9e71a278e56db01552e0d1acfd1464259f9575b6e72842f893cd299079", size = 357934, upload-time = "2026-05-11T07:43:39.027Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/66/18c2aaac0b2a5dea9f1db5984ce83b905ad205cfc7c02d0091e707c0c2e7/maturin-1.13.3-py3-none-linux_armv6l.whl", hash = "sha256:3cc13929ca82aefa4adbf0f2c35419369796213c6fb0eb24e914945f50ef5d8c", size = 10190971, upload-time = "2026-05-11T07:43:10.431Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/26a988d092e4fd6a9523d46d44400a46cad7cdf3fd206ce702240c748aee/maturin-1.13.3-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:53b08bd075649ce96513ad9abf241a43cb685ed6e9e7790f8dbc2d66e95d8323", size = 19716714, upload-time = "2026-05-11T07:43:36.911Z" }, + { url = "https://files.pythonhosted.org/packages/82/5c/f3fd0e184255d9fc7e272c62af3dfa84c617b2577ef83af9ce615f5279cc/maturin-1.13.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4cd478e6e4c56251e48ed079b8efd55b30bc5c09cf695a1bdafaeb582ee735a0", size = 10194726, upload-time = "2026-05-11T07:43:07.05Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e1/f4edb69fb647b77c4769a9bfd4d6fb62961e653d164bc277ecdffac3ab61/maturin-1.13.3-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:a2675e25f313034ae6f57388cf14818f87d8961c4a96795287f3e155f59beb11", size = 10172781, upload-time = "2026-05-11T07:43:40.796Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7d/a1be934690cdcc3c6609769ceaad322ab7501c2ee5bafcac1b14d609e403/maturin-1.13.3-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:4667ef609ab446c1b5e0bfe4f9fb99699ab6d8548433f8d1a684256e0b67217f", size = 10682670, upload-time = "2026-05-11T07:43:13.132Z" }, + { url = "https://files.pythonhosted.org/packages/18/f5/372ae19b72ce8f6e37e5864ae4dc5b252ee9fce0619ccc3aa366aa3a7f97/maturin-1.13.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:3db93337ed97e60ffc878aa8b493cd7ae44d3a5e1a37256db3a4491f57565018", size = 10060363, upload-time = "2026-05-11T07:43:21.107Z" }, + { url = "https://files.pythonhosted.org/packages/cb/5b/c68340cca09368af0df80965dfabed4234205a492a93da00793c7b9aae20/maturin-1.13.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:1cc0a110b224ca90406b668a3e3c1f5a515062e59e26292f6dbaf5fd4909c6f3", size = 10017551, upload-time = "2026-05-11T07:43:33.916Z" }, + { url = "https://files.pythonhosted.org/packages/28/1e/f90fb2b000bad9e6d850cd5afb88b2f1e2a279cfb4de02ea40078484690e/maturin-1.13.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:c00ea6428dea17bf616fe93770837634454b28c2de1a876e42ef8036c616079a", size = 13301712, upload-time = "2026-05-11T07:43:26.492Z" }, + { url = "https://files.pythonhosted.org/packages/be/58/1670f68a8f04ccd7b90df11047bd9a046585310e84e1967cc9849cd1c5a3/maturin-1.13.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:49fd6ab08da28098ccf37afca24cdba72376ba9c1eedf9dd25ff82ed771961ff", size = 10946765, upload-time = "2026-05-11T07:43:16.135Z" }, + { url = "https://files.pythonhosted.org/packages/4b/ac/00c955c2ef134817b1a7bdaa76b0309e9c5291eb17d9ff88069eecd08bc2/maturin-1.13.3-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:b6741d7bf4af97da937528fd1e523c6ab54f53d9a21870fa735d6e67fd88e273", size = 10388661, upload-time = "2026-05-11T07:43:18.727Z" }, + { url = "https://files.pythonhosted.org/packages/97/c6/cbf8a51dde19c19aeba0d9b075095a2effb9b31fd312b1aae3ac79f8aea2/maturin-1.13.3-py3-none-win32.whl", hash = "sha256:0ef257e692cc756c87af5bea95ddfe7d3ac49d3376a7a87f728d63f06e7b6f8b", size = 8901838, upload-time = "2026-05-11T07:43:23.76Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ff/c6a50a59dc8313097d43ac5f4d74df6a500c8cb62b0dc9e054f53e203a48/maturin-1.13.3-py3-none-win_amd64.whl", hash = "sha256:def4a435ea9d2ee93b18ba579dc8c9cf898889a66f312cd379b5e374ec3e3ad6", size = 10340801, upload-time = "2026-05-11T07:43:29.239Z" }, + { url = "https://files.pythonhosted.org/packages/6c/93/e32e79333f0902ba292b996f504f5f06be59587f7d02ab8d5ed1e3066445/maturin-1.13.3-py3-none-win_arm64.whl", hash = "sha256:2389fe92d017cea9d94e521fa0175314a4c52f79a1057b901fbc9f8686ef7d0b", size = 9706562, upload-time = "2026-05-11T07:43:31.743Z" }, +] + [[package]] name = "mdit-py-plugins" version = "0.6.1" @@ -4142,7 +4166,6 @@ source = { editable = "." } dependencies = [ { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "setuptools" }, { name = "torch", version = "2.10.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130')" }, { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "(sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, @@ -4165,6 +4188,7 @@ cu130 = [ [package.dev-dependencies] dev = [ { name = "build" }, + { name = "maturin" }, { name = "mypy" }, { name = "nbmake" }, { name = "pip" }, @@ -4175,6 +4199,7 @@ dev = [ { name = "pytest-timeout" }, { name = "pytest-xdist" }, { name = "ruff" }, + { name = "tqdm" }, { name = "twine" }, { name = "wheel" }, ] @@ -4199,7 +4224,6 @@ docs = [ [package.metadata] requires-dist = [ { name = "numpy", specifier = ">=1.23,<3.0.0" }, - { name = "setuptools", specifier = ">=80.10" }, { name = "torch", specifier = ">=2.1,<3.0.0" }, { name = "torch", marker = "extra == 'cpu'", specifier = ">=2.1.2,<3.0.0", index = "https://download.pytorch.org/whl/cpu", conflict = { package = "torchpfaffian", extra = "cpu" } }, { name = "torch", marker = "extra == 'cu128'", specifier = ">=2.1.2,<3.0.0", index = "https://download.pytorch.org/whl/cu128", conflict = { package = "torchpfaffian", extra = "cu128" } }, @@ -4210,6 +4234,7 @@ provides-extras = ["cpu", "cu128", "cu130"] [package.metadata.requires-dev] dev = [ { name = "build", specifier = ">=1.4,<2" }, + { name = "maturin", specifier = ">=1.0,<2" }, { name = "mypy", specifier = ">=1.15,<2" }, { name = "nbmake", specifier = ">=1.5,<2" }, { name = "pip", specifier = ">=25" }, @@ -4220,6 +4245,7 @@ dev = [ { name = "pytest-timeout", specifier = ">=2.4" }, { name = "pytest-xdist", specifier = ">=3.7,<4" }, { name = "ruff", specifier = ">=0.9,<1" }, + { name = "tqdm", specifier = ">=4.68.2" }, { name = "twine", specifier = ">=6.1,<7" }, { name = "wheel", specifier = ">=0.45,<0.46" }, ] @@ -4258,6 +4284,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/71/2e/7b1c769803121b809112cf9a00681c472eae1d80e32d7ec0e0bd61d0d0e1/tornado-6.5.7-cp39-abi3-win_arm64.whl", hash = "sha256:ff934fce95643af5f11efdae618eaa73d469dc588641e5c8d19295a0c65c4796", size = 450506, upload-time = "2026-06-08T17:34:49.702Z" }, ] +[[package]] +name = "tqdm" +version = "4.68.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/85/05/0d5260f1f1ca784f4a4a0def9cbe6affe587f5b4025328d446c3d67765f4/tqdm-4.68.2.tar.gz", hash = "sha256:89c230e8dbc67c7615c142487111222f878c77427ea09549960f62389e258add", size = 171923, upload-time = "2026-06-09T13:26:42.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/75/1a0392bcc21c44dcdf87b3cf2d137e7829be2c083a1e38d44efca3d57a16/tqdm-4.68.2-py3-none-any.whl", hash = "sha256:d4240441fb5353290b87d6a85968c9decc131a99b8c7faa28269d829de669ede", size = 78578, upload-time = "2026-06-09T13:26:40.731Z" }, +] + [[package]] name = "traitlets" version = "5.15.1" From 7c301c6e2c9c54f628f513c4a60b04f31df7f03d Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Thu, 11 Jun 2026 12:10:17 -0400 Subject: [PATCH 4/7] Enhance Pfaffian strategies with adjugate computation and update benchmarks --- notebooks/_strategies_benchmark_helpers.py | 92 ++- notebooks/strategies_benchmark.ipynb | 279 ++++++++- pyproject.toml | 1 + requirements.txt | 15 + .../strategies/pfaffian_block_det.py | 8 + .../strategies/pfaffian_parlett_reid.py | 21 +- .../strategies/pfaffian_rust_parlett_reid.py | 19 +- src/torch_pfaffian/strategies/strategy.py | 62 ++ .../test_pfaffian_block_det.py | 12 + .../test_pfaffian_parlett_reid.py | 30 +- .../test_pfaffian_rust_parlett_reid.py | 30 +- tests/test_strategies/test_strategy.py | 32 + uv.lock | 580 +++++++++++++++--- 13 files changed, 990 insertions(+), 191 deletions(-) diff --git a/notebooks/_strategies_benchmark_helpers.py b/notebooks/_strategies_benchmark_helpers.py index 7d9cedd..824c4d2 100644 --- a/notebooks/_strategies_benchmark_helpers.py +++ b/notebooks/_strategies_benchmark_helpers.py @@ -3,6 +3,8 @@ import matplotlib.pyplot as plt import numpy as np +import pandas as pd +import seaborn as sns import torch from torch.profiler import ProfilerActivity, profile from tqdm.auto import tqdm @@ -11,7 +13,7 @@ from torch_pfaffian.strategies.strategy import PfaffianStrategy Strategy = type[PfaffianStrategy] -BenchmarkResults = dict[str, dict[str, list[float]]] +BenchmarkResults = pd.DataFrame METRICS = ("forward_time", "backward_time", "forward_memory", "forward_backward_memory") @@ -96,13 +98,6 @@ def _forward_backward_call(strategy: Strategy, matrix: torch.Tensor) -> torch.Te return grad_matrix -def _confidence_interval(values: np.ndarray, confidence_z: float = 1.96) -> float: - # Half-width of the normal-approximation confidence interval for the mean. - if values.size < 2: - return 0.0 - return float(confidence_z * values.std(ddof=1) / np.sqrt(values.size)) - - def benchmark_strategies( strategies: list[Strategy], sizes_n: list[int], @@ -110,12 +105,13 @@ def benchmark_strategies( device: str = "cpu", n_seeds: int = 20, n_repeats: int = 3, -) -> BenchmarkResults: +) -> pd.DataFrame: """ Benchmark forward/backward time and memory of each strategy over several random seeds. - For each matrix dimension and strategy the metric is measured once per seed; the returned - values are the across-seed mean and the half-width of the 95% confidence interval. + Returns a tidy DataFrame with one row per (strategy, dimension, seed) combination and one + column per metric. Pass it directly to :func:`plot_results` or use pandas/seaborn to + build custom views. :param strategies: The strategy classes to benchmark (each exposes ``NAME`` and ``apply``). :param sizes_n: Matrix dimensions to sweep (even integers); each yields ``n x n`` matrices. @@ -123,27 +119,18 @@ def benchmark_strategies( :param device: Device on which to run the benchmark. :param n_seeds: Number of random seeds used to build the confidence intervals. :param n_repeats: Number of timed repeats per seed (the median is kept). - :return: A mapping ``strategy_name -> {"dimension", "_mean", "_ci"}``. - :rtype: dict + :return: A DataFrame with columns ``strategy``, ``dimension``, ``seed``, and one column per + metric in :data:`METRICS`. + :rtype: pandas.DataFrame """ is_cuda = device == "cuda" - results: BenchmarkResults = { - strategy.NAME: { - "dimension": [], - **{f"{metric}_mean": [] for metric in METRICS}, - **{f"{metric}_ci": [] for metric in METRICS}, - } - for strategy in strategies - } + records = [] p_bar = tqdm(total=len(sizes_n) * len(strategies) * n_seeds, desc="Benchmarking strategies") for n in sizes_n: - per_seed: dict[str, dict[str, list[float]]] = { - strategy.NAME: {metric: [] for metric in METRICS} for strategy in strategies - } for seed in range(n_seeds): torch.manual_seed(seed) - # PfaffianBlockDet only returns the true Pfaffian on block-antidiagonal inputs; every other - # strategy is valid on any skew matrix, so benchmark those on a general random skew matrix. + # PfaffianBlockDet only returns the true Pfaffian on block-antidiagonal inputs; every + # other strategy is valid on any skew matrix. block_matrix = make_block_antidiagonal(n, batch_size, dtype=torch.float32, device=device) random_matrix = make_random_skew(n, batch_size, dtype=torch.float32, device=device) for strategy in strategies: @@ -151,32 +138,29 @@ def benchmark_strategies( p_bar.set_description(f"Benchmarking {strategy.NAME:^30} (n: {n:^5} | seed: {seed:^5})") forward_time = _median_time(lambda: _forward_call(strategy, matrix), is_cuda, n_repeats) full_time = _median_time(lambda: _forward_backward_call(strategy, matrix), is_cuda, n_repeats) - record = per_seed[strategy.NAME] - record["forward_time"].append(forward_time) - record["backward_time"].append(max(full_time - forward_time, 0.0)) - record["forward_memory"].append(_peak_memory(lambda: _forward_call(strategy, matrix), is_cuda)) - record["forward_backward_memory"].append( - _peak_memory(lambda: _forward_backward_call(strategy, matrix), is_cuda) + records.append( + { + "strategy": strategy.NAME, + "dimension": n, + "seed": seed, + "forward_time": forward_time, + "backward_time": max(full_time - forward_time, 0.0), + "forward_memory": _peak_memory(lambda: _forward_call(strategy, matrix), is_cuda), + "forward_backward_memory": _peak_memory( + lambda: _forward_backward_call(strategy, matrix), is_cuda + ), + } ) p_bar.update(1) - - for strategy in strategies: - results[strategy.NAME]["dimension"].append(n) - for metric in METRICS: - values = np.asarray(per_seed[strategy.NAME][metric], dtype=float) - results[strategy.NAME][f"{metric}_mean"].append(float(values.mean())) - results[strategy.NAME][f"{metric}_ci"].append(_confidence_interval(values)) p_bar.close() - return results + return pd.DataFrame(records) -def plot_results( - results: BenchmarkResults, strategies: list[Strategy], batch_size: int, device: str = "cpu" -) -> plt.Figure: +def plot_results(results: pd.DataFrame, strategies: list[Strategy], batch_size: int, device: str = "cpu") -> plt.Figure: """ Plot the benchmark results as a 2x2 grid of time and memory panels with 95% CI bands. - :param results: The mapping returned by :func:`benchmark_strategies`. + :param results: The DataFrame returned by :func:`benchmark_strategies`. :param strategies: The strategy classes that were benchmarked. :param batch_size: Batch size used for the benchmark (shown in the title). :param device: Device used for the benchmark (shown in the title and memory label). @@ -191,23 +175,23 @@ def plot_results( ("forward_backward_memory", "Forward + backward memory", memory_label), ] + df_long = results.melt( + id_vars=["strategy", "dimension", "seed"], + value_vars=list(METRICS), + var_name="metric", + value_name="value", + ) + fig, axes = plt.subplots(2, 2, figsize=(12, 9)) - for ax, (key, title, ylabel) in zip(axes.flat, panels): - for strategy in strategies: - record = results[strategy.NAME] - dimension = np.asarray(record["dimension"], dtype=float) - mean = np.asarray(record[f"{key}_mean"], dtype=float) - ci = np.asarray(record[f"{key}_ci"], dtype=float) - line = ax.plot(dimension, mean, marker="o", label=strategy.NAME)[0] - lower = np.clip(mean - ci, np.finfo(float).tiny, None) - ax.fill_between(dimension, lower, mean + ci, alpha=0.2, color=line.get_color()) + for ax, (metric_key, title, ylabel) in zip(axes.flat, panels): + subset = df_long[df_long["metric"] == metric_key] + sns.lineplot(data=subset, x="dimension", y="value", hue="strategy", marker="o", ax=ax) ax.set_title(title) ax.set_xlabel("matrix dimension") ax.set_ylabel(ylabel) ax.set_xscale("log", base=2) ax.set_yscale("log") ax.grid(True, which="both", linestyle=":", alpha=0.5) - ax.legend() fig.suptitle(f"Pfaffian strategies benchmark (batch_size={batch_size}, device={device}, 95% CI over seeds)") fig.tight_layout() diff --git a/notebooks/strategies_benchmark.ipynb b/notebooks/strategies_benchmark.ipynb index 66842f0..dfb24e3 100644 --- a/notebooks/strategies_benchmark.ipynb +++ b/notebooks/strategies_benchmark.ipynb @@ -84,10 +84,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "6ace4294c6d4b34", "metadata": { "ExecuteTime": { + "end_time": "2026-06-11T12:15:32.924961778Z", "start_time": "2026-06-11T11:54:45.649903607Z" } }, @@ -98,8 +99,263 @@ "text": [ "Benchmarking PfaffianFDBPf (n: 2 | seed: 0 ): 0%| | 0/640 [00:00" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKYAAAN3CAYAAAAI21LiAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4VMXawH9nd7Ob3khCQg8EwQCKgigI0qUIiA3BqxBEAREQexewoVdFEBHR+wlexEITlUsTQUXAhqIgAgESwJBCet925vtjs4dssmmQkJCd3/PkyezsnJl53znn7Jz3vPOOIoQQSCQSiUQikUgkEolEIpFIJBcYXX13QCKRSCQSiUQikUgkEolE4plIw5REIpFIJBKJRCKRSCQSiaRekIYpiUQikUgkEolEIpFIJBJJvSANUxKJRCKRSCQSiUQikUgkknpBGqYkEolEIpFIJBKJRCKRSCT1gjRMSSQSiUQikUgkEolEIpFI6gVpmJJIJBKJRCKRSCQSiUQikdQL0jAlkUgkEolEIpFIJBKJRCKpF6RhSiKRSCQSiUQikUgkEolEUi9Iw5REIjlv4uPjuf766wkKCkJRFNavX18rx//yyy/06tULPz8/FEVh3759zJkzB0VRal8IiQv1oed+/frRuXPnC9pmTVi+fDmKovDrr7/Wd1eqRVxcHP7+/udVx7Rp0xg8eLD2+dtvv0VRFNasWXO+3as1FEVh+vTpF6Qtp/zffvvtBWnvYkdRFObMmVNn9cvxkEguHHFxcbRp06ZGx2zevBl/f3/OnDlTN52SSCSNBmmYkkgkbnE+hDv/vL29ueSSS5g+fTqpqakuZSdMmMD+/ft56aWXWLFiBd27d69RW+6Ot1qt3HbbbWRmZvLmm2+yYsUKWrduXZsi1joHDx5kzpw5JCYm1kn977zzDsuXL6+TuiWSsiQkJPCf//yHp556qk7b2bhxY50aLzyB999/n759+9K0aVNMJhPR0dFMnDix3L3o1KlTzJ07lx49ehASEkJYWBj9+vVj27Zt9dNxSb3y6aefcuWVV+Lt7U14eDiTJk0iPT29XLnSc4HSf6+88opLuV27dnHllVcSEBBAv379OHToULm6Zs6cyZAhQ2rc188//5xhw4YRFhaG0WikWbNmjBkzhu3bt2tlGqLh3NMZOnQoMTExzJs3r767IpFIGjiG+u6ARCJp2Dz//PNER0dTXFzMDz/8wJIlS9i4cSMHDhzA19eXoqIi9uzZw9NPP31OXgsVHX/o0CFOnDjB+++/zz333KPlP/PMMzzxxBO1Ilttc/DgQebOnUu/fv1q/FaxOrzzzjuEhYURFxdX63WXpSHrWXJhWLhwIdHR0fTv379O29m4cSOLFy++KIxT1113HUVFRRiNxvruigu///470dHRjBo1ipCQEBISEnj//ffZsGEDf/zxB82aNQPgiy++4NVXX2X06NFMmDABm83Gf//7XwYPHswHH3zAxIkT61mSmtFQx+NiYMmSJUybNo2BAwcyf/58/vnnHxYuXMivv/7KTz/9hLe3t0v5wYMHM378eJe8K664Qkvn5ORw4403cs011zB58mSWL1/OLbfcwp9//olerwfgr7/+4v3332fv3r3V7qcQgrvvvpvly5dzxRVX8NBDDxEZGUlycjKff/45AwcOZNeuXfTq1es8tCGpS6ZMmcIjjzzC3LlzCQgIqO/uSCSSBoo0TEkkkkoZNmyY5gF1zz330KRJE+bPn88XX3zBuHHjNPfs4ODgc6q/ouPT0tLc5hsMBgyGi//WJYSguLgYHx+f+u6KWxqLnj2RgoIC/Pz8zqsOq9XKypUrmTp1ai31qnGg0+nKPbA3BN55551yeaNHj6Z79+7897//1YzM/fv35+TJk4SFhWnlpk6dSteuXXnuuecuOsNUQx2Pho7FYuGpp57iuuuu4+uvv9aWbffq1YuRI0fy/vvvM2PGDJdjLrnkEu68884K69yzZw9FRUWsWbMGb29vhg4dSnR0NEePHqVDhw4AzJo1i3vvvZfY2Nhq9/WNN95g+fLlzJo1i/nz57ssMX/66adZsWLFRf1bpaoqFoulUZ/Ht9xyCzNmzGD16tXcfffd9d0diUTSQJFL+SQSSY0YMGAA4FjmM2fOHG153aOPPoqiKJqn0IkTJ5g2bRodOnTAx8eHJk2acNttt7ksLano+Li4OPr27QvAbbfdhqIo9OvXTzumbOyjZcuWMWDAACIiIjCZTMTGxrJkyZJyfW/Tpg0jRozghx9+oEePHnh7e9O2bVv++9//Vkv2Tz/9lG7duhEQEEBgYCBdunRh4cKFgGPp42233QY4Hv6cSx2csU+cbW/ZsoXu3bvj4+PD0qVLq93/Nm3a8Ndff/Hdd99pdTt1ApCdnc2sWbNo2bIlJpOJmJgYXn31VVRVdaknIyODu+66i8DAQIKDg5kwYQJ//PEHiqK4LBOsKMbURx99RLdu3fDx8SE0NJSxY8dy6tQplzLx8fHccsstREZG4u3tTYsWLRg7diw5OTnV0vPevXvp1asXPj4+REdH8+6775YrYzabmT17NjExMZhMJlq2bMljjz2G2Wx2KeeMP7R+/Xo6d+6MyWSiU6dObN68uVydSUlJTJo0iWbNmmnLoe677z4sFku5th966CHCw8Px8/PjpptuKhc/wzne3377rTbeXbp00c6HdevW0aVLF7y9venWrRu///67y/F//vkncXFxtG3bFm9vbyIjI7n77rvJyMhwKeccp4MHD3LHHXcQEhJC7969K9Ttvn37CA8Pp1+/fuTn51dY7ocffiA9PZ1Bgwa5/d5ut/PUU08RGRmJn58fo0aNKnce7Ny5k9tuu41WrVppY/Tggw9SVFSklYmLi2Px4sWA63IhJ6qqsnDhQk1X4eHhDB061G2cr+qMcVVUdo1D+ZhGZZc8l/4rfX1C9a6d2sR5L87OztbyOnXq5GKUAjCZTAwfPpx//vmHvLy8c2rLbDbz4IMPEh4eTkBAAKNGjeKff/5xWzYpKYm7775bW3bYqVMnPvjgA+371NRUDAYDc+fOLXfs4cOHURSFt99+G6g4xtRPP/3E8OHDCQkJwc/Pj8suu8xlHMHhlXvrrbcSGhqKt7c33bt358svvzwn+SuSs7L7ifPc+f7775kyZQpNmjQhMDCQ8ePHk5WV5VJXRbG6nL+XNeXAgQNkZ2dz++23u1xvI0aMwN/fn08//dTtcUVFRRQXF1f4nbe3t2ZgCQ0NBaCwsBBwXJ+///6723GtiKKiIubNm0fHjh15/fXX3f4m3XXXXfTo0aPadTpJS0tj0qRJNG3aFG9vby6//HI+/PBD7Xur1UpoaKhbY21ubi7e3t488sgjWl5Nf5NWrlxJp06dMJlMld6rfv31V4YMGUJYWJj2m1jWuKOqKgsWLKBTp054e3vTtGlTpkyZUu48Ati0aRN9+vTBz8+PgIAAbrjhBv76669y5Zz3U29vbzp37sznn3/utn9V3TMBIiIiuOyyy/jiiy8qlFMikUgu3lcMEomkXjh27BgATZo0oWfPngQHB/Pggw8ybtw4hg8frgVb/uWXX9i9ezdjx46lRYsWJCYmsmTJEvr168fBgwfx9fXl5ptvdnt806ZNad68OS+//DIzZ87kqquuomnTphX2acmSJXTq1IlRo0ZhMBj46quvmDZtGqqqcv/997uUPXr0KLfeeiuTJk1iwoQJfPDBB8TFxdGtWzc6depUYRtff/0148aNY+DAgbz66qsA/P333+zatYsHHniA6667jpkzZ/LWW2/x1FNPcemllwJo/8HxUDVu3DimTJnCvffeq71Frk7/FyxYwIwZM/D39+fpp58G0HRSWFhI3759SUpKYsqUKbRq1Yrdu3fz5JNPkpyczIIFCwDH5HXkyJH8/PPP3HfffXTs2JEvvviCCRMmVGvsX3rpJZ599lnGjBnDPffcw5kzZ1i0aBHXXXcdv//+O8HBwVgsFoYMGYLZbGbGjBlERkaSlJTEhg0byM7OJigoqNI2srKyGD58OGPGjGHcuHGsWrWK++67D6PRqE3GVVVl1KhR/PDDD0yePJlLL72U/fv38+abb3LkyJFywfd/+OEH1q1bx7Rp0wgICOCtt97illtu4eTJkzRp0gSA06dP06NHD7Kzs5k8eTIdO3YkKSmJNWvWUFhY6LJUaMaMGYSEhDB79mwSExNZsGAB06dP57PPPnNp9+jRo9xxxx1MmTKFO++8k9dff52RI0fy7rvv8tRTTzFt2jQA5s2bx5gxYzh8+DA6neN90ddff83x48eZOHEikZGR/PXXX7z33nv89ddf/Pjjj+Ue0G677Tbat2/Pyy+/jBDCrW5/+eUXhgwZQvfu3fniiy8q9dbbvXs3iqK4LNUpzUsvvYSiKDz++OOkpaWxYMECBg0axL59+7R6V69eTWFhIffddx9NmjTh559/ZtGiRfzzzz+sXr0acCzxOH36NF9//TUrVqwo186kSZNYvnw5w4YN45577sFms7Fz505+/PFHl1h21RnjqqjqGnfHddddV67fJ06c4JlnniEiIsJFX1VdO+C4lp0P8pWh1+sJCQkpl5+RkYHdbufkyZM8//zzAAwcOLDK+lJSUvD19cXX17fKsu645557+Oijj7jjjjvo1asX27dv54YbbihXLjU1lWuuuUZ7OA8PD2fTpk1MmjSJ3NxcZs2aRdOmTenbty+rVq1i9uzZLsd/9tln6PV67SWAO77++mtGjBhBVFQUDzzwAJGRkfz9999s2LBBG8e//vqLa6+9lubNm/PEE0/g5+fHqlWrGD16NGvXruWmm24CHPeazMzMaukgKCgILy8voGb3k+nTpxMcHMycOXM4fPgwS5Ys4cSJE5rRrS5wGkvc3QN8fHz4/fffUVVVux+Bw5D2zjvvIITg0ksv5ZlnnuGOO+7Qvr/iiivIycnhjTfe4NZbb2XBggUEBQXRoUMHzGYzDz/8MHPnznV73lbEDz/8QGZmJrNmzdKWA9YGRUVF9OvXj6NHjzJ9+nSio6NZvXo1cXFxZGdn88ADD+Dl5cVNN93EunXrWLp0qcuYrV+/HrPZzNixY4Ga/yZt376dVatWMX36dMLCwipc+p+Wlsb1119PeHg4TzzxBMHBwSQmJrJu3TqXclOmTGH58uVMnDiRmTNnkpCQwNtvv83vv//Orl27tPNyxYoVTJgwgSFDhvDqq69SWFjIkiVL6N27N7///rvWj61bt3LLLbcQGxvLvHnzyMjIYOLEibRo0cKl3ZrcM7t161bjjXEkEomHISQSicQNy5YtE4DYtm2bOHPmjDh16pT49NNPRZMmTYSPj4/4559/hBBCJCQkCEC89tprLscXFhaWq3PPnj0CEP/973+1vIqO37FjhwDE6tWrXfJnz54tyt663LU1ZMgQ0bZtW5e81q1bC0B8//33Wl5aWpowmUzi4Ycfrkwd4oEHHhCBgYHCZrNVWGb16tUCEDt27Cj3nbPtzZs3l/uuuv3v1KmT6Nu3b7myL7zwgvDz8xNHjhxxyX/iiSeEXq8XJ0+eFEIIsXbtWgGIBQsWaGXsdrsYMGCAAMSyZcu0/LJ6TkxMFHq9Xrz00ksubezfv18YDAYt//fff3c7btWhb9++AhBvvPGGlmc2m0XXrl1FRESEsFgsQgghVqxYIXQ6ndi5c6fL8e+++64AxK5du7Q8QBiNRnH06FEt748//hCAWLRokZY3fvx4odPpxC+//FKuX6qqCiHOXhODBg3S8oQQ4sEHHxR6vV5kZ2drec7x3r17t5a3ZcsWAQgfHx9x4sQJLX/p0qXlzht358Qnn3xS7vx1jtO4cePKlZ8wYYLw8/MTQgjxww8/iMDAQHHDDTeI4uLicmXLcuedd4omTZqUy3del82bNxe5ubla/qpVqwQgFi5cWKkM8+bNE4qiuMh///33l7umhRBi+/btAhAzZ84s911p/Vd3jKuiOte4U35317gQQhQVFYlu3bqJZs2aieTkZCFE9a8dIc6OZ1V/rVu3dtu+yWTSyjRp0kS89dZbVcodHx8vvL29xV133VVlWXfs27dPAGLatGku+XfccYcAxOzZs7W8SZMmiaioKJGenu5SduzYsSIoKEg7Z5zXxP79+13KxcbGigEDBmify46HzWYT0dHRonXr1iIrK8vl2NLnzMCBA0WXLl1crgVVVUWvXr1E+/bttTzn71N1/kqfEzW5n3Tr1k27twkhxL///W8BiC+++ELLK6tHJ61btxYTJkwol18VZ86cEYqiiEmTJrnkHzp0SJOn9Bj16tVLLFiwQHzxxRdiyZIlonPnzgIQ77zzjsvxr732mtDr9dp97uOPPxZCCPHSSy+Jzp07V3ptuWPhwoUCEJ9//nm1ylc0byjLggULBCA++ugjLc9isYiePXsKf39/7d7mvGd/9dVXLscPHz7c5fe5pr9JOp1O/PXXX1XK8/nnnwvA7XnkZOfOnQIQK1eudMnfvHmzS35eXp4IDg4W9957r0u5lJQUERQU5JLftWtXERUV5fKbtnXr1nL3nurcM528/PLLAhCpqalVlpVIJJ6JXMonkUgqZdCgQYSHh9OyZUvGjh2Lv78/n3/+Oc2bN6/0uNJvYq1WKxkZGcTExBAcHMxvv/1Wq30s3VZOTg7p6en07duX48ePl1s+FhsbS58+fbTP4eHhdOjQgePHj1faRnBwMAUFBXz99dfn3M/o6Gi3uxHVpP/uWL16NX369CEkJIT09HTtb9CgQdjtdr7//nvAsW2zl5cX9957r3asTqcr51XmjnXr1qGqKmPGjHFpIzIykvbt27Njxw4AzSNqy5Yt1fL8KIvBYGDKlCnaZ6PRyJQpU0hLS9MC5q5evZpLL72Ujh07uvTFuczU2RcngwYNol27dtrnyy67jMDAQG3MVVVl/fr1jBw50u2OkmW9FiZPnuyS16dPH+x2OydOnHApFxsbS8+ePbXPV199NeBYDtuqVaty+aXPwdLnRHFxMenp6VxzzTUAbq+fymJB7dixgyFDhjBw4EDWrVuHyWSqsKyTjIyMSj0bxo8f7xLE9tZbbyUqKoqNGze6laGgoID09HR69eqFEKLc0kV3rF27FkVRynnNQPkxqWqMq0NtXOPTpk1j//79rF27lsjISKD61w449Pr1119X+bdy5Uq37W/atImNGzfyxhtv0KpVKwoKCirtb2FhIbfddhs+Pj7ldlirLs4xnzlzpkv+rFmzXD4LIVi7di0jR45ECOGiiyFDhpCTk6Od2zfffDMGg8HFC/HAgQMcPHiQ22+/vcK+/P777yQkJDBr1qxy8Qmd50xmZibbt29nzJgx5OXlaX3IyMhgyJAhxMfHk5SUBEBkZGS1xuPrr7/m8ssvB87tfuL0aAG47777MBgMLtdSbRMWFsaYMWP48MMPeeONNzh+/Dg7d+7k9ttv1/pSesmt0wNm1KhRTJ06lb1799K5c2eeeuopl3KPPPIISUlJ7Nmzh6SkJMaNG8fp06eZN28eCxYswGazMWPGDFq1akWPHj3YtWtXpf3Mzc0FqPWA2Rs3biQyMpJx48ZpeV5eXsycOZP8/Hy+++47wHGvDgsLczkPs7Ky+Prrr13Ow5r+JvXt27dacbac5/CGDRuwWq1uy6xevZqgoCAGDx7s0na3bt3w9/fX2v7666/Jzs5m3LhxLuX0ej1XX321Vi45OZl9+/YxYcIEFw/nwYMHl+tzTe6Zzt8Td7s+SiQSCcilfBKJpAoWL17MJZdcgsFgoGnTpnTo0MHFvb8inLEhli1bRlJSksvyourGGqouu3btYvbs2ezZs6ecMSQnJ8dlclXaIOAkJCTEbSyG0kybNo1Vq1YxbNgwmjdvzvXXX8+YMWMYOnRotfsZHR193v13R3x8PH/++Sfh4eFuv3cGkj9x4gRRUVHlluvExMRU2ff4+HiEELRv397t986HmejoaB566CHmz5/PypUr6dOnD6NGjeLOO++sUg6AZs2alQvcfckllwCQmJjINddcQ3x8PH///XeV8jqpaszPnDlDbm4unTt3rrJ/7upzTrjLnkNlyznlb9mypdv80sdnZmYyd+5cPv3003LyuLt+Kjq3iouLueGGG+jWrRurVq2qUZBgUcGSQKDceaAoCjExMS4x5E6ePMlzzz3Hl19+WU431bkHHDt2jGbNmmmxairjXK/r0pzvNb506VKWLVvG0qVLNSMiVP/aAWjbti1t27atdp/L4txBcdiwYdx444107twZf39/tzum2u12xo4dy8GDB9m0aZO2c19NOXHiBDqdzsUwCGhLlZ2cOXOG7Oxs3nvvPd577z23dTnP9bCwMAYOHMiqVat44YUXAMcyPoPBwM0331xhX5xLzSu7lo8ePYoQgmeffZZnn322wn40b94cb2/vCuOsVURN7ydlzwt/f3+ioqJcrqW6YOnSpRQVFfHII49osZLuvPNO2rVrx7p167Rl+e4wGo1Mnz5dM1KVjmvXtGlTl6X3jz/+OAMHDmTgwIE888wzfPPNN3z22Wfs2LGDG264gcTExAo3TwkMDAQ459hnFXHixAnat29fbi7jXHrvfMlgMBi45ZZb+PjjjzGbzZhMJtatW4fVanUxTNX0N6mi+3VZ+vbtyy233MLcuXN588036devH6NHj+aOO+7QXjDEx8eTk5PjsnTYXdvx8fHA2TihZXHq2im7u/tVhw4dXF6M1OSe6fw9qavlqRKJ5OJHGqYkEkml9OjRw+1b36qYMWMGy5YtY9asWfTs2ZOgoCAURWHs2LHlAnKfD8eOHWPgwIF07NiR+fPn07JlS4xGIxs3buTNN98s11ZFcSoqewgHR/DOffv2sWXLFjZt2sSmTZtYtmwZ48ePdwmYWhnu4nnUtP/uUFWVwYMH89hjj7n93mnYOR9UVUVRFDZt2uRWh6UfYt544w3i4uL44osv2Lp1KzNnzmTevHn8+OOP5WJUnGtfunTpwvz5891+X9bwc65jXhHVra+ictU5fsyYMezevZtHH32Url274u/vj6qqDB061O05UVG8KGdg6y+++ILNmzczYsQIt+XK0qRJkxoZdcpit9sZPHgwmZmZPP7443Ts2BE/Pz+SkpKIi4ur1XsA1M4Yn881/vPPP/PAAw9wzz33MHnyZJfvanLt5OfnVxqU3oler6/wIdhJu3btuOKKK1i5cqVbw9S9997Lhg0bWLlyZYUPq7WJc8zvvPPOCuPaXXbZZVp67NixTJw4kX379tG1a1dWrVrFwIEDywVvP9d+PPLII249WOGssd5ut5fb2KAiQkNDXeIQXQjsdvs5HxsUFMQXX3zByZMnSUxMpHXr1rRu3ZpevXoRHh5e5U67zvtsZTG4fvzxR9asWcOBAwcA+OSTT3j22Wfp2bMnPXv2ZOnSpWzYsKHC3f46duwIwP79+xk9enTNhawFxo4dy9KlS9m0aROjR49m1apVdOzYUfOQg5r/JlV3N15FUVizZg0//vgjX331FVu2bOHuu+/mjTfe4Mcff9R+FyIiIir0onTeJ5zn/YoVKzRvztKcy86GNblnOn9Pzvf6lUgkjRdpmJJIJHXCmjVrmDBhAm+88YaWV1xc7LJDVG3w1VdfYTab+fLLL128Jsq6ztcGRqORkSNHMnLkSFRVZdq0aSxdupRnn32WmJiYc3oTWJP+V1R/u3btyM/Pr/LNfuvWrdmxYweFhYUuXlNHjx6tsp/t2rVDCEF0dHS1DF1dunShS5cuPPPMM+zevZtrr72Wd999lxdffLHS406fPk1BQYGL19SRI0eAs7uMtWvXjj/++IOBAwfWytvX8PBwAgMDtYen+iYrK4tvvvmGuXPn8txzz2n5zjfeNUFRFFauXMmNN97IbbfdxqZNm8rtFueOjh07snLlygo99sr2RQjB0aNHNcPC/v37OXLkCB9++CHjx4/Xyrlb8lHZeb1lyxYyMzOr5TVVG1R1jbvjzJkz3HrrrXTt2lXbYbA0Nbl2Xn/99WrtWta6detqedQUFRWV2xUMHLugLlu2jAULFrgsZzoXWrdujaqqHDt2zMVL6vDhwy7lnDv22e32ankhjR49milTpmjLqI4cOcKTTz5Z6TFOr60DBw5U2IbTI83Ly6vKfpw6dara3i07duygX79+Nb6fxMfHa55u4DBOJicnM3z4cC0vJCSk3G+nxWIhOTm5Wm1URqtWrbTfnuzsbPbu3cstt9xS5XHOZbIVGUiFEMycOZMHHnhAG5fTp0+7eOY1a9ZMWzbpjt69exMSEsInn3zCU089VWsB0Fu3bs2ff/5ZLsD7oUOHtO+dXHfddURFRfHZZ5/Ru3dvtm/frm1A4qS2f5PKcs0113DNNdfw0ksv8fHHH/Ovf/2LTz/9lHvuuYd27dqxbds2rr322koNXs4xiIiIqPS8d8ru7vem7DUN1b9nJiQkEBYWVqVBXSKReC4yxpREIqkT9Hp9OW+FRYsWndcb3oraAcotFVy2bFmttpORkeHyWafTaQ/hzgc/pzGlJsa3mvTfz8/Pbd1jxoxhz549bNmypdx32dnZ2Gw2AIYMGYLVauX999/XvldV1e3DdFluvvlm9Ho9c+fOLTeuQghNP7m5uVp7Trp06YJOp3P7gFwWm83G0qVLtc8Wi4WlS5cSHh5Ot27dNHmTkpJc5HBSVFRUZVydsuh0OkaPHs1XX33Fr7/+Wu77c/WsOlfcnROAtrtiTTEajaxbt46rrrpK25WxKnr27IkQQovrVZb//ve/Lstr1qxZQ3JyMsOGDatQBiFEuW3EoeLr5pZbbkEI4dZQUxdjUp1rvCzO5XAWi4W1a9e69Zip7rUD5xZjymazufVu+/nnn9m/f385j9fXXnuN119/naeeeqrC3QZrgnPM33rrLZf8suerXq/nlltuYe3atW6NNmU9k4KDgxkyZAirVq3i008/xWg0Vuk1c+WVVxIdHc2CBQvKnU9O3UdERNCvXz+WLl3q1rBTuh/nEmOqpveT9957zyV+0JIlS7DZbJpewWFUcMYKLH1cbf+ePvnkk9hsNh588EEtz53HWF5eHgsWLCAsLEy7L5dl+fLlnDp1ysWI07RpU834Y7VaOXr0qFvvHSe+vr48/vjj/P333zz++ONur/uPPvqoWve00gwfPpyUlBSX2FE2m41Fixbh7+9P3759tXydTsett97KV199xYoVK7DZbOXinNX2b5KTrKyscjJ37doVOHtPGjNmDHa7XVvyWhqbzaZdB0OGDCEwMJCXX37Zbbwq5zhHRUXRtWtXPvzwQ5cl119//TUHDx50OaYm98y9e/e6xFyUSCSSskiPKYlEUieMGDGCFStWEBQURGxsLHv27GHbtm3V3rq9ulx//fXaG7spU6aQn5/P+++/T0RERK28TXZyzz33kJmZyYABA2jRogUnTpxg0aJFdO3aVYtL0bVrV/R6Pa+++io5OTmYTCYGDBhQYeyHmva/W7duLFmyhBdffJGYmBgiIiIYMGAAjz76KF9++SUjRowgLi6Obt26UVBQwP79+1mzZg2JiYmEhYUxevRoevTowcMPP8zRo0fp2LEjX375pbYUo7I3ve3atePFF1/kySefJDExkdGjRxMQEEBCQgKff/45kydP5pFHHmH79u1Mnz6d2267jUsuuQSbzcaKFSu0h9KqaNasGa+++iqJiYlccsklfPbZZ+zbt4/33ntPi8Vz1113sWrVKqZOncqOHTu49tprsdvtHDp0iFWrVrFly5YaLz99+eWX2bp1K3379tW2+05OTmb16tX88MMPVS5rqU0CAwO57rrr+Pe//43VaqV58+Zs3bqVhISEc67Tx8eHDRs2MGDAAIYNG8Z3331XaQyc3r1706RJE7Zt2+Z2mVdoaCi9e/dm4sSJpKamsmDBAmJiYrTA+h07dqRdu3ZaMOTAwEDWrl3r1oDifLCdOXMmQ4YMQa/XM3bsWPr3789dd93FW2+9RXx8vLaMcefOnfTv39/t8rTzoTrXeFneffddtm/frp2LpWnatCmDBw+u9rUD5xZjKj8/n5YtW3L77bfTqVMn/Pz82L9/P8uWLSMoKMgljtLnn3/OY489Rvv27bn00kv56KOPXOoaPHiwFh8oMTGR6OhoJkyYwPLlyytsv2vXrowbN4533nmHnJwcevXqxTfffOPWE/OVV15hx44dXH311dx7773ExsaSmZnJb7/9xrZt28otC7v99tu58847eeeddxgyZEiV16FOp2PJkiWMHDmSrl27MnHiRKKiojh06BB//fWXZrxfvHgxvXv3pkuXLtx77720bduW1NRU9uzZwz///MMff/wBcE4xpqBm9xOLxcLAgQMZM2YMhw8f5p133qF3796MGjVKK3PPPfcwdepUbrnlFgYPHswff/zBli1b3C6LcnqWVuVR98orr3DgwAGuvvpqDAYD69evZ+vWrbz44otcddVVWrnFixdrwdxbtWpFcnIyH3zwASdPnmTFihVujbF5eXk89dRTvPzyy+U2SXj++edRVZVdu3ZRXFzs4hnmjkcffZS//vqLN954gx07dnDrrbcSGRlJSkoK69ev5+eff2b37t2V1lGWyZMns3TpUuLi4ti7dy9t2rRhzZo17Nq1iwULFpQLtn777bezaNEiZs+eTZcuXcrdD+riNwngww8/5J133uGmm26iXbt25OXl8f777xMYGKjprW/fvkyZMoV58+axb98+rr/+ery8vIiPj2f16tUsXLiQW2+9lcDAQJYsWcJdd93FlVdeydixYwkPD+fkyZP873//49prr+Xtt98GYN68edxwww307t2bu+++m8zMTBYtWkSnTp1clhpX956ZlpbGn3/+Wa2NViQSiQdTt5v+SSSSixXnVtaVbVMsxNnttF977TWX/KysLDFx4kQRFhYm/P39xZAhQ8ShQ4fKbW9d0fEVbfvs3E69NF9++aW47LLLhLe3t2jTpo149dVXxQcffCAAkZCQoJVr3bq1uOGGG8rJ0LdvX9G3b99K5VyzZo24/vrrRUREhDAajaJVq1ZiypQp2pbwTt5//33Rtm1bbcts5xbiFbVdk/6npKSIG264QQQEBAjApc95eXniySefFDExMcJoNIqwsDDRq1cv8frrr7tsRX7mzBlxxx13iICAABEUFCTi4uLErl27BCA+/fTTSvUshBBr164VvXv3Fn5+fsLPz0907NhR3H///eLw4cNCCCGOHz8u7r77btGuXTvh7e0tQkNDRf/+/cW2bdsq1a8QjnHo1KmT+PXXX0XPnj2Ft7e3aN26tXj77bfLlbVYLOLVV18VnTp1EiaTSYSEhIhu3bqJuXPnipycHK0cIO6///5yx7vbZv3EiRNi/PjxIjw8XJhMJtG2bVtx//33C7PZLISo+Joou2W9s3534+2uP+6ugX/++UfcdNNNIjg4WAQFBYnbbrtNnD59uty28c5xOnPmTLm2JkyYIPz8/Fzy0tPTRWxsrIiMjBTx8fHljinNzJkzRUxMjFtZP/nkE/Hkk0+KiIgI4ePjI2644QZx4sQJl7IHDx4UgwYNEv7+/iIsLEzce++94o8//hCAWLZsmVbOZrOJGTNmiPDwcKEoist5Z7PZxGuvvSY6duwojEajCA8PF8OGDRN79+6tVKdCuB/jyqjONV52rJ36d/dX9p5S1bVzrpjNZvHAAw+Iyy67TAQGBgovLy/RunVrMWnSJJf7R1X9LXsO79+/XwDiiSeeqLIPRUVFYubMmaJJkybCz89PjBw5Upw6darc+SqEEKmpqeL+++8XLVu2FF5eXiIyMlIMHDhQvPfee+Xqzc3NFT4+PgIQH330Ubnv3V17Qgjxww8/iMGDB4uAgADh5+cnLrvsMrFo0SKXMseOHRPjx48XkZGRwsvLSzRv3lyMGDFCrFmzpkp5q0N17yffffedmDx5sggJCRH+/v7iX//6l8jIyHCpy263i8cff1yEhYUJX19fMWTIEHH06FG353hYWJi45pprquzfhg0bRI8ePURAQIDw9fUV11xzjVi1alW5clu3bhWDBw/W9BQcHCyuv/568c0331RY96OPPiq6d+8uVFV1yc/Pzxfjx48XwcHBomPHjmLz5s1V9tOJ8/oMDQ0VBoNBREVFidtvv118++23WpmK5g3uSE1N1eYoRqNRdOnSxeW+VBpVVUXLli0FIF588UW3Zc73N8kdv/32mxg3bpxo1aqVMJlMIiIiQowYMUL8+uuv5cq+9957olu3bsLHx0cEBASILl26iMcee0ycPn3apdyOHTvEkCFDRFBQkPD29hbt2rUTcXFx5epcu3atuPTSS4XJZBKxsbFi3bp1YsKECaJ169ZamerOi5YsWSJ8fX1Fbm5uteSWSCSeiSLEBV6jIJFIJJIGxfr167npppv44YcfuPbaa+u7O5IGwvHjx+nYsSObNm1i4MCB9d0dyQXmnXfe4bHHHuPYsWMuu6xJaofly5czceJEfvnll3PypnHHwYMH6dSpExs2bOCGG26olTolkvPliiuuoF+/frz55pv13RWJRNKAkTGmJBKJxIMoKipy+Wy321m0aBGBgYFceeWV9dQrSUOkbdu2TJo0iVdeeaW+uyKpB3bs2MHMmTOlUeoiYseOHfTs2VMapSQNhs2bNxMfH1/lxgUSiUQiPaYkEonEg7jnnnsoKiqiZ8+emM1m1q1bx+7du3n55ZflxFHSKLHb7W4DOJfG398ff3//C9QjiaRuPKYkEolEIrlYkcHPJRKJxIMYMGAAb7zxBhs2bKC4uJiYmBgWLVpU64GkJZKGwqlTp4iOjq60zOzZs5kzZ86F6ZBEIpFIJBKJxAXpMSWRSCQSiaTRUlxczA8//FBpmXPZDU8ikUgkEolEUjtIw5REIpFIJBKJRCKRSCQSiaRekMHPJRKJRCKRSCQSiUQikUgk9YI0TEkkEolEIpFIJBKJRCKRSOoFaZiSSCQSiUQikUgkEolEIpHUC9IwJZFIJBKJRCKRSCQSiUQiqRekYUoikUgkEolEIpFIJBKJRFIvSMOURCKRSCQSiUQikUgkEomkXpCGKYlEIpFIJBKJRCKRSCQSSb0gDVMSiUQikUgkEolEIpFIJJJ6QRqmJBKJRCKRSCQSiUQikUgk9YI0TEkkEolEIpFIJBKJRCKRSOoFaZiSSCSSOuLbb79FURS+/fbbc66jTZs2xMXF1VqfJBKJRCKRSJy0adOGESNG1Hc3aky/fv3o16/fOR+/fPlyFEUhMTGx1vokkUjOHWmYkkgkdY7zx9/d3xNPPFHf3at3du/ezZw5c8jOzq7vrkgkEolEIrnAuJsnRURE0L9/fzZt2lTf3buoefnll1m/fn19d0MikVSBob47IJFIPIfnn3+e6Ohol7zOnTvXU28aDrt372bu3LnExcURHBzs8t3hw4fR6eQ7BIlEIpFIGjvOeZIQgtTUVJYvX87w4cP56quvLkqvpobAyy+/zK233sro0aNd8u+66y7Gjh2LyWSqn45JJBIXpGFKIpFcMIYNG0b37t1rvd6CggL8/Pxqvd6qEEJQXFyMj49PnbUhJ0wSiUQikXgGZedJkyZNomnTpnzyySceZ5iq67mdXq9Hr9fXWf0SiaRmyNfwEomkwbB9+3b69OmDn58fwcHB3Hjjjfz9998uZebMmYOiKBw8eJA77riDkJAQevfuzZdffomiKPz5559a2bVr16IoCjfffLNLHZdeeim333679nnZsmUMGDCAiIgITCYTsbGxLFmypFz/nHEYtmzZQvfu3fHx8WHp0qUA/PPPP4wePRo/Pz8iIiJ48MEHMZvNVco8Z84cHn30UQCio6M1F35nzIOyMaac7v4//PADM2fOJDw8nODgYKZMmYLFYiE7O5vx48cTEhJCSEgIjz32GEIIlzZVVWXBggV06tQJb29vmjZtypQpU8jKyqqyvxKJRCKRSC4MwcHB+Pj4YDC4+hK8/vrr9OrViyZNmuDj40O3bt1Ys2aN2zo++ugjevToga+vLyEhIVx33XVs3bq10nY//PBDDAaDNj+58sory82lunTpUm7e9dlnn6EoijZ3O3HiBNOmTaNDhw74+PjQpEkTbrvttnJxnZxzm++++45p06YRERFBixYttO/fe+892rVrh4+PDz169GDnzp2VK64ERVEoKCjgww8/1OZXzjmVuxhTznnet99+q83zunTposUKXbduHV26dMHb25tu3brx+++/l2vz0KFD3HrrrYSGhuLt7U337t358ssvq9VficSTkR5TEonkgpGTk0N6erpLXlhYGADbtm1j2LBhtG3bljlz5lBUVMSiRYu49tpr+e2332jTpo3Lcbfddhvt27fn5ZdfRghB7969URSF77//nssuuwyAnTt3otPp+OGHH7Tjzpw5w6FDh5g+fbqWt2TJEjp16sSoUaMwGAx89dVXTJs2DVVVuf/++13aPXz4MOPGjWPKlCnce++9dOjQgaKiIgYOHMjJkyeZOXMmzZo1Y8WKFWzfvr1Kndx8880cOXKETz75hDfffFPTR3h4eKXHzZgxg8jISObOncuPP/7Ie++9R3BwMLt376ZVq1a8/PLLbNy4kddee43OnTszfvx47dgpU6awfPlyJk6cyMyZM0lISODtt9/m999/Z9euXXh5eVXZb4lEIpFIJLWLc54khCAtLY1FixaRn5/PnXfe6VJu4cKFjBo1in/9619YLBY+/fRTbrvtNjZs2MANN9yglZs7dy5z5syhV69ePP/88xiNRn766Se2b9/O9ddf77YP7733HlOnTuWpp57ixRdfBKBPnz588sknWpnMzEz++usvdDodO3fudJl3hYeHc+mllwLwyy+/sHv3bsaOHUuLFi1ITExkyZIl9OvXj4MHD+Lr6+vS9rRp0wgPD+e5556joKAAgP/7v/9jypQp9OrVi1mzZnH8+HFGjRpFaGgoLVu2rFSfK1as4J577qFHjx5MnjwZgHbt2lV6zNGjR7njjjuYMmUKd955J6+//jojR47k3Xff5amnnmLatGkAzJs3jzFjxriEXPjrr7+49tprad68OU888QR+fn6sWrWK0aNHs3btWm666aZK25ZIPBohkUgkdcyyZcsE4PbPSdeuXUVERITIyMjQ8v744w+h0+nE+PHjtbzZs2cLQIwbN65cO506dRJjxozRPl955ZXitttuE4D4+++/hRBCrFu3TgDijz/+0MoVFhaWq2vIkCGibdu2LnmtW7cWgNi8ebNL/oIFCwQgVq1apeUVFBSImJgYAYgdO3ZUqp/XXntNACIhIaHcd61btxYTJkzQPjt1OWTIEKGqqpbfs2dPoSiKmDp1qpZns9lEixYtRN++fbW8nTt3CkCsXLnSpZ3Nmze7zZdIJBKJRFK3VDRPMplMYvny5eXKl523WCwW0blzZzFgwAAtLz4+Xuh0OnHTTTcJu93uUr70/KF169bihhtuEEIIsXDhQqEoinjhhRdcyq9evVoA4uDBg0IIIb788kthMpnEqFGjxO23366Vu+yyy8RNN91UYT+FEGLPnj0CEP/973/Lyd+7d29hs9lc5IqIiBBdu3YVZrNZy3/vvfcE4DK/qQg/Pz+XeVTZNkvPvZzzvN27d2t5W7ZsEYDw8fERJ06c0PKXLl1abo43cOBA0aVLF1FcXKzlqaoqevXqJdq3b19lXyUST0Yu5ZNIJBeMxYsX8/XXX7v8ASQnJ7Nv3z7i4uIIDQ3Vyl922WUMHjyYjRs3lqtr6tSp5fL69OmjuXfn5eXxxx9/MHnyZMLCwrT8nTt3Ehwc7BJ0vXSMKOfbyr59+3L8+HFycnJc2oiOjmbIkCEueRs3biQqKopbb71Vy/P19dXeztUFkyZNQlEU7fPVV1+NEIJJkyZpeXq9nu7du3P8+HEtb/Xq1QQFBTF48GDS09O1v27duuHv78+OHTvqrM8SiUQikUgqpvQ86aOPPqJ///7cc889rFu3zqVc6XlLVlYWOTk59OnTh99++03LX79+Paqq8txzz5XbRKX0/MHJv//9bx544AFeffVVnnnmGZfv+vTpA8D3338POOZSV111FYMHD9bmV9nZ2Rw4cEArW7afVquVjIwMYmJiCA4Odumrk3vvvdcl7tOvv/5KWloaU6dOxWg0avlxcXEEBQWVO742iI2NpWfPntrnq6++GoABAwbQqlWrcvnOOVZmZibbt29nzJgx5OXlafOrjIwMhgwZQnx8PElJSXXSZ4mkMSCX8kkkkgtGjx493AY/P3HiBAAdOnQo992ll17Kli1bygXBLLu7HzgmTu+++y5Hjx7l2LFjKIpCz549NYPVvffey86dO7n22mtdJmm7du1i9uzZ7Nmzh8LCQpc6c3JyXCY/7to9ceIEMTEx5SZ67uSpLUpPjgCtj2Xd2oOCglxiR8XHx5OTk0NERITbetPS0mq5pxKJRCKRSKpD2XnSuHHjuOKKK5g+fTojRozQjDMbNmzgxRdfZN++fS7xLEvPQ44dO4ZOpyM2NrbKdr/77jv+97//8fjjj2txpUrTtGlT2rdvz86dO5kyZQo7d+6kf//+XHfddcyYMYPjx4/z999/o6qqi2GqqKiIefPmsWzZMpKSklxiXpZ98Qfl51jO+WH79u1d8r28vGjbtm2Vcp0LNZlfAdoc6+jRowghePbZZ3n22Wfd1p2Wlkbz5s1ru8sSSaNAGqYkEslFibud8Hr37g043ugdP36cK6+8Ej8/P/r06cNbb71Ffn4+v//+Oy+99JJ2zLFjxxg4cCAdO3Zk/vz5tGzZEqPRyMaNG3nzzTdRVbXKduuDinaScZdfeiKoqioRERGsXLnS7fFVxbaSSCQSiURyYdDpdPTv35+FCxcSHx9Pp06d2LlzJ6NGjeK6667jnXfeISoqCi8vL5YtW8bHH398Tu106tSJ7OxsVqxYwZQpU9y+hOvduzfffPMNRUVF7N27l+eee47OnTsTHBzMzp07+fvvv/H39+eKK67QjpkxYwbLli1j1qxZ9OzZk6CgIBRFYezYseXmV9Aw5lg1mV/B2TmWU55HHnmknGe9k5iYmFrooUTSOJGGKYlEUu+0bt0acAQWL8uhQ4cICwur1pbBrVq1olWrVuzcuZPjx49rb+2uu+46HnroIVavXo3dbue6667Tjvnqq68wm818+eWXLm/JarKkrXXr1hw4cAAhhMvbSnfyuMOdS31d0a5dO7Zt28a1117bICaAEolEIpFIKsZmswGQn58POHYc9vb2ZsuWLZhMJq3csmXLXI5r164dqqpy8OBBunbtWmkbYWFhrFmzht69ezNw4EB++OEHmjVr5lKmT58+LFu2jE8//RS73U6vXr3Q6XT07t1bM0z16tXLxYCzZs0aJkyYwBtvvKHlFRcXk52dXS3ZnfPD+Ph4BgwYoOVbrVYSEhK4/PLLq6zjQs2xnB5cXl5eDBo06IK0KZE0JmSMKYlEUu9ERUXRtWtXPvzwQ5fJyoEDB9i6dSvDhw+vdl19+vRh+/bt/Pzzz5phqmvXrgQEBPDKK69o2yo7cU6gyrqXl53gVcbw4cM5ffq0y1bNhYWFvPfee9U63ml0q+5E7XwYM2YMdrudF154odx3NpvtgvRBIpFIJBJJ1VitVrZu3YrRaNR2utPr9SiKgt1u18olJiayfv16l2NHjx6NTqfj+eefL+edVHrO46RFixZs27aNoqIiBg8eTEZGhsv3zjnVq6++ymWXXaYtZevTpw/ffPMNv/76q8syPmdfy7a1aNEil75XRvfu3QkPD+fdd9/FYrFo+cuXL6/2fMXPz++CzG0iIiLo168fS5cuJTk5udz3Z86cqfM+SCQXM9JjSiKRNAhee+01hg0bRs+ePZk0aRJFRUUsWrSIoKAg5syZU+16+vTpw8qVK1EURVvap9fr6dWrF1u2bKFfv34uATSvv/56jEYjI0eOZMqUKeTn5/P+++8TERHhdmLhjnvvvZe3336b8ePHs3fvXqKiolixYkW5bZArwmkoe/rppxk7dixeXl6MHDmyWl5iNaVv375MmTKFefPmsW/fPq6//nq8vLyIj49n9erVLFy40CWIu0QikUgkkgvDpk2bOHToEOCIR/Txxx8THx/PE088QWBgIAA33HAD8+fPZ+jQodxxxx2kpaWxePFiYmJi+PPPP7W6YmJiePrpp3nhhRfo06cPN998MyaTiV9++YVmzZoxb968cu3HxMSwdetW+vXrx5AhQ9i+fbvWbkxMDJGRkRw+fJgZM2Zox1x33XU8/vjjAOUMUyNGjGDFihUEBQURGxvLnj172LZtG02aNKmWPry8vHjxxReZMmUKAwYM4PbbbychIYFly5ZVO8ZUt27d2LZtG/Pnz6dZs2ZER0drgctrm8WLF9O7d2+6dOnCvffeS9u2bUlNTWXPnj38888//PHHH3XSrkTSGJCGKYlE0iAYNGgQmzdvZvbs2Tz33HN4eXnRt29fXn31VbexDirCOSnq2LGjy8SnT58+bNmypdykqUOHDqxZs4ZnnnmGRx55hMjISO677z7Cw8O5++67q9Wmr68v33zzDTNmzGDRokX4+vryr3/9i2HDhjF06NAqj7/qqqt44YUXePfdd9m8eTOqqpKQkFAnhimAd999l27durF06VKeeuopDAYDbdq04c477+Taa6+tkzYlEolEIpFUznPPPaelvb296dixI0uWLGHKlCla/oABA/i///s/XnnlFWbNmkV0dDSvvvoqiYmJLoYpgOeff57o6GgWLVrE008/ja+vL5dddhl33XVXhX3o0qULmzZtYtCgQYwcOZLNmzdrS//79OnD6tWrtRd/4DD8+Pr6YrPZyhl8Fi5ciF6vZ+XKlRQXF3Pttdeybdu2CmMwuWPy5MnY7XZee+01Hn30Ubp06cKXX35ZYYDxssyfP5/JkyfzzDPPUFRUxIQJE+rMMBUbG8uvv/7K3LlzWb58ORkZGURERHDFFVe4jK1EIimPItz5ckokEolEIpFIJBKJRCKRSCR1jIwxJZFIJBKJRCKRSCQSiUQiqRekYUoikUgkEolEIpFIJBKJRFIvSMOURCKRSCQSiUQikUgkEomkXpCGKYlEIpFIJBKJRCKRSCQSSb0gDVMSiUQikUgkEolEIpFIJJJ6QRqmJBKJRCKRSCQSiUQikUgk9YI0TEkkEolEIpFIJBKJRCKRSOoFQ313oLGhqiqnT58mICAARVHquzsSiUQikUjOAyEEeXl5NGvWDJ1Ovs+rS+QcSiKRSCSSxkNN5lDSMFXLnD59mpYtW9Z3NyQSiUQikdQip06dokWLFvXdjUaNnENJJBKJRNL4qM4cShqmapmAgADAofzAwMBardtut5OYmEibNm3Q6/W1WvfFgtSB1IETqQepA5A6AKkDJ3Wlh9zcXFq2bKn9vkvqjrqaQ8lrxIHUg9QBSB2A1IETqQepA6hbHdRkDqUIIUSttu7h5ObmEhQURE5OTq0bpiQSiUQikVxY5O/6hUPqWiKRSCSSxkNNftdlsISLCCEE+fn5eLItUepA6sCJ1IPUAUgdgNSBE6kHSUXIc8OB1IPUAUgdgNSBE6kHqQNoODqQhqmLCCEEaWlp9X7S1CdSB1IHTqQepA5A6gCkDpxIPUgqQp4bDqQepA5A6gCkDpxIPUgdQMPRgVzKV8tIN3SJRCKRSBoP8nf9wiF1LZFIJBJJ46Emv+sy+Hk9IITAZrNht9trfFxBQQF+fn4eu42y1IFn68DLy0sLyufcftSTtxWXOpA6AKkDJ1IPkoqQ54YDqQepA5A6AKkDJ1IPUgfQcHQgDVMXGIvFQnJyMoWFhTU+VgiB3W5Hr9d79IUjdeC5OlAUhRYtWuDv748QgqysLPz9/T1OD06kDqQOQOrAidSDpCLkueFA6kHqAKQOQOrAidSD1AE0HB3IpXy1TGXuaqqqEh8fj16vJzw8HKPR6LEXgERSU4QQnDlzhsLCQtq3b++xW7pKJJILi1xeduGQupZIJBKJpPEgl/KdJxs2bODhhx9GVVUef/xx7rnnnlqp12KxoKoqLVu2xNfXt8bHe7KnjBOpA8/WQXh4OImJiVitVnQ6HTk5OQQFBXmcHpwIIaQOpA6kDkqQepBUhDw3HEg9SB2A1AFIHTiRepA6gIajA7krXxlsNhsPPfQQ27dv5/fff+e1114jIyOjVtvQ6c5d7aqq1mJPLk6kDjxXB6Vvls710J7s9Cl1IHUAUgdOpB4kFSHPDQdSD1IHIHUAUgdOpB6kDsxmM+s+WsKnb81l3UdLMJvN9dYX6TFVhp9//plOnTrRvHlzAIYNG8bWrVsZN25cPffM8VBuNBrruxv1itSB1IETnU5Hy5Yt67sb9YrUgdQBSB04kXqQVIQ8NxxIPUgdgNSB2Wxmw6oPyE0+SWBUK0aMuRuTyVTf3brgmIsK2bZsLoUpJ/GNbMWgibMx+dR8Rc/FjKfrYMXCubRZsYrYfKfDw2Z+XriYxLvGcNcDsy94fxqdx9T333/PyJEjadasGYqisH79+nJlFi9eTJs2bfD29ubqq6/m559/1r47ffq0ZpQCaN68OUlJSRei61Xi3M2vIVp0169fT0xMDHq9nlmzZlXrGCEEkydPJjQ0FEVR2Ldvn9u8fv36aXU2ZB2cL+5kr6hcY9VBTVBVlczMTI/1HgOpA5A6AKkDJ1IPkoqQ54YDqQepA2G3k//jjyR9+hn5P/6IqOEO4Rc7KxbO5efeVxL70ltc88F6Yl96i597X8mKhXPru2sXlLUvxbG3TzfavvUlnVfto+1bX7K3TzfWvhRX3127YHi6DlYsnEu3JZ/SJN/1Xhiar9Jtyaf1ck00OsNUQUEBl19+OYsXL3b7/WeffcZDDz3E7Nmz+e2337j88ssZMmQIaWlpF7in54aqqthVwZ5jGXyxL4k9xzKwq3VvoIiLi0NRFM1bJyYmhueffx6bzQbAlClTuPXWWzl16hQvvPBCtercvHkzy5cvZ8OGDSQnJ9O5c2e3eevWrXOpszYmE8uXL9fkKf33n//8p9z3er2ekJAQrr76ap5//nlycnIq1I2iKDRp0oShQ4fy559/upQrXSYoKIhrr72W7du3V6qPivDUCVVZioqK6rsL9Y7UgdQBSB04kXqQVIQ8Nxx4sh7MZjOfr3yXVYtf4POV79brkpX6IHfrVuIHDORU3ERy58zhVNxE4gcMJHfr1vru2gVBexDPK/Mgnld/D+L1wdqX4rh0xU8E57vmB+XDpSt+8gjDjKfrwGw2E73iMwDKRpTSAQKI/uizC36PbHRL+YYNG8awYcMq/H7+/Pnce++9TJw4EYB3332X//3vf3zwwQc88cQTNGvWzMVDKikpiR49etR5v6uDoihsP5LB3K8OkpxTrOVHBXkze2QsQztH1Wn7Q4cOZdmyZZjNZjZu3Mj999+Pl5cXM2bMIC0tjSFDhtCsWbNq13fs2DGioqLo1atXpXmhoaFaujaXsQUGBnL48GGXvKCgoHLfCyHIzs5m9+7dzJs3j2XLlrFr1y4XWZ26AUhJSeGZZ55hxIgRnDx50qX+ZcuWMXToUNLT03n66acZMWIEBw4coG3btm5ld4dcyudAp9O5eDd6IlIHUgcgdeBEp9Np3tISiRNPX6rhxNP10NCWrFxocrdu5Z+ZDwCuD6LW1FT+mfkALd5aSOD119dP5y4AZrOZNh+tAtw/iKtAm49WYZ76RKNe1mcuKiTq85+AivUQuf4nzA8VnvP9QQgBQoCqOv4LgXB84ZLvWPghzuYLgXC+eBdl80W5so46apIHCBVLcREt1lasAwG0WPsT6dd+g95gQLVZsdtt2Gw2bDYrtpK03Vby325Dtdmw2W2odjt2e0meXcVus6KqdlSbDVW1I1QVtaScqqpgt5fk2xF2FaHaQXX8F6paknb8R7WDKhBCRXHmCVXTp6KqKKpw5Dk/C4GiCsf/kjwE+BRZaJVfsWOLDmiSJ9jw2X+4Zfz953QenAuNzjBVGRaLhb179/Lkk09qeTqdjkGDBrFnzx4AevTowYEDB0hKSiIoKIhNmzbx7LPPVlin2Wx2sSbm5uYCZz1anP91Oh2qqmrLr5z/FUWpdnrzgRSmrfyNsqdRSk4x9330G+/860qGdo7U8mtSd1VpAJPJRGRkJEIIpk6dyueff86XX37JU089BcCAAQMA2LFjB507d2bGjBl8//33ZGVl0a5dO5566inGjh0LwMSJE/nwww+1+lu3bk2/fv3K5SUkJNC/f38uv/xyFixYADi8mRYvXszhw4fx8/NjwIABLFiwgPDwcAC+++47+vfvz9dff80TTzzBwYMH6dq1K8uWLeOSSy5x0U/Tpk3dyi2E0L4HiIqKomPHjowYMYLOnTvz2GOPsWLFCre6adq0KU888QR9+vQhLS2NiIgIrf6goCCaNm1K06ZNeeedd2jRogVff/01e/bsKSd7YmKi2/EAR5B+g8FQq2N8rml31GWbzs82m42srCyaNGmiteu8zpyeaRWl7XY7Op2uwjQ4rt3Sab1ejxCiwrQQAp1OV2G67L2gpml3cpTWgbOdi12mmo6TzWYjOztbM2A3BplqOk52u53s7GxCQkJQFKVRyFSTcbLb7eSYc0gpTMGaZ6VTy04YDIZalUlycbL2pTiiPv+Jttpb8X3s/eBLkm+6mlueXl6PPbuweLoenJ4yZQnNV2my5FNWQKM2Tgm7naOzn8Wbio0RR2c/yxUDB6Lo9TWvXwiw2RB2O8Jmc0nbLVasFisWswWzuRhzcRHF5iLMlmIsZjNmczFWqxmb2YzVasFuNWO1mLHbLKgWi+PB3mpxPNjbrQibtVQbNhR7yX+bHUW1g92OTrWjaP9VdHaVgIJiYsp4SpXVQ1ieyg99r8RsPLugSCmZ6mp6KzX1VcqUKXuMo4yo8Luq2lDclCl/zNkvyvdHlKvfYBeEnPVtKIcOCM2Dgz26IRTX+nTC9bMiHHUqJTaji2kZVmAl3ylAYCGcmTq9ynoMNG5jijVh7wVtrzHrshzp6enY7XbN2OCkadOmHDp0CACDwcAbb7xB//79UVWVxx57zOXBtyzz5s1j7tzyrp9paWkEBweTnp4OQEREBOnp6drk2LndvV6vJ6egGJ1OwWAwYDZbMBj06PV6l3RBYTFzvvqrnFEKHLcdBZjz5V9cG9MEnQJmswUfH29UVcViseLtbXJJG3Vgt9sxmRz5NpsNk8mEvcSCazQaXdKqqmp9dy7f8/HxIS0tjQMHDtC5c2c+++wzevXqRUREBElJSVxxxRU8/vjjmEwmtm7dyl133UXLli3p2bMnCxcupHXr1nzwwQf88ssvWK1W/P39adeuHUuXLuXnn3/GYDBQXHz27llcXIy3tzcWi4Vnn32WLl26kJKSwkMPPURcXBxfffWV1jeAp59+mjfeeIOQkBDuv/9+7r77br777juXZXBWqxWj0agd5+XlhdVqLTdOBoMBq9VKkyZN+Ne//sUHH3ygHWu32zVjidlsxmKx8NFHH9GuXTvtYdmdHN7e3oDDYPrmm29q+vjpp5+0B6HSY+NMlx6bsmPmjD3lTiZFUbR0aZmcaYvFgsFgQK/Xu6TNZjNGoxFFUVzSxcXFmEwmLe3t7Y0QArPZjI+PD0IILBaLlu9Mu5OpsnOvrEzOsUlLSyMvL48mTZqQnJyMj48PoaGhJCUlERAQQHBwMKdOnSIkJITAwEASExOJiIjA39+fhIQEmjdvjo+PD8eOHaN169aYTCbi4+Np164dOp2O+Ph42rdvj6qqHDt2jI4dO2KxWDhx4gSXXHIJxcXFJCUlERMTQ0FBAWlpabRt25a8vDyysrJo3bo1OTk55OXl0bJlS7KzsykqKqJ58+ZkZmZitVqJiopyuUekpqbi5eVFWFhYtWQ6ceIEOp2OJk2aNBqZajpOR48eJTAwEJvNRkJCQqOQqabjlJqaiq+vL/n5+WRnZzcKmaozToWFhQSEB3D0n6NkFWZh9jMTlB1Euk86kZGRtSZTQkKCu59/SQPHuVSjLEH5ELziJ9YS5xFGmYtJD04Dh91ixWI2Y7dYKS4qxmwuwlJUiNlSjNVsxlJchNVixmouxm4pMWRYzdgtFuwWi8OQYbUgrBZs5mIu3bANqNg7otP/fcqnf/2NotOdfagv++BfznjgmH1X/n35fAWHp0jZcmXrLWdUKGNscKKIsp/L99+UW0CzrFwqQgf4ZOXy7YBrsXoZUFQVnd1e8l9Fp6roVIHerqITAr1dOD6XpPXnEFHEVPIXUPND65Rm2SoOU51n422t7x6cRQVQShyelJK/MnmU+U7Lc3OMwQb+1Vihlh4ABd6OY1Wdox9CAaEr1U6JNU7oSvWpJK0owtGPkvYdF7lA6EAp1WdFs/A58oVSct8p+UzJZy2tONJKSRvgKKcooFOEoxlnWgEdjjxFV5JWoCDHQNu9VXsGBgf7VK2oWkQRjTiCsqIofP7554wePRo4G9h89+7d9OzZUyv32GOP8d133/HTT+V/uKvCncdUy5YtycrKIjg42OUtbWFhIYmJibRt21ZzEy2y2ol9bst5SHlu/DX3enyN1fe4iYuLIzs7m/Xr16OqKt988w0jR45k+vTpPP3004SGhrJ9+3b69etXYT0jR46kQ4cOvP766yiKwptvvsnChQtdPIMWLlzIggULXB4ESntMuav7119/pUePHuTm5uLv7+/iMTVo0CCEEGzcuJERI0ZQWFiIt7c3H374IRMnTsTPz09rx9/fn5SUFIQQLF++nAcffJCsrKxycixdupT77ruPlJQUmjZtSlxcHB999JFmaCooKCAqKoqvvvqKK6+8UjtWp9Oxbt06Ro8eTWFhIY8++ijvvfcev/32G126dGHBggUsXLhQk70heEM1NI+poqIiEhISaNu2rbac8WL08GiMXitSJinThZJJURSyi7NJKUghrSgNm2oj2BRMvi2fCO8IOoR2qFWZsrKyCA0NJScnh8DAyt6zSs6X3NxcgoKCzlvX5qJC9vbpRnB+eWMEOB4aikwQdd9UDF4lS+N1CgLFYRLQrAEKiq7kd8jxFOA4Xin5fUKU5JUYE8o+hJRkCwSKonN5gHL2RAD2EiuC6iiJKgSiJG0XAhSBKhzfIwSqS5mS44XzwUk4jgGsFjM+by4jsLBiPeT5wLGx14MAu91W4pFiR9gcy0+w2RF2G9hVsNlQ7A6vFIcnih1K/uvsjuUleqchw646jBaqis7uMGroVYFeFRjsjv+O7x1eHAYVDNIe0Kiw6cBe9k/v+K8qYNMrjv86BVWnYC/509KKgl2nQ9UpqM7/ig67TofQ6VDL/Bc6vfYfvQ5KPis6PcbMTAbt/afKPm+97hK8mrVEJ6zosKNTbeixoxc2dMKOHhs67OhVGzps6J15wlZSxpGnw4bB+RmH95Yeq+t1qLj8c0G4y9SOK+s+5frRjh5Vp8Om6FHRY1cM2HQGVHRkp9vp/H3VF9qvA30wRYWU1K9ZR1AAVVfKsqLdEx2WEaXks6qAgk5zoxKKrlRxBUruh6KkbqXk/it0DnOvZmkpEU5RlBIzsFJieFFKUiXfo8NpkVG0vum0b0Ep0alC7uFD9FqXXKUO9t3SkpgrumFQdBgUHUZFj0GvYFD06HWgVxxzCr3OqR5diQFIOdsfBXQ45hKaoQkdupI+6s5mlvzE6M4anTS5HfkVUuG5UvFJZE6NZ+/z/yMo372nmwrkBEC3lYsxXTKgMjVVSU1+1z3KYyosLAy9Xk9qaqpLfmpqKpGRkRUcVTkmk6lRr0UuzYYNG/D399c8iu644w7mzJmD1VrerG6323n55ZdZvXo1SUlJWCwWzGYzvr7nF89ACMHPP//MCy+8wJ9//klWVpb2wHHy5EliY2O1spdddpmWjopyxN9KS0ujVatWAAQEBLB3714Xw1F1+wCcvfHhMJ4tWbIEIQRZWVksWbKE4cOH89NPP9GmTRut3B133IFer6eoqIjw8HD+85//cNlll1Vq5HHXvnMpnyejqioZGRnaEk5PROrAoYP09HTCwsLquyv1hlMHTZo0cbkvNUZyzDmkFqWSWpCKXbUT5B2ESW8CAXnWPAqyClCD1WrfzyWNk23L5pZatlYeBfA1Q86Cdy9Yn84XHbW/VEYBAovgimUNN/i1XQGb3mHQsOlK0iUGDrX0fx2oOuHwbNCXeC3oBD4FCtGnq74vHo5WKQx1zMXKzshKe1+U/uxAcfl8tuxZV6nS9Tkfjl3ySsq5++yuzbIGzsr7q+Cdo9B7H1Xy3TUqhDqMsDpdyR+gV4TDzlPyMK7XgU5R0OsEBhQMeoFeUTDqwKAoeOnAS1EwIPBVFIzo8AKMioIXjj+D03BByXxa++06a2BAOWuEcBopHJ8FKHYUVIcbSEkZRbP0OB/0z9ZrLcrhl8NU+SA+LWonXtjPjkfNVzZWC6HzAoMJDEbQeyMMppLP3o4/L2+EwRsMJoSXDxh8EF7eCL03GEt99vIBLx9Uo1/JsSZKn0yi1NkhAHNxMYd/u79SPWQHwA0vfIG3t59j0NE0f/a/omjGEs1ApJzVuUs5t+OMa/oCYi4qZO/WblXq4OZn1jfaOHwm1Y5l2waUrQoqrnpQcZxBlp4CU0zfC9ovj3qyNRqNdOvWjW+++UbzonJ6/0yfXvU60spYvHgxixcv1pZgVXcpn4+Xnn3PDKhyKd8Ph1OYvPKPKvuxLK47V7UJqdZSPovFUqOlfH379mXp0qUoikKzZs3w8fHBYrFoO7w4AsDZMRgMvPrqq7z11lssWLCADh06EBgYyMMPP0xxcbH2Vrz0sjvnEjHA5a142SVwdrudG264gUGDBrFy5UqaNGnC8ePHGTlyJMXFxVgsFq2809hjt9u1cbFarZohTafT0bp1a4xGo4txrbKlfDqdjr///pvAwEBCQkK0+n19fYmJiaG4uJh27drxn//8h6CgIN5//31eeuklTY758+fTp08fIiIiCAsL07ztnMYmZ7qyZW/O8XCOnycv5SsoKCA8PPyiWXpUF0v5nAbKxiLTuSzlCwkJ8filfAEBAY16KV9IVAgJKQmkZaWhD9bjbfXGZDPh7e9NYXYhwi7AB8wFZtLT5VI+T6cw5WTVhYAjzSAjsOQBSuAaMwXKxVCp6DsF5/fCpZ6yx+hK1+P8XpSK3VJR/W7qq7SNks9eNvA9Oy2qkIxAKPRxGHRUncOoo+pFiXHnrJHHaR0TupKGSv4rOod9QFEEil44lpDoQKdzpB1GDhWd4sjT6wR6RWDQCfSKikEBg07FUJJnUAReJWkvwCCEI5aLEOiduqsmv2X5wemgKsu1uiSPK0MKalDzxcMvrU2kH2tCaF7FD+KZAdDtkiyustRgFy61zP8GjBeg9ghE2e5f4YO4elU+XkqpmIKKvsRYVMpgVMZ4hMHHzf/Sf75g9HX8N3g78gwmFJ3rI/iFMtH4+/uQPLwLwav2V6iHlNFXc21oywvUowuPyceX5JuuJnjFT5XqoLEapQDQ6ek39d/stE1H/7MfIaVe5OQEgP2qAvpNfRt0dWSZrYBGZ5jKz8/n6NGj2ueEhAT27dtHaGgorVq14qGHHmLChAl0796dHj16sGDBAgoKCrRd+s6V+++/n/vvv19zV4uIiABweYsfFhZGfr5j5L28vACH9TjIz1tL+3jp3aYHxDYjMugwqTnFbuNMKUBkkDd92oej1yn4mbw0T6CK0vqSAIc6nU4zCun1ei2/dFqn0xEQEEBMTIyLd4+Xl5f2YOw0ZAD8+OOPjBo1ijvvvFNbonHkyBFiY2O1N9mlPX5Ke505l1IA2vI4Z/q3334jIyODf//737Rq1QohBHv37i0nB+Aik7MtvV6v6b70OJTui5eXl9bHsmXT0tL4+OOPGT16tEudzv6WlkOn02lGO6cckZGRdOrUyUUmp8zO+hRF0eopLZMzrSiuu/KVHqfScpSVqaq0O92Vlal0uuzYOPteOu0sX5VMZeWoTCbn2Di9HHU6neYRB9C8eXNtPFq2bKml27Rpo6Wjo6O1epwPzgDt27cvl9bpdLRv317TS7t27TSZo6OjAfDz89M84wICAvD39wccwe6dbqvBwcEEBwcDrjtNlr5HlI5/Vx2ZoqOjteulschU03G65JJLXPIbg0w1HSdnnUIIAgICGoVMznESJkGxfzH70vZhVa2ERITgY3QYvp0/hj5BPiCgyFxEaItQIkIjalUmZ78kFw++ka2AfVWWi7/6Coo6j0CHDr1zCUXJn07RlRhSFHQK6FHQlzhz6BXHEgxdieeIrmSBiU7B8YeCXlFQFFHyGQw6BUUBveIop+A4VnEeI8TZ40uO0Tn74+JOU4GHtRCu5YAD366m68pfqtTDP6Ou4YrBd6LoSimg1FKdC+mJaS/5M4sSKx7Oa92RVkqlXXUhSnSAy3chKftI3vXfqpes3PQQtOjqvlNl23GbTzXKiAqLlfGrqrqNCusV5ZKXpxzgyZyVTPqCCh/E1w+AeVfdD5GxbtosrWtRqgnnGJXpT+myLjG4SpctNa4u5Z1J9Wxe6fZEKStY2eNEqfbKHpeZQO/fPuSHAaD72b/cg7h6VT69I3Jh4Gxo0d1hRNKfnSM3Jm6Z+iRrmUfUxv0uesgOcBhkGkrMubrklqeXsxbHphCeqgNiR9FnOlg3Ps7+UznkmQ0EmGxc1TIIr+FvQ+yoC96lRmeY+vXXX+nfv7/2+aGHHgJgwoQJLF++nNtvv50zZ87w3HPPkZKSQteuXdm8eXO5gOjni3NCW3o5gTNeBbguA6tO2qDXMXtELNNW/qaFLdDKlfyfPTIWg971Z7em7VSUrqzO0jI50+3bt2fNmjXs3r2bkJAQ5s+fT2pqKrGxsVXqoKLPiqLQsmVLjEYjixYt4r777uPAgQO8+OKL5dovXUdFfSxbpmxbQghSU1MRQpCdnc2ePXt4+eWXCQoK4pVXXnE5xmw2k5KSAkBWVhZvv/02+fn5jBo1qsK+uJOvMr0400IIrFari3GzsvIXIu2Oumqz9OfU1FSaNm1a7jqrKu00etU0rShKhemqzrea9rE6aUCLddZYZKrpOCmKUk4HF7tMNR0nIQTJycku18LFLlO+NZ/kgmRSC1Kx2C0Eewfj7XPWGK4oivbj50wLISjILIDQupNJcnEwaOJs9n7wZZVLNYbdNBGj0dtNicbBZUPuIuuLX6rUQ5fr70BX6oVUg0BROHuRn82uKvBB2e/Vlj0xX7MMZZu+4iUr19gxxfS74N4BFwpjUAsG/vlf5t/kxYRtKmF5Z7/LDIAPB+m4OcKK8dIbGq0OaNMHDm+kd8QZbMNz+TPHT3sQ7xFUgEEH+EVA9HWNVweluGXqk5jHprDtf2vJzcomsEVbBk2c07i9hMpwy9PLMT9UyLZlc8j957hH6oDYUXh1vIGuibvISTpMUPMO6NpcW2/XQKMzTPXr16/KeD3Tp08/76V7VeFcblQ24Kqzb+cSAHpo50gWjb2cFzceJiX37BK3yCBvnhsRy5BOkS6y16TuqtKlKVumtEzOJXhPP/00x48fZ8iQIfj6+nLvvfcyevRocnJytDKl+1p2zNx9FkJocZmee+45Fi1axJVXXslrr73GjTfe6NKX0nW462PpMu7kFkKQm5tLVFQUiqIQGBhIhw4dGD9+PLNmzSIgIEA7FmDz5s3aG/mAgAA6duzIqlWr6Nu3b4V9KTtO1T03yo5JXQQZr0naHXXZpvOzqqqaN1VDD9ZclwGonTpoTDLVZJycy4eFENjt9kYhU03HSVVVvLy8tPTFLFORvYjk/GRSClKwCAuBxkBCTCFnA1AL3KZVVSU+Kx5LgQWbn42roq7SvEdqQybJxUV1lmokDo6lRyM2SgEYjd4kXB/LFesOeq4eFD0dhk/imPo2ejeeMvar8uk39pHGbYzQ6Rne4368ds3j+ckhhCbrCMmHLH/IjFJ5LCuDwT2ebPQ6oNcM+Po5DDrcL9vsNb1x66AMJj0M+9dMMo3NCA0NLffi0xMw+fgybOorZGZmeqwO0OmhTW/sgbEQGqrFFasPGvWufBeS0jGmjhw5wuHDh7nkkktIS0sDHDE8Tp48SW5uLjExMdqSBmdsH2fabDa7xPZxpouLizEajeh0OgoKi/jjdD5n8i0EmxR6tW+KQa9zG+fHGYvIGdvHmbbb7S6xfZxpZwyf0vF8nDGYnHF+nPGYvLy8sFgsKIqipc9VptLpoqKiSmMXSZk8V6a8vDxOnDhBTEwMWVlZWvyYpKQkLX7MqVOntPgxJ06c0OLHHD9+XIsfc/ToUS1+zJEjR7SYOIcOHao0Jo7ZbNZi4hQVFWkxcfLz87WYOLm5uVrsouzsbC3OT2ZmphbnJz09XYvzU/oekZycLGWSMnmkTOk56Rw9eRRbqI2igiK8Cr0IbxmOucBMcV4xQZFBFOcXYym0EBgRSFFuETazjYDwAHYe3cnHxz8my5Kl/SY39W3KlPZT6N+i/3nL9Ntvv9GtWze5K98FoLZ25XOy9qXySzUyA0qMMWNmnXf9Fws/r1pA9NaDHq0Hv9O7Cf59KYfSijVPmS7NfPHqPcPhJeMJJHyPbfcifrfnckavJ9xu5wp9IIZenqUDdi+CgjNn8/wiHEYpT9GBk+x/oNnlENyqvnsiacTU5HddGqZqGafys7KyCA4OdnlLW1hYSGJiIm3btnWJvVMTrxGr1YrBYNDe6taX18qFSFeEUwdOr4CG0t8L5V3k1IGXl1ejkam66aKiIhISEmjbti0Gg4GUlBSaNWumtetpHlM2m03TgbOdi12mmo6TzWYjNTVV81hsDDLVdJzsdru2u6yiKBeVTPnmfNKK0kguSKbYWkyQTxA+Bp8KPaPKpn9J/YX5e+dTFqe31Ot9X+f6Ntefl0xZWVmEhoZKw9QFoLYNU+DYgWnbsjlkHD+E3j+ArsPjGvXyvYqwWIr565vPKM5IxbtJUzoNvN3j9JCRV0RrSzwmcxbBYc3QNbvMozxkAFDtqKf/JDv9tNSBJ+tAqJCXjNr8apJzLURFRXmmtxCOOUlycrLUQR3poCa/641uKV9DwTmopQfXOckF16VY1U2XfvB0V487zqWdhpQuS2kdNJQ+nq9MNa3DqYP6lqO+zj3nZ51Oh6+vr5Z2Up10Y4rH5NRBY5KppnL4+vpqBpnGIlPZdGUy6XQ6fHx8yumgIctUaC0kpTCF5Pxkim3FBJoCCfEJ0cqUjR/lLq2isvyv5bhDlASjfu2X1xjYaiD6Ug8d5yOT5OLDuVTj730/Yk4/4XHGGCdGozddh46nyGLDx2io8je8MSIUHfrmV4JOAT8jeKAO0OmheVcIjpU68GQd2IodOwgaffHxkb9xPj4+9d2Feqch6EAapi4iFEVx2aHME5E6kDpwotPpXHYY80SkDqQO4OLSQVmDVIApgGDv4HOq6++Mv8kszqzwe4EgpTCF39J+46rIq86xx5LGgE6nw8/HhMUDnz9LoygKvqbGudNYVagq6FDw9jIQ6OPZcyidohDqb6q6YCPG43VgLQYvX3RGX0JNfvXdm3rlYppD1RUNRQee6a92AXAuG1BV1SXtXJbkXGZR07TFYnFbj7u/82mnIaQr+jObzZpO67uPtSHTudRhNpsblUznkrbZbJw8eVK7xtxdZxWl7XZ7pWkhRLm0s/2K0qXPSXfpsn2sadqdHKV10Fhkquk4Wa1WTp48id1ubzQy1XScbDYbp06dwm63N1iZ8ovzOZ59nN9Sf+NY5jG89F409WuKr95X669QRY3SWUVZVIczhWfOWybJxY2qqmTmFiAqXoHuEQghyM4/O3/wJCx2O0aDDi+9wqn0AlTV83TgRFWF1IGn68BWDD4hqEJw6tQp7ffRE1FVVeqggehAGqZqicWLFxMbG8tVVzneyjqDyqanp5Oenq6lnQNutVq1yW7ptNPwVDbtNMbodDosFos2qSguLnZJg2PiUTptNpvLpVXVEYy6bNput2tBs0unbTabS9pms2l9L52uqUzOvpdOVyWTUweNSaaajpOiKG7lu5hlqu44Oft15swZLSZMcnIy2dnZACQlJZGTkwPAqVOnyMtz7IucmJhIQYFjF5aEhAStn8eOHdP6EB8fr7URHx+PqqrYbDbi4+M1vRw7dkyTOSEhAYCCggISExMByMvL49SpUwDk5OSQlJQEQHZ2NsnJyQBkZmaSmpoKuN4jUlNTycx0eIBUR6aTJ09qscYai0w1HaejR4/i7++P3W5vNDLVdJxOnjxJQEAA+fn5DU6mvKI8ErIT2PPnHo5lHUOPHlOWCT8vP+xWO1lJDuOSzWIjO9nRprXYSk6Ko01LoYXctFwAzAVm8tId7R9OPswX8V9QHcJ9w89LJqeuJRcviqLgbfRMT6GymLw8c9mOxSYwGXR4e+kI8PHyyNVbThQFqQNP14FQwRSAoigEBAR45NJeJ1IHDUcHMvh5LVPXwc8rSrujtuqur7SU6eJIX0iZSgc/NxqNQMMJQC1E4wuqLWWSMp2rTMX2YlLyUjhdcJpCWyEBXgH4m/wdNwhBtQKbu0tnFmXy2ZHP2PnPTgSVT18UFCJ8I9hyyxYtGLoMfn7+nDp1irvuuou0tDQMBgPPPvsst912m/b9hg0bePjhh1FVlccff5x77rmn2nXXRfBzJ4l/7yXrnyP4h7eo1XolFwfp+WZaBPvSMrT+46hIJPWKaoP8dGh9DZSO7SiR1AEy+HkDoK6Cn5vNZoxGo9t63HEu7TSkdFmEcCxndBolGkIfz1emmtbREHVwvjLVJF3686lTp2jZsmWDCEBd+pp0l66LoNPg8Jpq2bJlo5GppuOkKEo5HVzsMtV0nIQQnDhxwuVaqC+ZLMLCmbwzJOUnUWAtIMAYQJR3lOv9ohqBzcumi23FfHnsSzYc24BFdXhk9WrWi0tDL+X/DvwfZXEaop7o8YRL4PNzkUkGP3fFYDCwYMECunbtSkpKCt26dWP48OH4+flhs9l46KGH2LFjB0FBQXTr1o2bbrqJJk2a1GufVVUlI6cAxcNfxTqX8gX7m6r8DW98CHxNescSrowCWjbxQ6fzNB04kDrwcB3YisHLG7z8tCVcZefSnoTUQcPRgTRMXWTIoNdSByB1AI4H1pCQEA+cXJ9F6kDqABqGDoptxZwpdBik8q35+Bv9ifSLPO8+qULl21PfsurwKrLN2QB0COnAnbF30j6kPQBBpiCW/7XcJRB6U9+mPN7jcQa1HnRe7UvKExUVRVRUFACRkZGEhYWRmZmJn58fP//8M506daJ58+YADBs2jK1btzJu3Lj67DKKouDnbaQwt1670SDwMXne/MFmF+h1OkxeOhQFQvyNePBPhtQBHq4DazF4B4PBiCJEvc8f6puGMIeqbxqKDjzv1+kCUTrIKpxdPuBclnSuy5lKL90one+Omtbd0NIVyVTaklvffawtmWpaX0PSQW3JVN106WvI398fRVE8djmVEEJbE95YZDqXcQoICAAcsckai0w1HafAwEAt/0LKZFEt2pK9fFs+/gZ/mvo2dfRBFWeX2wk0L6jqLt/7M+NPPjr4EafyHHGzmvo2ZVyHcVzd7GpHNapA0SlcFXkV3SK68VPqT6DCZeGX0T2yOwqKpo/zHaeLie+//57XXnuNvXv3kpyczOeff87o0aNdyixevJjXXnuNlJQULr/8chYtWkSPHj1q3NbevXux2+20bNkSgNOnT2tGKYDmzZtrsc7qE0VR8DZ5UeS5zx1AiR6Mnjf1t9pUjHodJoMeRVEI9DHWd5fqFakDD9eB3Qy+jh3YFEXx+CXqUgcNRwee6a9WB1yo4Odms7lBBKAuG1R7/fr1xMTEYDAYmDVrVrVkKi4uZvLkyYSGhqLT6fj9998RQjBp0iSaNGmCTqfjp59+on///syaNUuT1amDupbpXMfJOR51NU7O4zw9+HlKSgoHDhxAVdUGEYC6PoJqJyQkcOjQIVRVbTQy1XScjhw5on3XWGSq6TglJCRw/PhxcnNzL5hMRxOOcjT1KPtS93Ew/iB2q50ovyhsZ2yoNsc1mnkqE2F3GJkyT2WCAGEXjjRUGPw8IT2BF394kXk/zeNU3il89b7cFXsXL3Z/kVivWBRFoTivmPyMfACKcooozi6mfVB72he3p7WuNXqdvtbG6WILfl5QUMDll1/O4sWL3X7/2Wef8dBDDzF79mx+++03Lr/8coYMGaLNWwC6du1K586dy/2dPn1aK5OZmcn48eN577336lym80VVVdKz86nkfYpHIIQgM+/sb7enYLar+BoNeOkUVFVwPDUPj92NDaQO8HAdqAKMfo6kqnL8+HFtbu2JSB00HB3I4Oe1TF0HP1dVFR0CTu5GyU9D+EdAq16gKx8DozY9VeLi4vjwww8B8PLyolWrVowfP54nn3wSg8FAZGQkcXFxzJw5k8DAQPz9/ausc+PGjYwePZpvv/2W6OhowsLC2LZtGzfeeCM7duygbdu2hIWFkZubi5eXl+YV4XwDfj4yffjhh0ycOFEbm8DAQC655BJuuOEGZs6cSVBQULXr3LFjBwMGDCArK4ugoKBKy7vjXDyUakMHF6PHVOng515eXhQUFBAQEKCVqW+vlQvtiWO32yksLMTf39/lnLiYZarpONntdoqKivDz80MI0Shkquk4qapKUVERvr6+Wl/qSiaraiW9OJ1T2afIs+Xhb/TH3+CPoivx4lMFKLikgWp5TGUXZ7Mmfg3bT25HINAreq5vcz03t7uZAO+AKj2s0ovTCSGEzs06o9fra22cLubg54qilPOYuvrqq7nqqqt4++23Acc51rJlS2bMmMETTzxRrXrNZjODBw/m3nvv5a677tLyd+/ezWuvvcbnn38OwKxZs+jRowd33HFHteqtq+DnQgiO/PkzBanHCYjw3ODnQgisNhUvw9mYp55Aen4xbZr4ExXkjRCCArMNP5PBo3RQGqkDD9aB3QJF2dCqJ3g7PK0LCgrw8/PzLD2UQuqgbnUgg583AJwPFWUDqzoHu/Sg1yStP/w/2Pw45DreWioAgc1g6KsQO6pcP861nbJpgKFDh7Js2TLMZjMbN27k/vvvx8vLixkzZpCWlsbQoUNdXPirqvP48eNERUXRq1cvLe/YsWNERUVx7bXXanllg6aWDXx8runAwEAOHz7seCDKzmb37t3MmzePZcuWsWvXLpo1a1Zr+qvqIq9pHbWlg4YkU3XT2rWg12s3uNJlziew8cUWKFyv12sG28YiU03HyWAwaDpwcrHLVNNx0uv12suA0jqoTZksdgtnis6QlJdErjkXP6MfUf5lgprjMBS5S1O6WJnA5ma7mY3HN/LF0S8otju8lHpE9uCOS+8g0i/SRabKAqQrioLJx6Tppi7G6WLHYrGwd+9ennzySS1Pp9MxaNAg9uzZU606hBDExcUxYMAAF6MUQI8ePThw4ABJSUkEBQWxadMmnn322QrrKu0BDY4JLFQcDqGidFWGRlVVMXrpKVRAFQIFx/niTEM52yk6pWT5eAVpqL8XQqX7XlG6Ipm8DDotv7HIVOk4CUdBk0GHqgp0OgU/kwEhQCk5HxCg0ynl0yX1qCVGdndppeTeU1Hargp0laTB4cBSOq0vMbhXlBYlfawoXR2ZfI0GTZeNRaaajpNvqWWtjUWmKsfJWoxdZ0Jn8IGSF1t+fg7vKU8Oh+Dv76/lNxaZajpOzpfc1ZG7pjJVF7mU7yJCHPwCsWo8Ive06xe5ybBqPBz8sk7bN5lMREZG0rp1a+677z4GDRrEl19+qT0UDhgwAEVR+Pbbb8nIyGDcuHE0b94cX19funTpwieffKLVFRcXx4wZMzh58iSKotCmTRu3eQD9+vVj1qxZDh0IwQcffED37t0JCAggMjKSO+64w2UJwrfffouiKHzzzTd0794dX19fevXqxeHDh13kURSFyMhIoqKiuPTSS5k0aRK7d+8mPz+fxx57TCunqirz5s0jOjoaHx8fLr/8ctasWQM4ln70798fQAsaFxcXV9uqd0EI4bKMzlOx2+0cPXr0oov/UptIHUgdQN3qwGq3cjr/NPvS9vF3+t/YhI2m/k0JNAWWM0rVFFWofP/P9zy440E+O/wZxfZi2gW1Y3bP2TzU/SEXo1R1EKogMynTo8+FqkhPT8dut9O0aVOX/KZNm5KSklKtOnbt2sVnn33G+vXr6dq1K127dmX//v2Aw1D8xhtv0L9/f7p27crDDz9c6Y588+bNIygoSPtzxqpyFw7hfJZmHj9+nNSMXISAzNxi7CXLd9JzilBLbBfpOUUIHA+c6TlFgONhNTPXYSy12VWy8hxpq00lK99hUDNb7WSXpIstdnIKHMtziyw2cgsd6UKzjfwix5L0gmIrBcWOdH6RlUKzY5l9bqGFIosjnVNgodjiOI+z882YrY50Vr4Za8lS2ay8Ymz2kmWz1ZRJFYL0nCIySuRrDDJVNU7pucV46fXY7SqnMgqwq4IDp7I4leE4N7ILLCRnFzrazDOTWlJnem4x6SV1puYUkZnn0EdydiHZJfpIyiwkp9Ah96mMAvJKdJB4Jp+CEh0kpOVpch9LycVSImt8cg421WHIiE/OQRVgUwXxyY5z2WJTOZaSq41BQprjvC4w20g841jGnFds1eTIKbSSlFlYLZnsqmDfiUzOlMjXGGSq6TjZVcEvx9LJKzmHG4NM1RonWzHxWWATjuebw4cPEx8fj9ls9uhwCEePHiUnJ6fRyFTTcUpOTubo0aOkpqbWukw1CYcgl/LVMpW5qzlPmujoaLy9vR2ZQoC1sOqKVTticQ/IS8b9o4ACgVEw7Se3y/rK4eXreFVUTeLi4sjOzmb9+vVa3o033sjJkyf57LPP6NChA2vXrqVXr16EhoZy5swZPvnkEwYNGkRgYCD/+9//ePDBB9m9ezc9evQgJyeHt956i/fee49ffvkFvV6P0WgslxceHk6/fv3o2rUrCxYsQAjB//3f/9GsWTM6duxIWloaDz30EMHBwWzcuBFwGKb69+/P1Vdfzauvvkp4eDhTp07Fbreza9cuAJYvX86sWbO0i6w0s2bN4oMPPiArKwu9Xs9LL73ERx99xIIFC2jfvj3ff/89U6dOZcuWLfTu3ZsvvviCW265hcOHDxMYGIiPj4+2pK8ucFq8S3tEeAqlryGTyURxcTHe3t4epwcnTiOl1IHUQW3rwGq3cqboDP/k/UOuJRcfLx8CjYHolNp5n3Uw4yAfHfyI4znHAQjzCWNsx7H0atbrnNs4U3iGJvomdI7qXKvnQl0tL7sQKIrrUj5ncPLdu3fTs2dPrdxjjz3Gd999x08//XRB++fOY6ply5ZuwyGcz9tbm83Gsb9+pSA1Ab/w5h7rMaUAVpsdvV6H3vkG/SKXqapxyi+24WXQERsZWOJJAkVmGyYvPXq9ziM9phQchkVvox69TtcoZKrpOAEUFtvwMenR6XSNQqZqjVPuaewRsehCowHHiy2LxYK3t2OZqyd6TKmqI96tM8xOY5CppuMkhMBisWA0GlEUpVZlqkk4BLmUr46oyA3d+QOs/RBbC+HlZtWqs/JptnAs73ulZbXqEk8mgdGv2pOF0qiqyjfffMOWLVuYPn064eHhgMNjqGnTpiiKQrNmzXj44Ye1eqZPn86WLVv47LPPuOqqqwgKCsLf3x+9Xk9kZKTWVkBAAHq9XnubW1pfTmPMpEmTtH5FR0ezcOFCevToQV5enstylhdffJG+ffsihODxxx9nxIgRFBUVnTUKltRbVtYOHTqQl5dHRkYGgYGBvPzyy2zbto1rrrkGgLZt27Jz506WLl1K3759CQkJASAiIsLFIOVOl+44l8mby1jW82SytmSqbrr0OWEymbSbIVxcPwI1TbuTQwihGSMai0znMk7Oa9qT3dB9fHy0/PORyS7spBWkkVSQRJ4lD5PeRIRvBHqdXttlT1Hcx5KqKO24YAEFkvOT+fjQx/ya+isAPgYfRseMZmiboRh1xrPXvKBaO/e5pBUFg9Gg3dfrww29oRMWFoZer9fe+DpJTU0lMrJmHmq1gclk0h4GSuM8/89nOWbptMFgwGT0orDkoU4rUypd+pfVmVYUpcI09ZyuSI6qZDJ6nZ36NxaZKhsnm10Q7KdHrz97pK+3l2vdSgVpZxnduaf11UmXEsqZVhSlwrRSRbo6MvmV1kEjkammcvj5nNVBY5Gp0nEqmT/rTQE4O2EwGDAYXM0BiuJ54RB8fHzK6eBilulcxqmsDupCpqqQS/lqifPZla8+cFqHy6Yr2hlNVVU2bNiAv78/Pj4+DB8+nNtvv52nn35a2+3NZrNpMhUXF/P888/TpUsXmjRpQkBAAFu2bOHEiROaDpzHgetub6WND043QGdaCMHu3bsZMWIErVq1IjAwkH79+gEOF0KnHAAdO3bU5HAaz5KTkzWZALc72Dn/K4rCoUOHKCwsZPDgwQQEBBAQEIC/vz8rVqzg6NGjLnWUlaMud+UrKiry+F35kpOT+eOPP7Db7Rel22xt7cr3119/YbfbG41MNR2nw4cPc/jwYY93Qz9y5Mh5uaGfTjnN0aSj/HHmD/Yf309hbiERfhHo8/RYS5YL5KblYilZxpOTkoO1ZOlAdnI2tpLlOllJWdhLluiU3pXvZMJJlh9YzqPfP8qvqb+iU3QMbDGQOZfM4caYG9HZddqufNZiKzkpDj1aCi3kpjmWSZgLzOSlO3Radle+wqxChCpIiU/R5PPUXfkqw2g00q1bN7755hstz/myqbQHVWPDbreTmpnrfC7zWJxL+VQPUoQdFb8ysYSOnM7Rlgl6IlIHHqoDWzEYTGD01bLsdjtHjhxpVC9gaorUQcPRgVzKV8vUeFc+QFgcE+FKPUUSd6F8fFuV7Ys7VkPrXlXXZ/ABRam8TKl0XFwcSUlJLFmyBC8vL5o1a4aXlxdCOAKHh4aGsn37dvr164eiKMybN4833niDBQsW0LlzZ/z8/HjwwQcxGAx8/vnnKIrCm2++ycKFC0lMTNTaWrhwIQsWLHB5EOjfvz+XX345CxYsoKCggDZt2jBkyBCmTp1KWFgYJ0+eZOjQofz222907dqV7777jv79+5OZmUlISAhCCPbt28eVV17J8ePHadOmDR9++CGzZs0iKyurnKwzZszgv//9L1lZWfz888/07NmTb7/9lmbNmrnoxmQy0apVq3rZlc/pEVDTY+siXRsyVTdddle+0u7HUP9eKxfaE8dpwDOZTFp/L3aZajpOdrsdm82G0WhECM91Q7fZbHh5eWl9qa5MVtVKljmLUzmnyLZkO5bseQVq/aqJZ5S7tFW1siVxC58f/ZxCm2PZ+hXhV3Bn7J008292bp5RlezK10TfhNimsR69K19+fr724uSKK65g/vz59O/fn9DQUFq1asVnn33GhAkTWLp0KT169GDBggWsWrWKQ4cOlYs9daGpy135jh74hbzkYx6/K59dFeh1nhEKQAjIKDATGxVEkI+hJE9gsakYPWxnwtJIHXioDoqyQe9Vspu7Y44hhOsSLk9E6qBudSB35WsAVOSGXtqdzoliOrv8zJ2LMoASM9Cx+15uMo41EWVRILCZo1ypGFMV1lc6XbovFaQB/Pz8iImJcW21AhfB3bt3c+ONN3LnnXcCjoerI0eOEBsb614HZdpy91lRFA4fPkxGRgavvPKKFiR179695dovXUdFfSxbBhyebp988gmjR49Gp9PRqVMnTCYTJ0+epG/fvrjDaWS02+3V1mVZqnNcQ067o67adH4u7XpbuszF5DZ7vmm9Xq/1obHIVNNxkm7oist5UFoHlclkU22kF6WTlJdEljkLb4M3kf6R5eI7VbTLXlVpIQQ/pvzIx39/zJmiMwC0DmzNnbF30iWsS6kGzvb3fNOKouBl8vL4Xfl+/fVXbVMOgIceegiACRMmsHz5cm6//XbOnDnDc889R0pKCl27dmXz5s31bpSqSxRFwcugx0OfOTQURcGg9xwlmG12jAYd3l5nr21FUTB5XVzXdG0jdeChOrAVgX9TzSgFJXpws5zak5A6aDg6kIapiwWdHjH0FVg1AVBQXIxTJZOMoa9QrcDnF4D27duzZs0adu/eTUhICPPnzyc1NZXY2Njzqrdly5ZakPT77ruPAwcO8MILL5xTXUIIUlJSNK+vPXv28PLLLxMUFMQrr7wCOGJePfLIIzz44IOoqkrv3r3Jyclh165dBAYGMmHCBFq3bo2iKGzYsIHhw4fj4+NTbuv22sS5XM6Tgz2DwxAYHx9P+/btL7oHx9pC6kDqAGqmA5tqI6Mog6T8JLKKszAajDT1a1prQc0BjmQdYcXBFcRnOZYhhphCuL3j7VzX4rpabacsQhWkn0jHHmz32HMBHDvZVuUMP336dKZPn36BelT/2O12UtJzMHr4GgHnUr6wIB+XODaNFatd4G3QY9Sfve/YS3ZUax8V5BKDx5OQOvBQHagqmAJcsuQcSuoAGo4OpGHqYuLSUYjbPkTZ8oQj0LmTwGYOo1TsqPrrWxmeeeYZjh8/zpAhQ/D19WXy5MmMHj1ai+txroSHh/PBBx/wzDPPsGjRIq688kpef/11Ro2quey5ublERUWhKAqBgYF06NCBCRMm8MADD7i4Gr7wwguEh4czb948jh8/TnBwMFdeeSVPPfUUAM2bN2fu3Lk88cQTTJw4kfHjx7N8+fLzkrMqGoJVu77R6XS0a9fOxcvB05A6kDqA6umgnEFKbyTcNxx9Lb7MSC1I5ZNDn/Bj8o8AmPQmRrYbyYi2I/A2eFdxdC2gQEjzEI8+FyTu0el0hIcEkFOUWnXhRowCNAn0qWIzncaDxaYS7m908ZTTKdAuMhBPsUW4Q+rAA3Wg2kFRwOjnki3nUFIH0HB0IGNM1TKVraMsvdV96Z3hqos2VKod5eQeyE91uGS27tVgPKXqmtKnq6d6C3myDkpfQ2XjKnkipXdhkzqQOnCnA7tqJ6M4g9P5p8koysCoNxJkCqpVg1SBtYB18evYkrgFm2pDQaFvy76M6TCGUO/QWmunKs4UniHCO4JLwy6t1XOhruIeScpTlzGmEg7uJTsp3uNjTJVskOkR98v0fDMxEf6E+599mSeEQBUOw4Qn6MAdUgceqANLAdgsjmdGL9fdyeUcSuqgLnVQk991zzUNXqQUFxc7jFDRfaDLrY7/HmKUclJ6pz5PReoAl93LPBWpA6kDcK8Du2rnTOEZ9qfv50D6AXItuYT7hhPqE1prRimbamNTwiYe2P4A/zv+P2yqjS5hXXjluleYevnUC2qUAkA4dgL05HNB4h5VVUnLzK3vbtQ7AkjPKXIbqbSxYbcLdIqCt8H1fqcKiE/OwZM2YyuL1IEH6sBW7NiNz8vVMULOoaQOoOHoQC7lqyOcA1t2JyCnt8u57kzm9LRy7spWHzuj1edub6V1cD56bEgynUsdDUkHtSFTTdKl23W6nTaEndHqY7c3gJiYGHQ6XaORqabjJIQgJiZGy28MMtV0nMAR109RFKw2K9mWbP7J+4eMogy8DF6EeodiUAzud7NzXls12HEP4JfkX/j48MekFKQA0Ny/OXdeeieXh11+NgB6qfKam0ZJurZ24nOmrTYrFtVCZKtI7f5Qm+MkubjR6XREhAaSnSSX8oUFecZSPotdxajX4V0mwLVOgfZRQZ6zhMsNUgceqAObGYJal8vW6XS0b9++3pdw1SdSBw1HB547ArXM4sWLiY2N5aqrrgIcu7sBpKenk56erqWdk2Or1apNdkunLRaLVqZ02mw2a4Yts9msPVAUFxe7pOFscGxn2mw2l0urqorFYimXdm4/XzZts9lc0jabTet76XRNZXL2vSYyqara6GSq6TjZbDa38l3MMlV3nJz9SktLIyMjA4Dk5GSys7MBSEpK0mKZnTp1iry8PAASExMpKCgAICEhQevnsWPHtD7Ex8drbTjfHNhsNuLj4zW9HDt2TJM5ISEBgIKCAhITEwHIy8vj1KlTAOTk5JCUlARAdnY2ycnJAGRmZpKa6nhAKn2PSE1NJTMzs9oynThxgvz8/EYl07mMk/Ncb0wy1WScTpw4gc1u41T6KX469BP70/eTmZOJT4EPYT5h2Aps5Gc4zpOinCIKswoBKMwupDC7JJ1VSFFOEQD5GfkU5zn6mJeeh7nAce3mpuVyOPUwz+95nvm/zSelIIVAYyDjWo7jpatf4oqmV5B9Ohu71XFPyTyVibALzZMJAcIuHGnAbrWTlZQFgM1iIzvZoUdrsZWcFIceLYUWctMcni7mAjN56Q6dFucVazJlZmSSlpZGC/8WmApNtT5OTl1LLm6qeunlKXiKGiw2FV+jAS83uxCqnqKESpA68DAdCAEmP7df1beXTENA6qBh6EDGmKplnOsos7KyCA4OdnlLW1hYSGJiIm3bttWCV9fUa6S4uBiTyaS91fVEjymnDpyeDg2lvxfSY6oh6aA2ZKpuuqioiISEBNq2bYter+fo0aNccsklmveQp3lMWa1WTQfOshe7TDUdJ6vVyrFjxzSPocYgU3XHSafTkW/JJ7Mok4RjCdhDHR5jIT4h6BV99byOnNdZFV5SGcUZfPr3p/xw+gcAvHReDI8ezo0xN+Kj96nSw6ouPKZUVSXTnIlBMdDKvxWRfpEcO3qMmJgYvLy8am2csrKyCA0NlTGmLgB1FWPKbrfzy+7vMBalenSMKU/alS89z0zrJr40C/ZxyffI3djKIHXgYTqwW6EwA1r1BJ9g168ayG5s9YnUQd3qoCa/69IwVcvUZfBzicTTkdeQRAKF1kJyLbmkFqaSY87BYrfgbfAmwBiAQVe7K/SLbEV8cfQL/nf8f1hVh+di7+a9GdtxLGE+YbXaVk0othWTVZxFmE8Y0UHRBJmC6qwtGfz8wlGXuk78ey9Z/xzBP9xzDVOeRHq+mQ6RAYT6Guu7KxJJ/WLOA1WFNteC3qu+eyPxMGryuy5jTF1EON/qO9/oeiJSB1IHToQQWCwWjEajx+pB6sBzdFBsKybHnEN6UTrZ5myKrEUYDUb8jf4YdUbsVrvDS6qWsKt2dpzawerDq8mxOJa9dQztyF2xd9EuuF2ttVNThBBkm7Ox2W20CWxDq8BWGPVG7TtPOBckNUcIgdVm95hlbBUhhMCuCvS6xj1/sNkEBp2CyVA+YokQAotNxWjw7B24pA48SAfWIvALd2uUkr+bUgfQcHQgY0xdZDjjkXgyUgdSB+BY4nTixIkGsSa6vpA6aNw6sNqtpBelczjzML+l/sb+9P2cKTqDyWAi0j+SJj5NMOlNICA3NZfa2GpLCMHvab/z+M7H+c/+/5BjySHSN5KHuz/M7J6z69UoZVNtpBak4qV4ERsWS7vgdppRChr3uSA5P1RVJTO3oL67Ue8IIDvf3Oh35TPb7Jj0erwN5d+/qwJOnMn3nN3Y3CB14GE6sFvBJ8TtV/J3U+oAGo4OpMfURYSiKB6/fEnqQOrAiV6v12IreSpSB41PBzbVRq4ll6yiLM4UnaHAWoBep8fPy49IU6TbN1mKTiG0Zeh5t30i9wQfHfyI/en7AfD38ufm9jdzfZvra32JYE3Jt+STZ8kjyi+K6KBofL18y5VpbOeCpPbQ6/U0DQ0kqzClvrtSr+gUhbAgn6oLXuRY7Cqhfkb0bl6/63UKlzSru6W/FwNSBx6kA6ebqNF94HP5uyl1AA1HB9IwdREhl3BJHYDUgRPnDoDe3t4eqwepg8ahA7tqJ8+SR5Y5izOFDmOUQODn5UeEXwQ6pXLnZiEENosNg9FwTjrIKs5i1eFVfHvqWwQCvaJnaPRQboq5CX+j/zlKVTuoQiWjKAO9oqdDSAea+TdDr3O/ZLExnAuSukEIgcVqk0v5hMBmVzHoG/fyJZsq8Pd2/4gjhKDYYsfbqG/UOqgMqQMP0oHdAnojeLk3SMvfTakDaDg6kEv5LjIa6hKu9evXExMTg16vZ9asWdU6RgjB5MmTCQ0NRVEU9u3b5zavX79+LnU2VB0ALF++nODg4Dpv53x0MGfOHLp27Vppmbi4OEaPHn3ObVwIVFUlKSmp3t1O6xOpg4tXB0IIci25nMo9xb60few7s4/jOcexCztNfJrQ1K8p/kb/Ko1SjsogPz2/xkv5im3FrD2yllk7ZrHj1A4EgmuirmF+v/ncFXtXvRulzHYzqQWpBBoD6RzWmZaBLSs0SsHFey5I6h5VVcnJL6rvbtQ7AsgttDTqpXxCgKKAt8H9vUIVkJRV6BlLuCpA6sCDdGArAi9v8HLvMSV/N6UOoOHoQBqm6gjnwKqq6pJ2boLo9HqpSRrA29sbu2rn5+Sf2Xh8Iz8n/4zNbtPKlv4713bcpePi4jQPHaPRSExMDM8//zxWqxUhBFOmTOGWW27h5MmTvPDCC9Wqc9OmTSxfvpwNGzZw+vRpOnXqxObNm1m+fDlfffWVlrd27Vqef/55zUvIZDJpej5XmZYvX67Jo9PpaNGiBRMnTiQtLe28dVZZ39z9KYrC559/7lJ29uzZdO3atVwdbdq0QafT4ePjg5+fH126dOH999+vUR8ffvhhtm3bVmmZ0lRVZ12fexWlFUWhbdu26PX6Cq+zitJ2u73StBCiXNrZfkVpZ/sVpcv2saZpd3IoikK7du3Q6/WNRqaajhNAu3bt0Ol0DV4mIQR5xXkk5SXxx5k/+D3ldw5nHqbYXkywMZimvk0JMAagQ3f2elJLnfsVpAFCmoeAQrXK2+12vj31LQ/ueJDVR1ZjtpuJCY5hTs85zOo2iwifiLPXnCrOO+1svyYyZRVlkVOcQ8uAllwaeikh3iFVjpNer6dt27ba277aPPckFzd6vZ7wkAA89GW4hk5RaBLog64RK8JqVzHqdXh7uTdM6XUKMZGB6HWNVwdVIXXgQTqwFoN3COjcP/Lr9XrNscBTkTpoODqQhqlaYvHixcTGxnLVVVcBkJaWBkB6ejrp6ela2jkxtlqt2mS3dNpisWhlSqfNZjOqqrI1YStD1g5h0tZJPL7zcSZtncTQdUPZdmIbxcXFwFl3PGfabDaXS6uqqnndlE7b7XasVmu5tKqqXH/99SQnJ3Pw4EFmzZrFnDlzePXVV8nOziYtLY2BAwfStGlTAgICqiXT4cOHiYqKolevXoSEhKDX6zl27BiRkZH07NmTyMhIbDYboaGh+Pv7U1xcrD1U1YZMgYGBnDhxgn/++YclS5awadMm7rrrLqxWKzabrcbjVPo455g5H2ycfXemqxonZztlZRJCMHfuXE6cOMHevXu58847mTx5Ml999RUANptNk89ms7nI4UybTCbNq6simUo/lJWW43xkOtdxKiuTs4+pqakkJSUhhCA5OZns7GwAkpKSyMlx7CJ26tQp8vLyAEhMTKSgwBH8NiEhQevnsWPHtD7Ex8drbcTHx6OqKjabjfj4eE1Hx44d02ROSEgAoKCggMTERADy8vI4deoUADk5OSQlJQGQnZ1NcnIyAJmZmaSmpgKu94jU1FQyMzMBqi3TmTNnEEI0KplqMk5HjhwhLy8Pq9XaYGWKPxbPifQTHEg/wJ6/9vBXyl/kWfMQGYJwUzjB3sHkJuUi7AIEZJ7KBAHCLhxpwG61k5WUBYDNYiM72dGmtdhKTkoOliILlkILuWm5AJgLzOSlO9ovzismPyMfgN9O/MYT3z3Bu3+8S5Y5izBTGDOvnMkTHZ+glb4VAPkZ+RTnOfSel56HucBx7eam5WIpdIxBTkoO1mLHdZmdnI3N4ri/ZCVlYbc67imZpzJrLJNNtZGSmYLljIVLm1xKpD6StNNp1RonIQSnTp3izJkztXruOc8fycWLEAKzRS7lE0JgsZ79fW+MOHdac7cjHzh0kF9sbdQ6qAqpAw/SgWoHn4pjaQkhyM/Pb/x6qASpg4ajA0XUdw8aGbm5uQQFBZGVlUVwcLD2EK3T6SgsLCQxMZG2bdtqXj+Korh4P1SW3nZiGw9991C5NhUc1v43+r7BoNaDzubXoO6q0nFxcWRnZ7N+/Xotf8iQIeTl5fHjjz+69GfHjh107tyZGTNm8P3335OVlUW7du146qmnGDt2LAATJ07kw/9n78zj5Cjr/P+u6ntmenruM5PJ5IKEI5FAMIAKbNZw/gSU1RU1iovX4oosi6yyKIuAbjgCguJ6gLcoKrIqyqGckSsxyBFyTGaSYTL39PR9VT3P74+ebmYyV/eke/qqz+s1r/l2dfVTz/fzVNXz1Le+xw9+kPxNe3s7p59++pRtXV1dnHHGGaxZs4atW7cCcO+99/LNb36T3bt3U15ezplnnsnWrVupr68H4Mknn+SMM87g0Ucf5ZprruH1119n7dq13HvvvcnEbj/4wQ+44oorcLvdSV1vuukmrrvuOnw+H08++SQ33ngjr776KiaTiQ0bNrB161aWLVuGoih0dXWxdOlSfv7zn/PNb36T559/nnvuuQcpJZ///OcZGxtL8vTQQw9x/fXX8/rrr9PS0sJHPvIRvvSlL2E2m+no6ODAgQOTdP7yl7/MpZdeOonTe++9l82bN9PR0cHnPvc5Pv3pT2Oz2VAUhdraWj7ykY9w++23I6VkbGyM//iP/+C3v/0tkUiEE088kdtuu401a9agKApf/vKX+e1vf5sMndR1nauvvprvf//7mEwmPv7xjzMwMIDH45k03jOdH9Mhk+feRDkUCiW5N5vNHDhwgI6OjuRxVVVFCJH0hptJ1nUdVVVnlCFuNJsom0ympMfGdLKUElVVZ5Qn3gvmI0+nh6ZpSQ4Sxyl0ndIdJ03TOHjwIEuWLAHIG51CsRDeqJfR8CgjwRHCehiL2UK5qRy7JR7DL4UEhUkyEI+3mSAr6vh1MIMsdYl30EtlY2X8+NPs0+vr5adv/JQdgzsAcJgdXLj8QjYt2YTNbJu2L5mSU9UpEA3gj/lpKGug3dlOpb0yrXGCuBGpvb0ds9mcsXPP7XZTU1ODx+OhsrISA9lDYg2Vaa6FEOx4/mlU3yGcDYsy1m6hQUqJ2x+husJWtLlURvxRml122munFkgAEELSPeRnSX0FarF7y8wAg4MS4UAK8PVD29uhvHbaXYQQdHd3JyMyShEGB9nlIJ153Uh+niUkBnXi4CYWuUDyv5SSkDZ33gNd6Hztxa9N+50czxbw9Re/ztub3z5rDo4EHGbHlL7MJk9EYrvD4WBoaIjdu3dz1FFH8atf/YpTTjmFmpoahoaGWLduHV/4wheorKzk97//PR/+8IdZtmwZ69ev54477mDZsmX87//+Ly+++CImkwmr1Tpl28Q+TuzPDTfcwFFHHcXg4CBXXnklH/3oR/nDH/4wqZ/XXnstt956K/X19XzqU5/i0ksv5dlnn51WF0VRKCsrQwiBrusEg0GuvPJKjj/+ePx+P9dddx0XXXQRO3funNSXa665hltvvZW3ve1t2O12/vSnP01q++mnn+YjH/kId955J+94xzvo7OzkE5/4RNJA9OKLL9LQ0MC9997LWWedhclkoqKigtdee40//vGPyZA7l8s1qa92ux0hBL/+9a9xu92TDJ3/9E//hMPh4OGHH8blcvHtb3+bjRs3smfPnmTurol9vO2227jvvvv4/ve/z6pVq7j11lv5zW9+w5lnnjmv82OufY9UTnw2m80sWza1dP3h19x08kRX1XRkRVFmlKc7VyfKqfQrXXkmDgpZp3THyWKxTOEgVzrpUscT8cSNUaERgrEgqqpSYamgylE15ZpRJiyGJ8pM3E15S6eZZMWsUNVSNYUDFPBGvDyw5wEeO/gYQgpUReUf2/+R9658L5XWtxYIM/UlU/JsOgkpGA2PoqCwvGo5rc7WZBXAdMdp4rmQjXPPQGFCVVXqqipw+3Pdk9xCURRqnMVd1VdKSZl15mtWVRWWNjoXsEf5B4ODEuFAC4PZPmPic4jfG5cuXbqAnco/GBzkDweGYSrHCGkhTv7pyRlpayA4wCk/PyWlfZ//4PPTlttOBVJKHn/8cf70pz/x2c9+loaGBgBqampoamoCoLW1lauuuir5m89+9rP86U9/4he/+AXr16/H5XLhdDoxmUzJ3wDTbjv82Js3b04a+ZYuXcqdd97JSSedhN/vp6LirWS9N954I+9617uAuAHp3HPPTVYcOBx79+7lnnvu4cQTT8TpdPLe97530vff//73qa+v5/XXX+fYY49Nbr/iiiu46KKLZuTq+uuv55prrmHz5s0ALF26lBtuuIGrr76aL3/5y0kvr6qqqkk6V1RUYDabp+XhC1/4Atdeey2RSCQZ6vgv//IvADzzzDO88MILDA4OJo1Vt9xyCw8++CAPPPAAn/jEJ6a0t3XrVv7zP/8zqcc999wzycCWr5BS4vP5cDqdRfvmdy4YHOSeA01oeKNe3CE3w6Fh/JofFZVya2oV9Y4UQgp2jexiyDtEfWU9q2pXoSoqUT3Kw10P8+C+B5MvP9Y1ruOSVZfQUtGS1T6lg6geZSQ0QrWtmo6qDmrsNfNuK9fngoH8hZSScCRmhPJJSSSmY7MUZyUyIeJ5tGbKLwXj94lwDKfdUpQcpAKDgxLhIBYGs2NWw5QxbxocQP5wYBimDKSM3/3ud1RUVBCLxRBC8MEPfpCvfOUryfw/E6HrOjfddBO/+MUv6O3tJRqNEolEKCubnzFsIl544QVuuukmXn75ZdxudzJE4+DBg6xevTq53/HHH5+Um5ubgXjur8WL43lUPB4PFRUVCCEIh8OcdtppfPe73wXihqrrrruO559/flJusIMHD04yTJ144omz9vXll1/m2Wef5cYbb0xu03WdcDhMMBicFx9XXXUVl1xyCcPDw1x99dV85jOfYfny5cnj+f1+amsnu+yGQqFkzp2J8Hg89PX1cfLJbxlHzWYzJ554Ys7jjOeClBK3201FRUVJTyQGBwvPgZACX9THWHiMwdAgvqgPJJRZy2goy74xKoEX+l7gvtfuYzQ8mtxWY6/h5OaTebH/RYZD8ZxYSyqX8OHVH+aYumMWpF+pwhPxENbCtDnbaK9sx24+Mk8O43owMBOklATCUYyzAkIRDdsshptCRlTX4/mlLDPfg6UEtz9Khc1Cqd4mDA5KhAMtDJWtzKagMW8aHED+cGAYpnIMh9nB8x98fs79tg9s5zOPf2bO/b75D99kXeO6lI6bLs444wy+9a1vYbVaaWlpwWyOnz6JhLITsWXLFu644w62bt3KcccdR3l5OVdccUUyefF8EQwGOf/889m0aRM/+clPqK+v5+DBg2zatGlK2xaLJSknLrKJuUicTic7duxAVVWam5txON7i5Pzzz6e9vZ3vfOc7tLS0IITg2GOPnXKM8vLpy68m4Pf7uf7666f1qprOcysV1NfXJw1wv/zlLznuuOM48cQTWb16NX6/n+bmZp544okpv0skPC8WqKpKe3t7rruRUxgcLBwHUkr8MT+eiIfBYNwYpQkNh8VBraM2GXq2UHih7wVu237blO2j4VEe7noYiBupPnD0Bzit9bQFM5alAl3oDIeGsZvsrK5dnTFjnnE9GJgJqqpS6yrH7ct1T3ILRVGoLuJQvqgmKbOpWE0z309UVaG9vmLG70sBBgclwoEUYJs9XNGYNw0OIH84MAxTOYaiKCmF1J3ScgqNZY0MBgeTOaUmtYNCY1kjp7ScklKOqfmgvLw86ZkzF5599lne85738KEPfQggWT1rokfTfLBr1y5GRka4+eabk55PL7300rzaUlV1Wn1GRkbYvXs33/nOd3jHO94BxEPk5oMTTjiB3bt3z8qbxWKZUo7carXOWKJcSommaZhMJtra2nj/+9/Pf/7nf/Lb3/6WE044gf7+fsxmczIZ9GxwuVw0Nzfz/PPP8853vhOIJ5Pevn07J5xwQuqK5gBSSjwez6T8W6UGg4PscxCMBfFEPAwEB/BGvUT1KA6zA5fNhcVkmbuBLEBIwX2v3TfrPg6zg1tPv3VeLyGyiWAsiDfipb6sng5XB05r5nJ8GNeDgZkgpSQYjhqhfFISjurYrcUZyhfVdRrH0xjMBCklnmAMV1kRh3DNAYODEuBAaKCYwTr7M6YxbxocQP5wkD+vUA3MCpNq4gsnfQGJTFbhSyDx+Qvrv5A1o1S6WLFiBY8++ijbtm1j165dfPKTn0yWXT8SLF68GKvVyje+8Q3279/PQw89xA033JCBHr+F6upqamtr+d///V/27dvHn//8Z668cmo1xFRw3XXX8cMf/pDrr7+e1157jV27dvHzn/+ca6+9NrnPkiVLePzxx+nv78ftdie3dXV1sXPnToaHh4lEIpPanej59bnPfY7/+7//46WXXmLjxo1s2LCBCy64gEceeYTu7m62bdvGl770pRkNeJ/73Of42te+xoMPPsgbb7zBZz7zmWm94PINiXjofA85zCYMDrLDQUgL0R/o57Xh19gxuIPXRl7DF/XhtDpprmimyl6VM6MUwK6RXZPC96ZDSAuxf2z/AvVobkgpkwnhl1YtZVXtqowapRLHKPXrwcD0iBtkpqYdKEVEYtO/9CoWOGZJfA7xEC5fqLTzjRkclAAHWhgsdpjD+cGYNw0OIH84MAxTBYR/XPKP3H767TSUNUza3ljWyG2n38bG9o056tlUXHvttZxwwgls2rSJ008/naamJi644IIjbrehoYH77ruPBx54gNWrV/O1r32NW2655cg7PAGqqvLzn/+c7du3c+yxx/L5z3+eLVu2zKutTZs28bvf/Y5HHnmEk046ibe//e3cfvvtk9wlb731Vh599FHa2tp429veBsB73/tezjrrLM444wzq6+v52c9+ltxfURSsVmvSor169Wre/e53c91116EoCn/4wx945zvfycc+9jFWrlzJBz7wAQ4cOEBjY+O0ffz3f/93PvzhD7N582Y2bNiA0+nkwgsvnJe+CwlVVWlrayvZ0q5gcACZ4yCqRxkKDvHGyBvsGNjBa8OvMRwexmF20FzRTI2jBqvJmqFezw9j4TH+sP8PfPvlb6e2f2Qsux1KEVE9ykBgAIfZwTF1x9Dh6sCiZt6wZ1wPBmaCqqrUVJYXby6ZFKEoClUVtqL0CtB0iUlVZs0vBfEQrra6clS1+DhIFQYHJcBBLAzWcjDP7kFozJsGB5A/HCgy16axIoPX68XlcuHxeKisrJz0XTgcpquri46OjnnlF5JSxsO7FPjb0N8YCg5RX1bPCQ0n5I2nVLaR4MBkKk439FRQyhxMvIasVitjY2NUVVXl/EaaKwghDA6OgIOYiOGNeBkNjzIcGiYQC2BSTVRYKnCYHXlxfQVjQV4aeIlnep/hlaFXpg3lngn/9fb/ynnCc2/USygWoqWihfbK9qyGFmbrephtXjeQWWSLayEEu3Y+R2T4AM6GRRlrt9AgpSQU1XBYzXlxf8skghENCRzb6sI8i7FBSMlYIEpVuRW1yDhIFQYHJcCBpxcaVkHtsll3M9aRBgeQXQ7SmdeNHFMFBiEEFouFk5pOynVXcgYhBCZTaRjiZoLBQRyhUKjokrqnC4OD9DjQhY436sUdcTMUHCIQCwBQbimnsbwxL5KEa0Jj5+BOnul9hu0D24mJt0KQllct55SWU3io86FZPaJq7bWsql21AL2dHokE5zaTjaNrjqapvGlBuDWuBwMzIaYVdwhbqohpAkdunT+zgqguqSqzzGqUAkBCKKpRVWalZMs0GhwUPwdSxj2mUoAxbxocQH5wYBimCgiJEK5ShsGBwUECqqrS2tqa627kFAYHqXEgpMAX9U2qqCekoMxaRn1ZfV4Yo4QU7B7dzbO9z/Jc33P4Y/7kd83lzZzWehqntp5KU3kTAHWOummr8iWw+ZjNOdMrpIUYC43FE5xXdVBpXRgvI+N6MDATVFWlylmG25PrnuQWiqLgKp89tKdQoQkdp31uj0xVVWitSe2BvVhhcFDkHOhRMFvnzC8FxrwJBgeQPxwYhqkCQqIam9lcfC7YqcLgwOAgASEEo6Oj1NTUlLTrrcHB9BxIKQnEAniiHgYDg3ijXjShYbfYqXHUYFbzY/o76D3IM73PsO3QNoZDw8nt1bZqNrRs4LTW0+hwdUy51tc3r+fKdVdy32v3TUqEXmuvZfMxm1nfvH7BdEhASok77EZIwdLqpbRVtC1oknjjelg4LFmyhMrKSlRVpbq6mr/85S/J726//Xa++93vIqVk48aN3HHHHTmfq4QQ+IPh4k10nCKklAQjGmW2Ils/SAAFm3luT3IhJaO+CDVOW3GGcKUAg4Mi5yAWBvPcic/BmDfB4ADyh4P8WJkXIRJV0xL/VVVFCJHMdp/4ryhKWrKUctrt0yHdtvNNngkJDvKhj5nQaT5tTCcXsk7pyInPQgii0WhShreuM0VRUBRlRlnXdVRVnVFOtDlRNplMSClnlKWUqKo6o3x4H9OVZ9IpwUEx6ZTOOOm6TjQaTeZei4gIY+ExBoODeGNeIloEu8mOy+aKG6MkKOr4eZWunDgPhQRl/vJweJhth7bxTO8z9Ph6kteNw+xgfdN6Tm05lWPqjol7PMkJ18Fh/VrfvJ51jevYNbSLwbFBGqobWFW7Kjl+C6lTTMQYDY9SYa5gac1S6hx1k+a8hTj3AKLRaPJYmTz3DEzFtm3bqKiomLRtaGiIu+66i9deew2LxcI73/lOnnvuOTZs2JCjXr4FXZS4VWocogh5iOoCi0nFbk7hgUpCTBdxY1aR2SNShsFBcXOghaGiEUypPebHYkbFUoOD/OCgNM2CWcDdd9/N6tWrOemkeO6nwcFBAIaHhxkeHk7KicVxLBZLLnYnyolF9eFyJBJBSonVak0+hEE8GfREGcbLIk+QI5HIFPnwh/qJD7eJE3OirGnaJFnTtGTfJ8rz0elweTadFEXBbDYn+1sMOqU7ToqioKpqUemUzjgl+jU0NITVakVVVfr6+hgbGwOgt7cXjycer9HT04PP5wOgu7ubQCCeT6irqyvZz87OzmQf9u7dmzzG3r17EUKgaRp79+5N8tLZ2ZnUuaurC4BAIEB3dzcAPp+Pnp64scHj8dDb2wvA2NgYfX19AIyOjjIwMABMvkcMDAwwOhr3fklFp4MHDya9FopFp3THqbOzk+q6avr9/Tz78rP8bfBvvNb/GgMHB6iwVlBvrUdxK1hMFmLhGJ7++DGjwSjeQS8AkUAE33D8+GFfGP9IPIwu5AkRdAcBCI4FCY6Ny+4gIU8IAP+In7Av3kffsI9IIH6eewe9RIPx/nr6Pbh9bh478Bj/9eR/8dk/f5afvfEzenw9mBUzJzWexMcXf5xvnfEtPnX8p2gNtaKiInXJaE+cOz2m4+51A6BFNcb64jzqEZ1F+iLOPOpMVpSvwD/kXzCdYuH4dTnQM8CQd4iWihYqvBVUmipRFGXBzz1VVTGbzcnzLVPnXqJfBlKDpmmEw2FisRixWIyGhoa5f5RlqKqKq8JhVOVTFJxlb1X1LRZENYHNrKbkMaWqCs3VZcVbjS0FGBwUOQdaFBxVKe2qqirNzc0l6ykEBgeQPxwYVfkyjETmebfbTVVV1aS3tMFgkO7ubpYuXYrNFo/xT9drRNO0ZDW2UvWYSnCQeIOeL/1dSI+piaF8xaBTqnIoFKKrq4ulS5diNpsZGRmhvr4+edxS85jSNC3JQeI4ha5TuuMUioTY0b2DoC2IRbXgtDuxm+xH5hmVIe+iiIiwY3AHz775LDuHdqLLuBFYQWFV7SpOaT6Fk1tOxml1Jn8LTH6Dm0K/pJCEvCEcLgcKyoJ5gQkEo+FRzJhZUrWE5vJmkOTs3IO4wbq2thaz2Zyxc8/tdlNTU1MwVfmeeuoptmzZwvbt2+nr6+M3v/kNF1xwwaR97r77brZs2UJ/fz9r1qzhG9/4BuvXpx7+2dHRkXT5v+KKK7jkkkuS333jG9/gS1/6EmazmU996lPcdNNNKbebzap8r+74K9rowZKvyhcIxyi3W4rKODXqj9JQaaOjbu6cQUJKhr1h6irtxRfClSIMDoqYAynBewjaToaK+jl3F0IwPDxMXV1dzo0SuYLBQXY5MKry5QESgzpxcBOLXGDSgiBVeeJDxHTtTIf5HCef5MMxkYN86eOR6pRuG4cbhIpBp3TkxOeJ19Ph19lc8sSKhunIiqLMKE88J6eT0+1jqnKi/WLSKR09RqOj+KN+WmpbMKkT3paPnzaKomROTjStzizrQufV4Vd5tvdZXuh7gbAeTn7fXtnOaa2nsaFlA3WOOiZiYjuTwgpS6Zf6ljzp3pghnaaTIyKCO+ymzlFHh6sDl83F4Vjocy9hWJpp/k1HnqnvhYBAIMCaNWu49NJLueiii6Z8f//993PllVdyzz33cPLJJ7N161Y2bdrE7t27k95Na9euTXrZTsQjjzxCS0sLzzzzDK2trfT19bFx40aOO+44jj/+eNxuN7/73e/o7u7G4XBw9tln89RTT/HOd74z63obKF3oCMptxiONAQPoETDbwDp3fikDBvINxl28gKAoChbLwiWSzUcYHBgcJKCqal6EiOQSpc5BVI9yKHCIyrrKyUapBYaUks6xTp499CzbDm3DE/Ekv6tz1HFq66mc1noabc62rBxfURTKqxemupCUkrHIGDE9RkdlB4srFy9ogvPZUOrXQwJnn302Z5999ozf33bbbVx22WV87GMfA+Cee+7h97//Pd///ve55pprANi5c+esx0hU72lubuacc85hx44dHH/88Tz22GMsX76cmpoaAM4991yee+65GQ1TkUgkGeYN8TerMHOezpnkuTzgpJQ4y2yMueOeEgrx6yYhwxRHRdTx380kw9SXhgspT6dHKjqV2y3J7cWgE1JBkQrWccOylBIhwZTwKJXxsK2Jcn2lHTnekBj3IlVVZao8zo0Y9xadTlaU8T7OIOtCos4iAwjJJDnR95nk6XSaKKeiU53TTgLFolM645TgIHEuFYNOiqIgIiEUsx3F7EjJ61xKmYw80HW9KDzp0/XQBmhoaEhuLwad5jNODQ0NCCGSx8pFns7S9FcrUEgpJ+WXKkUYHBgcJCCEoK+vb1IYT6mh1DkYCg3hCXtQfWo8zGyB0efv45e7f8nnn/g81z57LQ93PYwn4sFpcfKP7f/I9adczzfO/Ab/fPQ/Z80oBSCFJDASyDoHmtAYCA5gUS0cU3cMS6uW5o1RCozrIRVEo1G2b9/Oxo0bk9tUVWXjxo389a9/TamNQCCQzMvl9/v585//zDHHHANAW1sb27ZtIxwOo+s6TzzxBEcdddSMbd188824XK7kX1tb/DqZLk/nkeQM279/P6PeAFLCqDecTIQ+7Akh4s+DDHtCSOIPnMPj+dZ0IRn1xr0eNV3gHs+9FtMEbn/coBaJ6YyNy+GojicQz8MWimp4x3OyBSMa/lA8J1sgHCMwnp/NH4oRjMQ907zBKKFoXPYEooSj8cX8mD9CJBaX3f4IMS1+frt9YTQ9Lqeqk5QSTyDCyLh+xaBTVNcxmxQOuQPJ/nYNxs+BQESjezzvni8co2ckgBCSzn4fPSPx/ccCUfrGc+2N+iIMjHMz7A0zPD72A54Qo744H31jQcbG+egdDeIJxvXuGQngG+ege8hPYJyDrkFfUu/Ofi/RcV339nnQRNyQsbfPg5CgCcnevvi5HNUEnf3elHQC8ARj9I4GU9JJCMkbh8aS+hWDTumOkxCSvx8YTZ7DxaATQPdIgIBSASnmHt2zZw+HDh0iGo0WTe7RdHNadnV10dfXh9frLRqd0h2n/v5++vr6GBwczLhO6eTpNHJMZRizxVEmTpqOjg7sdvsMLcwMKeWk3EKliMM56O/v58Mf/jDbtm3DYrEkL5q58OCDD3LVVVfR1dXFZz/7WbZu3Tpl29q1a7niiitSbnOhMNN5oCjKtLlE8gXd3d10dHTwt7/9jbVr1067zxNPPMEZZ5yRzNF2OCZeQ1arNS9Km+YSQuRHeddcIKpH2Tm4k5iIYQ1b4/mVFuC+OBYeY9uhbTzb+yydns7kdqtq5cSmEzm19VTW1K+JVwBcIEgpCXlCWeXAH/Xji/poLm+mw9VBWQplqBca2boespX3aCFw+Lxw6NAhWltb2bZt26RKeVdffTVPPvkkzz///Jxt7t+/nwsvvBCIv2G/7LLL+NznPpf8/ktf+hK//vWvUVWVf/iHf+COO+6Y8byczmOqra1t2jydR/L2NhaL8cbLzxMb7aG8vrVkPaYU4kYkh82MKfEGvcB1CoR1bGaFo5oqMZvm9lpBgRFvmOoKG2aTWpIeUxA3ftQ4bZhVtSh0Snec5DgHtU4bJlUtCp0URUGM9aA0r0WpXpySJ46maYyNjSW9XEvRY0rXdcbGxqiurkZRlKLQKd1xEkIwNjZGVVUVqqpmVKd08nQaoXwFBEWJh3BJXSfw0na0oSHM9fWUnbgOJcs5MD760Y/ygx/8AACz2cyiRYu4+OKL+e///u95GdkOx5IlS7jiiiu44oorktsSRooEGhoaOO2009iyZQtLly4F4Pbbb6evr4+dO3ficrlSPt4nP/lJPvaxj/Fv//ZvOJ3OabeZzWbOOeecI9btcExcoFdWVnLsscdyww03cOaZZ6b8+0yE8n30ox9lbGyMBx98MLltJuPRV77yFa6//nogflNqaWnh7LPP5mtf+1pyMpsLbW1t9PX1UVdXN/fOKUBV1Yy1VagoZQ6GQ8P4oj4ayhtQ7dk1ygVjQV7sf5Fnep/h1eFXiT/KgaqoHFd3HKe1nsZJTSdhNx/5vXA+UBSFsqrsGIqEFAyHhrGoFo6qPoqWipachk3OhlK+HhYSS5cu5eWXX57x+xtvvJEbb7wxpbZsNluyGMxEZCJP2ETZYrHgLHfgdjMp0fFEeaLpLCErijKjTI7lmfSYS6cKh3VSe4WuU1TXqXc6MJuUZHvj4vhD0lS53uWY3LYyg5zYR52/bEpFnqDUxL7PJE+n00Q5FZ0aJnJQJDqlo4dyGAfFoBNCR1VNYKuI9zGFPJ0Wi2VSEaGkHgWcezTdnJZms3nK2qHQdUp3nKZbP+UiT6dhmCogSClxP/wwI//zP2j9A8nt5qYmGr/4n1S++91ZPf5ZZ53FvffeSywWY/v27WzevBlFUfj617+e1ePu3r0bp9PJ3r17+cQnPsF5553H3//+d8xmM52dnaxbt44VK1ak3J7f72dwcJBNmzbR0tIy4zYAh8MxUzNHhHvvvZezzjqL4eFhvvSlL3Heeefx6quvJg1us0FKSSwWw2KJV9WJRqNYrdY5f3ekOOaYY3jsscfQdZ1du3Zx6aWX4vF4uP/++1P6vclkoqmpKWP9SYTt5EN501yhVDmI6lHe9L2J3WJHkQq+YR8VtRWTE4gfITShsXNwJ8/0PsP2ge3ERCz53YqqFZzaeiobWjZMm/R7oSGFxD/izzgHYS2MO+ym1l5Lh6uDKntVxtrOBkr1ekgHdXV1mEymZChCAgMDAxm9P+cbhBCM+YKUeoyAlBJvMEplmXWSQaiQIaXEYU39cUYISd9YkOaqskkP96UEg4Mi5UCLgNkBaXg0G/OmwQHkDwelyX6BwvfIowz8+1WTjFIA2sAAvZ+7Au8jj2T1+DabjaamJtra2rjgggvYuHEjjz76KBD3eNq6deuk/deuXctXvvIVIL5w+MpXvsLixYux2Wy0tLTwb//2bwCcfvrpHDhwgM9//vOTrLkJNDQ00NzczDvf+U7+67/+i127drFv3z6WLFnCr371K374wx+iKAof/ehHgXhi1+OOO47y8nLa2tr4zGc+g98fj/N+4oknkh5SZ555JoqizLjtvvvumxRO1tnZyXve8x4aGxupqKjgpJNO4rHHHpvU1yVLlnDTTTdx6aWX4nQ6Wbx4Mf/7v/87hcuqqiqampo49thj+da3vkUoFOLRRx9lZGSEf/7nf6a1tZWysjKOO+44fvazn0367RlnnJH0Lqurq2PTpk3TjldPTw//9E//RFVVFTU1NbznPe9Jxhx/5Stf4Qc/+AG//e1vk5w/8cQTdHR0APC2t70NRVE4/fTTk+2ZzWaamppobW1l48aNXHzxxcnxT+C73/0uq1atwm63c/TRR/PNb34z+V13dzeKokxKqvuHP/yBlStX4nA4OOOMM5L9SxXZMhwWEkqRg+HQMN6ol0prJShgtpknv0afJ4QU7BrZxXf+/h0++egnueWlW3iu7zliIkZLeQsXr7yYrWds5YbTbuCsjrPywigFZJSDBMbCY3gjXtor2zmm7pi8N0olUIrXQzqwWq2sW7eOxx9/PLlNCMHjjz8+KbSvGGEx56en30LDYi6epb+ux8NSbJY0dFKIG7KKxBYxLxgcFCcHWihejc+Snve2MW8aHEB+cGB4TOUYUkpkKDT3frrOwI03Mu3rPhmPOR648SbKN2xIKaxPcRxZLpJXX32Vbdu20d7entL+v/rVr7j99tv5+c9/zjHHHEN/f38yFODXv/41a9as4ROf+ASXXXbZrO2UlcXfAsRiMV588UU+8pGPUFlZyR133JG8oFRV5c4776Sjo4P9+/fzmc98hquvvppvfvObnHLKKezevZujjjqKX/3qV5xyyinU1NRMu+1wI4nf7+ecc87hxhtvxGaz8cMf/pDzzz+f3bt3s3jx4uR+t956KzfccANf/OIXeeCBB/j0pz/Nu971rhkTwCb6HY1GCYfDrFu3ji984QtUVlby+9//ng9/+MMsW7aM9evXJ3/zox/9iE9/+tM8++yz07YZi8XYtGkTGzZs4Omnn8ZsNvPVr36Vs846i7///e9cddVV7Nq1C6/Xy7333gtATU0NL7zwAuvXr+exxx7jmGOOmdETq7u7mz/96U+Tvv/JT37Cddddx1133cXb3vY2/va3v3HZZZdRXl7O5s2bp7TR09PDRRddxL/+67/yiU98gpdeeol///d/n/Z400FV1ZTDCIsVpchBTI/R6+/FYXGgKvGHEUflkU2mB7wHeKb3Gbb1bmMkPJLcXm2r5pTWUzi15VQ6XB1562GgKMoRc5CAJjSGg8OUW8pZXbuahrKGvNX7cJTi9TAd/H4/+/btS37u6upi586d1NTUsHjxYq688ko2b97MiSeeyPr169m6dSuBQCBZpa8Yoaoq5Q4b0cI4lbMGRVEos+VPwYIjRVQXWM0qdkvqRkdVUaipmBo+WkowOChSDrQIuBbPvd8EGPOmwQHkDweGYSrHkKEQu09Yl4GG4p5Te05aP/e+wFE7tqOUpZeT5He/+x0VFRVomkYkEkFVVe66666Ufnvw4EGamprYuHEjFouFxYsXJw0tNTU1mEwmnE7nrKEEfX193HLLLbS2trJy5cpkbgqHwzHpdxPzVC1ZsoSvfvWrfOpTn+Kb3/wmVqs1WU68pqYm+bvpth2ONWvWsGbNmuTnG264gd/85jc89NBDXH755cnt55xzDp/5zGcA+MIXvsDtt9/OX/7yl2kNU8FgkGuvvRaTycS73vUuWltbueqqq5Lff/azn+VPf/oTv/jFLyYZppYvX87Xv/71GR8Y77//foQQfPe7303uc++991JVVcUTTzzBu9/9bhwOB5FIZJK+iTjz2traKTy88sorVFRUoOt6stLCbbfdlvz+y1/+MrfeeisXXXQRAB0dHbz++ut8+9vfntYw9a1vfYtly5Zx6623AnDUUUfxyiuvpBwaKoSgt7eX1tbWkna9LTUOhkJDeCIeGssbgXgYm2/Yh7POmVYY21BwiG2HtvFM7zP0+HqS2x1mByc3n8ypradyTO0xSeNXPmO+HByOQCyAL+KjsbyRDlcH5ZbyDPYy+yjF62E6vPTSS5PyM1555ZUAbN68mfvuu4/3v//9DA0Ncd1119Hf38/atWv54x//SGNjY666nHUIIRj1BsAI5cMTiOIqL45QvqgmqHRYsKRx3xNC0jsapLWmiEK40oTBQZFyIEQyv1TqPzHmTYOD/OHAMEwZSBlnnHEG3/rWtwgEAtx+++2YzWbe+973pvTbiy++mK1bt7J06VLOOusszjnnHM4//3zM5rlPwUWLFiGlJBgMsmbNGu6///5Zcyo99thj3Hzzzbzxxht4vV40TSMcDhMMBpMeV/OB3+/nK1/5Cr///e/p6+tD0zRCoRAHDx6ctN/xxx+flBVFoampKVn6OoF//ud/xmQyEQqFqK+v53vf+x7HH388uq5z00038Ytf/ILe3l6i0SiRSGRKv0844YRZ+/ryyy+zb9++ZIhiAuFwOFlaNF0cddRRPPTQQ4TDYX784x+zc+dOPvvZzwLx0qSdnZ18/OMfn+T1pmnajEnpd+3axcknnzxpWzqhJIqi4HQ6i2JxPV+UGgdJbynzW95SKGAts6bkju+L+niu7zme7X2WN0bfSG43q2be1vA2Tm05lRMaT8Bqyn7OtowiDQ6mg5CC0fAoCgorqlfQUtGyoFUFM4VSux5mwumnn56sdDYTLr/88kkvVIodiqJgt1oI57ojeQBbGt5F+Y6YLqiwpaePooDTYaGUbxMGB0XIgR4Dkzmt/FJgzJtgcAD5w0HhrTyLDIrDwVE7ts+5X/Cll+j5xCfn3K/tf79N2YknpnTcdFFeXs7y5csB+P73v8+aNWv43ve+x8c//vFkGcqJiMXeShbc1tbG7t27eeyxx3j00Uf5zGc+w5YtW3jyySfnrDD39NNPU1lZSUNDwxRDy+Ho7u7mvPPO49Of/jQ33ngjNTU1PPPMM3z84x8nGo0ekWHqqquu4tFHH+WWW25h+fLlOBwO3ve+9xGNRiftd7g+iRKaE3H77bezceNGXC7XpGoYW7Zs4Y477mDr1q3JPFlXXHHFlGPMdfPw+/2sW7eOn/zkJ1O+O7z6RqqwWq3J8f/a177Gueeey/XXX88NN9yQzOH1ne98Z4qxKZ1qDOlAUZRJOcBKEaXGwXBoGG/ES0N53MMxkRNqLDJGVbiKVbWrpng4RfQI2we282zvs+wc3IkudQAUFFbVruK01tNY37SeCmt6bxnzCYqiYK+YX0XAiB5hNDRKta2ajqoOauy5d+WeL0rtejCQOhRFocxuJVK6zx3AeNivrUiW/hJQwG5N1zClUFVeYC8fMgyDgyLkQAvHE59b0/N0NuZNgwPIHw6KZHYqXCiKklJIXfmpp2JuakQbGJw+z5SiYG5spPzUU1PKMXWkUFWVL37xi1x55ZV88IMfpL6+nr6+vuT3Xq+Xrq6uSb9xOBycf/75nH/++fzrv/4rRx99NK+88gonnHACVqsVXdenPVZHR0fyYpFSJqvQTWeY2b59O0IIbr311qQr4i9+8YuM6Pzss8/y0Y9+lAsvvBCIG3/STdadQFNTU9LIc/gx3vOe9/ChD30IiLtW7tmzh9WrV0/aT9d1pJQzGqdOOOEE7r//fhoaGqisrJx2n+k4T3iizTQWE3Httddy5pln8ulPf5qWlhZaWlrYv38/l1xyyZy/BVi1ahUPPfTQpG3PPfdcSr+FODc9PT20tbWVtOttqXAQ02O86X8Tu9mOqqi80PcC9712H6Ph0eQ+NfYaPnrMR1nXuI5Xh1/lmd5neLH/RcL6W34SSyqXcGrrqZzScgq1jtpcqJJxSCHxDnqpbKhMK5TPE/EQ1sK0OdtY4lqCzVTY+TZK6XowkB6EEIx4AihGKB9j/ghVFbacvxk/UsR0gVlVsKeZ1F4ISc9IgLba8uIJ4UoTBgdFyIEWhrI6MKWXQ86YNw0OIH84KE32CxCKyUTjf35x/MNhN9Dxz41f/M8FMUolcPHFF2Mymbj77rs588wz+dGPfsTTTz/NK6+8wubNmyd5ytx3331873vf49VXX2X//v38+Mc/xuFwJJOnL1myhKeeeore3l6Gh4dnPe5s4X/Lly8nFovxjW98g/379/OjH/2Ie+65JyP6rlixgl//+tfs3LmTl19+mQ9+8INTPKEycYxHH32Ubdu2sWvXLj75yU9OKesNzHnTuOSSS6irq+M973kPTz/9NF1dXTzxxBP827/9G2+++SYQ5/zvf/87u3fvZnh4mFgsRkNDAw6Hgz/+8Y8MDAzg8XhmPMaGDRs4/vjjuemmmwC4/vrrufnmm7nzzjvZs2cPr7zyCvfee++kPFQT8alPfYq9e/fyH//xH+zevZuf/vSn3HfffSkyFTfqVldXF/zi+khQShwkvKUqbZW80PcCt22/bZJRCmA0PMpt22/jskcu4+YXbubp3qcJ62HqHfVcsPwCbnnXLXztnV/j/GXnF41RCoh7DTjtKYfyaUJjwD+AgsLq2tWsrF5Z8EYpKK3rwUB6UBSFcnsReUccAYrFYyqqCWwmE7Y0DVOKAtUV1uIJ4ZoHDA6KkAMtCvOonmvMmwYHkD8cGIapAkLlpnfTesdWzIclKDU3NtJ6x1Yq3/3uBe2P2Wzm8ssv53/+53+45ppreNe73sV5553HueeeywUXXMCyZcuS+1ZVVfGd73yHU089leOPP57HHnuM//u//6O2Nv5w+N///d90d3ezbNmyWUPNFEXBZDLNeOGsWbOG2267ja9//esce+yx/OQnP+Hmm2/OiL633XYb1dXVnHLKKZx//vls2rRpzlxP6eLaa6/lhBNOYNOmTZx++uk0NTVxwQUXTNlPUZRZbx5lZWU89dRTLF68mIsuuohVq1bx8Y9/nHA4nPSguuyyyzjqqKM48cQTqa+v59lnn8VsNnPnnXfy7W9/m5aWFt7znvfM2t/Pf/7zfPe736Wnp4d/+Zd/4bvf/S733nsvxx13HO9617u477776OjomPa3ixcv5le/+hUPPvgga9as4Z577kkauVKBoihUVlbm/CaaS5QKB4ncUnZzPFztvtfum3X/oBakwlzBP7b/I9efcj13nnknHzj6AyxyLlqA3i48FEXBVp6aB0QwFmQoOERdWR3H1R1HU3lT0Zw/pXI9GEgfiqJgtxVRPpl5Ip5ry1wU10hUF1TYTZjSfJJRFIVKR3Ekf58vDA6KjAMpAZl2GB8Y8yYYHED+cKDIuTJkGkgLXq8Xl8uFx+OZEkIVDofp6uqio6MDuz39fCCJMDaLyURo+w60oSHM9fWUnbhuQT2lcom5QvlKAaXMwcRryGq10t3dzZIlS0ra9bYUOOgP9PPq8Ks0ljeya2QXNzx3w5y/+eLJX+T4+uPn3K8YIIXE0+/B1eSaMZRvYoLzxc7FtDpbsajFUzYesnc9zDavG8gsssW1EIIdzz+N6juEs6E4DdSpQEqJ2x+hughC+Yb9ETrqymmqTG89LYSke8jPkvqK4gjhmgcMDoqMAy0CYS+0bwDb7Ll4D0eprCNng8FBdjlIZ14vTfbnwIUXXkh1dTXve9/7ct2VKTCbzSgmE+Unr8d13rmUn7y+ZIxSCaRSya/YYXAQt+43NDQU/OL6SFAKHMREjDd9b+WWGouMpfQ7X9SX3Y7lExQoqy6bMZQvqkcZCAxQbi7nmNpjWOJaUnRGKSiN68HA/KAoCs6y+RUIKDZU2Av/2pcyfrtLN78UxEO4Glz2kvaeMzgoMg60MFjsaVfkA2PeBIMDyB8ODMPUNPjc5z7HD3/4w1x3YwrmCmMrBRgcGBwkoCgKFRUVJc1DKXAwEhphLDKGy+YCoMpWldLvUt2vGKAoCtYZQhK8ES/usJtFzkUcW3dsceXWOgylcD0YmB8URcFmNRfHQ+gRQFEUrJbCXz9ENYHFpGK3zMcwpVBhtxQ8B0cCg4Mi40ALg70a1HleDyU+bxoc5A8HhmFqGpx++uk4nem5Qi4EpJSEw2FKOfrS4MDgIAFd19m3b19KFQSLFcXOQUzE6PX1Jr2lAFbVrqLGXjPr72rttayqXbUQXcwLSCFx97qR4q17gi50BgIDCClYVbOKldUrkzm6ihXFfj0YmD90XWfI7Zu2qHEpQUjJiDeEKHAiorrAZlGxmdN/jNGFZF+/F10UNgdHAoODIuNA18A+v9BnY940OID84aDgDFNPPfUU559/Pi0tLSiKwoMPPjhln7vvvpslS5Zgt9s5+eSTeeGFFxa+o1mC1WpUlTE4MDiAeGXC1tbWko0Hh+LnYCQ0gjviTnpLAaiKyv9b9v9m/d3mYzYnDVklAQUq6iqSoXwhLcRgYJBaRy3H1R9Hc0VzSfBR7NeDgflDVVVcFY5cdyPnUIDKMmuqBTzzFlFNUGmfXzJ7VYHW6jIKPa3QkcDgoIg4kOPVweeR+ByMeRMMDiB/OCi4RDWBQIA1a9Zw6aWXctFFF035/v777+fKK6/knnvu4eSTT2br1q1s2rSJ3bt309DQAMDatWvRNG3Kbx955BFaWlqyrsN8MVcltlKAwYHBQQKKouBwlPaDRjFzkPCWspltU4wqr4+8DoBFtRATseT2Wnstm4/ZzPrm9Qva11xDURQsNgtSSkZDowgpWFq9lDZnW1HmkpoJxXw9GDgyxEPYjFA+RVGwzCMvU75BInFY56eHoig4bAX3+JNRGBwUEQdHkF8KjHkTDA4gfzgouCvy7LPP5uyzz57x+9tuu43LLruMj33sYwDcc889/P73v+f73/8+11xzDQA7d+7MWH8ikQiRSCT52ev1AvHs9hP/q6qKEAIpZfI/xE+EdORIJJKsxjZx+3RIt+18k2fj3Gq1oqpqzvuYCZ3m00Y+cZAJnVKVJ147sViM/fv3s3z58qShLnGdJa6PmWRd11FVdUYZ4tfuRNlkMiWv3+lkKWVyPKaTD78XpCtPp8dEDhL7FrpOCXkkNII75KahIv5CQYp4tts97j280P8CCgo3nHoD/rCf3v5eWptbWVW7Ktl3JCiqklk5cU6O9yUbclxZJslz9UvqkpFDI8RcMVx2F0url1Jrr032OZvjlE/Xk5SSffv2sXTpUiwWS0Z1MlDY0HWdgVEvliKI2jkSCCkZ9YapqbSjFqiVTghQUeaV+BziIVyd/V6WNVViKnh3mfnB4KCIOIiFwVwGlvkZFXRdp7Ozk2XLlmEqsWJaCRgc5A8HReWzFo1G2b59Oxs3bkxuU1WVjRs38te//jUrx7z55ptxuVzJv7a2NgAGBwcBGB4eZnh4GICxsTGEEBw6dIjR0VECgQDhcBifzzdJDgaDU2Sv10swGEQIgc/nIxQKEQ6H8Xg8k+RwOEwoFJoke73eKXIwGMTn802RA4HAtLLf758k+/3+ZB8nyunqlOj7RHkunXRdT/alWHRKd5xisViyj8Wi01zjFAqFGBwcRAiBxWJheHgYp9OJqqr09fUxNjYGQG9vLx6PB4Cenh58vnh1tu7ubgKBAABdXV2Ew2EAOjs7iUajAOzduxdN0xBCsHfvXoQQaJrG3r17k/eYzs5OAMLhMF1dXUDck7O7uxsAn89HT08PAB6Ph97e3uT139fXB8Do6CgDAwNT7hEDAwOMjo4CpKRTT08P9fX1qKpaNDp1d3fj8Xvo9fUiRgUiFjcouHvdaFGNH+/6MQCnLzqddmc7zeFmzjzqTFZVr2LszXjbekzH3esGQItqjPXFt8fCMTz98WNGg1G8g/EXCZFABN9w/PhhXxj/iB+AkCdE0B0EIDgWJDg2LruDhDwhAPwjfsK+OO++YR+RQPxFhXfQSzQYHwNPv4dYOO7ZNdY3hhbVkjrpsbjRY7RnFKnHDU6jPaMgQeoyLs+gk5CCMd8Yb/a8iXAJ6sx1VIerqXPULcg45dv1pKoq5eXlST0ypVOiXwYKF6qqUlM5v1CXYoICVFXYCjqUL6rpWM0qNsv8HmFUBdrrKwo/hOsIYHBQRBxoESirYb7uoKqq0t7envMQrlzC4CB/OFBkAWdQVhSF3/zmN1xwwQUAHDp0iNbWVrZt28aGDRuS+1199dU8+eSTPP/88ym1u3HjRl5++WUCgQA1NTX88pe/nNTeREznMdXW1obb7aaqqmrKW9poNMrAwEBy8ZvwCEl4fOSTfKReLvmih6FT8eikKAqtra04nc6i8PAoRq+VTOg0EBzg9ZHXqbPXJStQSiF5vv95tu7Yis1k4/bTb6faXp22d1Ghe0yhQDAWxB/1I5GUm8upK6ujzlGH0+pEQTHOvQzr5Ha7qampwePxUFk5vwSzBlKD1+vF5XJlhevuXdtxv7mHivpFGW3XwMLCE4xRbjexqsm4Fg0YwNMLLW8DV2uue2LAwLRIZ14vuFC+hcBjjz2W8r42mw2bzTZle2IBPtHyqKoqdrudxYsXo2la2uEBuq5z4MAB2tvbS9rV0OCgdDmwWCxJnaWU7N27lxUrVkzi4fBrbjp54v7pyIqizCgnjGszyan0K11ZSsmePXumcFDIOgkEfYE+rGYrZvNbU5SOzs/f+DkA5y09jxpHTZKD0YOj1LTVoKhv9TFh2MmoPA5Fza48yZ1hXI6JGP6on4gWwWFx0FLRQl1ZHS6rCxWVvXv34lzhRDWpyf5mc5zy8XrSdT15T8iWTgYKE7qu0z/swVqwr2IzAyElw54QdS5HwYbyxYSg0jb/CqO6kOzt87Ci2VXYIVxHAIODIuFAaKCY5h3GB5PnzVKd6wwO8oeDojJM1dXF364nwhQSGBgYoKmpaUH7MlOOqYRsMpkwmUxpvb21Wq2sWLEiuYAvpjfSqb5lt9lsLF++HFVVMZvNRaFTuuOkKArLly9PnkPFoFM64zTxWB0dHUWh03zHCWDp0qWoqlo0Og0FhhgJjdBY3jjJo+jR7kfpD/bjsrk4r+O8pAeTlJKqliokEkRxeUzpQicQDRDWw6iKisvqYnnVciqtldhN9kljtmzZsiSXxXjfS1Wnjo4OEsikTgYKG6qqUl/txBMamHvnIoYC1FY6CjqUD5h34nOIh3Ata6os/BCuI4DBQZFwoIXBbJ93RT6I3xuXLVs26cVMqcHgIH84KKoRsFqtrFu3jscffzy5TQjB448/PmMoXqZw9913s3r1ak466SRg+hxTmch3oaoq+/fvL+j8MUeal0TTNPbv319UOqU7Tn6/v+h0SnecBgcHk3oUi07pjtOBAwcm5cEpdJ00obFn/x4smgWTakrmYwrGgjyw+wEALl55McG+YDIfk/tNd9ywM0c+JiiMHFNSSAYODDDgH2AkMEKoL8Ty6uUcU3UM5d5ymiuaUXV10jgdOHAAVVWL/r6Xik6jo6MZ18nIMVUcmOj1WMooZBo0XWJWlXnnl0qgUL3FMgmDgyLgIBYGWzmYp0bupINcGyPyAQYH+cFBweWY8vv97Nu3D4C3ve1t3HbbbZxxxhnU1NSwePFi7r//fjZv3sy3v/1t1q9fz9atW/nFL37BG2+8QWNjY9b7l4ijnCnH1ExyKm9vpZxccagQvSGO9C07wJ49e1i2bBlWq7UodEp3nBLhW8uXL5+z8lSh6DSfcYrFYuzbt4+VK1dOCu8pZJ3SHaeJHCT2LWSdBoODvDL4CvXl9ZhN5qQX0c/f+Dm/7fwtLeUtbHnXFlTUpHeR1CWjb46H8ilKwXpMhWNhfDEfmq7hMDmoK6+j1l6L0+LEZrHNOk6aptHZ2Zn0Ji3G+14qOqVzb0xHJyPH1MIhWzmmdF3nxW1PYg0N4Gwo3RxThR7KF4zEjfrHtLowz9PVpShCuI4QBgdFwoGnFxpWQe2yeTeRLyFcuYTBQXY5SGdeLzjD1BNPPMEZZ5wxZfvmzZu57777ALjrrrvYsmUL/f39rF27ljvvvJOTTz55QfqXzcSdiYV7YrFcijA4MDhIwOChuDjQhMYrQ6/gj/mT+aMAhkPDfP4vnycmYlx14lWc2HTipN8ljEcJA08hQRMa/pifUCyE1WSl2lZNfVk9VbYq7ObUc6gU03lwJMgWD9mc1w1MRra4llLS9fp2xnr3lrRhSkqZrK1QiPeKsUCMqnILKxoq5t2GlBIh46FchchBJmBwUCQceHph0YngnH+6GmP9YHAA2eWgqJOfn3766cxlS7v88su5/PLLF6hH0yPxdjaTb6QT26SUJZtjSlXVpPdYKeeYSuQ8KcUcUxNlTdOwWq1FpVO645Toc6HrNBwcZjQ8Sp29LnmeSyG5/437iYkYR9cczQkNJwBMysckRTz8TTEpBVGVT9d1glqQYCwIEiptlSyuXozL4qLCVjHpPp/qOAkhknwW630vFZ0URUHTNMxm85z3xnR1MlD4KLD3sFmDlIUbzhcTOk77/BM9JyCkLEiPsUzC4KDAOdCjYLIcUeLzBCbOz6UKg4P84KC0RyCDWIgcU8FgkM7Ozpzn8MhlXhIhBHv27CkqndIdJyEEr7/+Om+++WbR6DSfcerv7+e1115DCFE0Os1nnN544w2EEAWtU/eBbg4OH8RisuAf9CfzMb3S+QrP9D4DwP+r/X8ILW5cSORjQoK7x427143U8jvHVCAQYCg4RO+BXvSITntlO7XBWlZXraatso1DBw6h6/q8x6mzsxOv11u0971UdBJC8OqrrybnXyPHlIEEhBAMuX257kbOIYERb4iCNNHJuPHZZj6yMBMhobPfiyhIEjIDg4Mi4CA2nvjcMv/E5xC/N3Z2diZf3pQiDA7yh4OCC+XLd2Qzx1Q+vJEuxrfshk6GToZOudWp39/PayOvUV9Wn8wfpSgKNz53I68Mv8IpLafw2bWfnbWCXULOJ4+pmIjh1/yEo2HsFjs19hpq7bVU26uxmW0FN07FeO6lopORY2rhkM2wye5d23G/uYeK+tIN5StkRDVBKKZzTEslDktp5oExYCAJ/yCUN0Dr23LdEwMGZkVRh/IVChIL8IkucUciJxbrkUgEq9WKMu56OjFB2XSyoigzyok2ZpIz1ffZdEpXllISjUaxWq1Fo9N0esym0+EcFINOh8up9EtRlCQPxaJTuvJEDgpVJ13o9Af7sZjilfgSeHnwZV4ZfgWzauYDR38AZUJy0omyRKLHdEwWU3K7oihJY1VG5WmOf7gspMAX9RGMBTErZlw2F8tcy6iyVVFmKWMiMjVOQHJuSPBabPe9VHSSUhKLxTJyb5yp7wYKE1JKYppOqb+KlVKiC4lJVSbd0woBUU1gM6vYjvB6lFIS1QRWc2nnkzE4KHAOtCiUVR9xMxOfKQqShwzA4CB/ODBC+bKExNtZIURK8sR8ItPJuq6j6zoHDhwgFotN2p54i3y4DMwqJ44/k5xq349Ep9nk6XQSQtDd3U0sFisandIdpwQHmqYVjU7zGSdN0+ju7k5uKwad0h2niRwUqk4j4RFGgiNUWuNvUaSQ6ELnJ7t+AsC7299NQ1lDPJfUuE4JWUqJ1CWefk8y11Sij1mRDzt+QhZCEIwFGfAPMBgYREVliXMJa+rXcHz98TSVNeEwO7J27mmaxoEDB5L3yIU49/Lxekrn3piuTgYKG0IIRr2BXHcj55DAmD9SkKF8UU1QYTOjHuGTi5BwYMhfuCFcGYDBQYFzIMcTxR1hGB/E740HDhxIzo+lCIOD/OHAMExlCAuRYyoWi7Fy5Uq6u7sLKn9MJvOSmEwmlixZkux7MeiU7jiZTCYaGxvp7+8vGp3mM07Dw8PU1tZiMpmKRqd0x6mnp4fW1lZMJlNB6uR2uznkP4QYE4hwfDL09Hv4S9dfOOg7iMPk4Pz28wFw97rRY3EDwaQcU71uahbVgGTBc0xF9Sj9ff0cGjxEVI9SHixnmX0ZJzSegNlrRo2qqIqa9XOvp6eHlStXEgwGi/a+l4pOJpOJ6upq3G53RnUyckwVPkwmE401lZToy/AkVEWhzuUoyITPOoJy25EHephUhZUtLkxq4XGQKRgcFDgHegTMNrCWzb3vHDCZTKxcubKkPYMNDvKHAyPHVIaRzRxTiqIQiUSwWCwlXZUvFAphtVpLuipfKBTCZrOVdFU+XdcJh8OUlZUlPRsKXad0x0nXdSKRCA6HI9nfQtJpODTMqyOvUmOrwWwyoygK4ViYzz/xedwRN5ccfQnnLTsvHsI6TS4niHssaTENs9WMgpL1HFNCCnwRHyEthNVspdJSSWNZI1WOKmyqLSfnnhCCaDSKzWZL8lts971UdFIUhWAwiN1uz2hVPiPH1FTccsst3HvvvSiKwjXXXMOHPvSh5HddXV1ceumlSWPhc889R3l5am/2s5VjSkrJ3ldewN+/H2dD6eaYklKi6QKzqbDCl4QAdzDK6uZKKh1HZpySUhKO6titpoLiIJMwOChwDkJjoJqh/VSO1IVQSkk4HMZutxceDxmCwUF2OUhnXjc8prKExAJcVdWU5Il5M6aTE4v13t7eSXk2EgaqRH6OiTLMnsNjYi6S6eRU+34kOs0mT6eTEIJDhw5NyjlS6DqlO04JDhIoBp3mM04Q94JIPPAWg07pjhPAoUOHkg/0haSTRHIocAiTasJitiT7+3D3w7gjbuocdWzq2PTWtT4hJ0pCTvwFRgJJo1Sij5mUpZQEtSCDwUFGQiNYzVZW1qxkbcNa1jSsodnZjMPsyNm5B3EvoITRZiHOvXy8noQQSS+qTOtk4C288sor/PSnP2X79u28+OKL3HXXXUlvNICPfvSj/Pd//zevv/46Tz75ZNJgmksIIfD4Q7nuRs4hAW8wWnChfFFdx2pWsVmO/LFFSOh1BwszhCtDMDgocA60EDhqjtgoBfF7Y29vb85DuHIJg4P84cBIfl5AMJlMLF++PNfdyCkMDgwOEjB4KGwORsOjjIZHqXXUJrd5Ih4e6nwIgA8c/QGsJuuc7SiqQnXrkScAnQ5hLYw/5kcTGg6Tg0XORdTaa3HZXJjV/Jk+C/k8yCQMHhYGu3btYsOGDdjtdgDWrFnDH//4Rz7wgQ/w2muvYbFYeMc73gFATU1NLruahMlkor7aiTvQN/fORQxVUaitdOS6G2kjpknsFhWb+cgfxE2qwvKm0vZ8NDgocA6EDvbM9N2YNw0OIH84MDymCghSSvx+fzKkpBRhcGBwkIDBQ+FyoAudXn8vJtU0ycDzqz2/IqSFWOpayiktp6TUlpSSaCiaMQ40oTEWHqPP30cwFqTWXsuxtceyrmkdK6tXUuuozSujFBTueZBpGDzE8dRTT3H++efT0tKCoig8+OCDU/a5++67WbJkCXa7nZNPPpkXXngh5faPPfZYnnjiCcbGxnC73TzxxBPJ3F979+6loqKC888/nxNOOIGbbropU2odEaSURKIaJX5qxO+XMb3grpGoruO0WzLSlpQSfzhWcBxkEgYHBcyB0EFRwXrkic/BmDfB4ADyhwPDMJUlJFzhhMhc1SMhBIODg2ialrOqR5nWaTZ5Op2klAwMDCSrLhWDTumOU4KDxD7FoNN8xknXdQYGBpK/Kwad0h2niRwUkk6j4VFGgiO4rK54m0JyyHeIxw8+DsAlqy5BVdRpK/FNlKWMV+ULjAaOqCqfLnR8YR8D/gFGgiPYFBtH1xzNmro1rKpeRWN5IxbFkrfXk67rDA4OTupLsd33UtEpnXtjujoVEgKBAGvWrOHuu++e9vv777+fK6+8ki9/+cvs2LGDNWvWsGnTpmTRFoC1a9dy7LHHTvk7dOgQq1ev5t/+7d8488wzueiii3j729+eDHfUNI2nn36ab37zm/z1r3/l0Ucf5dFHH10QvWeDlBJfMJzrbuQF/OFYrruQNiQShzUzIbVSwqAnTI6fv3IKg4MC5kCLgNkBliNPfA7xe+Pg4GByvitFGBzkDweGYSpDWIiqfNFolKVLlyZlyO+KW9mo5KSqKosWLUrqUQw6pTtOqqpSW1ub1KMYdJrPOA0NDeFyuVBVtWh0SnecDh48SGNjI6qqFoxOo6OjHAocQngEeij+wO8d9PKT136CLnWOqzyOFeUr4u33jaFF40bo2aryVTVXzasq30j/CIPBQfqH+wmPhGmvbGeZbRmNopFFzkVE/dGs3MszPU4HDx5k6dKlyQp9C3Hu5eP1pKoqTqczqUepVuU7++yz+epXv8qFF1447fe33XYbl112GR/72MdYvXo199xzD2VlZXz/+99P7rNz505effXVKX8tLS0AfPKTn2THjh385S9/wWKxsGJF/JptbW3lxBNPpK2tDZvNxjnnnMPOnTtn7GskEsHr9U76g8y/3JNSUusqR1FAyLeM3AlZSjlFTvxuJlnmWJ5Oj7l0UhSF6gpbMsdUIeik6RJVUbCa4/n+9AkvJvQJLxpmksVhsqoqdDRUkICYsM8UOXkuzSzLOWR9DjkTOh0uz6WTqiosqa9IFhEpBp3SHacEB4mUnQWjUywI1jKEapnzvpfKSyMpJR0dHSiKkrcvYbP9Igxg6dKlKIpSNDqlO04JDiZ+zsXLPaMqX4aR7ap8fr+fsrKykq7K5/V6KS8vL+mqfF6vl4qKipKvyufz+XC5XMmbX6HrlO446bqO3++nsrIy2d9812kkNMKrI69SbatOVuLbNbyL65+7HgWF/3nH/7CochGKMn0lvokyxL2noqEo1jJrSlX5YloMv+4nHAvjMDmoLaul1l5LpbUSu8VekNeTEIJAIEBFRUWyL8V230tFJ0VR8Hg8OJ1OoyrfOBRF4Te/+Q0XXHABEDcGlpWV8cADDyS3AWzevJmxsTF++9vfptTu4OAgDQ0N7N69m4svvpgdO3ZgNpvRNI2TTjqJP//5z7hcLt7znvfwyU9+kvPOO2/adr7yla9w/fXXT9m+e/duVq5cmTQMNzQ00NfXh8Vioa6ujt7eXhwOBzU1NfT09OB0OqmqquLAgQNUV1dTWVnJ/v37aWhooKKign379hEaGyA2epCIrZaqChtmk8rgWJDaSgeKAsOeEHUuB1LCiDdEQ1UZmi4Y80eoczmIaTreYJTaSgfRmI4/HKPGaScc1QhFNKqddkIRjUhMp6rCRjASI6YJXOU2AuEYQkicZVb8objhtsJhxReMoqoK5XYLnkAEi1mlzGZhzB/BZjHhsJlx+8I4bGbsVjOjvjAVdgtWi4kRb4jKMisWs4lhTyglnepdDoLhGMGIRn1VWUHoFNMkI74QJ6+ox2ZS2dvnYUWzCyElnf1ejm6tIhLTOTDkZ2WLi1BEo9cdZHlTJf5wjEFPmKWNTryhKG5/lMV15RxyB9GFZHFdBaP+CKGoRmtNOcPeMDFd0FxdxqAnniy/weWgzx3EYlKpq7TTOxrAYTVTU2GjZziA02GhqtzKgSE/1RVWKh1W9g/4aHDZqbBb2NfvpbW6DIfNzJ5DHtrrK7BZTLzRO8aypkpURTlindrrKxgLRPGFYrTVlc+pU32lna5BH067hXqXoyh0SnecnHYLu3rHaKstx+mwFo5OsTFqFq2kJ+xI6b7X2tqKw+Fgz549tLe3Y7PZeOONN1i2bBmqqrJnzx6am5spKytj//79HH300UQiEQ4cOMDKlSsJhUL09vayfPly/H4/g4ODLF26FK/Xi9vtpr29nbGxMXw+H21tbYyOjhIKhWhtbWV4eJhYLEZzc3NG7+Vz6bR3715WrFiBEILOzs6UdKqrq0NKydjYWNHolO44lZeXEwqFUBQlozrt2LGDdevWpbSGMgxTGUa2Sh1DfDHf09NDW1tbcoFfajA4MDhIwOCh8DgQUvDK8CuMRcaoc9QB8Tc41z17HXvH9vIPi/+By46/LK02pZB4B71UNlQmq+lNd1x/zE8wFsSsmHHZXDSUNVBlq6IsQ+7wuUShnQfZQrZ4yOa8nm0cbpg6dOgQra2tbNu2jQ0bNiT3u/rqq3nyySd5/vnnU2p3w4YNeDweysvLueeee1i3bl3yu4cffpirr74aKSXvfve7ue2222ZsJxKJEIlEkp+9Xi9tbW0Zf7kXi8V4+aVtqL5DlNe3ooxzI6RM2LiRMElWlbgxeyY5wW+u5ETfZ5Kn00kB3L4wrgobpoSxN8918oQ0nHYzRzXGDe9CQuJWL2Q8ibWUckZZSlAnyAAHh/0sqinHbFbj3ijj+0yRx7kR4y9DppOV8RcmM8m6kKizyJnQ6XB5Lp2Q4xzUlmM2qUWhU7rjJCUcGPazuLYck0ktHJ08b6K2nYioaMrISyNN0+jt7aWtrQ0gL1/CZvtFmK7r9Pb2smhR/KVoMeiU7jgJEa/K19raiqqqGdUpnZd7+ZXB1cCsUFWV9vb2XHcjpzA4MDhIwOCh8DgYDY8yGhqlxvFWpa7n+55n79hebCYb71v5vrTbVFQFV5NrynYpJSEthD/qRyIpt5Sz1LWUGnsNTqsTVSkeA06hnQfZgsHDwuGvf/3rjN+dffbZnH322Sm1Y7PZsNlsU7YnFuATDYxHIlssFuqqKnD74w94yX0myBPN2glZUZQZZXIsz6THXDrVTKjKVwg6aULgcliS+5kmKJWQFUWZUVamkZc0OCcfR5lBTuyjzl82pSJnQKeJ8pw6KYdxUAw6pamHokDHBA4KQid0MFvAUpbSfS+R+2822WKxsGTJEiZCUZTkPofLietwJjlT9+wj0Wk6eTadzGbzlLVDoeuU7jhNt37Khk5zoXhW5iWAhIthKTu5GRwYHCRg8FBYHAgp6PX3oqpqsqqdJjR+9sbPADhv6XlU26vTbldKSdgfTnIQ1aOMhEYYCAwQ1aO0VLRwfP3xnNB4Ah2uDlw2V1EZpaCwzoNswuBhbtTV1WEymZJ5xhIYGBigqakpR73KPqSUBMNRSv3UkFISimiFc41IQErslswkPofx+0Qgc5VcCxEGBwXKQSwUT3yeoYp8YMybYHAA+cNBca3O8wgJl7eEe9xccuJEmElOVOXz+XwlX5XP6/WWfFU+r9drVOXTdbxeb/J3xaBTuuM0kYN812m6SnyPdD/CQHCAKlsV5y09L7k90fdUq/KFfCHGQmP0efvwRX1UWitZVbOKExpPYGX1Sqqt1VjGE4UW4z0ikW9tYl8KXaf5jFM698Z0dSoWWK1W1q1bx+OPP57cJoTg8ccfnxTaV2yQUhKOFl41umwgEiuc8zmmCywmEzZz5h5XpARfKEaOn79yCoODAuVAC4PNCSZLxpqUUuLz+ZLzXSnC4CB/ODAMUxnCQlXla2trK/mqfI2NjSVfla+ystKoyjc0RFlZ3J25WHSaT1W+mpoaVDW/q/INjwxzyH8IzaOhBeJG5YH+AX6959cAnNt0Lmo0Ph15+j3ExsuZp1KVb/jNYULlIayKFafXydqGtRxdeTT+Pj8OsyMvxmkhqvK1tbUZVflUFbvdXvJV+fx+Pzt37kxWw+vq6mLnzp0cPHgQgCuvvJLvfOc7/OAHP2DXrl18+tOfJhAI8LGPfSyHvc4uVFWlprKcCREyJQlFUaiqsE0Kn8tnRDSB1axiN2fOY0pVFdrqyieFSJUaDA4KlAMtCo70Pctng6qqJZ+f0uAgfzgwkp9nGNmsygckKw6ZzeYFT4yWrpyNZG+JJGqVlZVYLJai0CndcQJwu924XC7MZnNR6DSfcdI0DY/HQ3X1W5N0oeuU7jhN5CBxnHzUabpKfD99/ac8tP8hWita+fppX09WGp2rEt9EWUhBv6+fOqWOYxYdg1k15+U4ZfvcS3jOuVwuFKU0E3cmkOq9MR2dCq0q3xNPPMEZZ5wxZfvmzZu57777ALjrrrvYsmUL/f39rF27ljvvvJOTTz55gXs6FdlKNC+EYNfO54gMH8DZsChj7RYapJSEohoOq7kgjFNuf5Q6p5Wl9RUZa1PIeAhXVbl1Ui6fUoLBQQFyICV4D8Gik8DZmLFmhRCMjY1RVVWVc6NErmBwkF0O0pnXjeTnWUJiUI8kcdjhScSEEIRCIaqqqpILioVMjJZpeT7J3oQQhMPhpDGiGHSaTo/ZdDqcg2LQ6XA51T4mPBqKSad05QQH+aoTCvQF+1AUBYs57n4+HBrm4e6HAfjgqg9iNr81FU2srDeX7A67qbZXU6PVYDFZksfNx3FKIBvjpKpqcm6YyEEh6zSfccrkvXG+iTvzAaeffvqc7viXX345l19++QL1KD8Q0wonhC2biGkChzXXvUgNmhSU2zL8qCIhFNWoKrNOzg5fSjA4KDwO9CiYrGDNfCXhxPqhlGFwkB8cGIapAoKqqrS2tua6GzmFwYHBQQIGD4XBwWh4lJHQyKTE5ve/cT8xEWN17WpOaDhhXu0GY0GQsLR6KbWO2kx1tyBRCOfBQsDgwcBMUFWVKmcZbk+ue5JbKIqCq3xqFcR8hJTx/totmX1UUVWF1prMJY8uRBgcFCAHWhgsdrBk1jBlzJsGB5A/HJSmv1qBQgjB8PDwpLCFUoPBgcFBAgYP+c+BkII+fx8oYBlP1tnl6eKZ3mcAuGTVJfMKJ9GFjjfiZXHlYqpt1XnNwUIg38+DhYLBg4GZIITAHwwXVqLjLEBKSSAcy3mC21QQTeSXsmT2UUVIybA3jCgADrIFg4MC5EALg70K1Mx68BrzpsEB5A8HhmGqwBCLGVVlDA4MDhIweMhvDtxhN8OhYaptcW8pKSU/2fUTJJJTWk5hWdWyebU7HBqmvqyeRc54rph85mChYHAQh8GDgZmgiwJ5AM0yRIHwENUFdrMJqynDjyoyXu2PwqAhOzA4KDwO9BjYXVlp2pg3DQ4gPzgwDFNZQsLiKETmynErikJzc/OkJNj5Ugp+vjqlW2JcVVWampqS+xaDTumOU4KDBIpBp/mME0BjY2MymXEx6JTuOAE0NTWhqmre6aTpGn2BPiQSsxoPxdg5sJNXh1/FrJr5wMoPvHUdC5my7Il4sCk2llQuwayYkVLS1NSUTFidj+OU7XMPoLm5OZmDrhh0ms84qWq8amsCmdTJQGFDVVVcFQ4KIcdxNqEoCs4ya0EkPo9qAqfdnPExU1WF5uoyCqoaW4ZhcFBgHEgBKGDNfOihqqo0NzeXbNJvMDiA/OGgdEcgw7j77rtZvXo1J510EgCDg4NAZstxB4NBBgcH2bdvX16Vgl/IEuNCCA4dOsS+ffuKRqd0x0kIQVdXV1K/YtBpPuPU399PZ2cnQoii0Sndcerq6uLgwYPJcyKfdOo+1M1QcAh70E7IE0JIwY9f+zEAm5Zswh60EwlEAPAOeokG4/319HuIheNvbcb6xtCiGgDuXjfhSJiwFsbmtuFQHQgh2LNnDwMDA0Sj0bwdp2yfe11dXQwODuL1eotGp/mMkxCCffv2JeffTOmU6JeBwoUQAm/ACOWTUuIPRQsilE8icVgzX3hASMmgJ1Q4IVxZgMFBgXGgRbKSXwri98bBwcFJL31LDQYH+cOBIgthdiogJEoiut1uqqqqkgOciXLcACMjI1RXV2M2m/OmFPyR6JRuiXFFURgaGqKmpgaLxVIUOqU7TgBDQ0PU1tbOWRK9UHSazzhpmsbIyAj19fXJ66/QdUp3nCZykDhOPuik6Rq7RncxHB6m3l4PCjzR8wTf/vu3KbeUc8cZd1BuLgcl/gZfCjmnrOs6A8EBFlcuZmnlUsymuBeWpmmMjo5SV1cHkJfjlO1zT9d1RkdHqa2tTVbpK3Sd5jNOkPq9MR2d3G43NTU1KZU6NnBkSKesdDoQQvDqjr+ijR7E2bAoY+0WGqSM55gqt1vy2mtK1yWeUIzVLZU47ZlNfp7ILVRXaUfNYw6yCYODAuMg5AaTDdpPIdMuhELEcwvV1dXl3FsmVzA4yC4H6czrhmEqw8jWosqAAQMGCgUjoRH+PvR3quxVWE1WwlqYz//l87gjbj68+sOcu/TctNscDg1Tbi7n2LpjsZvtWei1AQPTw5jXFw7Z5Lp713bcb+6hor50DVOFgnBURxOSY1tdWEx5bjQwYCDb8PZBTQc0rMp1TwwYSBvpzOulaRYsUCRClnLtZpdLGBwYHCRg8JCfHEgp6Qv0oSgKVpMVgD90/QF3xE1DWQPvbn932m0GY0EUFDpcHVOMUvnIwULD4CAOgwcDM0EIgccfMkL5pMQXzP9QvogmcFhNWTFKCSHpcwcplCTw2YDBQYFxIHSwObPTtDFvGhyQPxwYhqkCg8ViyXUXcg6DA4ODBAwe8o8DdyReic9li1ePGYuM8dC+hwD4wFEfwGJKr7+a0PBEPCx2LqbWUTvtPvnGQS5gcBCHwYOBmWAqhCTHC4BCSPYcEwKnLbMhfEkoYDGpkP80ZA8GB4XDgdBANWUlv1QCxrxpcAD5wUGW7voGsgFVVZN5VEoVBgcGBwkYPOQfB1JK+vzxhNQJb6lf7fkVYT3MUtdS3t7y9rTbHA2N0lDWQKuzddrv842DXMDgIA6DBwMzQVVVKsrsuEdz3ZPcQlEUyu25f/iYC1KSlcTnAKqiUFdZ2uHgBgcFxIEWBrMjKxX5wJg3weAA8ocDw2OqgCCEoLe3N+dudrmEwYHBQQIGD/nHgTviZig0lPSW6vX38vjBxwH40OoPoSrpTTmeiAebyUaHqwOLOv3DVL5xkAsYHMRh8GBgJgghGPMFjVA+KfEEInkdyqdpEotJwWbJziOKEJLe0UBhhHBlCQYHBcSBFgFbOZhtWWnemDcNDiB/ODAMUwUGh8OR6y7kHAYHBgcJGDzkDwcJbykpZdJb6me7foaQgnWN61hduzqt9qJ6lLAWZmnVUpzW2XMr5AsHuYTBQRwGDwZmgsWcHQ+cQoPFnN9L/4imYzWp2M3ZC+VzWM35H8KVTRgcFA4HsTA4arJ6CGPeNDiA/ODACOUrIKiqSk1Ndm9O+Q6DA4ODBAwe8ouDscgYQ6EhquxVAOwa2cVLAy+hKiofPPqDabUlpGAkNEKbs42GsoZZ980nDnIFg4M4DB4MzARVVSl32Ijm+0NolqEoCmW2/A7li+mS6nILpizZz1RFoaYiO94nhQKDg0LiQGYtjA+MeRMMDiB/OMjv1yYFjIQrnBAiJTnhVj2TrOs6uq7T09NDLBabtF1KiZRyigzMKieOP5Ocat+PRKfZ5Ol0EkJw8OBBYrFY0eiU7jglONA0rWh0ms84aZrGwYMHk9uKQad0x2kiB7nUSUpJry/uAmw1WRFC8ONdPwbgjEVn0FLREv+tkMl+zSaPhEaotlXTVt6GMv46cyadYrEYBw8eTN4j83Gcsn3uaZpGT09P8h5ZDDrNZ5zSuTemq5OBwoYQglFvwAjlk5Ixf56H8glBhT17782FkPQMF0AIVxZhcFAgHOhRUC1gzV7icyEEPT09yfmxFGFwkD8cGIapDOHuu+9m9erVnHTSSQAMDg4CMDw8zPDwMAADAwOMjsYzb/b19TE2NgZAb28vHo8HgJ6eHnw+HwDd3d0EAgEAurq6iEQiOJ1Ourq6iEajAOzduxdN0xBCsHfvXoQQaJrG3r17AYhGo3R2dgIQDofp6uoCIBAI0N3dDYDP56OnpwcAj8dDb28vAGNjY/T1xRMZj46OMjAwkHGdwuEwAJ2dnSnppCgKdrs9qUcx6JTuOCmKgqIoHDp0qGh0ms84DQ0NIYRAUZSi0SndcTp48CAWiwVFUXKq01hkjP6hfmyh+NvHpzqfonOsE5vJxrkN5xLyhADwj/gJ++J99A37iAQiAHgHvUSD8f4O9w4jI5IlriUc6jk0p0779u2joqICXdfzdpyyfe4dPHgQp9OJ3+8vGp3mM06KoqBpGiMjIxnVKdEvA4ULRVGwW/PbU2ihYLPkcUijBBSwZTHsUlHA6bCglLD3nMFBgXAQC4PFAZbseUwpioLT6UTJayKyC4OD/OFAkfn82qQA4fV6cblcuN1uqqqqkpZHVVVnlRPGhplkXddRVXVGGeLWzomyyWRKvmGeTpZSoqrqjHKqfTd0MnQydCpdnaSU7Hbvpj/QT0NZA5rU+Pcn/53B4CAXr7yYi5ZfBEp80pNCzirrUmfQP8iK6hUsqVpijJOhU17o5Ha7qampwePxUFlZiYHsIbGGygbX3bu2435zDxX1izLaroHMIaoJwjGd1S2VOPLZgGbAwELAPwjlDdD6tlz3xICBeSOded3wmMoSEgtwVVVTkhMWypnkxGL9wIEDyYVzYnvi8+EyMKucOP5Mcqp9PxKdZpOn00mIeKhGYt9i0CndcUpwkEAx6DSfcQKSbqfFolO64wQkQ/lypZM35mUoNES1oxpFVXj0wKMMBgepslVx7tJzUdS37ldzySPBEZoqmlhUuSjlcVIUhYMHDyKlzNtxyva5B3DgwIGk0aYYdJrPOAkhkt5VmdbJQGFDCMGIxwjlk1Li9oXzNpQvqgmsZhV7Fj2mhJAcGPKT1yFcWYbBQYFwoMegrDqrhxBCcODAgeTLm1KEwUH+cGAYpgoIiqJQXV096aG01GBwYHCQgMFD7jmQUtIf6EeXOlaTlUAswK/3/hqAi1dejN1sT7ktT8SDw+Kgw9WBWU09v0iuOcgHGBzEYfBgYCYoikK53ZrrbuQFHLb8rXsU0QROu5lsXsKKAtUV1qweI99hcFAAHEgZ76Qle/mlwJg3weAA8oeD/J2dDEyBoiglH0ZgcGBwkIDBQ+458EQ8ce+o8Up8D+59EH/Mz6KKRZzednrK7UT1KGEtzOra1VRYK9LqQ645yAcYHMRh8GBgJiiKgt1mIVS6zx1AItdW/i79JZLyLPdPURQqHaVtpDQ4KAAO9AiYrAtimCr1edPgIH84MDymCghCCPbv359zN7tcwuDA4CABg4fcciClpC/Qhy51bCYbQ8Eh/tj9RwA+uOqDmNTUQjGEFIyERmitaKWhrCHtfhjngcFBAgYPBmaCEILhMb8Ryiclo3kayicEqCjYs5xbSgjJ/gFffodwZRkGBwXAQSwMZnvWDVPGvGlwAPnDgWGYKiAoikJDQ0PO3exyCYMDg4MEDB5yy8Hh3lL3776fmIhxTO0xvK0h9USdo+FRqm3VLHEtQVXSn5KM88DgIAGDBwMzQVEUnGWphxYXMyrs+VmdMKrrWM0qVnN2H00UBRpc9vwN4VoAGBwUAAdaGBw1oGb7ejDmTYOD/OEgf/15DUyBoihUVKQX5lJsMDgwOEjA4CF3HBzuLdXl6eKZ3mcAuGTVJSlPbMFYEAWFjqoObCbbvPpinAcGBwkYPBiYCYqiYLOaCZbucwcQ58Gap9XuopqkzKpiy7phSslb49xCweCgADgQOtizH1plzJsGB5A/HBgeUwUEXdfZt28fuq7nuis5g8GBwUECBg+548Ab9Sa9paSU/Pj1HwNwWutpLK1amlIbmtDwRDy0O9upsdfMuy/GeWBwkIDBg4GZoOs6Q25fyYfyCSkZ8YYQeUhEVNepsGXfUKALyb5+L3q+hnAtAAwO8pwDoS9I4nMw5k0wOID84cAwTBUQVFWltbU1WfK6FGFwYHCQgMFDbjg43Ftq5+BOXht5DYtq4f1HvT/ldkaCIzSVN9HqbD2i/hjngcFBAgYPBmaCqqq4Khy57kbOoQCVZVby03FMUmbLvjeXqkBrdRlqfpKwIDA4yHMOtEg8v5Q1+4YpY940OID84aB0R6AAoSgKDocj5/GfuYTBgcFBAgYPueFgoreULnR+8sZPADhryVnUl9Wn1MZYZAyHxcGSyiWY1SOLKDfOA4ODBAweMo8LL7yQ6upq3ve+903aPjY2xoknnsjatWs59thj+c53vjPp+2AwSHt7O1ddddVCdndGxEPYzPmbT2aBoCgKFrMp764RTZeYVBWbJfuPJYqi4LCZ846DhYTBQZ5zoIXi3lLm7OfFM+ZNgwPIHw6ykmPqoosuSvs399xzDw0N6VdkKiXouk5nZyfLli3DZMrPHAHZhsGBwUECBg8Lz0HSW0rEvaX+fPDPvOl7k3JLOe9Z/p6U2ojoEaJalFW1q6iwHnk8u3EeGBwkkK88FPKa6HOf+xyXXnopP/jBDyZtdzqdPPXUU5SVlREIBDj22GO56KKLqK2tBeDGG2/k7W9/ey66PC10XWdg1IslD6N2FhJCSka9YWoq7ah59BAW0wRWk4rNnP3rVheSzn4vy5oqMeWlu0z2YXCQ5xxoYXAtZiEs6fk6by4kDA7yh4OsvJp48MEHsVqtuFyulP5+//vf4/f7s9GVooKqqrS3t+fczS6XMDgwOEjA4GHhOUh4S1XaKglrYX65+5cAXLTiopSMTEIKRkOjtFS00FjWmJE+GeeBwUEC+cpDIa+JTj/9dJxO55TtJpOJsrJ4mEkkEkFKiRzPW7R3717eeOMNzj777AXt62xQVZWayvJcdyPnUICqClvehfJFdEGZ1YxlAQwEqgLt9RX5GcK1QDA4yHMOJGBbmETU+TpvLiQMDvKHg6xV5bvzzjtTftv3wAMPZKsbOYMQYtJ/VVVnlRVFQVGUGWVd11FVFZvNlpQnbk8ca6JsMpmQUs4oSylRVXVGOdW+H6lOM8kz6WS1WotOp3THyWq1IqVMHr8YdEp3nKSUWCyWaTkoVJ3SHScpJVardcF06gv0EdNi2Gw2fr3v17gjbhocDby7/d3xh1IJiqokH1AVRUEKCUpcHgmNUGWtYolryaR9jnScrFYrEH/jk4/jtBDnns1mS24vFp3mM04WiyWle2O6Oh0psrEmeuqpp9iyZQvbt2+nr6+P3/zmN1xwwQWT9rn77rvZsmUL/f39rFmzhm984xusX78+3e5Pi7GxMd71rnexd+9etmzZQl1dHQBXXXUVW7ZsYdu2bRk5TibwVghbrnuSWyiKgtmUfyRoQsdpX5gcYIqiYMvTyoQLBYODPOZAaKCaFiTxOYzzYJtfVeRigcFB/nCQFbPYX/7yF2pqUq+y9PDDD9PaemQJcHONu+++m9WrV3PSSScBMDg4CMDw8DDDw8MADAwMMDo6CkBfXx9jY2MA9Pb24vF4AOjp6cHn8wHQ3d1NIBAAoKuri0AgwBtvvMG+ffuIRqNA/M2kpmkIIdi7dy9CCDRNY+/evQBEo1E6OzsBCIfDdHV1ARAIBOju7gbA5/PR09MDgMfjobe3F4gvOvv6+gAYHR1lYGAg4zqFw2EAOjs7U9JJ13Vee+019u3bVzQ6pTtOuq7z8ssvJ/UrBp3mM059fX3s3LkTXdeLRqd0x6mrq4tXXnkFXdezrtPu/bsZDA5SJsro7evloc6HALig9QIsJgshT4igOwhAcCxIcGxcdgcJeUIEYgE0t0adUofNZMvYOO3evZtdu3YRiUTydpyyfe51dXXxxhtv4PF4ikan+YyTruv87W9/S+qXKZ0S/ZovsrUmCgQCrFmzhrvvvnva7++//36uvPJKvvzlL7Njxw7WrFnDpk2bkusTIJkj6vC/Q4cOzXn8qqoqXn75Zbq6uvjpT3/KwMAAv/3tb1m5ciUrV65MWd+FgK7r9A97jKp8UjI4Fsyvqnwy/mdfICOBLiRv9I7lZzW2BYLBQR5zEAvFc0stkGFK13XeeOONnFdjyyUMDvKHA0XKfJqdCh9erxeXy4Xb7aaqqiqjb6Qn/jeZTAXp4XGkb9lVVSUWi6GqKmazuSh0SnecFEUhFothMpkwmUxFodN8xknXdTRNS3qPFYNO6Y6Truvouo7FYkn2N1s67R7ZzaHAIRrKG/jeK9/jsYOPsaxqGTdsuAHVpM7qMaVJjZHQCMtdy2mrbMvoOOm6jhAieT/Ix3HK9rknhEh+TvSl0HWazzgpikI0GsVsNs95b0xHJ7fbTU1NDR6Ph8rKSvIRiqJM8Zg6+eSTOemkk7jrrruAOO9tbW189rOf5Zprrkm57SeeeIK77rprVk+uz3zmM5x55pls376dH//4x5hMJvx+P7FYjH//93/nuuuum/Z3kUiESCSS/Oz1emlra8v4GkrTNLp37cDb10l5fSvKOGdCymRYm4RJsqrE72UzyQnecyUn+j6TPJ1OCvEHckUBU+KayrFOkZhOKKpzbKsLq1lFHfew1YWcIgMIySTZND7nzCRLCeoEWVEgpgtMioLJpMaNdOP7TJHHuRHjnr/TyYqS8PydXp5Oj0zrdLg8l04KENUFZlXBpKpFoVO64wQQ1QQWkxJfU+aLTqFhhL0aWtctyNxsrKGMNZQQIvn7xLEzqVM6a6isBxLu2LGDV155Jfn5t7/9LRdccAFf/OIXk29VixGJk0dV1ZRkZfwuOZOcMESpqpqUJ25XFGWKDMwqJ44/k5xq349Up5nkmXRKGGSKSad0x8lkMhWdTvMZJ7PZXHQ6pTtOE6+LbOnkjXoZDA/isrs4FDjEn3v+DMCHVn0I1fSWrsr4ii1xDIgbqkZDozSWN9Ja2ZqVcUp8zudxyva5N3ExUSw6zWeczGZzVnTKFBZqTRSNRtm+fTsbN25MblNVlY0bN/LXv/71iNsfGBhIepp5PB6eeuopjjrqKG6++WZ6enro7u7mlltu4bLLLpvRKAVw8803T8qv1dbWBmTe67y7uxtNjy+sR73hpJfEsCeEiD8PMuwJIYk/cA57QkDciDPqjXvOabrA7YvLMU3g9scNapGYzti4HI7qeALxcQxFNbzBuByMaPhDMQAC4RiBcFz2h2IEIxoA3mCUUDQuewJRwtH4m+sxf4RILC67/RFiWlwPty88L50SCdDzRadRXwSTCjazia5BX3Kfzn4v0XFd9/Z50ET8oX9vnwchQROSvX3xcY9qgs5+b7K/XYPxcyAQ0egeiudr84Vj9IzEzwd/WKN33MN3LBClb9zDd9QXYWCcp2FvmOFxngY8IUZ9cT76xoKMjfPROxrEE4zr3TMSwDfOQfeQn8A4BwulkycYo3c0dZ2GvZGi0yndcXpzJJB/OmlRhiPWBfVmBvI6OiDbHtoHDhxAVdWi0indcRocHERV1azolI7XedY9pk466SSuueYa3vve97J//36OOeYYLrzwQl588UXOPfdctm7dms3DLzgSHlPZeLOq6zp79+5lxYoVGV0oFxIMDgwOEjB4WDgOdo/uptfXS2NFI1te3ML2ge2c2HgiV500dyn4scgYKirH1R2XkSp8h8M4DwwOEsgWD5mc17O1JlKUyR5Thw4dorW1lW3btrFhw4bkfldffTVPPvkkzz//fErtbty4kZdffplAIEBNTQ2//OUv2bBhAy+88AKf+MQnkm9g//Vf/5VPfvKTk35733338eqrr3LLLbfM2P5CeUxFo1G2P/c0tvBgSXtMAQyNBal1OTCr+eExNeqLUFdpZVm9c0G8ViSw59AYy5tcWMyl6TEl5TgHzS4sptL0mBLjHKxodmE25ZHHlO8QouVEcDYc8X0vFU+cWCxGZ2cnK1asSL4gKjWPKU3T6OzsZPny5cmXWIWuU7rjdHhVvkzqlI7HVNYNUy6Xix07drBs2TK+/vWv8+c//5k//elPPPvss3zgAx9IWvGKBdk0TB3uZleKMDgwOEjA4GFhOPBGvewc3Em5pZwuTxfX//V6VEVly7u20Foxex6ciB7BE/awqnYVTeVNWemfcR4YHCSQLR4yOa9na02ULcPUQiNbaygpJV2vb2esdy/OhkUZa7fQkDBEJYxY+YBhf5ildRU0VtoX5HgJ40HC8FCKMDjIUw60CIS90L4BbFOroWYDxvrB4ACyy0E683rWQ/kSigI89thjnHPOOQC0tbUlXcUMpI4El6UMgwODgwQMHrLPQZ+/j5gew2qy8uPXfwzAmYvPnNMoJaRgNDRKq7OVxrLGrPbROA8MDhLIdx4Wak1UV1eHyWRKhhwkMDAwQFNTdozE+Y4sv4ctGOQTDfFLQcFuyVqR8OmPm08k5AgGB3nIgRYGy8IlPk8g3+fNhYDBQX5wkHXD1IknnshXv/pVfvSjH/Hkk09y7rnnAvF4w8bG7D6sFBuEEHR2dubFiZMrGBwYHCRg8JB9DrxRL4PBQarsVTx36Dk6PZ3YTXbet/J9c/52JDRCta2a9sr2rL6BMs4Dg4MECoGHhVoTWa1W1q1bx+OPP57cJoTg8ccfn+RBVSoQQjDk9uW6GzmHBEa8IfLlcTyq61jNKnZL1h9HkhAynkMo34qxLSQMDvKUAy0MdheoCxeSXwjzZvAllqEAAQAASURBVLZhcJA/HGT9FcXWrVu55JJLePDBB/nSl77E8uXLAXjggQc45ZRTsn34ooLJZOLoo4/OdTdyCoMDg4MEDB6yz0F/oJ+oHsVpdfKzN34GwPnLzqfKVjXr7wKxAKqisrRqKTaTLWv9A+M8AIODBAqBh0yuifx+P/v27Ut+7urqYufOndTU1LB48WKuvPJKNm/ezIknnsj69evZunUrgUCAj33sYxnVqRBgMploqnPhfnNg7p2LGKqi0FC1sN4YsyGmSewWE1bTwhmmTKrC0a1VC3a8fITBQZ5yoMfAXrWghyyEeTPbMDjIHw6ybpg6/vjjJ1WgSWDLli0lnaR1PpBSEo1GsVqtJR0Da3BgcAAGD5BdDrxRLwOBAVx2F48ceISh0BDVtmrOXXrurL/ThIYv4mNF9Qqq7dUZ7dN0MM6DEuZA10CPxv9iIeSBbWgBN+bGlSjtpy7oW+dUkck10UsvvcQZZ5yR/HzllVcCsHnzZu677z7e//73MzQ0xHXXXUd/fz9r167lj3/8Y0l6q0spiWl6XoWx5QJSSnQhMalKXtwrorqg3mllIbsipSSqCazm0s4nY3CQZxxIAShgLV/Yw5bq+mECDA7yh4OFDeqeALt9YZIcFhOEEBw4cCCZMb8UYXBgcJCAwUN2OegP9BMVUazCyq/3/hqAi4+6GLt59nv3cHCYxvJGWipaMtqfmWCcB0XKgZTxt8cJw1PiT4tCLADRYDxRrIhB9zbYcR9KaBRL4veVLXDW12H1/8ulFiljPmui008/fc68SZdffjmXX375fLtVNBBCMOoNvHV+lCgkMOaPUFNpJx8evyQSh3Wh80vBgSE/y5oqMeUDCTmAwUEecqBFcpZfqujWD2nC4CB/OMhKVb6amhr27NlDXV1dSvsvXryYp59+mvb29kx3ZcGRzap8BgwYMLAQ8EV9vDz0MnaznV/t+RW/2/872pxtfP2dX0dVZg65GIuMYcLEcfXHUW5Z2Ld+BgoMQkwwOMVAj4x7PoUhFoz/6bH4n4i9lbFZAVQLqGYwWaDnefjzV6c5wPiTxj/98IiNU0c6r5fymihdZHMN1b1rO+4391BRX7pV+fIJui7xhGOsbq7Eac/Ze3IDBvIDITeYbNB+CgvqQmjAQJaRzryelZlgbGyMhx9+GJfLldL+IyMj6Lqeja4UFaSUhMNh7HZ7SbsaGhwYHIDBA2SPg/5APxE9QkzE+GP3HwH44KoPzmqUiugRolqUVbWrFtQoZZwHecrBxDC7iYanaCju8aSF39pHxEgakhQVTOa48clkAYsj/n+6c0/o8Py3Z+iAjLf5x2vg6HNzGtZnrIlyDykl0ZhmhPJJiaYLzKbchy9FdTGe+Hxhr00pJeGojt1qyjkHuYLBQR5yEAtDRdOCG6Xycv2wwDA4yB8OsvaKYvPmzdlqumQhhKC3t5eOjo6SdjU0ODA4AIMHyA4HvqiPgeAAldZKvvfK99CExjG1x7C2fu3M/ZCC0dAoiysX01i2sPlrjPMgBxxMCbMbNzxNDLNLGJy0GMgJRhbVFDc0qWaw2MBWEZfTXQhpEdj/FwgMzdZR8PbCgW3Q8Y55qZopGGui3EIIgccfojTvEG9BAt5glGpn7kP5oprAabdgWeA4KiGh1x2ko8GZHyFcOYDBQR5yIHSwL3ykjbGGMjiA/OEgK4apXJcaLFaYTKZkBZ9ShcGBwUECBg/Z4WAgMEBEjzAaHuXZQ88C8KHVH5r1DcpIaIQaew3tle0L/qbFOA+ywMGUMLto3PB0eJidGPd4minMzloOdnP8c7qQEsJj4D0U//P1gfcQMiEHhlFSLXrvz20lNmNNlHuYTCbqq524A3257kpOoSoKtZWOXHcDgJgucNoX/gHIpCosbyrtVBsGB3nGgdDiL20WOL8UGGsoMDiA/OHACOouIEgpCQQClJeXl7SrocGBwQEYPEDmOfBH/fQH+3FanPzv3/8XgNNaT6PD1THrb0yKiQ5XBzaT7Yj7kC6M82AeHEwJsxs3PB0eZicS+Z3GfzcpzM48e5hdKtCjCE8/wnsI4e0FXx+Ktw/FdwiTvw9FC0/5yUTtdNWCScTmPk5F6VWhMzAZUkoiUSOUL16dUGDJh0pkCtitC2+YklISiGiU28y55yBHMDjIMw60CJgdC16RD4w1FBgcQP5wYBimCghSSgYHB1myZElJXzgGBwYHYPAAmeegP9BPRIuwP7Cf10dex6JaeP9R759xf01o+KI+VlavpNpefcTHnw+M8+AwDmCaMLtxOeqfHGanx+IlqqWMW3yUCWF2ZhuY5hdmp4l4SXpdF4jQGMJ7CMXXh+LtRfX3o/r6MAX6MYeGUZHMZNaSKERttUTKGomWNREta0QrayJW3oxe0Yy0VtD6p49TFh1BnaaLQkKkrAlH+ylpMmqg2CClxBcMz3iulRL84RjVFQv/EmEiNE1iVhXs5lwYpmDQE2ZJfUXJ5pg2OMgzDrQw2JzxeXeBYayhDA4gfzgwDFMFBFVVWbp0aa67kVMYHBgcJGDwkFkO/FE/A8EByi3l/GzXzwA4q+Ms6svqp91fSslwcJim8iZaKloy0oe0ocdQIz6W1pjBc5DU3CFS2CeVdmbbJ/ndbO3IDLUDKrC0TELfzsPC7MYNTzA1zM5SBnZLSmF2QoAu48YmTQqEDpoUceNTLAq+fqT3EKqvH9XfhyXYjzXYjy3Yj0mf6vU0EbrJTrSskVhZE1p5M1p5E7GKpvjnsgakyTrt7xRACMn1sY/wdW5HSCYZp8Q4ZdfHPsKNqCWfW6jUoaoqdVUVuP257kluoSgKNU57rrtBRNOxmUzYcmCYUlWFpY3OBT9uPsHgIM84iIXBlZsqrMZa2uAA8ocDwzB1GHp6evjwhz/M4OAgZrOZ//qv/+Liiy/OdbeA8Td+Ph9Op7OkLboGBwYHYPAAmeVgIDBAWAvz2shrvOl/E6fFyQXLL5hxf0/EQ7mlnA5XB+b55BCaD4SIe/1EfPHSysERZMSPL6zjtCmTOUiIKYXuzLBTSpxmaJ+Uhm86tyCBHNxFyO/GUVmL0nR8PKm4xRE3Os1QjS7p1aTp8f9CJo1PupBENZ2oLonFdGTYiznQh3mCwckWGqA8NIA1PDJnrqeYo27c8NRErKyRWHnc6ylW3oRudc27CtHzhzR+GT4Jr3oFX7b8kBZGk9/1U8v1sQ/zp8ha3tM1yoZltfM6hoHigJSScCRmhPJJSSSmY7PkthJZVBfUllsx5cCFTUqJLxzDabeU9trB4CCPOJDxQiC5OLKxljY4IH84MAxTh8FsNrN161bWrl1Lf38/69at45xzzqG8fOHjfg+HlBK3201FRUVJXzgGBwYHYPAAmeMgkVvKarLyyz2/BODCFRdSbpn+vhfRI0T1KKtrV8+4T8YQDcYNUWEPBAYhGojnYzCZwVKOLK/HHY1QUVmOMl08Vx7iSB2ykvt0PYX63DdQAkMkUqbKsnrCJ3+G2KJ3oEkdXWhxTyddEtUEMV0S1fWkIUoIidRiWMKD2EID2Mf/nMFB7OF+bMEBTHpo1n4Iky1ubCprGjc6vSVrZY0zej2lAl1IBoOSg16dHq+I//ni/8cicZL+JNbzaORE1qtv0MAYg1TxgjgaMR64Neib3WvLQPFDSkkgHM15Jbp8QCiiYbPk1odQE5Jye24eQaQEtz9Khc2S+xCuHMHgII840GNxb2brwic+B2MtDQYHkD8cLMis0NnZyb333ktnZyd33HEHDQ0NPPzwwyxevJhjjjlmIbqQMpqbm2lubgagqamJuro6RkdH88Iwpaoq7e25cfXMFxgcGBwkYPCQOQ4S3lLPHHqGscgYDWUNvHvJu6fdV0jBaGiU9sp2GsoajvjYU6CN50KKeME/FP8fGzeMWMvA7gKzjYgmCIWj6D07sHqH6RmoIli7Op4nCVKKlEtgpl3khG+OxNMiYxGGE3Zy9f+V9r99fepOwSHsf7meg8f/B6MNbx//ocASC+II9+MID+EM9WEPDWANDWANDmAJDaMwe+W4mL123ONpgvFp/LNuq5q311MCoZjkzXGD00HfW0aoN32CWApF7QQqz4nV037XkAehSxNRSGuiYoGqqtS6ynH7ct2T3EJRFKpzfD1IGb9d5CK/FMRDuNrrc+Odki8wOMgjDrRw3MM52y/5ZoCxljY4gPzhIOuGqSeffJKzzz6bU089laeeeoobb7yRhoYGXn75Zb73ve/xwAMPpNXeU089xZYtW9i+fTt9fX385je/4YILLpi0z913382WLVvo7+9nzZo1fOMb32D9+vVp93379u3ouk5bW1vav80GpJR4PB5cLldJW3QNDgwOwOABMsNBIBagP9iPRPJ/nf8HwD8f/c8zhueNhEaosdewuHJxZngXAqK+uFdUcDT+FwvEn17M1rhXlL2asC4IxwRBn4Y37MXa8wyLdn0PW2Qk2VTUVsubq/6FscYNk4+RqUi6DGGuY81Jq9Rp2fXdadtSiNu4lr9+F8GhZ7AEB7AE+jFpwVmbFCbbW2F2ZW+F2sW9nhqQGai4KKVkJCzf8nzyirgnlE8wFJzZMmdRJW3lksUVgjYnLHaqLHJZaaoq47I/BhgO6tP+TgGaXHbWd9Qccd8zhUyviQykBiklwXDUCOWTknBUx27NXShfTBdYTSr2HHltSSnxBGO4yvIhhCs3MDjIIw5iISivj3uB5wDGWtrgAPKHg6xfBddccw1f/epXufLKK3E630oyd+aZZ3LXXXel3V4gEGDNmjVceumlXHTRRVO+v//++7nyyiu55557OPnkk9m6dSubNm1i9+7dNDTE3+6vXbsWTdOm/PaRRx6hpSWexHd0dJSPfOQjfOc730m7j9lCIv6zsrKypC8cgwODAzB4gMxwkPCW+t3+3xHRIyyvWs7bm98+7b7+qB+TYqLD1YFtvoYKKeMJupPheUPx8Dw9Gs+JZC1HlDUQFgqhmE7Qr+EN+wjFdGKaDopCw/ALLN35P1OatkRG6Nj5dfrWf5FAyxFWYpMSpIYidBShoYgYitBA6klZmSgLDcb/K1KbdVu8ncmfE/sgYpOPKTWY9FlHjQUxR9wzdl0BTFoIZ99fJ23X7DWTQ+6S3k/NGfF6SiCqSw75xWGhd3EvqODUqTeJKqtgcYWkrUKyuFKhzWlmUbWduqpKVGsZUrUizDakyYZUraAoXPauYW5++I1pOQD48vmrMeVRiGem10QGUkPcIBPLdTfyApFY3DCVK0Q1gdWsYjPnpkailOALxah0lHYYm8FBnnCgx8CRm6rGYKylweAA8oeDrBumXnnlFX76059O2d7Q0MDw8HDa7Z199tmcffbZM35/2223cdlll/Gxj30MgHvuuYff//73fP/73+eaa64BYOfOnbMeIxKJcMEFF3DNNddwyimzP9xEIhEikUjys9frBUAIMem/qqqzyooST9w7k6zrOqqq0tbWhq7rSCknbU8ca6JsMpmQUs4oSylRVXVGOdW+H6lOM8kz6bRo0aLksYpFp3THadGiRcjxV7/FolO64wTQ2tpaVDqlO04AixYtmrdOYRHmkP8Q3oiXPx/8MwCXHH0JiqLEzy8JihqXNV3DF/WxsmolLqsrvXNPi6LGAoiQB4KDqFE/IhqK62EtJ2ZxEbaohGMCv0/DF/YT0QQxXaAANosZu1ml0mZGUQSLn5ndW6hp+634e59NGo4QGqrUx40+CYPSBGOT0McNRwkjU/xzocOz6AwCi95B1NFIrKwBLI7kfSM5xhPl8Xll1n0myN6IpMcnkvmf3vTFc0H1B2SyKt7hUBVJS9m491OFwiKnQnuVlebqcsrLnSgWO0K1IUxWMNuRioomJcr49URSFiAlpyyr45qzjuK7T3bSfPANaiI+Rm1ORpau5trzj+HdqxuBqedquveITCHTayIDqUFVVWoqy3F7c92T3EJRFKoqFr4k/URENEFNuT1nxgBVVWiry316jlzC4CBPOEi4cFpz14/Es2Upw+AgfzjIumGqqqqKvr4+Ojo6Jm3/29/+Rmtra0aPFY1G2b59O//5n/+Z3KaqKhs3buSvf/3rLL98C1JKPvrRj3LmmWfy4Q9/eM79b775Zq6//vop2wcHB6mqqkouNBsaGhgYGMBisVBXV0dfXx8Oh4Oamhp6e3txOp1UVVXR09NDdXU1lZWVdHd309DQQEVFBV1dXTQ3NxOJRBgaGmLJkiXYbDb27t3LsmXLUFWVvXv3smLFCoQQdHZ2cvTRRxONRjlw4AArV64kHA7T29vL8uXLCQQCDA4OsnTpUnw+H263m/b2djweDz6fj7a2NsbGxgiFQrS2tjI6OkosFqO5uTmjOrW2tuJwOOjs7KS9vX1OnVauXMng4CAej4ejjjqqKHRKd5za2tp48803kVLS3t5eFDrNZ5z6+/sJh8MsWbKkaHRKd5y6urqw2+00NzfPSydrs5VQOMQvXvsFEsm6+nU0RZoAiIVjBN1BqlqqiAajDA4P0ra4jQq9gt7e3tl1GhyAWIgGp4WB3h4sWoA6W5Q+j47DbsVZ6aQraMZsMUEM+ka8YAJVUQhFNCrsVirsZrzBCJVlVixmE96BN6mKduHq24YlPMJMUABFj1DZ+2RK9/x0IBQzqGaEYkaqZjBZ0FFBNaOYLGjSBKa4HJMqismCarYQ0VVMZguK2UJYUzBbragmC8EYWO12FJMFf0TgcDjAZMYXFpSXlyEUM76IoLKiHA0VX0RS6SzH7N5P86vfnrO/fQ2nY2paRzASIxYVuCwQjGgIIXGWWQmE4x4kFQ4r/lAMVVUot1vwBqNYzCplNguj/gieqMpQRGH3UJSBEBzywwGvji8687HLzJJmh6SjUrC4UqHSorC6uYLGqgp8gTA1jS3EpIp3bIyqlqVo0TAj7iGqqpqIhYMEx9y4GlqJhQKEAx4q61qIhvxEQwGctU1EAj60aISKmgbW73+edzzyLdSRt84L875GrMs/zWjLPxzxfa+rq+uIz50EFnJNZOAtCCEIhCJGKJ+UhKIaDqs5Z2/FpZSU5dBjS0jJWCBKVbkVtUS9IwwO8oQDPQJmG1hyk/gc4vfGsbExqqqqki8uSw0GB/nDgSJldqfpq666iueff55f/vKXrFy5kh07djAwMMBHPvIRPvKRj/DlL3953m0rijIpx9ShQ4dobW1l27ZtbNjwVo6Rq6++mieffJLnn39+zjafeeYZ3vnOd3L88ccnt/3oRz/iuOOOm3b/6Tym2tracLvdVFVVZdRrBaC/v5+GhgbMZnNBengciddKNKbxQrebPT39rFzUwCkrGlEVClqn+YwTxM/1pqYmzGZzUeg0n3HSNI3+/v5k+G0x6JTuOE3kIHGcVHUKRAK8PPIy+8b2cctLt6AqKlveuYWW8pakl1TCY8odcmPCxPGNx1NmLpuqk6IgIn6I+FAjXoQ/Xj1PFRrCZCaqOohix68J/GGNYFQnHNURUmJWVSwmBZvFhMUc50zRwjg8+7CN7sbu3o3DvRtzeJR00NvwTkLVR6OazJjNFszmuFFJquP/JxiXhGIa3x6XmbhdicsSFcZ5T9WjaDpZSBk3ns0gQ9zra6KsjreRlIVGxyMfxxwemTZflQQ0Rx1d//hdFNWcUr+C0XjIXcLrKRGC1ztH8vFGh6CtXLDYqdBWaWKRy0JrTQXVlRUI1Yo025EmO1K1gJpITD+dB1S6crxT2pN/wf7VL8X1mNix8QeNlq2349q06Yjue263m5qaGjweD5WVlTOTkQKyuSYqBni9XlwuV0a4ngghBH9/6VnE2Js4GxZlrN1Cg5QSbzBKZZk1J4YpIWAsGGV1SyXOHFXlE0LSNxakuaoMNY/CfBcSBgd5wkF4DBQztJ8KOTIGCCHo6+ujubm5pI0yBgfZ4yCdeT3rs8JNN93Ev/7rvyZD0FavXo2u63zwgx/k2muvzfbh08Zpp52WXMCmApvNhs021S06MagTB/dIZJMpvqA//I1qYvtMsqIoM8qJRclM8pH2XUoZL0ku4pW8xPhnIeMTgpDxcuVSMr5fXNaEQBeSmC7QhEQTgmf2jnDftm5GA4lX9D3UV1i56t1Hcc7xzZQpKiY1+zrNJc81HjPJ6Y7TokVvLayLRad0x8lsNk/ioRh0SleeiYNUdBqMDBKIBfj13l8DsHHxRlr/P3t/Hh/ZVZ174999hppLJZXmVndLPXk23Z7xwGDHYDBDgEBISMCx7+VNcoGX/JwETG7CkHsTSEy4TsCJEwjg8BJiwmVIGIyDjQewsbFNg43tdg+SWq3WrFLNVWfY+/fHqaqWuqVuqVtSlaTzfFzW6lOnztnr2ftM66z17Pix84sQAgSUnBK2tNnVuotoZdYYIQQ4ZbRyFkoZyI97tl0CTcMWIYoiTlHoZAsO+bJD2ckjlcTUdIKGRnMkgK4LUJJA9gihcS8IFZreRyAzeMIscUpoTId6GXSTXGw9dYLPx+MPj7ycnxyeO0tbyICQLggZEDYEIWO2PWuZDiFTzFpXETLceX8T0sHUj/X3HP7msbVF2LNvkau2EOKYrRlMvOR36X7iL5HA7FsIWfnNxIX/D6IiYF/dv1KKqaLi8HG6T0MZyUTx5OLjW6PHhMe3NGlsbomwKdlEIOxpPyk9iDSCoJkAHF8IOV/QyBtjS7NtqSgUbYqWi3Rtev7hjhO37zkLQjD+8U/QdP31aLPG/pmcI84Ua+2eaL1A0zSa4xFS6Xq3pL4QQpCI1q+Uz3JcT1/KrN/Dn6YJepJ+GZvPQQNwYJcgsbVuQSnwzo0bPVvX56BxOFjxwFQgEOCzn/0sf/Znf8azzz5LLpfjoosuYteuXcu+r7a2NnRdZ2xsbM7ysbExurq6ln1/J0M1uLXcGVOpVIpEIrEiGVNCiEqASKIQOK6LVKAQSNfFkQolBNKVXkAJgetIXCVxlcCyHRwFrlI4jsSR3pt7KV1cBSBwpYtUApTAVS4gvGwLJUEJhOY9qGpCQwjQgaeGZvjMDw+ewPFEzuKDX3+Gw1M5rjmrk0TYIB4yiIdMQqZGQNfWbcbU1NQULS0tGz5jKpVK0draWhsTa92n08mYqnKwlIypgl3gaOYo+1L7OJQ+RNgI82tn/doJulJSSlKlFL3xXtoCLVBMoUpZVH4KrTyDtPIoJbFEkCJB8m6YXNElbzlYThEAU/NEblsiAYRQ6OU04dSLBKdfIJR6kVDqxXlnjMuZrRw0d/Izdyf3F3bwpN1HsRhCQ/Kj4P9LF9PM95JTKhillWe0cwgJKM2SByo5UHIUlME7Oy0PDM0LUIUqgauwQS2AFTIE4cp3YVMQrNgRo2pDxNQI6BCprB+sBL6CuvcgeULGlFJ8z72UJ6w/4CPmv7BJHMsmG1WtfMx+J9syF9PuWAxl1bEAVFZSPIl0VktVfDwOW+I6W5oD9LREaU3E0ANhXGGijJCn/VQJ/DhCoKQ8lk02jw0cmyO+Yi82M8pxJUXLoehIbEei6xALBNiSDBJ5bh/5qYmFHVIKZ3SUwpNPEb7sUuD0zxHLhdW8J/JxDFJKcoWSX8qnFIWyQyRYn1I+y1VEgt79Wb0glWI6WyYZD27oMjafgwbgwHUgFD/1eisIKSXT09Mkk8kNnS3kc9AYHKxaHu3WrVvZunXriu4jEAhwySWXcP/999fK+6SU3H///bz3ve9d0X3feeed3HnnnbUb2JXSmLJtm0OHDtU0pva9+CJ927YDgoMHD9C7fQeO63K4v58t23ZSKpcZO3qE7q3bKBaKTE+M0bZpK/l8jvT0FLH2TRTzOYq5DMHmTqxCFqeUx0i0YxeyuFYZPd6Kk0ujlIsWbUHmZ1CAHmnGzacQmo4ZTeDkpjDMIGakCTszjhGMEozEsTKTBCJNBCNR8pMTRBJJAqEQmfEjxFraMQIhUiODNLV1o5sBpo/209y5BSE0pkYG+MoTJxeE/coTh7lieztHxmew8ymCLd0YbgnDKbB1ay9uOYdbLrCjb33oMW3ZsoV0Ok2hUNhQGlPtHZ0cGRnFciThJq/txWKeTsvEyk4TCYdpSSaZHhshkYjTmmzh6JHG9ulM+2lwcBBN02htbV2STyPZEaaHpvnGkW8AcH3b9SSCCeyyTW4yR0tPC3bRZnz0KB1tQZKpNEcOPURv3CGVs0hZOsmmMKOFCOmii2Hq5IveQ188EsR1JCFdoykocMb2Ecu8SCJ3kMDU8wSL4yccw5YIMmhu5+dqJw8Wd/BTZydjpeScdQwBu5o1WsM6Hxt9F/9g3oFUzAlOVQW3P2a/k1svNXn59ihl22EyaxGJhMgUXaYLNsFggHTRJVNyMUyTTMkhZ0nQDHJll4ItcdHJWy4lB2wlyFuSsgtlF4qOouRQCbiDIyEnIWcrljPgBRDUj2VnmZoiFtAJaJLnphS2vJz/Kl/K5doLdDDDOM08Ic9BosHe+QWgNKHoCiv6mhRdYUFPXGNnR4ymkEFTJEy4qYVMNo8eihKKJ8lOjVIKeOfyzORRQtEAAVOQmThKpKkFMxQhPTFcO5fPjA3VzuWp0cHauTw1OkhLVy9KSWbGhkhu2oZ0bDKTI7R09+LaZXKpCRIdm8nl8mRnplDxdoRdRLcLdPZsJijLKKvIzm1dpGdSpI8sTvvJmZhoGI2pKlbjnsjHXLgLKfJvMMg68mC5Lp3zVBmsKhTYrpxbM73R4HNQfw6U9G5gzPpnrtm2P2Opz0FjcLDiGlNKKb72ta/xwx/+kPHx8RPK5L7+9a8vaXu5XI4DBw4AcNFFF/GpT32Ka6+9lmQyydatW7nnnnu46aab+Md//Ecuv/xy7rjjDr761a/ywgsv0NnZuWx+LYRqHeVya0xZtsNj/dP88miGuKmzqytey2SSUCmPkyi8hyUlvYwm7/8ShA6zsjfAe0DRNR1RsTVNRwMEqlK6oNA10DXP1gQIcUzb46T2Kd6gz7algkLZpmhLSo6kWLGLtsuLYxm+9vTRU/L+l2+6gAt6EqAUEkHRcijZDpaX8kXAEESDJs1hg1jQJBoyCRsCo5JVtd6zi9aaT2XboWi7WI4iX7ZIFx3ylvT61PHaf2giT7bkEA8bbG+NeNl2CHQBhq5hGjoGinDQIBo0MDVPxyhg6OhCEjAMgoaOUnJD9VPJLfGz8Z/xwOEH+Pf9/05LsIX/88r/Q8gMoewylAsIJ082M4JVTnN+pIsgIYoqRIEg6bKiZLs40jtXBAydkKljCjCLY4RT+whWSvKCmUNo8sQUnRGjh2fUTh4p7+Qpdwf71BZcjpVLBXXY0aKzs1ljV4vOrqTO5rggoHvni9/+zxyXlB8/IVvoaCVb6OngFdz9+iimrp2QaeSdo5bHdqQXpCo6ygtY2YqSoyi5XmZW0fYytoqOpOR4Qa1CZZ2yCwVHUa4EuYqz/paXKUFna9Tl3KRgS1yjpznA5mSMzkQMIxBCmSGkMFF6cI5m05mcy083Y8qWkC/bFG0HEAQNjVhQp70pTCxoEAlohAPmnOOp1N/Pkf/xP7D7B07Nw913n1HG1HJqTC33PdF6w0ppTAEMPP8UqSMvEmvfuBpT9cZkrsxZnXFao4F6N8WHj/rCKoBTgt6rwAzXuzU+fKwYGkpj6g/+4A/4x3/8R6699lo6OzvPOHX4ySef5Nprr639+9ZbbwXgpptu4otf/CJvf/vbmZiY4MMf/jCjo6Ps2bOHe++9d1WCUrNRC/4sg5bMvc+O8LH/fI6RdKn2XTIS4J1X9vLSba3ownvoEgJPZwmvdnp5U1OPbUsqQcl2KdqezkfRrnysBf4u8F3JdinYbi3QcCb4/KP9XNKbpDcZobc1yqZEiFjI0zpRSlF2vEDXYKGEVAUMQyNs6DSFDRLhANGgQSSgE9IaX49JSsnk5CRtbW2n1cZG88l2FcWy7Y2HskO66JCzHMqOi+14gtABwysHaw4HeXJwmn965BBTuWMZIa2xAP/Py7Zz1Y423Ioume0qb9t5m/GM5YlLC+/VmKELT3Rb0wgGBGHT639T1zB1jYDhlRqYKAxda1iNKYCJiYlaGfNi+mY8N85UaYrvDnwXgF/f/kZCpRlIzSDKORy7SNGyGLFLdAa3MFzooCQlrisRwq0EDUyCqkgo9SLB1D7C014wyrBOnIs9q8V5lp08Zu3kabmTX8jtZDj2hjBiwgUtOjtbdHa16Oxs0dgc9zTj5oMu4H9cHOLPf7xwttCHLw5hVkpFhBBzdJpYRtus6Es1LSYBQElQEqEUKPeYjUJUvvOWSaSUWK5XdldyhBfccoX3b1fw0wmdbw2ap9zlb1zey8vP6kDpQWrC48DsuNcxbo6Nqzm2tjw2s/hzpKJYsilYLq6UBAyNcMBgU0uYprBJPOiVYx9/v1D99/SXv8z4J/8GVSyenAAhMDo7iVx6yZy2nMl570yx3PdEPhYHKSWZvF/Kp5QiX7KJhsxVH3uOq9A1UVd9KfBKuCYzJdqaQhu6jM3noM4cOCVvNj4jtPr7noXZzxQbuYzN56AxOFjxwNSXvvQlvv71r3PjjTcuy/Ze+cpX1t5WL4T3vve9K166dyosl8bU9385xv/48tMIJC+d/QBWOIe/vX8/TVcN8bLNlQAMxx4yZmcIOFJhSW/WpbyjKDuCvC0rb+gFBVtSqLypL9iq8jCkKDiKgn0sI6BgU8sGWAkYGoQNiFTKViKmwJGK/SmvvzXk/CUrwIHxPAfG87VtmRpsThj0NQfoazbpbQnQ1xKgJ2p4uiUSSnmX6bRkQnmsBQ2DaMgLVEWCJpFQgFAlo0rTNaT03vILoVWCHBpCm7vclRJN0xGahutKNL1qL6/GVHWdRsrEWYxPtoSi5VCwHIq2ZKZgUbQcyi61MtigYRAwNJpDBgHDmJO98eMDE3zi3n0njJ2pnMXHv/cCH3rtOVy5LUlA1wgaC2dv2I6LXRHcz+QdpqWFC96+FOiahqGBYegEdEHY0IiGAgQMUcm8MrzgllCEAscCoPXImKqOicX0U76U42jqIA8d+j55O8/WUDtXqRj5Iy9go5F1TQpukDGrSLPejtBakQGIGYKoNexpQlW0oQK5I4jjytYcdF4UfTxu7+Rncic/UzsZUh1Uz0xNAcGupFYLQO1s0emOaXMCR7PP7wvNYHf1ZoMPXx3i758u85PiMYHz9rDg9y8Occ1mA6nUvNpMx+/npLZ0QSk0FEo6QNV2EUp6OanSCyYJUTkmlay0VyCo2gDCO18I71whhIaLAKFRnQ3Qm7nOwNVMhDAIazohdDRdx9ubhjBM9KMFvjU4cMJxcDwSTQmUGamMa3liNtQyZ78unBWrKFkOBVtSdlwMIYiETLqbgzSHTZrCASJmJUt31nmv2h/VY8gaG2PkQ39C4dFHAQjs3El4zx7SX/vaic5XjvWOD92G0PUzPu8tF5b7nsiHj7UCy3EJ6BohY/kCvT58rFk4JUhsnvPSxoePjY4VD0wlEgm2b9++0rupO1ZCY+rgoX4++h+HeLX2xDwlK0k+Zr+L2x+/jJ8O5Sm5kC4LXKBgQ84WlCUUHCi7K3PS04UibEBYh6jp6Z9EDYgFvIEVCyjiAUBBUwCaAt4MfckQNAWhbCvaI5AIQM6CzqgXnBrLQVvEO1eP5eD9jxpcYv10QQ4e0y/jt85y6M8IDmY0juQERVfQn3LoT80tIwrriq0xxc4ml56oYktUcUHSQUPgSomuuQxbXoZF3FQUpUk8pNERM5guabSENdqiJkMzLi1hjaawzsCUTUcsQCyk0T9p0ZMIEA5oHJwo0ZsMETQ19o8W2dER9XR+xgvs6koggYNjOc7ZnMRyJIMTOc7qaaVkuwxP5di5uZ18yWI8lWN7TzvZfIlUtkBvdztBu8jIoTG2dHcyk8lTLNv0dHcwncpgu5Luri4mJ6cAnY7OzlXXmDr77LPJ5IsMDAzSvrmPmUyOsbER9EQ3pUIBO58i0NKF7pShnKO1YxNuOY9VzBNv7qKUS2MVygSSHZRyaaTrEmpq5Z8ePlEEfzY++8ghzm+yCUVjBCNxstOjhKIJAuEomcmRmiZOYXrE08QJh0iNHKXtOH0zqQTTI4PobZspl22mjx7FaNmMa1u42XHMZA+atJC5FPH2zRjKws2n2LSlD7ucp5hNs2VrL6VclmIhS98KaYEdPnyYjo4ONE3jwIED8/fTC8+xo6cNzc7xzAvP0u/8jB+O/BiAVze9lIFsEGmHsc0ChjKQDmzWHc4rDBEe+iHN+YOEZvajueUT+D5CB0+5O9krd/AzuYvnVC8WXqAuGYKzkgZXxhQ7WnQu6AgQUBYBUycSNJnJlQmaXvAolS0RDhqEAgapXJlYyCRg6qSyJZoiAUxDZzpTojkWxNAFk+kiV/WEeekmgx8PFHD1AC0hwaagRVezgeM4zOTKtDeZOLZDpujQFtUo2y75sqQ17JXQ5S1Fa8j1SvBcjWRQkrfBlhrNQUnW1nCVRiIkyFpeECkW0smWQOg6sXCQVFFimibhcISZvEUgGCQUDjOTzhGKRAiGIqRSKSKxBGY4TGpinFhLG0YwzPTYUU+PKRDyxl77QnpMW3Btq6LH1MmuTWGS4SGmiwsHTFqjJr0hL8u2nM/iWGVis46naHMbxcwMAJFEkkJ6Gk3XCcdbyKcmMQJBQrEEudQ4gXD0pMfT8RpT8dYuHGEwPdyPaur0spXSI3Ru3kZzOMzM2BDnbzsX6dgMDg7Sc9ZZFIvFk2q2NT/7S0Y+9jFUJgO6TuD1r0de+0pazzob+ZILyX36M6iJY0LoRmcngd//PexLLgFoGI2pjXJP1GjQNI2maIhUqt4tqS+EEMTC9SmjsxxFc9TEWCAbdrWgCUFHYmOXTvkcNAAHSkEgVr/9V6BpGh0dHfVuRl3hc9A4HKy4xtTdd9/Nvffey+c//3nC4fV/ElxOjalHD0xw9+c/wz+Yd3jrziPy+/v2H/B9efmi2qYJb9ansCnmZCWFDTFnedj0xHbDhiBiejNGhXXlfW9qhHRFxPT0Xqo4HZ2WhbIhqjZ4mV9HnnmEaw/+9YIcPLDjA/S+5OXHsomAsbxkIC0ZTEsOzbgMpiWHs95MgfOhOSjoS2j0NetsaxL0NWn0xEDDxbIlVBS7AoZ2TPPE1IiYOqZGRX8LL2OKygyHrkQTylvuestBeYLNVVt6qe1KyYrt6YNJVbW9GRI14eWmKFfC5POkZ2ZoSjSjd5yLFAIEaMJAAmi6N66UBkLUsi3QDDQ9gBQ66CaabnrZG5qO0AykAqEbCE33bE1HaDouopIFZuBKhWaY3vJaxpaXDVFyFUXbJVu0yJZdCpaDZXvtF0BQF4SCBgFdQxfMOxOX60qmCjZjmSLjmTITOcuzs2WOpIqkCqcW5muJmHTEQzRHTBJhk+awSSISoDlkkIiYtESDJII6sbCJrs2fEeINpIU1cZQQOK7EdlxcJbBdieO6uAiUVCAUhq5jCDA0QTBgeDOxmTrBgIFZ0cEKBgx0oTxO5snqmG3Pd45wHIfx8XG6urqOzconXdziDJqVg8Ikhcw0djHPdLnEU9mj/PvMj3i+dIC+wFbe1fE2wjgkC8MkM/00zRyiOd1PZJ6SvBxhfubuYK/ysqF+LncwRQKArqhgZyULaleLzo5mjWRYO63zwknPEUqiKRfllNGkjZAOynXI2hpNpgJR2QYCJXQ0zcsykgg0zUAKUMIA3UQJw8tQ0k2U0FCichzUspgMLz9KCG+58BT40A1UZZ166DFV7UcPTPKJ75+YPVjFba85h6u2J0+uH7WMGVO2VJ42YNnGBUKmTsTUaIsFiYdNoqZGOOgFLZeSKeqk04x+5KNk770XAGPzZlp+6x0Ezz+fYF8fgY4OL3PQdSk+9RST+w+Q3LGD+BWXo8SxMtozyZhaTo2pjXZPtFSslMaUlJJnnnoUNzVEvGPjakwppcgVbWLh1S/lm8yV2NYWo6up3qVLirF0kc5EGK3OQbJ6weegzhxIB3KT0PtSCLes7r6Pb4qUjI2N0dnZuaHL2HwOVo6DhtKY+vVf/3W+8pWv0NHRQV9fH6Y5Vxfj6aefXukm1AXLoTE1kS3yEfNfvOXHnTM14QVm/rf5BbqaO9jWYhI0PNHYYHXKcV0jZAovIGAITK3yoFG7Gan8nf3vin0sNCRmfV/9jUDZgD37+1nrVP6tjt/2cfvTZq2jz/q9XtueAOXy8qP/TCX2cgIHCnjFyOcZuPBqhNBre+qO6XTHdK7sOba+IxXDWS9g1Z92GZiR9KclIznJTFmxd9xl7/jcDISuqKAvodOX0Olt0tgUE7RLhSh5Ir0B3SVk6jSFDMIBg1DAS1M3NMHsZPVT2eIkdo3B/ocRj34a8hPULmPRdrSr3gd9LwPllRFVtWq0mpaNQlMuuBZYuVnrVJZT7Y9Z3KK8h3OhoVf+IjQEmifcLL1MvLzjZedZLpSVjhQ6mm5iGgbNpvdX03WU0EDoWI5iMiMZzzmM5hzGsxbjOYuxrMV4tsxUrlwLOJ4MJyvrTBXsRQWwNAGJcCV4FQl4AaxZdjWwlYiYNIcDBLSKxo0QFd0rT0h9IbhSVQJWiqLlki0qHFmuFb9pCAzdC1AZmkbY1AkHNMKmgWmIWVpXClPXahoI1XOE6zi88JPvMXP0ENMdPZx74WUoK0sxM0G5kKFYKpN1dPIEKasIY3aR5+1Jni8dQAC35m0u2Xs7sdxRb0zMbjuCfXKrlwlVCUQdVJtQePpPO1s03lLRhdrZotMUXPimbsn6TUiE6wWddGkjKgGo6reuMHEwKIkglt5MyQxT1CQzoSimYaAbBkblo1eCq0rTQejeOD4NHD8k55wRV1iPqWpXx17VvnpXOx/SxAl6a22xAO+u6K3N28al2gu00ZtkwgtAO67CMATRgEFvW4xExKwE8PV5H34Xq9mW+9GPGfmTP8EZHwchiL/61TS95gYC27YR6OtDC3kPuJqmgaYRufxyYjt3Ekt6AbnZe14ubb0zxUa9J2oE6JpghZQI1hTqEoiolDMHG6GMT+BpEG7MeIwHn4P6cmAXwQw1xIx8wAnXoY0In4PG4GDFA1M33XQTTz31FL/927+9oYQ+l0Njakf+53NK146HJqCdNB9L/wmkV9ihBoUAzOIkfff+DtKMoXQTpZkozaj8NVF6oGZ3awaXVJe1GagOExuTKUtnvGQwWjIYKeoMF3SmLAOraFAumDw7YvA0JhYGDibJWJBNTUE64wE6YwbdMUFHFEzNE82Oh0wiAZ1IwCAU8AJV1XvB2VPcS0UlY0otaCsF2uAjqP/6cM3nGvITqP/6MOpXPoa24xVelpTybjxlJfNEE8KbHlrMb4tKlsnxtpQSy3Eolm0sx6ZQdigUi9iuiytdlFIYSmLqgpgOLRo4rmSsCCNFjdGCxkhRMFbUGC0IxoqCyZKYFfScH6YGnVGNzqhGR8ykM2bSETPIWop/eCLFDScpbf2+vJzfe2kHbVGDdEmSKlikS5J0ySFVdJkpusyUHLJliVSzglhThVOOtYgpaAnpJEI6zWGN5pBGc0inJaSRCGm0hDRawjqJgEYsIAgICFXFrYWX/UYlmw4pkUohyxJHShxHYitJ0VWVTDRvfV3zAsq6EJg6hAI6AU0w+MyP2LX/c1xAhYPnYOzBJM/0/AbJs66gpIKgR4iqAsnMC4TTz9M3uZdvhnIQCvCGbI5rJx+v+TaqWviZ3MneyucZtY2SCLG1ycuAelWLxu+3aOxoMYhUrhrH60EtKRtKSZRroUkbTTkox0JTlexCJXCFgYtBiQC2nsAyI9jCROoBNCOEMEyMQIiAoZEwNTYFTWxXki95mXt5x8WxvGw2pSQKB10zvAw2XRCoBI8NgRc4nZONtPLZRcuRMYVSXLWjjcv7kjx3NE2q6NASMTmvK45hLL9PcGz2VMv1MkjDQYOOJk8nKh7yPizDLJdOscj4J/6K9Fe/Ckqht7WR/K13EHzJSwj09RHo7kbN2ubs62kymayNyeXU1lsurLV7oje/+c08+OCD/Mqv/Apfm6XltW/fPt7+9rfP+fdXvvIVLrnkEt75zncyPj6OYRj82Z/9GW9729vq0fQ50DSNWCREauFbqg0BIQTR0Oo/fFiuxNQ1Qkb9sxE0IWirc9ZWveFzUGcOnBKEk2DUf3ZKTdNqkyltVPgcNA4HKx6Y+s53vsP3v/99rrnmmpXeVV2xEhpTrcXDi9q3Y8ZResC7qa+WfCnpBT9michCpTzCs0CBEJXSpJoN1Xwpb53KbysP2KBq6QNizr/VrGWrD7OcgvLpi0d0z7fwZNcLG5iqfABL6diYOMJAVoJgaAaYARwjQAmdQDCEbgQouhrxaAR0k0wZWpqiuBiky9DaHMdROjNlRXtzE2WpkS5JOp/9J2DhFzvqx3dA2y5mihJbCTpbYkxlbZSm09EcZSxdxtQN2hJhRmYKhAMGyViQ4ekC8bBJLGxyaCxDOGhg6DqHJ3NemZuATK5MMKgTNExSRRdbC5O2NA5MlshJg/GCZDjjMFUSTJdO3f9BHVpD0BMTtIUULUHFtoQgGZAkTElfk6LkKGxH0Rx0yVvgKog1KSaCz/LX/O0J2+ximn8w7+A28X5+JfYSooYiElZMhTWihiJkKCZLGnFTEtRhJO8dBTkH+rM6jlJkLcGRvE7ZVcxYGhMlQc6GGUtgS0HBVhRsh+Gsc6JTx8EQiuagIhGAJlPRHlbETEXchO6IIqxDPACbYxJDeMGneADStheQjOmQssFwIWgqUkVwNIUtFIP7fsYbRj/D8QOiXU3zK0f+nn2lfWwxyjRlDxAsjNa+fzAc5qnmdgJScfV0G//oXMle6WVDTYgkXXGbs1sCnB/T+K1NIXoi4DgOyXiIkuVQLDtETZNi2aFsuzTHghQtB9uRJKJBCmUHKRXxSIB8yQYpiQckuYKFjkPccEgXBaauCJswVfay6UQgwowVg2AEEYhSLuYxYy2Y4QR2eoLmtg664lFSI4fZ1NNDNBJmqP8AO7d0EDANXnzxRQwVY1NHB/39R9lz9tlkC0VPu6hvB7l8nvHRURLtm0lncqRTk9DSRSabw85n0ZvakeU82CXCzR2ocg7hWjS1dmLn0yi5snpMTRV9s9ToIM2dC2lMbUM6dkVjqhfXLpNLTdDcuQVll+gN5tkeDWCGdAozYzS1bcIq5jzNttau09aYEqEYMxMjOFoIEYwg8pMkmlvY0ZEkMzFMT0cXLYk4Bw4coK2nB10L8OKLi9OhO+ecc7Asi8HBQc466yxKpRLDw8P05PIc+cAHcA5717/A1Vdjvf51RHbupNTayozrskXTSE1Pn6DZ1tnZyQsvvEAymaSrq2vZtPWWU2Nqrd0Tvf/97+eWW27h7rvvnrP87LPPZu/evQDkcjn6+vp41ateRSaT4Y477mDPnj2Mjo5yySWXcOONNxKN1jczQErJTLbgz8qnFJmCRVMksKpBUcuRlYz++mdMSakYmSnQ3RzZ0GVsPgd15MC1vMBUA0BKycjICN3d3Ru6jM3noDE4WHGNqXPOOYevfvWrvOQlL1nJ3TQMllNjSh56GO1f3nDKfQ5d/ZcU2y48cVY+BK5UuEp5tpKVLBpvP1IBwtNCqo4CVylUNcOjGoCa9TbfK+vytqdplWnYBRiV5boQmIYOSmLqYGgamvAyhHTN26guKqnkyhNQ13QQsrKO7mVVGICmgRz5Bfp9f3JKDqyXvg+7qRfXskDauE4Z1yrjOhaOVUa5VkWPxgLXRlM2wvWyNXTloEsLTTpoyqlkcXjlQ0Jalb92pbzIqv1uTUIcK2tSml7R0NGRQkOh4woNR+nYaNhKx1Y6ZalRkhpFqVNyNVx0HI7/q+MqDQcdNI2gYRA0dYKmTjhgEDZ1IkGDaNDwZuTRvI+srI8wajo/aPos+9hyIQStj/8VITvDfPfTUkHJbGbiyj+tZKFUFnJsdq9a0FXJY8dKxfZWV8eCqxVbKW+myqItyVqSnKUo2oqsJSlYirztCWbnbZe8pSrZJNT2JWYFbUXt7+x1vEkEoqYgano6cLGA9zdqQDQAEd3L2AoZkuSzdxNX+Xk5mA8H5CaeVjv4P1smyAULyKmX0WHfwJaES2/CpbvJIhyaZke0h65g2+JnsANwvVI7TTk1uxIPx0HgCANbGZRFCMuIYhNAGpWsJz2AFggRCgaIGN5b/KDp6XIFTa9M0hDeLG0nm2nQcRwymQzNzc0Ap9QuklLiKO9BqWy7uArKtusF3xxFvuzgSBdHgu1IQFbKWL0ZGU1Dx9AUpq57ZQDV/q1DxlTVVtLFKuYJRGKIyux/p5Mx5bieTlTBsnGl8o5fQ6M1HiQRCRCtHMenyi46nYwp17KY+MydpD7/eXActHiclne8g9DFF2Fu3Upoyxao/Gah6ylAKpUikUhgGMayZUwtp8bUWrwnevDBB/nMZz4zJ2NqNv71X/+Vb33rW9xzzz0nfLd7926+/e1vs2XLlkXtayU1pp7f+xPKk4MbXmOqaDmEA8aqBqamcxYdTUG2tdW/dEkqxUzeojkaqJXIbzT4HNSZg/QwbL4U4l2ru995IKVkZmaG5ubmDR2U8TlYOQ4aSmPqb/7mb/jABz7AXXfdRV9f30rvrmGwHBpTWt/V0LQJlRmZNxNJAVawlSOhnZAvMyd9ovJgoyE8HV+8B3VNiEoASUPXvRIhI2igVUpcdCEwdK22rvfxHkhrtgZ6NTBVXQ/BShzL+tYrINoO+YmFV4p2ELjgTQS0hd/EOVLhuApHSRzHC9bZrsRyFGXHpexIHFfiKE+Q3DlO6EgXohZk03WBgcAQbiWAZSMdi4lcmZG0xWi2zGS2zESuTKZgYeIQwCaAQ0B4f4PYJEyHtoBNW8AhGXBpC7q0BiVB4QXLNOUgXAty4zAzeGqyhFGJrpwkaKZcRCWr77Quw4t92SmBcuWz3Fig4ZqAiDND7yN/tAI7XSR0Fs/R8XArn8XgFJ13j/Nyvi2vYr+2nUQiAs0PkQsMEhJhbrvkEqJmDvAeUqacFG1mCx3BVu+hvLoLr/7QC8RWtZ4qwSfwQmo2GpYysDGxtCYsPYJrBJFaEGEG0c0QhhkkHDBpDuqETJ2gUdHOMryyV0Nf3IljIc0f0zRpbW2dS89JtIt0XUcHgobulZ4dB6UUliuxXYXlyMp5QlKyXQqW9/GEvm1s1wt2esE8DVPzzp+m7mmEGVVZvRXQmJptC90gFEucwMGxdebXj1IVnaiibVN2XAxNIxLQ2ZyM0lzRiYoGjHnfJi9Gj+lUdrU/SgcOcPQDH6T83HMAhC+6iMSv/RqBvj6CO7ZjtNRU9WoP0wtdN2ePhTO5/q6UxtRy3hM9/PDD3H777Tz11FOMjIzwjW98gze96U1z1rnzzju5/fbbGR0dZffu3Xz605/m8ssXN2HKYvHVr36Vd73rXScsf+qpp3Bdd9FBqZWEpmlEw0GsjfkMXoMQgkhw9Uv5XCTR4Io/ciwKmhAkY8F6N6Ou8DmoIwdOGXQTzMjq73seHF8CvxHhc9A4HKz4VeK3f/u3KRQK7Nixg0gkcoKw1vT0Bi/4Pxk0HV7zV4ivvqsys9ksPZfK3+zFv0dfW1PDBJKWHZoOV70PKvpK8+Kq93rrnQSGJipTFGsLlui5Ek/vR0oc15thrypeXXZcyq7EthW2qyhJF1eCQve2SQg9Kuht0tg2K8jnKsFwriK2nvaE1wdmXMYKygtClOa2QQCdUUFvk2Bbs855HSZX6C9w9k9uOyVV1mv+msnEBfSnbAZTFkMzJcayDpMF29NWKjqUbImBiy5cDCQ6s/+66EjihktbSNEWUrSGFK1BSUtQ0hJQNAckIU2i4XpBC+l6wa7KBym9v7V/V7+T3rI568va9xz3+9oyWdmPctGsDGbp1OcLx4yjjJDHppidu8SsB/7qd5XvZy+vrXds2Um/F8fpZtW+E1RTCuf/3muXq8CWeBk6UmBLKh+BVV3mKiwJbaS4UBs4JQfljou45aIraY04PJN7gU8PPQIu3NB2NVHzmKZC1s0TFgF6jBZMu1ARGj8mNu5KsDGw0bGFSVlLYukhMIIoPYRuellPgUCoJnbticIfCzwFdG1F0+SllF4JWE/PsrzlEcIT6A0awDz3rIsJXFmupGA5tcAVeFk4swNXhqZh6GJZ3tQqKcmlxom1dMwNcM3T9rIjKVguJdtFCAgHdJLRAMlogHjIIBY0Fh0sPFNIKUl98W4m/u7vUKUSIhSi+dd/nchLryCwZQuB3l60wOI1OJZ7LKwElvOeKJ/Ps3v3bm655Rbe8pa3nPD9Pffcw6233spdd93FFVdcwR133MENN9zAvn37atNC79mzB8c58WXGfffdx6ZNm07Zhkwmw6OPPsq//du/neDHu971Lj772c8u2p+VhJSS6Uz+xJkMNhiUUqTzFono6pXySQka3sQwjQApFcPTBXqSG7uMzeegThw4JTBCEKh/9iCsjevmSsPnoHE4WPHA1B133LHSu2hILIf4uZQSce4bEL/+L/C9D0L26LEdRNsRV/weLVuv9rSkhKiIaldK9ZSqlcV5QtpeyZJUoqZDJV2vpK5S8YGma8fEtqvi2QvZnL6odtV2paoF0eazoSIU3vcyuP5j8NhnELMzp6IdqCvfg+x9GTrMaftC9sl8EgKChoYpBZigCeMEn5QCF4Vle2WRjvIeTqX0HvhKtsRyXBxXUXJdXKlIGIrdrbA7CZrQ0TWDsgtHc4rDWcVQFgYyXuAqXVaM5r3P4yMSsNHYzI+CSbqYPmF2xipHo7Tyqv/oIO9OHvftiSk88cAxcfHOiKAzqtEV0+gIe3Y8qM0p3fLK2zzbUgr7uOVQffT2DFcdK4uTFY0yt1Zqc6yMtCayXsnuk7JSUioEslZidKykNJH6Jec//ZH5D7hZeOHCPyTTcr6XGaK8sKF3klVeULZSUlqzK/vRK+VP1YCuEszxr1retpBd5Wu5bFMpzOOWH963lwtf+LNTcrClq42emMZoOc3D0z8l7xZoM5p5afgsRDmNcB0saSNVga1GN5oqkxc6ZWVi6XFcM4bUTDACGIEQuhEmFAzSFja9jCddEAoY6AIChkbQPHnZlJTzl18tVYB6oRKxWCwGgOu6pyzlq5aCLWQv5pxtal6QKRac329bKsq2dx6wpaJkOZQd6ZXJlW0vOCQdLKeaIufNUWpWMshMDQxd9wJXcOpSPqUIhKPeM7eUc9ZxFOTLDkXbRiqNoCGIBXV6W2NEAzrRoEEkaC6rUPhiSvncsTGO3vYhik88AUDg7LNJ/MbbCW/bhtm3Db29rSZMv9h+EkIQi8Vqx0sjip8v5z3Ra1/7Wl772tcu+P2nPvUp3v3ud3PzzTcDcNddd/Gd73yHz3/+89x2m/eyo6oTdbr41re+xatf/WpCoWMB73K5zJve9CZuu+02rrrqqpP+vlwuUy4fS63NZDLAMt5DzbKDpkEZ5lzT5r2OUZ9z/lLt+fw4lU8C75wtlSe9sBo+lR2XgOEF5Kuap2d8XzjLXtQEMrNsISAWMirtbKB73TPwaSn3ul7fQDRkVPJ914dPS+8nj4PqkbFqPtlFVKwbTdMXfX5byF6r91Crfb+xGJ/i8fic364Hn5bST1UOqttZbp8WixUPid10000n/awX3HnnnZx33nlcdtllgCd+DjA5OVkTQB8bG6u9DR0ZGWFmZgaA4eFh0uk0AENDQ2SzWQAGBgbI5/Nw3hs5+IZvUv61L8PL/5ihy/4M68ZPQ/du9g9P4xQyyEKa/UemkIUZnHyK/UMTkJ/Cykxy8Mg45CcpzUzSf2QMcuPkp8cYODIC2VGyUyMMDQ9DZpj0+BGGh49AepiZsWFGjnr29OgwYyPDkB5mcnSYyYo9NuJ9R+YoI0ePMDPmLR8ePkJ64iikhxk6Mkx2wls+MHSE/OQwpI/Sf/gIpSlv+cHBI1jTnr1/4AhOahg5M8z+/iHkzBGclh3se+kn4dr/iX35exi65E/g9XdQajmH/iMjUJgiPzPFwNEJKKXJZtIMjU2BVSCdyTI8mQbXYiZTYGQ6B0oynS0zli56/ZQpMZnx0pfG0kWms96N8shMgZm8NxX78HSBbMkmoGtMZUuAIhkJUCjaNIUMtrVFMYViV0eMC3oSRAyNXZ0xzulOENQEW5MROhJBLMuhKaSxo0Xj4qTDO87R+MClOp+8WvEPrzL50GUGv3mW4PpenV0tAl3T+JjtlUkcV2FY+/fH7HeSd73DuSkAZyU1rtyk8as7dd5zcYjbLjf5P68I8H/fFONz1wf4xDUBPnRFiLfugOs2C/a0CWJY2LZNtuhwdLrAVM5iJm8zPJlnIlNmMldmaDLHRLbEZK7M4YkcE9lyzZ7MlZnMWQxP5UiXbDIli4l0kZLtUrIlqWwZqRSuqyiUbUxDoGveCbY5YhIL6AR0QU9ziLZIkKagwba2GO3RIK0Rk66zL8cJtS74wlsBbqQd0XkhnfEQfa1RQrogETFIxkxcV2LoYBqCXNHGlhJHKqayJfKWQ65sc3Q6TypvMZkvc3g8y2SuzES2zOGJrFeemfU4mM5ZTGXLHJ0qkCk6pPI2o6kihbJDpmAzkS5hOZJc0fb8llAsO2QK3lgqlB1yRa8kLl+yPbFwIFf0Zj8EyBQsipZnp/MWJctl864LGSN5wjiYPR5GaSXYvBkrc4TB6V/w08wvALg+dhlOIU7aDjCmEkw5nRC9lHLzlYwYmyn1vBRz68WY8U52nn0BO3q30hE1ufSsXs7ripAUWXZ1xmnSbezsFM2RAHYxx+T4GOBlSIyNjS3feQ/o7++nVPKOy4MHD2JZHn/79+/HcRyklBw4cICmpiZc12X//v0AWJbFwYMHASiVSjXx6nw+z8DAAADZbJahoSGP33Sa4eFhAGZmZhgZGTltnzKZDEFDJzU+giHLdDaFcDPjbIpp7N7STDtpXtId4bJtrXSR5vyuKOdtaiJWHqc5rGNokB47TKZYZjxdYGjgAEdnioymchwdGiBdtMnlC0yPHfGC4+Ui2alRgpE4TrlIenKUXMlhdGKaI8NHSBUtVDlHUhS4eGszO5tgc8imry2GKmXJpVOr0k/79+9HSolt2+z73D/T/6tvovjEEyjDIPG2txH7vd9jcssWwhdeiBWLMjg4uOR+EkJg2zZTU1PL6tNyip+v1j2RZVk89dRTXH/99bVlmqZx/fXX89hjjy3bfr761a/OmZ1PKcXv/M7vcN111/HOd77zlL//+Mc/TiKRqH2qZX/Leg9VsU1DRwiYzpRwKyfRyXQR6T3jMpkuei/tlGcDuFIxXbk3cFxJKuvZtiNJ5bz7hLLtMlOxS5ZLunLPULTO/JwPMJMrU7Y9O5UrV7TvIJUt4bievVifhBAETJ1U5R5nNXzKlxxChsZEpkS64K0zNJUnW1l/YCJHvrJ+/3i25vfB0QxWxdf9I2kc6T307x9JI5Un0bB/xOt3y5EcHM3U2ts/7o2BfNlhYMIrXc+WbIam8rUHp6Mpr49n8hYjM97MvKdzX9gIPgGkCzbD04VF+SSEoGy7pHLWuvFpqf0khGAmb1Go+LF6PjkMZ71j9UzvN9bjPdRy3m84jrMonwYHB2lubiaXy60bn5baT9VJ26amppbdp6XcQ62I+Hkmk6mJW1Xffi2E5RS3bAQsq/j5cZFHgCOD/Wzq6qjoQFUiksIL30slPVt5WSjHovfH3oxJJWuZIer4qHD17ZlS3lsIqWpTf0upgIrtVttefZvpZZgc86nSdqpvJ1zPD5jlk1cqp1F9IyGPvZ2o+eS1fbZPQikOj83Q0xrF1EBJG+m66Lgo6aJcB014vqnKWw6lXJTy9iWlW8mWUZ6NV0oz540LAN7shbJS8qVpeiXLR0NoGlIJhCYQorJc85a7ytveXFvHPe4tiwAcpbAdicS7IXRchURh2S5FxysPclzJDw/b/N3TDjdoT/AR81/YJI6VehxVrXzMfiffl5fzjnN1rt+qETLECW8tK4l0FQF6702RpmmVWRepjSFNA11olWwirwTSE7cXGLrujRlRGUOui6ZRm/1REx5nKIVugKgIjxtaRdgZMDQQSiGE1x9KycrY88qRFJ6wfjWLSoO5fTP0U8Sjd5wgsVQ9iYmr34/subQy9rT53yhrGk7leFIIHCnxJqT0JgjA+w9ZORakqr5VVkh5LBPMkdQywRxXeQ8Fwrt5UQpQXmaYBITimF2ZyVIxOyNMeJMAKBCV44lK+W317YGocD20/+dce+QfKpwc46AarLpv8/9L09kvY8TN85XJf2Nf4Tl6Qr38zvb/H8FgiGDAoOCmaAk1c0H7BUQDQQwNQgFzTb4ZcxyH4eHh2gPtWn/bp1Ql20p554Wy4wmxl2yHfMmh5CovK9NxcZWGVK7XhlwKFUt6OlEhk+aQQXPEJB4OEDE1dE3U/W2fm0ox9pGPkrv/fgDMLVtI/PZvE9q+DbOvD6OzEyMQOO1+Ajh8+DCbN29uKPHz1bgnEkLM0Zg6evQoPT09PProo1x55ZW19T7wgQ/w0EMP8fjjjy9qu9dffz0///nPyefzJJNJ/v3f/722vXQ6zVlnncXQ0BCBSsnlj370I17+8pfPEXf/0pe+xIUXXjjv9ufLmNqyZcuy30PZts3Pn3wULXuUaHvPhs6YSmVLJGLBY/eCK+zTVK7M5pYIPc3hSqZKfTNxAA5P5ticjGJUssc2WsYUqsJBaxRD19aFT0vtJ6VgcDLH1tYouq6tjk8CVHoYteUKtHhH3e83YP3dQ8HSs4tc12V4eJjNmzcjhFgXPi21n6ScW8q3nD4t5R5qRUr5WlpaGBkZoaOjg+bmZoQ4/jHSe6s2O+Cy3lAdPNW/Z2pXB1pLWwdGOF7jdHaR1ny2OIktTmHPTqdbCftUbZ/PVkqRDGUx4nEQYn6flEIoWdE1knNsrfIXpdCUqtizlx9nS9cTE5cumnS85dLxlisXL4ClvHVchY63bZREr+wHJLo63idBAAhUQyqiwo4QENQgJEBoOBIyJa9Hvi8v57/Kl3K59gIdzDBOM0/Ic5AVVl+2CV7S6gU+NOF6s3NV2uddkCWaqvLkBY0qcada+docVK/c3jxr3sfQvH8LQeWq7UVMoPJXHPveqPhT/bfQK78zKlEWHYGG0HQQGl7Qz1tHE8f2c8zW0DZfCm074IG/gNzosabGu+G6P4OzXuP1xzzjTVPHls8+8ZkL5WCpBZZ7X867VEqvxNOt3IRUSxVlxa7etEjlBSFd7x9IPDF+V3pvsKUCx3Wx5LH1q7+NXHIu3wm0cln/39PFsSDluGjl6XP+iK3X/AaGIXlh9Ae8ePh5AG7e/Tuc39qF0CBn5WiSMS5oPYfmUGxO+4WYKxRePc8sZC/X+e1k571T2YZhkEwmaxfA+fxYSz4JIQgHT64TZbsVnauKxlXJdslkdZriTcRDJtGgQcCYfxv16qfCgw8y8tGP4U5MgBDEb7yR+HXXYW7qJrh9O3oiUVv3dPtJKUUymaztdyV8Oh2s5XuiH/zgBwt+l0gkam+Oq7jmmmvmBApPhWAwSDB4opjbct9DGYZBLBykkGWOrttse3av1O6JhFjQps72Qn6czCelFJGQWVtntXwKHzeJwkK2vhh7llNVWwixoC2Os5VSJONB9MpK3qRAzG+for2N4tPx9ql8UlQ40Krn07Xv09L9ULTGg7V/r4pPdhFhhhDBaKUt/j3USvh0sslWFrJbWlpO4GAt+7TUfhJC0NLSUpsJe6V8OhVWJDD1wAMP1JTdf/jDH67ELjYkhBDrLsNsqVgUB9UgyGlPj7YEyGNBrBM+VANfauF1qh8pawEwVCUYplwM6XLNVofuaIbRvEKi8RN53lx3ga6o4NXbQuh6NRjkBX4QWuWjg1b5W12mGccCS7UAkjYr2LTQd9V/n2q9WUGseR7EThsXvwv2/BYMPgq5MYh1Qu9VnEoAfzWgVT7LeWKtBqTcSpBLKXDPvwDbfi9PPnkf5dRRIsnNnHPFDdwY8rIWhjJDfH/oGygUl3VdxgXt5wLgSIesleXslrNpDjUvYyvrh412XhRCEDCEF3ia/Tzf2hhCqsfDyeUY//jHSX/9G142ZXs7yZtuIrhjO4HeXgKbNyOWIHB+MjTqWKjHPVFbWxu6rp8QOBobG6Orq/5TlK82hBCEgibFZbwUrUUI4ekDrhZc13s7HzQXDravNoQQNIWX55yzVuFzUCcOnBKY4YaZkQ8a97q5mvA5aBwOVuTq9IpXvKJmb9u2jS1btpzwhlApVat59LE4SCkZGBigr69vTlRyI6HhONCqoYiVgw585E0j/P6Xn67lLlVRPao+8qu70bd3zQoQrXNoOrL3am8s9DbIWFghVN/AzX5rB0DQ4OKXv+GE46HklLj/8P08N/0cutD5zXN+E/DOuZPFSbqj3WyKnXq2rbWChjsn1AGNykH+iScY+Z9/il251kdf+UqaXncjZmcnwe3bMdralnV/jcpDPe6JAoEAl1xyCffff3+tvE9Kyf3338973/veZdvPWoGUksmZHNrJEmE3AJRSpHJlWmLBeTP3lhuWKwkYGiGz/i+OqpBSMTCRo689NieTZiPB56BOHNgliHU11H16o143VxM+B43DwYrvedu2bUxMTJywfHp6mm3btq307uuGaip7tW7zVHa1Jn8hu5re39HRccLyas3o8TZwUru6/4Xsxbb9THw6mT2fT0II2tvb57R3rfu0mH56zYXd/P1vXUxn07GZjwC6EiHufMdFvPqCbi9Ycxq+1sunM+0npRRtbW1U65rXg09L7SelFO3t7bUSIKUUY/kx7tl3DwC/svVX6I50ew8jpRRRPUpfUx+a0BrWp6X2k5SS9vb22vL14NNSx55Sio6Ojtq+6u2TWywy9om/4vDNt2APDaE1NZF873tp/rW3ENyxg8AFF2C0tS17PwkhaKtsd7l9Wi4s5z1RLpdj7969tZn1+vv72bt3L4cPHwbg1ltv5bOf/Sx33303zz//PL//+79PPp+vzdK3kSCEIB4JnXrFDYBYyFy1fVmOJBowMBso+CEEdCRCjRQbWHX4HNSJAyUhVP+slNkQQtDR0bEqgepGhc9B43Cw4oGpqm7C8cjlcnOmF17rWNFZ+fBuOMvlMrFYjEOHDtVFsb8RZiEQQhAIBDh06NC68Wmx/XR1b5R//c0dfOXdL+XjbzyLv3vTdn70wet46ebQmvXpTPppfHwcy7IQQqwbn5baT4ODg7Wa8f7+ftL5NN888E2O5I4Q0kO89ay3Mj00TbFcxHZszGmTkB5qaJ9OZ0aZSCSy4WeUicViDTGjzIv330//23+D6S9+EVyX0CWX0H7bBxk7axeB885D37GDg5XAyXL3kxCCUqnU0LPyLec90ZNPPslFF13ERRddBHiBqIsuuogPf/jDALz97W/nk5/8JB/+8IfZs2cPe/fu5d5776Wzs/PMHVljEEIQDBgb+kEcKqXApr5qDx+2K4kFGydbCjwOYiGz7g9g9YTPQR04kK5X1dBAZXxQ4SEW88eCz0FDcLAis/KBd4ME8Ld/+7e8+93vJhI5diC6rsvjjz+Oruv8+Mc/Xond1w0rOSufUoqBgQG2bt2KaZq15aul2L9UezE+LXUWAoBDhw7R29tLoDJ701r3aan9pJTi0KFD9PX1YZrmuvDpdPrJtm0GBgbYvn37HKG+tezTUvtpNgcA/el+brnvFlLlFG8/++28edebcV2X0cIo25q2sa1pW02EsFF9Wmo/2bbN4OAg27Ztoyr+uNZ9WurYcxyHwcHBWgp2PXzCcZj+/BeYuusuVLmMCIdJvOMdhC+8EHNTN2ZfH2Y8vqJjbynnxqX005nOygcb955oqajeQ50J1/PBdV2efvwR9NwI8Y7Ny7bdtQapFKlsiZZ4aI5o9IpAwUSuxDndTSQjjaNn5EpF/3iWbR3xE0vkNwh8DurAgZUHx4beK8FsnMQM13Xp7+9n27ZtSxKpXk/wOVhZDpZyXV8xBcSf/exngHej+Mwzz9SmEgZP+2D37t380R/90Urtvu6oPlQsp2K/Uoqenp5aUKq6fPY6x9vVB7X57Oo2FrJXYuaBxSj2n8xWSrF582ZM01w3Ps3nx8l8qnJgGMa68el4ezHtMgyDzZs31x4e14NPS7Vnc2BJi3994V9JlVMkQ0lu3H4jANPlaToiHfQmejH0Y6f8RvVpqf1kmiabN2+eM5PIWvdpqWPPMAx6enpO4GC1fHIGBxn50z+j+PTTAATPPZeW3/otjPY2An19BHp6EMbKj73lPDcu56x84N8T1RuappGIhcnl6t2S+kIATZEAqxGKsF2JqWuEjMZ60NME9LRETpyJeAPB56AOHDglCMQaKigF3rmxp6dnzvVvo8HnoHE4WLHAVHXmmZtvvpm//du/bQil97UOIQThcLjezagrfA58DqrweZjLwcHUQb7d/20Afv3sXyeoB8lZOQzNYFtiGwG9cd5YLyf8cVA/DpTjkPr3f2fibz6FzOXAMGj+9V8ncvnlGG1tBHdsx2hpWbX2NPJY8O+J6gshBAHTL+UTQmCuUqCo7EiCuk6wwQJTQgjCwdWbmbAR4XNQBw7sEiR6V29/i0QjXzdXCz4HjcPBiofFvvCFL/g3YMsE13V58cUXl1WIda3B58DnoAqfh2McFK0in3v2cxSdIlvjW3n55pdjuzY5K0dvvJdEMFHvpq4Y/HFQHw6skRGG3vNexj7258hcDrO3l87/+T+JXXM1wR3bCb/kwlUNSsHaGAv+PVF94LouY9MZVka8Yu1AKsVkuohcBSJsVxIL6egNloTgSsWLR9O4cuMOBp+DenCgIBhbpX0tHmvhurnS8DloHA42drh8jUHTNHp7e+ueZldP+Bz4HFTh83CMg59P/ZwHDj8AwG+d+1sIBFPFKbqj3WyKbapzK1cW/jhYXQ6U65K5917G/uIvcaenQQia3vAGYte+Er25meD2HRgd7XPKa1cL/ljwsRA0TSPZFCWbr3dL6gsBNMeCq1LK5ypFpAGzcjQBve2xDV/G5nOwihy4NmgmBBpL+Bz86yb4HEDjcNB4VwwfC0IIQTAYrHcz6gqfA5+DKjY6D650eXr8aY7mjvKl576Eq1wubLuQ3R27mS5NEw/E6Uv0oWuNVUax3Njo4wBWjwN7aprxT3yCzLe/DUphdHaS/G//DbO7G7O7m+C2PrRodMXbsRD8seBjIVRL2PxSPoGhrzwJSnlBsEbTl4LKecJsvHatJnwOVpkDpwRmuOFm5AP/ugk+B9A4HGzc0OAKozoDkJRyUXZ1csSFbNd1cRyHF154Acuy5iyvzlR0vA2c1J49k9F89mLbfiY+ncyezyfXdXn++edrU6yvB5+W2k9VDmzbXjc+nU4/2bbN888/j+u668anxfbTfw38Fzf83xu45fu38Kc//lP2pfYBsLt9NyWnhG3b9DX1ETEja8an0+0ny7J4/vnncRxn3fi01H6ybZsXXngBx3FWxCfpuuQeeoiBt72NzH/+JyhF9LrraPvjPyawrQ/z7LMInnM2WjRa1+NpKefGpfaTj7UN13UZnUz7pXxKMT5TWPFSPsupCJ83YPDDlYoXhmc2fBmbz8EqcmAXIRgH3Vz5fS0RruvywgsvbOjrnM9B43DgB6aWCXfeeSfnnXcel112GQDj4+MATE5OMjk5CcDY2BjT09MAjIyMMDMzA8Dw8DDpdBqAoaEhstksAAMDA+TzXt55f38/lmWxY8cOBgYGaoGZ/fv31x5G9u/fj5QSx3HYv38/AJZlcfDgQQBKpRL9/f0A5PN5BgYGAMhmswwNDQGQTqcZHh4GYGZmhpGREQCmp6cZGxtbdp9KpRIABw8eXJRPmqaxZcuWWtvXg09L7SdN02hvb6/5sR58Op1+mpycpKWlBU3T1o1Pi+mne56+h1sfupWxgvf72fj/nv//eGjoISLpCE1605rx6Uz66eDBg2zbtq3m33rwaan9NDQ0xI4dO2r2cvp0eP9+Dn/sYwz9j/fgHD2KSCRov/VWcq9/HW5HO5GXvIRhy6JcCQbV83jSNI1EIlHzY7n6qdouH2sXmqbR3hKvdzPqDgG0NoVXvJTPciVBUyNoNN5jhiZgR1fThi9j8zlYRQ5cG8Krq7m4WGiaxo4dO+pewlVP+Bw0DgdCqY3+/mh5kclkSCQSpFIpmpuba29oNU07qV2dBnsh23VdhBC1N87VacFd160NIinlHFvX9dob5vlspRSapi1oL7btZ+KTpmkL2vP5pGlaLZprGMa68Gmp/TR7POi6vi58Op1+qmZKVcfBevDpVP0kleSG/3vDvEGpKpKhJN/91e8SCUbWhE9n2k/V80G1bevBp6X2U7UNVV2n5fBJSUlp788Z/chHsCrBo/Dll5N429swYlGMLVsIbtmCFgw2zPEkhMBxHDRNO+W5cSn9lEqlSCaTpNNpX7h8hVG9h1purpVS9D/3FDPD+4l3bF627a41KKVQeAGqldSBm8pZbGoOsTXZeKVLSimk8gIT9dDCawT4HKwiB0pB5ihsuRxiHSu3n9NE9dpbvd5tRPgcrCwHS7mub9zQ4AqjegOuadqi7NkPFPPZ1Zv1/fv3126cq8ur/z7eBk5qV/e/kL3Ytp+JTyez5/NJSsmBAwdq664Hn5baT1UOqlgPPp1OP4GXnVE9ka4Hn07VTz8a/tFJg1IA06Vpnpt5bs34dKb9JITgwIEDtaDUevBpqf0EXnZSNWhzpj6pUompz3yGoVtuwTp4EBEOk/y936Plt3+LQGcH4QsvJLxzJ1pFj6BRjqdqBl0Vy9lPPtY2pJSMT2fq3Yy6QwGT6SIr/UZaoQgHGvO4kQr2j6TZwFVsPgesIgeuBUawIfWlgDkZzRsVPgeNw4Evfr6GoGkau3btmvNgvtHgc+BzUMVG4iFrZRnJj/DU6FOLWn+iMLHCLWocbKRxsBCWiwOlFKXnX2D0ox+l9ItfABA6/3xa3vUu9GgEs6eHQF8fWji8HM1edvhjwcdC0DSNjmQTM8MnD+yvdwigLbGypXxSgoZoSOFz8DJkdnUnNnwZm8/BKnHgFMEINWxgyr9u+hxA43DgB6bWGGaXQ2xU+Bz4HFSx3nnIWlnG8mMczR/lidEnuHfg3kX9rj3SvsItayys93GwGJwpB7JUIvWVf2PyM59B5vNgmrT8xm8QufwytEiE4PbtGJ2diAbn2R8LPhaCr1zhQSlYyWoVy3EJGBpBs3GPQ6kU2gYt2anC52CVOLBLkNgCDXxd8q+bPgfQGBxs7B5YY6iWKdQ7za6e8DnwOahiPfOQs3IcSB3gydEn+dcX/pWPPfox7v7l3acs4xMIuiJdXNxx8Sq1tP5Yz+NgsTgTDpRSlPv7GXrPexj/q79C5vME+vro+uhHiVx2GUZnJ+GXvASzu3tNBKU2+ljwMT+klEyksvVuRt2hgKnMypbylR1JOKAT0BvzfCEVHBzNbPgyNp+DVeLAdSDUuNqE/nXT5wAahwNf/HyZsVLCnT58+Fj/yFk5RvOjHEof4oHDD/DI8CNkLE8XJWbGuKHvBtoj7dz187tO+K2oFGd86pWf4vre61e13T7WJmS5TPo//5OJv/kUbioFQtD0pjcRv+46RMAk0NtLYPNmhLGxk6v96/rqYSW5Hnj+KVJHXiTWvnHFz1cDk7kyW1si9LQ0ZsmvDx+rBiUhOwJbroRoa71b48NHXbCU6/rGvttcY1BKYVkWgUBgQ88a4HPgcwDri4dqQGpfah/3DdzHo0cfpeR6U9W3hlp53fbXcd3W6wgZIQp2Acu1+Pr+rzNTnqltozPSyQcv/+CGC0qtp3FwujgdDqyjRxn/69vJ3uuVhxpdXbT+7u9itLWit7QQ3L4NI5lcyWYvO/yx4GMhKKWwHZeN/ipWKYUrFbomVuwYUYqGFT6HynnCkQSMjT0Dl8/BKnDglMAIQ6Ax9aXAv26CzwE0Dgd+YGoNQUrJ4OAgO3bs2LCzBPkc+BxUsR54yFk5xvJj7J3Yy7399/Lk2JM4ygFgc3wzb9zxRq7adBWa0MhZOVKlFGEjzI3bbuSd576T/an9PDf4HOf3ns9l3Zeha2uThzPBehgHZ4qlcCAti9yDDzL28U/gjIwAEHvVq2h64xvRdA2zZzOBvt7ajHtrCf5Y8LEQpJRMZ/KY9W5InaGAmVyZZFNoRQTQHVdh6qLB9aVgcCLHjq4m9I35DOpzwCpxYJc80XMjtEI7OHP4102fA2gcDvxSvmVGNV0tlUrR3Nxcq9WsTmW9kF2dRnsh23Xd2lTW89kwV7RMSomu6yilFrSrU4svZC+27b5Pvk++T0vzKVvOMpYb4ydjP+F7/d/jmclnUBXVj7NbzuaNO9/InrY9uMolY2ewbZtYMEZPrIfmYDOxQKzhfFqP/bTefHKnphj/278j8/Wvg5Rozc0k3/1ugr1boSJwHujsrIlErwWfVqOfUqkUyWTSL+VbBfilfGsbhbL3YuX8ngTGRp7yzYcPgMxRSO6AjnPq3RIfPuqGpVzXG/eVxhrDnXfeyXnnncdll10GwPj4OACTk5NMTk4CMDY2xvT0NAAjIyPMzMwAMDw8TDqdBmBoaIhs1hPoHBgYIJ/PA9Df30+xWKRYLHLw4EEsywJg//79OI6DlJL9+/cjpcRxHPbv3w+AZVkcPHgQgFKpRH9/PwD5fJ6BgQEAstksQ0NDAKTTaYaHhwGYmZlhpPJGfXp6mrGxsWX3qVTyypUW65NSinQ6va58Wmo/KaUYHx/nyJEj68an0+2nkZERlFJrxqeBIwMcmD7Al57+En/04B/xVz/9K34x+QsUiks6L+G282/jg+d/kHOT5zI6MsrU9BTNwWa63C52hnaypWkL06PTc3yanp5GKdXQ/bSSY+/FF1+kUChg2/a68el0+qlYLJLJZOb1KTUxwcD37uXwu24i87WvgZREXvpSgn/6p+R6NmF2dZPbtImsYSCEaBifltpPSimGh4eZmJhY1n6qtsvH2oVSCst2/FK+WknjyhBhOYpI0GjooJRSimLZ2dCzNPocrBIHSkIwvnLbXwYopSgWi/5Y8DloCA78jKllxkpmTCmlGBgYYOvWrZimua7eSC/2LTvAoUOH6O3tJRAIrAufltpPSikOHTpEX18fpmmuC59Op59s22ZgYIDt27fX6qEb1aeiW2Q4M8x3+r/D9we/z3DOe7jWhc5Vm67iDTvewOb4ZjKlDAWnQMSM0BZqoyPcQSKcAMW8fszmoOp/o/XTSo8927YZHBxk27ZtCCHWhU9L7SfHcRgcHKSvrw9N0+b45M7MMPXZzzHz5S+jLAsRidBy882EzjsXTJNAXx+hnh7UccdQvX06nX5ayrnRz5hqTKxUxpTrujz9+CPouRHiHRs3Y0oqRSpboiUeQhPLHzyazJbZ1h6lq6lxS5dcqegfz7KtI47ewAG0lYTPwSpwIB3ITULvSyHcsvzbXya4rkt/fz/btm3bsGVsPgcry8FSrut+YGqZ4c/e48OHjyrydp7D2cN8/cWv81+D/8VUaQqAoB7kuq3X8brtr6Mp0ETGyuC4Dk3BJroiXbSGW4mYjSuW6aPxoWybwjPPMPYXf0n5l78EIHTBBST/+39HaAKjvZ3gtm3ozc31begagH9dXz34pXxrGAom82XO6WqiJbLR1bx8bHhYOXAd6L0ajEC9W+PDR93gz8q3TqGUIp/PE41GaxkiGw0+Bz4HVTQyDwW7wIGZA9yz7x4eOPwAOTsHQNyM85ptr+FVva9C13Sy5SyZcoZkKElntJOWUAumtvgb+kbmYLWw0TlQrkv+ySfJDx0humUz0UsvReZyTH/l35j6p39CFQqIQIDmd7yDyBVXIFAEensJbN6MCKyvm+WNPhZ8LAylFGXLL+XzSvkk5grMRGa5ElPXCDWw8DlUzhNlh2jQ2LDnCZ+DVeDALnmZUg0elPKvmz4H0Dgc+IGpNYSqtlBfX9+GPnB8DnwOoDF5KNgFnp16lq88/xUeGX6EslsGoC3cxuu3v56Xb345lrTI23nCRpjepl7aI+00BZpOy4dG5GC1sZE5yNx3H2N/+XGc0VEApgG9tRU9mcSq6DgFtm+n9fd+Dy0cQo9GvCyptrZ1ydVGHgs+Tg6lFNlCyRdWBXIlm5bY8s+6aTmSoKERbPBSGKVgPF2irz3GRj1N+BysAgduuaFL+Krwr5s+B9A4HPilfMsMP+Xfh4+Nh4Jd4MmxJ/nyc1/m8dHHcZULwNb4Vt64441c3HkxeTuPVJKmQBPdsW5agi1+uZ6P00bmvvsYfv8fsGAKiBAk3vIW4q9+NdgWZk8Pgb4+tHB4Vdu5HuBf11cPfinf2sV0zqKjKci2tmi9m+LDR/0xcwS2XAbxrnq3xIePusIv5VunUEqRzWaJx+MbOqLrc+BzAI3BQ8Eu8NCRh/jy81/m5xM/ry0/N3kub9zxRnY27yTv5Ck6RdrCbXRGvHI9Q1ueU28jcFBvbEQOlOsy9pcfXzgoBWhNTURf8XKEoRPcdR5GVxdCW9/5IhtxLPhYHJRSlMq2X8qnFGXbJWjqy36MSBTRYOM/ViilyJZs4iFzw54nfA5WmAOn7JXwrYGXj/510+cAGoeDxr+C+KhBKUUqlSIWi23oA8fnwOcA6stD3srz3f7v8pUXvsL+mf215Zd1Xsbrtr+OrmgXJaeEVJK+eB9tkbbTLtc7GfyxsDE5yD3yo1r53kKQ6TTu5CSxK69Ejzf2dNXLhY04FnwsDkop8iULf1RAsewQNJe33E5KEAhCRmOX8YEXz0/lLGJBc0OXsfkcrCAHThmMEAQaP3vQv276HEDjcLC+X5+uM2iaRm9vb23K7Y0InwOfgyrqwUOmnOELz36Bt/7nW/nzn/w5+2f2owudV255JR9/2cd55/nvpCXUQkgPcW7ruVzUeRE7WnaQCCZW5ETvj4WNw4FyXZypKUrPP0/m+99f1G/0WGzDBKVg44yF1cLQ0BCvfOUrOe+883jJS17Cv//7v8/5/s1vfjMtLS289a1vnbP829/+NmeffTa7du3ic5/73Go2eUFomkZrIrphH8KrEELQEg+tgPC5S8DQCDa48DmApgl622No2sYdDD4HK8yBU4JwM2iNH6j1r5s+B9A4HPgZU2sISinS6TSJxMo85K4F+Bz4HFSxmjxMF6f51xf+la+9+DWmSlMAhPQQ1229jldueSUBLYCpm7SGWumMdtIcbF62cr2TwR8L658DWSziTk9THj5K4bHHyD3wAOV9+xb1W6NzY2lbrPexsNowDIM77riDPXv2MDo6yiWXXMKNN95INOplAbz//e/nlltu4e677679xnEcbr31Vn74wx+SSCS45JJLePOb30xra2u93AC8sVEoWX4pn1KULJdQYHlL+SxHETY1gkbjP9gppUgXbBKRjV3G5nOwghy4NoQSy7vNFYJ/3fQ5gMbhwA9MrSFU6z+bmpa/JGitwOfA56CK1eBhJDfCF3/5Rf7j4H+Qs3MANAWauKHvBq7ovgJDGETMCJ3RTtrCbcTN1a3N9sfC+uRASYmbTuOMT2AND5N/6CFyDz10rHxPCIRpoixr/g0IgdHZSeTSS1av0Q2A9TgW6onu7m66u7sB6Orqoq2tjenp6Vpg6pWvfCUPPvjgnN888cQTnH/++fT09ADw2te+lvvuu4/f/M3fXNW2Hw8vIGPXtQ2NgrLtBaaWE7br0hFf/pn+VgJKQbZo0xTe2GVsPgcrxEE1+m02fhkf+NdN8DmAxuHAD0ytIWiaxpYtW+rdjLrC58DnoIqV5GEgPcDnnvkc9w7cS9ktA9AR7uCGbTewp30PpmaSCCbojnZ7pXtGaEXacSr4Y2F9cSDLZdzpaezRUayBQXIPP0T+Rz9GZrMAiEiE+PXX0/Ta11J6/nkm/+7vTtxI5Yai808+hGjwaduXG+tpLCwGDz/8MLfffjtPPfUUIyMjfOMb3+BNb3rTnHXuvPNObr/9dkZHR9m9ezef/vSnufzyy5e8r6eeegrXdU/J79GjR2tBKYCenh6Gh4eXvL/lhqZpJJuipDL1bkl9IYSgObb8ASSFIrzMwa6VgqYJtmzwmQN9DlaQA6cERhACjS98DhvvujkffA4ahwM/MLVCkFLO+atp2kltIQRCiAVt1/Wmn0+n08TjcQzDqC2v1oNKKefYuq6jlFrQVkqhadqC9mLbfiY+aZq2oD2fT0IIUqkUTU1NmKa5Lnxaaj8BpFIpEokEhmGsC59Op58cxyGdTtPS0lI77s7Up2fGn+Fzz36OB488iFTevrbGt/Lq3ldzbvJcQkbIK9eLddIcaEYg6jr2ZnNQ3U+j9dNKjz3HcchkMjQ3NwOsOZ+EEKhsFmtiAmd8nPKLL5J7+BGKTzwBjgOA0dFB/MYbiV53HZoQuDMpAuedS8cHP8D0F76IMz5eOwaMzk46/+RDxF/1qlp/N0I/rcbYg8WfG5fqUyMin8+ze/dubrnlFt7ylrec8P0999zDrbfeyl133cUVV1zBHXfcwQ033MC+ffvo6OgAYM+ePTiVcTYb9913H5s2bQJgenqad73rXXz2s59dWYdWEFJK8sWyX8qnFEXLIRwwlu2tuOMqdG1t6EsBSKWYyVs0RwNoGzQ7wudgBTlwSmCG18SMfOCdG2dmZmhubq67vlC94HPQOBxsTPZXAHfeeSfnnXcel112GQDjlQeFyclJJicnARgbG2N6ehqAkZERZmZmABgeHiadTgOe2Gi28nZ8YGCAfD4PQH9/P6VSiWKxyKFDh7AqJRz79+/HcRyklOzfvx8pJY7jsH+/N1OYZVkcPHgQgFKpRH9/P+Dd0A4MDACQzWYZGhoCvMBX9e3mzMwMIyMjgHdjOjY2tiI+ARw8eHDRPmWzWQ4dOrSufFpqP01NTa07n5baT+Pj47Xj7Ex9euTwI/y37/833vG9d/DA0ANIJdkV3cV7dr+HP9j9B5wvz2dXchfnN5+PmTJpC7dhW3bdx97g4GBtnUbtp5UeewcOHKBQKKw5n5Rl8eLPf0HmF78g//TT7P/WfzD+yb9h4hN/RfHRR8FxCJx1Fu7v/i49n/40wVe8goHJCWSxgNu9ifG2Nlpvvpmu//wPjI//JeH/+Se0/v2dmJ//Z5pe/eqG66fVGntjY2PL7lO1XY2G1772tfzv//2/efOb3zzv95/61Kd497vfzc0338x5553HXXfdRSQS4fOf/3xtnb179/Lss8+e8KkGpcrlMm9605u47bbbuOqqq07Zpk2bNs3JkBoeHq5tq96wncYMMK42bEeeeqUlbs/UNULLPNPfikFB0XJgIwcpfQ5WjgOnBOFkLXt5LaBYLNa7CXWHz0FjcCCU2ujvj5YXmUyGRCJBKpWiubl53b2RXo9v2X2fNqZPCLj/8P388zP/zHPTzwHedNcXd1zMKza/gt54Ly3hFrqiXTQHmgkHwg3v03rsp/Xmk5XJIKencUdHsaamKT39NPkHH8SuPswLQeSlL6Xpda8jePbZuPk8KpuBYBCjs5Pgpk1osVhD+bQe+2m2H6lUimQySTqdpqmpiUaEEGJOKZ9lWUQiEb72ta/NKe+76aabmJmZ4Vvf+tYpt6mU4h3veAdnn302H/3oR+dd58EHH+Qzn/kMX/va1wAvg/Hcc8/lwQcfrImfP/roowuKn5fLZcrlcu3fmUyGLVu2rMg91OF9P2NmeD+Rth5EhTOpFNXHRwVzbE0Ib8wtYFd5r5ddbftC9mr5lC46NIUMdnXG0IRASgWCeW0hKm1cwHalQjuJDSAVc2xd89qykK2UV7a1kC2VgoVs5vfD98n3aUGfZobRN1+EauppqOvYerw2+z6tDZ+Wcg/lZ0ytEKqDR9O0RdlCiJPa1YE2OTlZ6/Tq8uq/j7eBk9rV/S9kL7btZ+LTyez5fJJSMjU1VVt3Pfi01H6qclDFevDpdPoJvEyJ6sl6sT7Z0uabB7/Jr37zV/nDh/6Q56afQxc612y6htsuv43//pL/zpU9V7K7czcvaX8J3bFuwoHwqvi01H4CL3uuejFqxH5a6bEnhGBqagqlVMP6JKTEnZqi9MtfUt67l+LTTzPz9W8w/rGPMfPlL2MPDyPCYZpe/3p67ryTjj/8Q8zNm3FGRxCOTWDbNqIXX0zk7LPR4/ETfAIv+6l6w9GI/bQaY09KWcuQWm6f1homJydxXZfOzs45yzs7OxmtiuifAj/+8Y+55557+OY3v8mePXvYs2cPzzzzTO3766+/nre97W1897vfZfPmzTz22GMYhsHf/M3fcO2117Jnzx7+8A//8KQz8n384x8nkUjUPlWNi+XOOj906BDpbAGlYDpTwpXew+xkuoj0nnGZTBdReA+ck2nvzbErFdMZL3POcSWprGfbjiSV8wJqZdtlpmKXLJd03ssYLFoOmYJnF8oOuaInvp4v2eRLnp0r2hTKXillpmB5GRxAOm9RsrwMr5lcmbLt2alcuZbxlMqWcFzPXqxPSimyRYupin/L4ZMjXaSUTFZ4GksXmc56vx2ZKTBT+e3wdIF0wfN7aCpPtsLBwESOfIWD/vFsze+Doxmsiq/7R9I40gsA7B9JIxU4UrF/xOt3y5EcHM3U2ts/7o2BfNlhYMKbuCRbshmayiOVYnAix9C0NzZm8hYjMwWPx2yZsQo3k5nSmvEJIF2wGZ4uLMonqRT7RzM1/9aDT0vtJ6kUvxxKkav4tyw+lS3604AZaagMbVg4m/nFF19kYmICy7LWVNb5yXxaaoZ2f38/k5OTZDKZdePTUvtpdHSUyclJxsfH65p17mdMLTOqGVMr8WZVSsnY2BidnZ1zHs43EnwOfA6qWCoPBbvAPfvu4UvPfYmJ4gQAIT3ENT3X8LLNL6Mn2kNXtIvWcCuxQGylm78s8MdCY3MgCwWc6RT2yFFkOo01Okb+Rz8i/+Mfg+3dDOttbTS97nXEr7sOEYkgczlkLocWDmNu6sbo6ESPnVygtZE5WE2sFA8reV1fLggxN2OqKkL+6KOPcuWVV9bW+8AHPsBDDz3E448/XqeWzsVqZUzZts0vf/YT5MwRou0bN2NKANmCRTRsomvamfukYCpf5uyuJpojZuNkrZwkEwdgdKZAR1MYw9DWTibOMmYXobzATWcijKFr68KnpfaTqnDQlQij69ry+FTOIW0LfdvVKCPYUFkrJ9PpnJiYqL3EWEuZOMuVXeS6LhMTE3R0dNRegK11n5baT1JKJiYmaG9vn/Oybzl8WkrGlC9+voagaVpt6uaNCp8Dn4MqFstDqpTiS899iX974d/I2l5UPx6I84rNr+CaTdfQE/cCUslQkoAeWOlmLyv8sdB4HCgpcWdmcCYmcCYmcPMFrIEBcj/8IaW9e2vrBXbuJPHGNxK54grQNGQuhzs6ihYJE9yxA7OzAy26uBmDGo2DesHn4Rja2trQdb32ZreKsbExurq66tSqExEMBgkGT5wlbnZ22/HLTsc2TZPmeIRUmjlCx7PtY9YxWwixoE2d7YX8OJVPTdFjfJ+pT7YrMXWdsKnX9qtps9qyRFtfjD3LqaothFjQFvPYm5LHzq2aEDVyTrBP0496+DTbPqVPAnpmc7AefFqiH+I4DpbFJ7eMHoqBGaoFio/5caK9XOe3hezZ2b4L2aZpnqADeLJs5rXg03z2yXwyDOOEe4e17tNS+2m++6eV8OlU8ANTawhSSiYnJ2lra9uwb8V9DnwOqjgVD0dzR/n8s5/nmwe+Sdn13si3hlq5dsu1vGLzK+iOddMR6SARTKCJtcmjPxYahwNZKuFOT2OPjuLOzCAti9KzvyR7333Yhw97KwlB5PLLaXrDGwiefbb3u2zWy5CKRQmetQuzvR0tsrTZfBqFg3rD5+EYAoEAl1xyCffff38ti0pKyf3338973/ve+jauDpBSksmXahkzGxVKKfIlm2jInBNkOl2UHUnA0Agaa6fcVSrFZKZEW1NoQ89I53OwAhw4ZUj0Ls+2Vgn+ddPnABqHAz8w5cOHjzUHV7o8Ofok/eP9bHO2cWnXpeiad2P8YupFPvfM5/j+wPeRyks93RTbxPVbr+eanmvoifXQGm4lai4uG8WHj4WglEKm09iTkzjj48h8HmnZFH7yE7L/9V/ISj2+CIWIXXcdTTfeiNnVhZISmckg8zm0eJzgOWd7AalwuL4O+VhTyOVyHDhwoPbv/v5+9u7dSzKZZOvWrdx6663cdNNNXHrppVx++eXccccd5PN5br755jq22sd6gu1IEk0BNuiznA8fc6EUBNeGFIQPH40IPzC1hqBpGh0dHfVuRl3hc+Bz8IPBH/CJJz7BWOFYiUpnpJO3nfU29k7s5UfDP6ot35nYyQ3bbuCl3S+lO9pNMpTE1M16NHtFsNHHAtSHA2VZOKmUlx2VSoHj4GSy5B54gPzDD6MqwpV6aytNN95I7Prr0aPRWpmfLOTRm5oInnsuZkcH2jylTEuBPw48bDQennzySa699trav2+99VbAm3nvi1/8Im9/+9uZmJjgwx/+MKOjo+zZs4d77733BEH0jQBN02iKhkil6t2S+kIIQSy8fCXrjpJEA2vrUUITgo7Exn4J4HOwAhy4Nmg6mGuL14123ZwPPgeNw4Evfr7M8MXPVxY+Bxubgx8M/oBbH7wVT651fggEF7ZdyOu2v45Luy6lI9xBU7BpzZbrnQwbeSxUsVocKKWQuRzO1BT2yAgylwPDxD5yhOz3vkfx6adr6wa2b6fpjW8k+tKXIgwD5bq4mQyqWERPNGH2bMZobzvjgFQV/jjwsJHFz9cLVoprKSXPPPUobmqIeMfmZdvuWoNSilzRJhY+81I+VRE+P687QSK8doJTUirG0kU6E+E52kMbCT4HK8BBOQtSQt/VsIZegPr3Dz4HsLIcLOW6vnauJD4AT6Ruo8PnYGNy4EqXTzzxiZMGpQJagA9f+WEu7riY1nArEXNpWj1rERtxLByPleRA2TbuzAz22DjO1CTKshDBEKUX9pH5znewK1PyIgSRyy6j6fWvJ3juuQghUK6Lk0qhSkX0RILA9m3o7e1ogeUX2ffHgQefBx8LQdcEbr0b0QBYrkCEVdGXCplr7EFOgKlrc5XhNxp8DpafA7sI0fY1FZSqwr9u+hxAY3DgB6bWEDRNo62trd7NqCt8DkAoRUJK5PQ0oqUFsYTZDtYyfjr60znle/PBkhYdkQ62NG1ZpVbVF/7xsHIcuLk8zvQUzugoMpNBaToIQf7Rx8jee69XwgeIYJDYtdfS9LrXYVZmNFGui5NOo8ol9OZmAjt3YLS2IlYgIAX+OKjC58HHQtA0jVgkRGq63i2pL4QQREPL8/BhuZKQoRPQ11ZgShOCtqZQvZtRV/gcrAAHrgXhluXb3irBv276HEDjcOAHptYQpJSMjIzQ3d29oVMNNzIHTipF6fBhRo+O0G7omK2tmD09GMkkogEi3csNpRT7Uvv45oFv8q0D31rUb1KljSMistGPB1heDpTr4s7M4IyPY09OokpltEgEaTtk7/02uR/+8Jh+VDJJ/LWvJX799ejx+JzfK8tCb2khcNYuLyC1wsemPw48+Dz4WAhSSmayBX9WPqXIFCyaIoEzLuWzHElbLMBam9RNSsXITIHu5siGLmPzOVhGDpQCBATW3qQ6/nXT5wAahwM/MLXGEPZnbdqQHMhCAWt4GHv4KK7rEGlpQQ8GcTMZnF88g96cILBpE3rb8unW1BNHs0f51sFv8d3+7zKQGVjSb9sj7SvTqAbFRjwejseZciCLRdzpaayRUWQmjVKgxeM4R0eYvvtuik89RfWJNtDX5+lHXXllLeCkHAd3ZgYcG72lBXPz2V5Ayli9S6w/Djz4PPhYCKahU653IxoAprE8Dx0KRTiwBjO2BYQDxoYvY/M5WEYOXAuM4JoTPq/Cv276HEBjcOAHptYQNE0jmUzWuxl1xUbjQDkOztgY5cOHkbkcenMLRjhMLfTU2loTVi4+9xxaLIbZ04PZ1oYWWVv6SjPlGb596Nt899B3eWbymdpyQxic23ouV3Rfwdf3f53p0vy1GAJBZ6STizsuXq0m1x0b7XiYD6fLgZISN53GmZzEGR9H5vOIcAStKUHhiSfIfPvbWIcO1dYPX3opTa9/PaHzz69lGlT1p3Ad9NZWzE09GK3JVQ1IgT8OqvB58LEQNE0jGg5ibeQHcbxSvkjwzDM4XVehIQgZay8wpQlBMrb2X+CdCXwOlpkDp1gJTK29jCn/uulzAI3DgR+YWkOQUjI8PExPT8+GTjXcCBwopbwMjsOHcSYm0aJRjK5uhBBIpRjNZemKxdGEQOg6RksLSiaQuRzlF/ZhR4cwu7sxOjrQY7F6u7MgCnaBHwz+gO/0f4cnRp/AkU7tux3NO7i081Ku7r6abc3baA23cl7yPP7woT8EmCOCLiqvvD54+QfRtbV3o3y62CjHw8mwVA6kZeFOT2OPjuGmpsF1EfEmRLyJ/A9+QOZ738Od9oKfIhDw9KNuvBGzp6e2jVpASrrorW2Ym7q9DKk66b3548CDz4OPhSClZDqT5yRzZ2wIKKVI5y0S0TMr5bPdqvD52rveSqkYni7Qk9zYZWw+B8vIgV2Cps2wBq87/nXT5wAahwM/MLWGIIQgHo+fsS7AWsZG4MDN5bGPDGEfHQEhMDo75zzwCiAWCJyQfSw0Db2pCS0eR+bzlA8exDoyjNnZidnZgZZINARvJafEYyOP8Z2D3+GR4UcoOIXad5uim7ik8xIu7bqU7YntdEW7SIaSBHRPNPpVfa/iU+JTfOKJT8wRQu+MdPLByz/I9b3Xr7o/9cRGOB5OhcVwoJRCZrM4k1PYY6PIXA4RCKI3t+BMTpL+t38j98ADqLJX6KM3N3v6Ua96FfqsqW2lZeHOzCBQ6K2tBHp60JNJRJ1vZPxx4MHnwcdCEEIQCpiU6t2QBkBwGYJJZUcSD5mY+to71oSAeNhcc9pYywmfg2XmwHUgnFiGDa0+/OumzwE0Dgd+YGoNQQhBc3NzvZtRV6xnDpRlYY2OYh8eQpaK6C3JefWihBA0BReeSUQIgR6LocdiyGIRe+gw9shRzPZ2jO5u9ObmVX+QLtgFfjn5S77T/x0eHHqQqdJU7buWYAuXdl3K7vbd7EjsoCPaQXu4nUQwgSZObOf1vddz7ZZreXr8aSYKE7RH2rm44+INlSlVxXo+HhaLk3GgbBsnlcIeG8OdmkbZFlosjt7RibVvH9P//M8UfvrTmn6U2dtL4g1vIHr11XMEy2W57AWkhMBob/P03Fpa6h6QqsIfBx58HnwsBCEEkVCA8sZ97gA8HsLBM7/1t6UkFlyb11whBM3RlZkhda3A52AZOVDSy5Rag2V84F83wecAGocDPzB1HGZmZrj++utxHAfHcXj/+9/Pu9/97no3C/DS7IaGhtiyZcuGTjVcbxwoKXEmJ7EOD+FOT6HFmzC7uhdcXyrF0WyGTfEmtFNEtrVwGC0cRpbLWKNj2GNjnhZO98qWHkklydt5DmcO851D3+Hh4YcZzAzWvg/poVowalfzLhLBBN2xblqCLUTMU2tj6ZrOJR2XeGOhY/2MhaViPR4PS8V8HLi5PM7UJM7oKG4mizAMtKYmhK6T/8lPyPznf2IdPFjbRvjiiz39qAsvnPO2yAtIpRCa5mUebqpPYPdU8MeBB58HHwtBSslUOo/wS/mYyZVpjgXP+M34mhQ+xyvhGprKs6U1uqHL2HwOlokDpwRGCAJrS9e1Cv+66XMAjcOBH5g6DvF4nIcffphIJEI+n+eCCy7gLW95C62trfVuGkIIWlpa6p5mV0+sNw7cTAbr8BDO2CgYJkZn1ymDRQJoDoWWNJGIFgyidXZ62jjTKdyJCbTmFgKbezCSSUTgzN8aOdIhZ+UYL4xz3+B9PDL8CC9MvYBEem0QGrvbd3Np56Xsat5FNBClNdRKZ7ST5mAzhra009F6GwunA5+DYxzgujjT0zjj49iTU6hyCS0SxejoQJZKZO+9l8x3v4s75WXriUCA6CteQdPrXkdg8+Y525SlkheQMgwCXV0YmzZ5AakG5dkfBx58HnwsBCEE0VCAQqbeLak/zjRjynEUhiYImmvzAU4IaIkFNnwZm8/BMnFgl8AIe8GpNQj/uulzAI3DgR+YOg66rhOpzGZWLpdRSqFUY7xiE0LQNEvvZCNivXAgy2Xs4aNYR46AVUZLtqItMjgkhCAWOL2ZRIRpYrS3ezP5pdMUn3kGPZHwZhNrb5u3dPBksFyLjJVhujDNI0cf4UfDP+IXE7/AklZtnZ3NO7lq01Wc33o+QT1I1IzSGe2kLdxGzIyd9klwvYyFM8FG5kAphSwUyP/kJ9jDw6QQmN1doOvo8Sa0ZBJ7bIyZr3+d3P33o0qeuoyWSND0mtcQf/Wr0RNzNSFksYhMz4BhEujpwejqauiAVBUbeRzMhs+Dj4UghCAUNCk29qG84vC0ts7s1r/suAR0jdAqzz66XBBC0BT2y9h8Dk7kQCqF5S5xQ5YN4W6oaFSuRQQCAcpruP3LAZ+D0+fANE30ZarAWXNXlYcffpjbb7+dp556ipGREb7xjW/wpje9ac46d955J7fffjujo6Ps3r2bT3/601x++eWL3sfMzAyveMUr2L9/P7fffjttbW3L7MXpQUrJwMAAfX19GzrVcC1zoFwXZ2ICa3AQN51BTyTQljg9p1SKI5k0m5sSpyzlWwhC1zGSSZTrIrNZSs/9Ei0ex9y0CbOtDS26cK18wS6QtbKkSin2TuzlR8M/4unxp8la2do6nZFOrum5hks7LyViRtCERnOw+QQx8zPBWh8Ly4GNxIGybS9wVCwi83ky37+P1L/8C24qVVtHTyZJ3nILenMzmW9/m8ITT4D0MvbMrVtpev3riV5zzQlB4FpAyjQxN2/G7O72Sv8aPCBVxUYaByeDz4OPhSClZHImh9YY7xnrBqUUqVyZljMo5bNcSTIaQF+jh5iUioGJHH3tsQ1dxuZzMJcDy1X0z4BEZ0klCbIdZlzI9K9UU1cUSilc10XX9TVzz7Pc8Dk4cw6am5vp6uo6Y/7WXGAqn8+ze/dubrnlFt7ylrec8P0999zDrbfeyl133cUVV1zBHXfcwQ033MC+ffvo6OgAYM+ePTiOc8Jv77vvPjZt2kRzczM///nPGRsb4y1veQtvfetb6ezsXHHfTgUhBB0dHRv2oIG1zYGTSmENDeGMjSNCIYyurtPSqhFAWySypOvmgtvSdfTmZrREApnLUX7xReyhIxhdnZidnejxOEop8naerJVlsjjJofQhHjv6GE+OPTlnZry4GefKTVdy1aar6Ix2UnJKhI0w7ZH2k4qZn3bb1/BYWC6sVw6UlMhCEVUsIItFnJkZZD6PKpVQjkPxF79g+rOfO+F37vQ0E5/85JxloT17SLz+9YR27z6BJ1ko4GbSiEAQc8tWzO6uObPwrRWs13GwVPg8+FgIQgjikRD57KnXXe+IhcxTr3QSuFIRC625x4cahICORGjDl7H5HBzjQCnFSA70YJgtnZ1LeOmrQLoQCMMS5SgaBUoppJRomrZhr50+B6fPgVKKQqHA+Pg4AN3dC2skLwZr7ih67Wtfy2tf+9oFv//Upz7Fu9/9bm6++WYA7rrrLr7zne/w+c9/nttuuw2AvXv3LmpfnZ2d7N69m0ceeYS3vvWtZ9z2M4UQglgsVu9m1BVrkQNZKGAND2MPH0VJF6Otbc6MX0uFEIKIubwp2EII9HgcPR7HzecpHTxEemA/xZYIM00ao3qOJ8Z+ytPjT3Nw5photKmZXNp1Kdf0XMM5yXMo2AWkkgT1IH1NfSRDyUWJmZ9um9faWFhurAcOlFKochlZLKIKBdxsFjedRpbLqLLl3TibAUQohN6SBCFIf/0bp9xu9LrrSLz+9QS2bj3hOzefR6bTiHCIQG8vZlcXejy+At6tDtbDOFgO+Dz4WAhCCIIBg8LGfOaoQQhBwDyDkgsFCAgaa1P4HCrniTMMzq11+BzM5cB2FQVHY1NHK5HwErSilAvKgGAElvHFqw8fawnhcBiA8fFxOjo6zqisb80Fpk4Gy7J46qmn+NCHPlRbpmka119/PY899tiitjE2NkYkEiEej5NOp3n44Yf5/d///QXXL5fLc+oxMxlPWVNWykeqfzVNO6kthEAIsaDtui5KKQYGBti6dSumadaWV0sWqpHOqq3rei0COp+tlELTtAXtxbb9THyqRmbns+fzCeDQoUP09vYSCAQa2ienXEZOTHhZUtksRnMLejiMgtr09ArQhPDauEgbYHAmxZZEM4amISvb0oQ4LVvgXaAt16Zg58irPDPBNJnsFL8ce4Gfqn6ecQ/j4BXeCwTnt53PNZuu4ZLOS1Ao8uU8RbtIW6iNjkgHyXASXeg1/lain2zbZmBggO3bt9ei+ys59hrxeJrNQXXdRvdJ2TaUyzj5PKpQQM7M4BSKUC6BAqXrnlh/NIZqNtGqfiuFsiyyP/xhTcD8ZIi+/OUEtm6dcww52SxuNoMRiWBu68Po7MRsaprzpqgRz3un6ifHcRgcHKyVsK2Fc/lKjD2lFIcOHaKvrw/TNJfVJx9rG67rMpHKom/wUj6pFKlsiZZ46LSkACxXevpSa1T4HLyMr/7xLNs64ugbtIzN52AuB64ChCCw1JfGSoGmr+mglFKKcrlMMHjmM3WuVfgcnDkHVX1u27bPKDC1do+keTA5OYnruieU3XV2djI6OrqobQwODvKyl72M3bt387KXvYz3ve99XHjhhQuu//GPf5xEIlH7bNmyBaCW0jY5Ocnk5CTgBb2mp6cBGBkZYWZmBoDh4WHS6TQAQ0NDZLNervnAwAD5fB6A/v5+LMuip6eHgYEBLMsTl96/fz+O4yClZP/+/UgpcRyH/fv3A16w7mBlWvRSqUR/v1cDnc/nGRgYACCbzTI0NARAOp1meHgY8LS2RkZGAJienmZsbGzZfSpVBIkPHjy4KJ80TaO9vb3W9kb0qVgs4kxNse+xx8j88jmQiqFgCBUKoYBDqWkU4CrFoZS3H8t1GZjxtHLKrsPhtLfPomNzJOPtM29bHM1mEEAsEGAslwMgUy4xnvfsmVKRyULB869YYLro2ZOFAjOlIgDj+RyZssf7kcw0w9kJBjMD/GxsP89NHeShqZ/y2fHv8KGZz/NPzgP8zO3HwaVXa+fN8Vfztxf+L267+I/Zae8kV8qBhGg6yu623ZyVOIvpoWkMzVjxsTc5OUkkEkHTtFUZe9B4x9PQ0BDJZBJN0xrSJyUlo4cPM9HfjzU0xODjjzP6+OMUnnqKwb17mTp4ELdQZNR1KSWaMbu7GQ0GsCJhhGky9OI+Zn74Q6Y+9zkG/+iPOPyud5H63IklfPNh9MgRzyfHYXB8DHvkKEXLYrylhfCei7A7Ozla0adq9PPeqfppaGiInp6emr0efDqdsadpGqFQqObHcvlUbZePtQtN00jEwvVuRt0hgKZI4LSlACxHEjA0Qms4Y0oT0NMSYYPGYwCfA5ifgyXToaQXmFrjCCzDzNxrHT4HZ8bBcgX0hGqUKedOA0KIOeLnR48epaenh0cffZQrr7yytt4HPvABHnroIR5//PFlb8N8GVNbtmwhlUrR3Ny87t5Ir8e37Mvpk5XJ4g4fwRkZRQJGMolmGLXMJKhlwtfspWRMSdfFeuEF3FQKraWF8Lnnoir8LC5LCvJ2gaJTIFPOkLGyWK7FmDvNU8UXebzwS6acdG08J/Umro7v5prYbnqNdkrTUxRLWWiKEd2ync4tZ5GMd2AKc03103oce/X2yXVdVLkM5TJuPo+bzaKyWZxiEVW20DSBMkxEMIgRCqEMo5atJ5VCptNYBw5Q2r8f68ABrAMHkJUgwWyISARVCb6eDO0f+Qihvj7cTAYRjRDs6cFob0dUgpkbtZ98n5buUyqVIplMkk6n/Vn/VhiZTIZEIrEiXA88/xSpIy8Sa9+8rNvdSJjKWXQlgvS1LjxBig8faw0lR9Gf0dm2dSuh0BJmp3YtCERB39hlkT58VF8ubtu2jVBobjnsUq7r66qUr62tDV3Xa2+DqxgbG6Orq2tF9hkMBgkGl3ASOwO4rlsrU6je4G80uK7LgQMH2LZt27JNTbkcUJaFNTZGefAwqlTESLaiBU7/reR8KDz+ONNf+MKcMia9tZWWm28mcsUVC/5OKpecXaBo50lbaXJWAUfa5Cmyt3iQx/LPMmAdra0f1oJcET2fa+J7OC+8DaUEeSfHpD1DIBEh2dpB0g4QHHExC0dhE8i2NrTw6r6Nrh4PO3fu3LCpt7M5WG0o2/a0mopFKBaxUylkoYiwyriuRBgGeiiEFo0hWgLo2rGyU2VZlPftw9q/n/L+/ZQPHMCtZJnOhjBNAtu3E9y1C3PnToI7d2K0tTH8nvectJxPb2lBTyQARfDss9Db2zGj0VpgY72hel7cvn37hr02gM+Dj4Xhui5j0xnM9Xf4LwlSKaYzJZJNp1fKp5QiGljbjw6uVBwczbCjq2lDl7H5HBzj4PQgPQX1Bi/j++Y3v8kf/dEf0d/fz/ve9z7uuOOOOd/PV8KllOJ3f/d3+drXvkYqleJnP/sZu3fvPmHZH/zBH7Bnz54TtrnWcKoytvn42LNnz+o3dAXRKOWMjX00LRGBQIBLLrmE+++/v7ZMSsn9998/J4NqJXDnnXdy3nnncdlllwErV8rX29u74Uv5uru7G6aUT0nJwWefZepneym/8AJHrDKyvR0tGGRgJoVV0SY5lJrGrWQ/nU4pX/4nP2Hik5884WHcnZpi8pOfZOShBz3/KqV8jnQ4kplk//QQ+6b38cuJQxycOcqUNcNP8vv5h+n/4Lajd/GV1H0MWEfR0dgdOof3tP8G/9j3IX6j6S1sM7eSLqcZzRXQMOmN9xLRN7GpqY9E51aOhEI4tkPp+ed5/sc/pnToEOV0ZtXG3uTkJPF4fMOX8rW3t694KV8mk2HwwAGcyUkmX3yR/scfJ//kk4w9+SRDP/855f5+ptMZplHobe1kmxNkYlH0piambJvpQwfJ/vCHDP/D3zP8x3/M4Xe9i7E//VNSd99N4dFHa0Epc/NmuOoqYrfcTPdf/zXq039Hy8c+SvJ3foeJ889DtbWhGQbW2+afjKL6zBn7zd9gpK2VyEUXoTo7GazwvlbPe6fqp6GhIXp7e/1SPk0jGo36pXw+ToCmaSSb/CwfATTHgqf10kxKLwM7dCbi6Q0ATUBve2zDl7H5HJwhB0p5QalZgSlXKh47OMW39g7z2MEpXLnykfDf+Z3fqWX6BgIBdu7cyZ//+Z/XZp//3d/9Xd761rcyNDTE//pf/2vebRxfwnXvvffyxS9+kW9/+9uMjIxwwQUXzLvs61//+oLbPF188YtfrPkz+/O5iozD7O91XaelpYUrrriCP//zP69d1+fjRghBa2srr3nNa/jFL34xZz1N0wiHw17JdyLB1VdfzQMPPHBSPtYjGqGccc2V8uVyOQ4cOADARRddxKc+9SmuvfZakskkW7du5Z577uGmm27iH//xH7n88su54447+OpXv8oLL7xwgvbUSqCaruaX8q1/n2Q2iz10BGt0BGGYGC0tKE2bU550vA1LL+WTrsvRU2WItLbS8Zk7KDhFMnaGrJWjaJdQSEzD5IA1zKO5X/Bk/nnKyq797qzQVq6J7eal8QuJaxGUgpJbomAXMDSD5mCC5mAL8WAcUzPn9UkphZvLoXI5tHAIvaODYHc3WjzeEP20HsfeSvskHMfLhioUUPk8zswMbqmEsGwUCswAeigEgQDCNOeUi8qZGa8cr1KSVz5wAFUsnjBmtUSC4K5dBHftIrBzJ8EdO9BjsXnH2Hx2cb4MwmSStve+l8Rb3gymue77yffJL+Vbb/BL+RoXJdvFcRXn9zQR0NfVe20fGxynVconbdBMCHiiz/c+O8LH/vM5RtKl2irdiRAfecN5vOaC7pVoNuAFX8bGxvjCF75AuVzmu9/9Lu95z3v4i7/4C973vvcRj8d54IEHuPbaaxe9zc985jPcfvvtDA4OnnTZSuCLX/wi73//+9m3b9+c5YlEgnA4POd7pRQzMzM8+uijfPzjH8d1XX784x+zadMmYC43AKOjo/z/2XvvODvqev//OTOn1+01m7rpCQmpEgUCgsHCD2zXqyIJKAgKirlIk4sg0kQgQRFEr0RB76UoXL+ISLmEEloIJJSQzWZLdrPZXk5vM/P5/TF7TnaT3WR3s8m2eT0eJ/vJnDkzn/frM/X9eb9f7+uvv57333+furq6zLYlSeKhhx7irLPOoq2tjZ/85Cc8//zzfPjhh0yfPv242T6WMWFT+d55551eJ9f69esBWLt2LZs2beJrX/sara2t3HDDDTQ1NbF48WKeffbZ4+KU6on0A3jPdIKjaSuKgqZpVFZWMnPmzEyYXc90tr7aaY9yX+30NvprD1ffD2fTYNs9ORgpm/REglTDfpL79kEqmUnbg97CiT3D5Hu2e66TbkuS1G87uWvXEauQae3tVL72D2JzJyMhY1fsdEhhtoR38Eb4fQLaAa2eImsuJ3sX80nvIoqsucbvhUYwGSKlJ3FaXJR6S8hyZOG2uHv1uC+bJElC9vnA50OPRFDr69GamrAWFGApKkJkZR2TcRJCZI6FnsfJsTr20n0cTeeTEILdu3cfwsGg2qpqpOLFYuiRCFpXF3o0hkjEEbqA7ip5Fo8XyWbrFeKrJxIkP/44k46XqKxE647A6QnJZsuk5KU/Sl5en+HC/Z03siShJ5PoiQQikcA2dQpFN9xAfO9emjs7KZ03D/8Zn0Y5KKV0NIzTsT72dF1n165dvY6DsW7TUMbp4PvDsbDJxNiEpmk0tQWwjamp2OGHLgRtgRh5fuegU/mSqsBlk8e8U0rTBZWNAWYW+yd0GpvJwQEOhgTRXZEPwyl16SPvcvDlpSkQ59JH3uX+85YcU+eU3W7PSNZceumlPPnkk/z973/nuuuuA+D0008H4KWXXmLhwoVcdtllvPLKK3R2djJjxgyuvPJKzj//fCRJYt26dfzxj38EjHvulClTWL169SHLamtrWb16da9UvocffpiNGzdSUVGB2+3m9NNPZ8OGDRQUFACwefNmTjvtNF544QWuvvpqdu7cyeLFi3nooYeYPXt2xh5Jkg4rwdPz++LiYubOncvZZ5/N/Pnzueqqq3jkkUf65KaoqIhrrrmGk08+mdbWVvLz8zPrOZ1OCgsLKSoq4v7776e0tJTnn3+eN954o0/bxxuEEMTjcRwOR5/P5scLY84xtXr16iNqhFx22WVcdtllx6lHfSM9Ozucs7eSJDFt0qTMzPN4mpEe6Cy7LMtMnz49cwwcT5u0VAqtrY1UXR2prgAWvx8lJ8coYy/EESM8hhIxlWptJfjccwM65ty/eRRbWSG1k228VhTkzeIQXR5jTz7ZzUnehZziPZFptpLMGMRScSKpKLIk4bV5yXVOwm/3o0jW7j4OzibJ5UJxuSCRINHQQGJ/I9aCfKxFRUh+PxabbdjGCWDatGkTOsIDyOjpDMQmTVWREgn0WAw1GoVQCDUYRE8kkDTNeKiy2bE4nUgej+GUkg5E7qn19YYTqtsRlaqrM/I7ekKSsE6ahK28HEe3NpR18mSU7iIAdB/buhBwmPMGXUeLxQxB9WQSXejIVhuK04GUl4vF70d2OnGsOgm/1Yq1+9iCQ68LIz1Ox/rYA5gxY0ZmX+PBpqGO07Rp0zKH4nDaZGJsQ5Zl8rO9BGLNR155HEMCcn3OIaXyJTWNguOkqXosIUswo8g34dPYTA7650AIQSylH/rFgTVA0wAdTU3x079/dIhTqnstJODGv+/kk+V5A3ICOq3KUTsGnE4nra2tVFRUMHv2bP7617+yatUqcnJyaG1tZenSpVx99dX4fD6efvppvv3tbzNnzhxWrlzJxo0bmTFjBg8++CBbt25FURRsNtshy/pCKpXi5ptvZvbs2bS0tLB+/XrWrVvHM88802u9n/zkJ9x1113k5+dzySWXcOGFF7Jly5ajsrmgoIBvfvOb/OEPf0DTtD77GA6HeeSRRygvLyc3N7fXd1brAQF7Z/cEZzKZ7JOP8YrjpZl9OIw5x9RoxX333cd9992XeYBtaWkhKysro99RUFBAc3MzVquVvLw8GhsbcTqd5OTk0NDQgNfrJSsri/r6erKzs/H5fNTW1lJQUIDH46GmpoairCxEVRV7I1Eml03ClZNDZWMj5bNnI8tyZqZY13WqqqqYM2cOyWSSvXv3MmvWLOLxOA0NDZSXlxOJRGhpaWH69OmEQiE6OzuZMmUKgUCAUChEWVkZXV1dxGIxSktL6ejoIJVKUVxcPKw2lZaW4nQ6qaqqYsqUKdjtdiorK5kxY0afNs2ePRtVVdm3b99xtcknSdTu3IkzHMbnctPicZNts+IB9gUD5LlcuKw26gJdFHk8OCxWars6KfX6sFssVHd2MDUrG1mSqO7sYHq24dCq7eqkPCeXpKbREAoyPTuHWDhEyyuv4Nj6DvGPPjJmZQYASQhsdU3MqoNZwIVAV7YNbeZkHOULoHw6ztx8gkkJVcTQiaJrbrIdeRR7cwjEBQ7FiVU27Dham0RePvu6OpnS1k6kqYk2m43yOXOI2+20dnQc9Ti1tLQgyzIFBQXH5dgbjefT3r17ycvLw2q19mmTFajYuZOpeXkQjrBnfwNTLFb0ZIK6VIrpbg8pq4VGSWZ6UQFxNUVTOMxUp5NQczMdOz/C27Cf2O7dpKqrIR4/9MDLysI1axba1CkwfQaF8+bR0f2I5nW5aYlEsKSS5FgstETCOCwWshxOmsIhPDYbPruDhmAAvyTj1nXqQiFyZQmX1Ua9rlGUlY17ymSquzl1+nxU7NnDjKIiZFlm9+7dzJgxA1VVqa6uHpXjdDyOvSlTphAKhejq6ho3Ng12nIqKiujo6ECWZQoLC4fNJlNjanxgJGeBRxOGToPAZR8fL2VDEX4fbzA56J+DWEpn3s9fGZZ9CKApGGfhjQObZN75szW4hlhgQAjBiy++yL/+9S8uv/zyTKRSTk5OJmqotLSUK6+8MvObyy+/nOeee47HHnuMlStX4vf78Xq9KIrSK2qpr2UH48ILL8y0p0+fzr333svy5csJh8N4PJ7Md7fccgunnnoqANdccw2f//znM9E6YOhJ9lzf4/HQ1NR0RPvnzJlDKBSivb09Y/vTTz+d2VYkEqG4uJinn366V4Q0HLg/RKNRrr/+ehRF4dRTT+2Xj/GI0XCPHHMaU6Mdx1JjSg2F2PXmm0y2O1DUFJIkIRwOLH4/luxscLuxeDxIFsuojfA42ll2IPMiauuOkDiWNqnhMMn9+9H2N6JpKtbsHGSbbcA6OAONmNJVldj77xN95RWib7+N6BYPBlDLJ5PYV4czTp/VCnSgwws3fFNm9n6JVU1e5u4Dd2MA6aDTW3c7SE0rRZo5Hc+8BfhnL8Tl9A7ajsFGgempFGoggJRKIft9WEtKsBYUIFmtQx6nVCrFnj17mDVrVq/0nrEW4XE051NPDoSqQiKBiMVRQyH0QBciFkeLx6A7JU+y25EdDiSbDSQpM05aLIZaU0O8OxoqWVmJ1i0a3ROSw4Ft+nRsM2dmoqEsubm9NKaO1BZCIKVSaPE4JBKgaQgJZLsd2elC8nmxeL0oLhfCZmhZHW6cUqkUVVVVmRTn0ThOx/rYU1WVqqoqysvLkWV5XNg0lHFKp7aWl5djtVqHzSZTY+r44VhpTGmaxtbXX8YWa8ZbMHE1poaayqdqglAixbwSH55xUJXPTGMzOejJQUqnl8ZUNKkNm2NqsBisY2rdunU88sgjOBwOUqkUuq7zjW98g9/85jekUimys7N56aWXWL16NWBcC2+99VYee+wxGhoaSCaTJBIJvvjFL/LYY48BsGHDBjZs2NArZa2vZasPSuXbtm0bN954Izt27KCzsxNd14lGo3z00UfMmzcvk8rX0tKSSaN77733WLJkCXv37mXy5Mls2rSJH/zgB7z77ruZ/ciykS0DhgbVFVdckSlm0hP3338/3/ve9zLbX7duHQ0NDdx///0AdHZ28pvf/IZnnnmGt99+mylTpgDGO43D4UBRFGKxGPn5+dxxxx2sXbu2X9vHG442lW/CakyNFaQfwHt6ZI+mrSgKQpaZardjycpCtloRuo6IxdDaO1CbmpEsCimnCyUnG8WfheRxG6lVo0gT52CbBtsWQjBr1qzMdo6VTUJVSTU2kqirQw+HUbKysfTQrjmcDs6R2j1P91RtLeGXXyby6qtoPS6yemEuseXziC+fT7U/xsuvPMx//E1Hp7dzSu/e3qYzZU6c8gm+eOJp5FiMk15EY+hVe9Eq9sCeWqy1jciROPYPq+DDKpJPPk+r1Yp9xgzsc+bgmDMH++zZKF7vUdnUl1aWbLViy8tDaBpaMEhi58eo+/ZhKSnBmp8PTuegx8lisWSOhZ4X0WN17KVtGsnzSagqqCp6KoUejxN9Zxt5zU0EduzAWlYGqRQilQJJQrI7kO12rF4vUg9bhKaRqqvrpQuV2rfv0JQ8WcY6adIBXajycqxlZb221Wv1/o4NVUVPJFATCUglEQIkmxXF7kApLkLx+ZBcLsNhdpgbYn9jY7VaDzkORnqcDtc+FseexWJh5syZh3Awlm0ayjgdfH84FjaZGJuQZZmCHB9dDWYqX55/8Kl8KVXHpsg4LGP/XJAlmFnsn/BpbCYH/XPgtMrsvP6U/n+sp0CxgdXB2zUdrHto6xH3t+mC5ayYlnPE9ZxDqHp52mmncf/992Oz2SgpKcFiMV7v+3Le3HnnnWzcuJENGzawcOFCXC4XP/rRjzLVdIeKSCTCmjVrWLNmDX/+85/Jz8+nrq6ONWvWHLLtnmlz6Xu63uMZVJZlysvLB92Hjz/+GJ/P1ytNz+1299rW73//e/x+P7/73e/4+c9/nll+9913c8YZZ5CVldVLe2oi4WCH0kjAdEyNMfR8dZRkGcntRnYbJZBFKoUei5Gs3wd79yLZHSgeN0puruFs8HgyIt1jGT1n3ocbQgi0jg6SdXWorW3IbjeWouJhDW9UOzqIvPoq4ZdfNjR6uqG7nSSWziGxYiGWGdNwWJ0oQuWj9ud4e7bMXV+Cdc/r5IUObKvDazil3p4tc7lzasYppQmNsCWFWp6PY04ZOY4cfIoHW30L8YoKEh9/THzXLvRgkMSuXSR27SLYvU3rpEnY5841HFVz5mApKBg2+yVFMaoX+v3ooRCJXRWk6uuxFpdgKchH6RG6OxAcy2PheENoGqLbsWR8VONvMoEejaHH44hUEqGqxN55h65HH+vlzFSys8lZtw73Jz95YJtCoLW3ZxxQicpKktXViD5S8pTc3IwDyj5zJrbp05EPEhIfkA3JpNHXZAJ0HcliQXI4sORko2RlGQ4opwvZ6ejXyTVYjKfjYKgwOTBg8jB8qK+v51vf+hYtLS1YLBb+8z//k69+9au91olGo8ydO5evfvWr/PKXvwTgnnvu4fe//z1CCM444ww2btw4KlIEzAQBA0IMPp0voen4nVYs48SToQsx4VPZTA7650CSJFy2wzyfaBpYbWCxcPLMfIr9DpoC8T51piSgyO/g5Jn5xyw67WDny+GwZcsWzjnnHM477zzAiKDavXs38+bNO6o+7Nq1i/b2dm6//XbKysoAo2DZ8UJLSwt/+ctfOPfccw/7DCBJErIsEzuoWnRhYSHl5eWj4l41UkjrJY8kTMfUMULa8zucqRKarlOXSDBNCKSDRIMBhMWC7PUie73G8mQSNRwh2d6OIsvgcCD7/dhycpDc3dFU3alUYyWlBWDPnj3HJJVPC0fQ9jeQaNhvCDgXFiJkOZOmNtRUN0mSUGMxYm+/TeSVV4i//35GN0pYFJILZhBfsQDlhHk4HB50Pcn26G7e6viI9yIVJIQx0/D2bJmtMyXm1guyw9DpgY/LJET3jS5L8RJXE4STkQNi5p6cjJg5gDwrC+vMmXi/8AUkINnYSLLbMRXftQt1/35S+/aR2reP8PPPA4bDIx1RZZs9G9vUqcjdQtZDEXQXQiAkCcXvR/J60SIRElV7SOyrx1JQiL24CDyezM2j3zRLVR0zqXySEGiJBEJVkTQNLZFEpJJIKRU1FkWPxpDUFLqqIlQVuft8R5KQZQWhKMiKgmS1EvvgQ9p/++Ah1xyts5PWe+4h2dAAFgvJykqSe/agdXYesq7kcGCbMQPHrFnYysuxlpdjy809ZJzSD219jaUEhk3xuCFOrqpIsoTicCK5nFhKirF4PGC3IzudKHb7oWOZvo4dxTiZqXxmKl/PVL49e/YMeyrfRBU/t1gsbNiwgcWLF9PU1MTSpUv53Oc+h7t7MgwMrZBPfOITmf+3trby61//mo8++gir1copp5zCm2++yUknnTQSJmSg6zqtnSHG/tTc0UEA7cHYoKOmVF3D6xjcRMVohS6gqilopLFN0HdQk4PeHAwO3e4nybifKbLET8+ex6WPvIt04Ftjle6/Pz173qhJmZw5cyZPPPEEr7/+OtnZ2dx11100NzcftWNq8uTJ2Gw2fvWrX3HJJZfw4YcfcvPNNw9Tr3tDCEFTUxNCCLq6unjjjTe49dZb8fv93H777b3WTSQSGX2qzs5Ofv3rXxMOhzn77LN7rZdKpY5JX8cSEonEiEdNmdOKw4T77ruPefPmsXz5csDw3AK0tbVlBGabm5vp6NZtaWxszIRYNjQ0EAgEAGOGMhQyQmJqa2uJRCIA1NTUkEqlmO5wUB8Kkux+UK7u7EDrflGs7jQkhzUhqOnqRHY40H0+GhwOlLx8EpJM7b4GYh99RPs771D52mvE9+yhq66OvVVVgCE419DQABghoI2NjQB0dHTQ3Nw87DbFuyM3qqqqMqGelZWVqKqKrutUVlai6zqqqlJZWYmiKEyfPj2T55vOaQUjjDS9PBQKUV9fPyCbRDLJ/p072f/OOyT37aPTbifs9SApCi2RMMGE0cemcIhQMgHA/lCQSMro775ggJhqXNDqAl0kNNWwtaOd0PbttP7qXuq/823af/Ur4jt2gBAkp5US/vezaLn5WiyXXYhYegKvRqrY0PTffLf2NjY2/w9vhj8gIZJky34ckvE4LWSJnVNktsyX2TlFPuCUkn3k4yGS1HBbcpmVM5McewkIF1bZRls0SlfcmB1I2yRJEu1eD+KTq8j73vfg5zeTc/9vyL/qKvjMZ7DMLAeLBa2zk+gbb9Dx0EM0XXMN9WvX0vSzn1Hzpz8S2bEDLRbrdexVdxrHQ1LTqO0ynCIJTaUuYBwbMTXFvqBxbETVFM1Cx1pcQkRR2FdTTfS97bS+9x77KisRut7vsdfW1kZ+fj6KohyXYw+MCh1V3edK+tgTmka4s5OaigrUzk469+6l9v33SdTU0PLee1Rv2UJ061aa33qLvW++SWzbuzTt2M7+jz4iUVND6/5GOkIhkGQ6kAg5nCiFRXT6fMSys7EWFtJmtxF1OZGdTtoffpjDIfDYYwT+8hdiW7eidXYiZBnr1Kl4zjwT7fzzKbr7bko2bSLywx+Q/c1vYlm6lH3dx1F/4xRJJWno6kQLhehqaaZhXz1aUxOBYIA2XcNWWkp8chnhqVNxLV9GtKyMkNdr9D0Wo7N7DI7FOFVXVxsaW0Icdpxg6NeIg4+9433dO5JN9fX1zJkzh2g0Om5sGso4KYpCbm4und3O2OGyaaKKnxcXF7N48WLAKLOdl5eX4ROM8d21axef/exne/1OVVXi8TipVIpUKpURoR1JKIpCUZ5/0JFC4w2yJFGQ5RpcpIwwPo4hpBiNRiiyxJzSrFHjKBgJmBwcBQdCGE4p6cAr9FkLirn/vCUU+Xu/1Bf5Hdx/3hLOWlA8HF0eFlx//fUsWbKENWvWsHr1aoqLizn33HOPerv5+fls2rSJxx9/nHnz5nH77bdnomiHG8FgkOLiYkpLSznppJP47W9/y9q1a3nvvfcoLu7N9bPPPktxcTHFxcWsXLmSrVu38vjjj7O6W3MrDbvdPuLRQiMJSZJwdsuqjGg/TPHz4cWxFD/Xw2GC27Zhy8pGsVoPjZhi4FErejKJFo1CIo7QdHDYsfr8KLk5SC4XVp8P0Z1mM5pm2WVZJpFIYLFYsFgsRzXLrqkqalsb6r4GUu1tyF4fVp/vsMLNA4mSStXXE375JcKvvIboEa2i5vlJrjwB+aRlWIsKiWgxtkV38Xb4I96P7SEl1My6hZYcVnoWsMI9n+n2Et6JfszdTX/p97j7ft5XOCvvU/hsPuwW56DEqA9nk0gmiVdWkqyoMKKqKioQ0WjvncsytqlTsc+ejX3uXCOqqo/om4G2SSZJdXYiSWDNz8dSVISSbRzzvcZP00gmkzgcjkyKxnAfexJGiqyWTCJrGnoyiZ5MGrpJsRhaLIaUShmaT6pmrCP0bptkUBSwWJAtFoSiIFkshj5cmro+xkPoOiIYJNXWhtbejt7enmmn6utJdb+kHw72efNwLVuGvbwcy7RpKN0zIAO9Rki6btiXSCAlkwgEWKxYnA4kjwfZ58PidoPdjuRwoHQXXOg5BgNpD8c4aZqGqqqZCMqJGDGVdvikdRvGg01DGSdJkojH49hsNhRFGTabRqv4+SuvvMKdd97Jtm3baGxs5MknnzzkBeO+++7jzjvvpKmpiUWLFvGrX/2KFStWDHpf27ZtY+3atXz44YeZZeeccw533nknr7/+Oh9++GHmJeRXv/oVP/nJT7BYLFxyySXceuutA97PsRI/F0Kw58OthBqrJrT4uRACTRco8gG9tiMhqerEkhrzS3w4D5feNEYghCCp6tgs8oA5GG8wOejNQULrLX5+WOiq4ZSyHyo9oemCt2s6aAnFKfA6WDEtZ9Q7/zKR/dLArwnjDSYHR8+BKX4+ypF+AO+Z53o0bUVR0ID9ySTTehw0gxGg7tmWbbaM3pQQAhGPowWDqK0tSIpC0unEkm1owgiPB9nlQjoGNg22rWkadXV1zJgxI2PTUARztWCQZF09anMTWKzYioozejdDETbXuroIvvYK4c2b0Wp76EY57aSWzUdatQzLzOmk9BjvRHbyVuO/+CBahcaBFJESax4rPQtY6ZnPFFtvXasVnvmsL/oGm1qfpkMLZpbnKn6+X/I1zso/BYvU+3Q+GoH2dFuy23EtWIBrwQIAhK6Tqq8nvmtXRqdKa2sjWV1Nsrqa0D//CYClsBD77Nk45s7FPmcO1tLSDPf9HZOZtt2OvajIcAi1d6C1tKDk5GAtKcGSm4vUQzSxvr6eGTNm9DpOBnrsCV1HT6UgmUJLJQ3RcFVFTSYRsRh6LIZIphDd6XWoKiLjUpKQLJYDjieHE8ViAYsFy2Eu6ELX0bq60NrbUdvb0draUDs6jL/pZR0dhn7BUcD7mc/g+dSnDlne1zUCISCRQEsk0BMJJKGDrCA57Fj9PkMXyuUyPg6HYXcfGK7rwmCvEZIkZa4Jo0Wk/mhtGqxQOMDevXsP4WAs2zSUcdI0LXNNOFY2jSZEIhEWLVrEhRdeyJe+9KVDvn/00UdZv349DzzwACtXrmTDhg2sWbOGioqKTBTT4sWLUVX1kN8+99xzlJSUAEZE2vnnn8/vfve7zPf/+7//y6xZs5g1axavv/56ZnlnZydPP/00tbW1OJ1OPvvZz/LKK69wyimHERI+DtB1nY5gBOuRVx3XEEBXOEGOzzHgVL6kqmO3ytjHgfA5GClce1vDzCjyTeg0NpODAxwMCkI3hM/7gCJLnDQjt8/vRjOSySR2+xEccuMcJgejgwMzYmqYcaxm+wC0UIjotm0oWdn9vhwOB4SmoUej6LEYaCqSzYbs9mDJyUHxdYuojwLl/qFATyRINewnuW8fpJLI2TlDFoTXEwlCb79B6OWXUd//KFPVTMgy6sKZSKuWIi+aT0CKszWyk7fCH/FRrBq9h4R9ma2QlZ75rHQvYJKtb5FxTejE1RhxNY4QUK+1ospQ6izkpKwTUaSRfVhU29oMR1X3J7l3b0ZDKw3Z4zEcVd2C6rYZMwbMu1BVtEAAkUyg+P3YSktR8vKQD3PxFLpuOJSSKUQqaTiVUin0ZBIRjxvi3PHEAaeTph4QxhUY55fFYgh3d39QlIxztr996sGgEYXXw9mUcUK1t6N2dEAfL4GHQJZRsrKw5OWh5OQYf3Nz0aNRAo8/fsSfF954I85uZ2KvPgqBSCaNTzyO0FTjmLPZkJ0ulCw/Svf5Lblc46JYggkTR4tjeV8fLkiSdEjE1MqVK1m+fDm//vWvAcM5U1ZWxuWXX84111wzoO0mEgnOPPNMLrroIr71rW9lll977bU88sgjKIpCOBwmlUrxH//xH8ydO5fNmzdz3333AUYFKCEEV111Vb/bTyQSmf8Hg0HKysqOSdR5XcV7dDVU4sorPSQ6GAavlZjmfaTaR4p4Hi6bOkIJ8nx2ZuR7jAhfAbIsHdru3o6uC5D6bktSdx/7aWu6QD5MGwyHQs+2Iqc1Eftui+4+9tc2bTJtSmhQHVCYNqUMp8ORmYSUkHpMSHZDS4HVBYp1RM//4Wj3hdHQL9OmsWdTIpGgurqaadOm4XQ6hxx1bkZMHSOkH5qG66FKTSaJbN1KaOs72EtLcS1YcPQC1P21ZRnF60VKV0jrTvtTq/YY69gdyD4vttw8JJcT2eNBsdmOWypfLBbDZrMNKpVPV1X09nbitbVogSDWrCzIzj4wXj1vbIdr6zrhj94nuPklUlvfRYodqG6mTS2FVctg+QkEXTpvh3fyVvMmPo7X9rqxTbEVs9IznxXu+ZTa8g+5+KRv1nEtRjxlPLA7rQ5K3CV4bF6WWE8kpQlsigVFkgfe937aA0lPPFxbyc3F9clPZqrBaZEIqT17iHdHVCUrK9HDYWLbthHbts0w0mIxqr/Nno1tzhycc+YgezwHUk179FEoCnJODpKuowaDRD78EMXjIdXWRiIYwlWQj33OHGO78ThqNArxBOgaWiqF1O0ISj+AyBYruqIgWyyGc8vlQuoWF+/vfNKFgFCIVGsrakcHenu74YDqjnBKRz4NyOkkSShZWSh5eVhyc42qmbm5WPPykHNyjHZODiIdodiDa3Sd8P/9H1p7e7+bV3Jzsc2ZYxxTmoYaj0M8Dqmk8aBosyLbHSgF+Vj8WUhOBzgcWFyubp56p1aN9rS3g1M6J2oqX8+ZrvFg01DGSZIkotEoDodjWFP5xqL4eTKZZNu2bVx77bWZZbIsc8YZZ/DGG28MaBtCCNatW8fpp5/eyykFcNttt3HbbbcBsGnTJj788ENuuOEG3nzzTV5//XXi8ThWq5XNmzdz8cUX97uP2267jZtuuumQ5S0tLWRlZWU00AoKCmhubsZqtZKXl0djYyNOp5OcnBwaGhrwer1kZWVRX19PdnY2Pp+P2tpaCgoK8Hg81NTUkIgnEQI6gnGyPHYsikRbIEauz4kkQVvAEAUXwhAIL8hyoemCrnCCPL8TVdMJRpPk+pykVJ1wPEWO10EipRFLqGR7HcSTGomURpbHTiypklJ1/G470YSKrgu8LhuRuKFJ6XHaCMdSyLKE22ElGE1itci47FYCkSR2q4LTbqErnMBpt+CwWegMJ/A4rNisCp2hOD6XDatFGbBN+X4n8aRKOJYiP8s1IJsSmkasu89dkSSxpEppjpuOUIKUplOc7aItaDwLFfidNAdiWBWZPJ+Dxq4oTpuFHI+dho4oXqeVLLeN+vYI2R4bPqeN2tYwBX4HHoeVmpYQpdkunHYLVU1BpuR7sFsVKhsDzCjyIUsSlY0BZhb70YWgqinInNIskqrO3tYws0r8xJMaDZ1Ryot8RBIqLYE40wu9hOIpOsNJJue5aemKkdB0Jud5xoVNU/I9BKIpQrEUZXnuI9qU73NQ3xbBZVfI9zvHhU2DHSevw0plY5CSHCdWqxVV1zNP6olUOs0R4ikNu1VBAuJJDYciISSJRDyO0+lECNHrGSTdTqfY27sLv6Tbmqah6zo2m61XW1WNCdJ0G8BqtZJKpZAkKdOWZRmLxdKrnUwmsVgsKIrSq51IJLDZbEiS1Ksdj8czmkrp9Pf0OuPFpnTfB2pTumCKpmnjxqbBjpPFYsk87wzWJjCex6PRKE6nk5qaGkpLSzPtgcKMmBom3Hfffdx3332ZspsVFRXMmjUrI4JeUFBAY2Nj5qGqoaEh81BVX1+feajau3dv5qGqurqagoIC9Ndfp+FnP4O2Ay+jck4OuRdeSOOsmUzNykaWJKo7O5ienYMuBLVdnZTn5JJQVRpCQaZn5xBXUzSFw0zNyiaaStIWjTLZn0U4maArHmeSz08wESecTFLi9dEVjxFXVYo8XjpiUVRdkO900hboQk8kyRGCNqFjdTjILyyiRVNx+f3klpSwb9++w9rk8XjYs2dP5qDdvXs3U6ZMwW63s2vXLmbMmIEsy1RWVjJz5kx0Xc9U3qqsrESSJGbPnk0sFqOhoYHy8nLC4TAtLS1Mnz6dYDBIZ2cnU6ZMob2ujs76egqiMYKKQtLhoNjny9hU4HbTFjUEb/NcbloiESyyRI7TRVM4hMNiwdLSSPMLLyC9+TZyR1dmHPRcP/HlS1FWnUigwMbLXR+xI/4RlYm63s4oaykneeez0jMfWyqXHJcRVNQZg1y3hKoLAnFwWuNEknGSmo1sp4xL8aHqNqbn5BFPaXTF45R4fexub8Nrs1Pq63ucBmJTlsPJ/lAQj82Gz+5gXzBAlsOBx2anLtBFnsuFy2qjtquTIo8Hh8VKdWcHpV4fdouFPR3tAzr2pnl9hPZU0vH+B7j27iX28ceI4IF0xDSU0lJE+QxyFp5AYvo0ktnZFHsPHafU1ndQH3mkd7U5vx/Hl79E3vIVNGoaHpsNv9NJQyxGlsuF1+Ho36aOdoqQULq62FdbS248jt7RQVfjfpzBEGpHB2p7e8bBdVhIErLfj56djaugAC07C9XnJ6e0lJjXQ8rvp6h0Ep2p5JDHqe6l/0O/7zf9diH30ktpnjWTYkXBbrVSo6pMKyjA4vNR09FB+cxZYLNSXVvLnDlzSCQS7N27l1mzZg3ofOrq6iIUClFWVkZHRwexWIzS0lLa2tpIpVIUFxcPy3VvoNeIiooKLBYLkydPpnac2HTwde9INjU3NyOEIC8vj0AgMC5sGso4FRQU8MEHH1BYWEhxcfGw2fTuu++ydOnSMRUxtX//fkpLS3n99dd7VcS76qqrePnll3nrrbeOuM3XXnuNU045hRNOOCGz7OGHH2bhwoW91ks7ptIaUz/5yU/429/+hizLfPrTn2bjxo1IUt/5QscrYiqZTLJ96xYskSbc+RM3YgqgIxgjy+vAknb2HsYmISQ6IgnmFPnIdlvHRSSOAKqbg0zN92K1yOPCpsFGFwnRzUGBF6sijwubBjtOuoCq5iDTC7yoQhpYxJSuG2eS3WN8O0quBUcTiZN2aKQntkZDv47WpoNxpN+Ndg6GYtNg22kO0k6xwW5nuCKmTMfUMGO4xc/Dz79AwxVXHJIalUbelVfiXrkSGMaIKQYecaOlUkbKXyyGrqlIdjsWtwc5JxuL34/i9RopUX3Yd6xn2bVIBLWxkeS+BnRdw5aTi+j26h7JPoFOtLOF4KuvkHj1DeTafRnOhcOOWLYQsWoJrVOzeSv6EW+HP6Iy0VuUeqa9zBAw98wn35LV5/gJAQk9TjQVRwgdp9WJ3+bDY/Phs3lRJGVYxulYRkwN9tjTdZ1UU5MhqP7xx8QrKlC7K231hJyVhWPOHGxz5hgpgNOmEdm6lbbDVPnIv/JKnCtXZvqo6ToiFDKEw7uFxLUeYuJat9OJgZSJlSQUvx8lNzeTYndI1FNODih9j9lwjBNCoKVSxN58k66DnHNyVhbZX/86npM/heTzoXg8KC4XwmZD6b7ZHo+olfEYiWPaNLFtGq3i5z0hScPvmBoJHMu0ydqPt9G5bzee/Ikrfj5YxFMaSU1nQYkfu8Us5G1ifCKuioGJn+spkC1gcx+/zpkwMQZgip+PcqQfwNN/h9KWhKD5ttv6dUoBdD70EO7ly5EUZVDi5wNpD0QkW7FaUaxW6D7Q9ETC0Keq7kQFJKcTxZ+FJSfb0KZyuzM6PUMRzBVCEIlEcLvdmf4eLJgrVBW1uZlEXR16OIySlY3V6ezFS1826UIjFA4QfOct4q9uQf5gN5KuI2PoRrFgFuKkJTTNK+St1G7eCv+L6voDDhUJidmOKUaanmc+uRY/fUEIQUJLEFVjCKFjV+wUuPLw27PwWN1Y5N7yrAePjRCCmJrCabEOeJyOdXswx54sy9hLSrCXlOA97TQAtECAREUF8W5nVaK6Gr2ri+ibbxJ9803jh3Z7RserP7Tddx/Ot95C73Y4aR0diO7S9UeCkpVlOJ26nUxpXafM/7OzewmvHw5DOZ+ErhupgKqKpmkZwXVNUzNT3ZJiVPpzLV6Ea8mJJKqriYdCeMrKcK1cieL1HlZ763gIUA9neyDXBVmWM9eE8WLTUMTPw+Ewbrc7s6+xbtNQxkkIQTQazdwfjoVNYwV5eXkoikJzc3Ov5c3NzRQVFY1Qr0YOQggSSfVwj1MTAkIIUqqOdYDV2FKqwGFVsCnjxyklhCCSUHHbLQPiYDzC5KA3B4P4keGYGkdITwqlJ2ImIkwORg8H4+vsGmeIvrMNtanpsOto7e1E330X17Jlo+Jkku32zIux0DREPI7a1kaqsRHJoiC73UakSXdEh+R0DqrfQghaWlqYOnXqIb8TQqB1dJCsq0NtbUN2u7EUFR92+6pQiSTDhHZ+QOyV11De+RA5liD9GiKmlCJOWkLjiZN4U67hrfCr1DY1Zn4vITHPOY2Vnvksd88j29K3J1gIQVJPElNjaLqGTbGR58jDb/fhsXmwygMXmRZAWzTKJJ9/wFV1RjsUvx/XihW4usuY64kEyaqqjKh6fNcuRDR6xO2IWIzoq68eslzOysLSQ0Q842xK/83JGbDTaShIi7HTLbYuNC3TTiPtdEqLrcteD7LTiex0IlmtxnKr1ehn91/XypXU1tZSPHVqr5fqiYTDXRMmCkwODJg8HIDNZmPp0qW8+OKLmSgqXdd58cUXueyyy0a2cyMAIQShaJyJeZXsjXA8RbZnYJWXEppGvtfGeDqdhICWQJyp+Z5xZddgYHLQm4MB/sL4I42/q4iqqtgmeLEbk4PRwYHpmBrFUFtbB7Re6x13IDmdWAoKsBQUYO3+aykszCwbiSp6kqIgud3I3bPXIpVCj0aNqm26QHLYjXSj3FwUrxfF7UY6wgkhyzLTp08/ZLkWjpDaV09qfyNIEpbCQqR+ZrlTepJIKkpoX43hjHprB0pbV6aMtMj2Iz5xIk3LpvCqt5G3ItvY1/XPA31AZoFzOis9C1jmnovf0v9NLaElianRjDMqy5ZFliMLt9WNXRnamMiSxGR/1pB+O1Yg2+045s3DMW8eYDh2An//O12PPHLE37o/+Umcy5YdP6eTpvVyNA3I6eRyITsdh3U6DeTFWpKkPs+HiYT+rgkTCSYHBiYaD+FwmD179mT+X1NTw/bt28nJyWHy5MmsX7+etWvXsmzZMlasWMGGDRuIRCJccMEFI9jrkYEsy+RleegMj3RPRhaSJJHjHdyzh9M2vl4VZFlieqF3pLsxojA5OIgDfQChlEKAJI07x5QkSRltpYkKk4PRw8H4utuMIqT1LI5G70LJyx3w/kQsRmrvXlJ79xLr43vZ5zvguCosRMnPRykowFZYiJKbC1brsdcuslqRfD4s3Wl/WiyGGgyhtrUhJAnZ5TKq5fn9WLxeZLfb6MtBGiXBYBC3243FYkFPJEg0NqLta0CLRZGzc7B0VyfQhcjYFNfixNQogfYm4m++heWtHVirG0i7wYTdhliygKYVU3m5qIu3YjvZn3oNuiV8FBQWumaw0j2fZZ55eOTu1EDpUBG4pK4SV2MktSQ2xY7P5sdv9+OxeHBYHBk9pqHqf0lAOJnAZbWhyCNflQ+Og76ZJGEvL+/v8O8F95ln4pw/P9PHNIZiE91OJ6GqSJqG3u1wkjQNgSHKqVgUhKKAoqBYrUguJ1K6yp3FYiy32411rFajnbavn+tC+lrQc3l/OjjhcBifz9crBHc86vwcripfJBLB6/UixMStyheJRPB0V1IdDzYNZZwkSSIQCOD1eidEVb533nmH07rToQHWr18PwNq1a9m0aRNf+9rXaG1t5YYbbqCpqYnFixfz7LPPUlhYOFJdHjEIIYgnUmYqnxAk0lXGjjD5oWnGM9R405YSQhCKp/A6BjYBNB5hctCbg4FBN5xS48wxNVpSuEYSJgejh4PxdXaNIO677z7mzZvH8uXLATLVjtra2jLljpubm+no6ACgsbGRrq4uABoaGggEAgDU19cTCoWM9XNzUQoKOFycrcjOpuRPf6J4wwa0yy8n+zvfwXP22egnnoht2jSk7mglPRgkuWcP0ddfJ/Dkk3Q8+CCtP/85DZdfTt03v0ndd79L4w030HjvvTQ88gjhzZvp2LGD5vo6hK7TFY/R1p1K1RGL0hEz2m3RKF1xwxXWEgkTTBhlW5vCIUJJo9LO/lCQSMrQ+dkXDBBTjfKT+5IJNL8Pa3EJ+6w2UkCquYWK7dsJbXuXyLZtfPz22yRbWkiGw1RWViKEoLW1lao9e0i1tND53naqPvoIFAU1L4/93fuPpJLs7WqnPd7Gx80V7Hr+aVrvvAvW/wznfz+DtboBIUmoc2fStPYzPHLdJ/jBGfu4wvV3ngy+wv5UG1bJwiLHHC7K/TIPTruW7+Wcz0nupXgVF8EEJLvfVQJxiKkqgWSQhlCESDKGx+bGrZQyw19OedYMAjEZq2I3qsF0diAATQiqO43jIalp1HYZXrCEplIXMI6NmJpiXzCQsWl/KIgAmsJhmsLG1G8wEaclYrSHe5wA6gJdJDQj+qe2q5Nk90tadWcHWrcz6WhtAgglEzSFQ/3a5Jg7Fyknu99zAUDJzaWzbNKAbIonk+iJBDWtLcQDAdSODvbs20e8sZFkUyN76upQ29tIhUPUBLqQFBnd46bBYccxexbSzJm0FBbgWrIEad482goLca1YgTZ9Oq1OJ7bJk4m6XDQnkyhZWQRTKZrb25EkiY6Ojoz2y9FcI2prazMV2WpqaojHjXGtqqoi2a2tVVlZiaqq6LpOZWUlum6Ujq2srDTGKZmkqqoKOCBeCBCJRKitrTXGJhSivt4Q9w8EAjR0i9V3dXXR2Giktg6nTZGIUalwoDZ1dHSQSqXGlU2DHafOzs5xZ9Ngx0kIQX19Pa3d0cbDZdNgSh0fT6xevTrjrOv52bRpU2adyy67jL1795JIJHjrrbdY2V0sZaJBCEEkPjC9wfGOWGIAFWaBpKZjs8g4rGNPY+1wEAI6w8kJ7aQ0ORgCB0KApBz2nWw04qmnnqK8vBxFUbjiiiv6XEc9qOq0EIKLL76YnJwcJEli+/btfS5bvXp1v9scaziYg4mI0cCBWZVvmHHMqvJBnyLoA6nKp0UiaC0tqC0tpFpajHZzs9FubT2yOLTFgiU/PxNxlU4TtBYUIBcUIHs8fUbuHE0kjkgmEbEYWiyKJEB2OpC8Xmx5eUh2O8mmZvSWZoRiQc7KQrFY0IVGRI0SV2N0RDuIV+7B9tYO7O/uQo4ciCMTk4ppXT6Nl+bqvKzsoU3tynxnk6wsds1khXs+SzxzcEr9lw5VdY24FiOuJrDKVjw2N357Fl6rB5fVRXel2uMfXTTI9piImOpuh998c0BV+dA06I5wQlV7tSXZKBcsKzKS1YqQZWSLBdnpBLsdpTu9TlgsRgSU1YpQFJTudNiJFIlj2mTaZNo0NqryjReYVflGDwJRI5pkdtFANXhMmBibGFBVPi0JVidYDle1T4O9r0O4GTyFMGUVyMfWsbtu3Tr++Mc/AmC1Wpk8eTLnn38+1113HRaLhcLCQi644AJ+8IMf4PV68XqPnML5z3/+k3POOYfNmzczffp08vLyeP755w9ZFgwGsVqtA9rmQLFp06ZMurksy/h8PmbNmsXnP/95fvjDH+L3911Yqi9s3ryZ0047LfNObuLYwazKN8qRfgDvKUg8lLZvzWdg4waab72tlxC6kptLzgUX4P7EJzLL+quMZvF4sHg82PvQ3hBCoHV1oXY7rjKf5mbjb1sbqCpqYyNqY+MhvwcGpW814GpvdjvY7ViysoyXkXgcrbOLrtdfJ9oVwJ2VhXPFCmS7lagaIxwJ05XoItG8H+Wt93G+vRN/S8cBO/1e2pdN59UFCv/y1tKhvW14UFSwSzaWuGez0rOAxa5ZOPoRIpckCU1oRFNRkmoKRZJxWd0UuYrw2D24LC6kHkGIco8BGWoFu77aQghCyQRem31wnB7D9tHadHC7v/14PvEJpCuvpOOhh9Da2zPLlexs/F/6ErapU9CamgxNp249J8miIHncWNNC4j30nNJtBqjpBP1XFEv/vr/20V4L+mqnU5f8fv+oqYw2nO2BVuU7mIOxbtNQqvJ1dXXh9/sz+xrrNg1lnIQQmQegY2WTibEJIQTR+MSOEIHulMakhsN25FS+lKbjdYy/Y18IQSCawu+a2GlsJgcHOBjA2safw6Xx7fw7PHs1BPcfWOYrgbPugHn/31H19Ug466yzeOihh0gkEjzzzDN8//vfx2q1cvnll9PS0sKaNWsoKSnp87dCCDRNQ1EOXBOqqqooLi5m1apVmfX6WpaTk3NM7PH5fFRUVCCEoKuri9dff53bbruNhx56iC1btvRry1DRFwcTDaOFA9MxNQbg+8xn8H760wRffpnGt94ib/IUXAsW9CvuPRhIkoQlOxtLdjbMnn3I90LTUNvbezureny0zs5B61v1irzKyzuiMLUkSUR37OjljIgBZGeR+Lc1RGYWY313F86tO3FU1h3ou81K1wlTePMEG08VNdApPjK+0MAp2VnqnsNKzwIWuWZik/vvgyZ04mqMuBpHlmRcFheF3iI8Ng9ua29n1PGAAMLJJB6bfdxU5RsMnCeeSOGUKST2VNIVDpNTUop7yYlGlcejdDqNNQghCIVC+Hy+cWvjkWByYHKQhsmDif5gOGRSI92NUYFEynBMHRESA1tvjEEICMVS+JzWsZaVNWwwOejNwYBWPpy+1M6/w2Pnk3FgpRFsNJb/25+OqXPKbrdTVFQEwKWXXsqTTz7J3//+d6677joATj/9dABeeuklFi5cyGWXXcYrr7xCZ2cnM2bM4KqrruK8884DekdgSZLElClTWL169SHLamtrWb16NYsXL2bDhg0APPzww2zcuJGKigrcbjenn346GzZsoKCgADgQwfTCCy9w9dVXs3PnThYvXsxDDz3E7B7voJIkZewpLi5m7ty5nH322cyfP5+rrrqKR7oLIem6zh133MGDDz5IU1MTs2bN4j//8z/5yle+Qm1tbUaDMTvbkAFJ6y/2hXTE9kTGaODAdEyNEUiKgmf5ckplGSUre1icUgPdr7U7EooFCw75Xk8kUNva+nRaqS0t6OGwoW/VrXF1CGQZJSfn0Iir7qgrJTub6Ntv09pH+pbo7ML220exKTKSZqRpCEkiPLOYd05w8sS0Vlottd0rg1t2sNQ9l5WeBZzgKscq9X/460IQU6PEVUOryG11MckzCa/Ni8vqQpZG7sSVJYkS78RLJ9GjUfRgACxW7CXFuJcuIT8rC0k+vo7B0QRZlikrKxvpbowoTA5MDtIweTDRH2RZJsfnpjM40j0ZWUiSRJbnyJWXVFVgkSUclvH3oibLEmV57pHuxojC5OAgDg6uyicEpHpMtevqAcfUwZ48XYN/XsUhTiljQ4BkRFJNXz2wtD6r66h1rJxOJ62trVRUVDB79mz++te/smrVKnJycmhtbWXp0qVcffXV+Hw+/vGPf3DBBRcwe/ZsVqxYwcaNG5kxYwYPPvggW7duRVEUbDbbIcv6QiqV4uabb2b27Nm0tLSwfv161q1bxzPPPNNrvZ/85Cfcdddd5Ofnc8kll3DhhReyZcuWw9pUUFDAN7/5Tf7whz9kIntuu+02HnnkER544AFmzpzJK6+8wnnnnUd+fj6f+tSn+Otf/8qXv/xlKioq8Pl8OJ3OPrctSRK2I1SFH+8YLRyYjqkxBF3XCagqWUIwWh4VZLsdW2kpttLSPr/XIxFS/aUJtrQgkkm0tja0tjYSO3ceugFFASF6aRilkfm/phMr9LN9sZcnZnVS72nJrOOVXSzzzGWlewELXNOxHMEZFVfjxNQYEhIOi4MSTzE+mw+X1YVymN8eT+hCEEzE8dkdvdLcxiOEEIZzMxxCcjiwlk3GWlSI7PMhhKCzq4usrKxeKTgTCbqu02VyYHJgcgCYPJjoH7quE4klzFQ+IYglVZw2y2GjChOqhl1RsI9Dx5QuBF2RJFlu27h/huoPJge9OTgEqRj8csYw7UkY6X23D3DS5Lr9YBua01AIwYsvvsi//vUvLr/88kykUk5OTiYCqbS0lCuvvDLzm8suu4xnn32WRx99lBUrVuD3+zOVbdO/AfpcdjAuvPDCTHv69Once++9LF++nHA4nKkaDHDLLbdw6qmnAnDNNdfw+c9/nng8fog20cGYM2cOoVCI9vZ2/H4/t956Ky+88AInnXRSZp+vvfYav/3tbzn11FMzqYYFBQWH1ZgaLWlsI4nRwsHoeNM2MWDEuwVcxwpktxv7tGnYp0075LsB6Vt1V4A70ilyx+khdk41qin5FTfL3fNZ6VnAPOdUlMNEN6WdUXE1jkDgtDgpdhfjtXlw2zyHdWSNJOKqiu/Ik55jFkLX0UMh9EgY2ePBPqMcS0EBiufAzVoIQSwWm/CChiYHJgdgcpCGyYOJ/pBStZHuwqhAStVxHmFiPKnp5LptKOPRvysgllTJctmO/HA5XmFy0JuDMY6nn34aj8dDKpVC13W+8Y1vcOONN5JKHZq+rGkat956K4899hgNDQ0kk0kSiQRu99FH0G3bto0bb7yRHTt20NnZmSk6UldXx7x58zLrnXDCCZl2cXExYFSznzx58mG337MI1Z49e4hGo5x55pm91kkmk5x44omD7vtoSGMbaYwGDkbnW/c4QPpkHM4KQZIkUdgdZieEGLHKaMNV7U0ASlYWluxs9FmzDlknlojQ+P+eQHn06SPyXRpzMMm3hJWe+cx1TiUtoy1Jh1bTEwKSeoJIKoYQOk6rg3xXHj6bH6/Nm0nTG80V7ArdnkzQ8HiqyqdrGiIYRIvHUHw+7HPnouTmIjsch5w3YNzQJnIVMYCSkpJxZdNgx0kIkRHCTM/2jHWbBjtOYMyCppePB5uGOk7ph9z0fobLJhNjG7Isk+V10RkY6Z6MLCRJwu8eQCqfLnA7xucrgixLlOaYaWwmBz04ODiVz+qEK6u6/yNAU8HuArmPc2Lv6/Dnrxx5h998wqjSdyRYXUde5yCcdtpp3H///dhsNkpKSrBYjH52dXUdsu6dd97Jxo0b2bBhAwsXLsTtdnPFFVeQPFKF9iMgEomwZs0a1qxZw5///Gfy8/Opq6tjzZo1h2zb2kNbOP0sm75HHw4ff/wxPp+P3NxcqqurAfjHP/5B6UFZO3b74GbuR0sa20hitHAwHudCRgT33Xcf8+bNY/ny5YDh+QVoa2ujra0NgObmZjo6jEpxjY2NmQtGQ0MDgYDxtFRfX08oFAKgtraWSMSIAqqpqSEai9GpqtQGAiS7H5SrOzvQul/uqzs7EIAmBNWdxn6SmkZtVycACU2lLmDsM6am2Bc09hlJJdkfMoQXQskETWFj/8FEnJZIGICueIy2aBSAjliUjpjRbotG6YobedgtkTDBRByApnCIUNLQZ9ofChJJGRelfcEAMdXw4NcFukhoqmFrV2fGpqqOdlqibewJVbPDNzCx0tMnn855uV+gVJqGLMkkNQgauyehQSgBcTVOazREUySEqqu4LTnkO6YwN2cubks+mm7DIluOiU3DOU66EOwLBmgMjew4DadNIpWiq7mZ/Y37kV0uklOnEiguxl5WRlc0SnNzs2FHj/OpqamJmpoadF0f0vkUjxscVFVVZW6alZWVqKqKrutUVlai6zqqqlJZWWnYlExSVWU8rKRLo4JxQ66trQUgFApRX18PQCAQoKGhwRibri4auytbdnR09GnTYK8RNTU17Nu3D13Xx41Ngx2n3bt309raSjKZHDc2DXacampqaGtrIxgMjhubhjJOuq5TVVWVuf8Ol03pfpkYu9B1nXA0bqbyCUEknso4tPtex5C4GY/6UmBM5rUF45lJuokIk4MjcCBJYHMZH6sD7G6we40Uu4M/M043qu/1G3omga/UWK+v3x/8GUIaldvtpry8nMmTJ2ecUv1hy5YtnHPOOZx33nksWrSIadOmUVFRMeh9Hoxdu3bR3t7O7bffzsknn8ycOXMy9+LhQEtLC3/5y18499xzkWWZefPmYbfbqauro7y8vNcnrTWZdrQcaXJJCEEqdfjr4njHaOFAEiPdg3GGdKnqzs5OsrKyhnVGWguF2Ld1K3m5eVi6K42N5YipvtpxLcb+0H7a4x3YLXa2R3Yz/6ZHyQn17UXVgQ4vfHzTv7PKtxjoHSWV1FNEU1FUXcVhseO1evHbs/DaPFhk23GxabjHCaA1EiHX5cIiy2M6YkqLx1EDXSiShJydg6W4CFteHqI7suJw542qqrS0tPTKdx+LER5Hc43oyUF6P2PdpsGOk6qqtLa2UlhYCDAubBrsOGmaRmtrKwUFBUiSNC5sGso4geGwLigowGKxDJtNnZ2d5OTkEAgE8PkmXuGJ44n0M9Rwc63rOh9sex2tsx5vwaRh2+5YgxCCcCyFx9l/tdqkqhNPacwv8eOwjr/5a10XNAdiFPqdyPLEzGMzOejNQVKHmqDCtMmTcTgOirbRVZCVw+s+ZaryQW8R9G5uj2FVvnXr1tHV1cVTTz11yHddXV1kZ2fz0ksvsXr1agDWr1/PE088wf/8z/+QnZ3NXXfdxeOPP85pp52W2caGDRvYsGFDZoKov2Wre1Tla21tZdKkSfzwhz/kkksu4cMPP+THP/4xu3fv5r333mPx4sWZqnzpd2SA7du3c+KJJ1JTU8PUqVPZtGkTP/zhD6moqEAIQVdXF2+88Qa33norQghee+21TGT09ddfzwMPPMBdd93Fpz71KQKBAFu2bMHn87F27VoaGhooKyvjoYce4nOf+xxOp7OX1lUaaaeMdRxX8T4SjpaD9OTitGnTDtEKG8x9fXzG6Y4CpB/A03+Ptq0oCigK+VYrSvfDMtBLtLDnYZRuS5I05HbPbR/rtkCjPd7B/vB+klqKbGcWzakO/l9wC1vPlPmPv+no9HZO6d12bjpTZo3Vn+EkoSWJqzFSWgq7xU62PQu/w4/H6sGu9C2sdzxtHY5xKuxxYT2efR8um0Q0itpdYc9RVISluBilR4W9ntvr75ywWCyZFC4GsP4h59MQ2pIk9dtOH3/9tYfrWjAQDsayTYMdJ6vVeggHY92mwY6TxWLplcI2Hmwa6jj1PBaOhU0mxiZkWcbvcdLZNdI9GVlIkoT3CJo6SVXHZpGxW8afUwpAliWKswefLjWeYHJwEAcHp/L1hNBBPkKK07z/z3A+PXu1IXSehq8Ezrr9mDmlhoLrr7+e6upq1qxZg8vl4uKLL+bcc8/NRBEPFfn5+WzatInrrruOe++9lyVLlvDLX/6S/+//G7ztwWCQ4uJiJEnC5/Mxe/Zs1q5dyw9/+MNejo2bb76Z/Px8brvtNqqrq8nKymLJkiVcd911gCFxcNNNN3HNNddwwQUXcP7557Np06ZD9jda0thGEqOFAzNiaphxrGb7AFKBAA1vv01eXj5Kj/zcsY5wKkxTpImOeDtOixObxc7/dr7MUx0vo2KEX66o0Fn3vE5e6MDv2ryGU6pqfjZ3l/2QuJogpSexyjY8Ng85jmzcFg8Oy+GrPIw16ELQEYuS43SNqWoqQhxUYa+gMFNhbyjeeV3XaWtrIy8vr9cL5USCyYHJAZgcpHGseDiW93UTvXEsI6Y+fPcN1I66CR8xFYmncDv6nxVvDycp9juYkjs+HRfpFK483/ivbNwfTA56c5DUDhMxpSWNaCllAO9dumZoToWbwVNoaErJo3tiQwiBqqpYLIev1DmeYXJw9ByYEVMmxjxUodIebaMp2mRESTmy2R2v43f7/5f9qVYAFjnLWWabyX/N/idbZ0rMrRdkh6HTAx+XSQhZ4ju+k4mrcdxWNzmOSXisaWfUxLy4jDYcqLAXQXa7uivs5aP0EU5rwoQJEyZMmBg5CCFw2Ub3y7QJE8cHuqH5JA1wokNWYNrJx7ZLJkyMY5iOqTEEWZbJtVrHxexGOBmiMdJIZ6ITl8WN3SLx+6YneSnyHgB+ycVax2mcZJuDZLfiz/WwKfAcO6ccCDXNlj2cb1vNGSzGJWfj8eQjWUc+DPFYQ5Yk8lyjv5qK0DS0YBARj6F4vdjnzsGal4fsdA7L9mVZpqCgYFi2NVZhcmByACYHaZg8mOgPsizjczvo7BzpnowsJEnC4+z/OUnXjWcMh3X8OqZkSaLAPzzPIWMVJgcHc9BP8pAQhlNqoI6pMQhJknpVyZuIMDkYPRyYjqkxBF3XaU2lKBCCsfrIkNJStAQaaA02oCeSZOHgTfUd/pR4maAwqsZ92recr08+F487G+w2sNtYYVvE3NRneK/5PWKhGLOKZ7Gq+BN4EzJ6KITa2oYWCCBSKpLdjux2Iw+yXOhYgS4EbdEoea7RmconUqnusUihZGdjmzEdJS8PeZhzl3Vdp7m5mcLCwgmbvmRyYHIAJgdpmDyY6A+6rhMIx8yqfEcQP0+qmqEvNQ5Fz9Mwhb9NDqA3B/1C6CBbh1Qpb6zAFP42OYDRw4HpmBpjsIyhE0aoKiKZRCST6Mkk4XiA1lgLAS2K251FV5bCb7qe4f34bgAmuUv4zsLvMCdvXq/tpLQUndFWrIqVNVPW4Eg6KMovMl483EBODrayMvRwGC0YRG1pQQuF0DrakWx2ZJdr2KJ0Rgsso/BBQk8k0AJdSICSk4u1uBhLbg7SEUrXHg1Gg3d/pGFyYHIAJgdpmDyY6A+KLHH4ouETA4dzRCQ1gcsuY1PGr2MKCayKPLHVHkwOBsaBEKNeI2o4MFGdMT1hcjA6ODAdU8cI6dLUw1mOW5Iksrtf8oUQxjpCZK6pAnq1ZUkyymsPsa13Ty0eqS00DSmVQkskEMkkkqYaFfQUBdluJ2WTaXMImnw6uq0IrzeXZ5te4ok9fyOlp7DKVr5Y/kXOnnE2VsWK0AVIoAudrngXKT1FoauQSZ5JZDmzMmXF0zykS4zLXi+Sx4O1tBQtHEYLBNA6OlA7u0h1dqBYbeByITmdKLI8YPt6tiXoxftg28M1TtkOZybweCh2DKdNeixmOKQsFiz5BShFhdhyc6H7GFYOGqehloI/uA2Qk5MzpsvbD6bdlx0Aubm548qmwY6TEILc3FwANE0bFzYNdpwA8vLyMsvHg01DHaecnBzSGE6bTIxtyLKMx+Wgs2OkezKykCQJt6N/521S0ygap9HmaciSRJ5vfBXFGSxMDg7moK9Qyu5l4ziND0ZPCtdIwuRg9HAwvs+244j77ruPefPmsXz5cgBaWloAaGtro62tDYDm5mY6OoynosbGRrq6ugBoaGjIlOmsr68nFDJKz9XW1hKJRACoqakhGovRnExSGwiQ7H5Qru7sQOt2WFR3diAATQiqu5++kppGbZchqpDQVOoCxj5jaop9QWOfkVSS/aEgAKFkgqawsf9gIk5LJAxAVzxGaySCnkjQ1t5Oa3MzqaZGmhv20dHSjEjEadNUon4fjjlz6CopITVrFrEF0/jAkaLGo+Ism0xdNMD1797Cf+9+lJSeYl7OPH5xyi9Y7VyNpBkv2h31HYTjYZrDzajNKvNz5zPTP5OmvU3ous7evXvZs2cPcKAKAEAkEqG2thZJkogKQZOm4TrhBNRZM+kqLsZSkE8wGqWpYR+p5mY6OjtpDRv2dcSidMSixphFo3TFjbTClkiYYCIOQFM4RCiZAGB/KEgklQRgXzBATE0BUBfoIqGpxvh1dR6TcdKFoKark8ZQ3+PUFo0ec5uEEFQ1NxFv3I8Wi1HvdOJYtAjL7FnUtLcjyTLJZJKqqqp+xwkgFApRX18PQCAQoKGhwbCjq4vGxkbDjo4OmpubDTt6nE9NTU1UVFSg6/qQzqd43OCgqqqKZNKwu7KyElVV0XWdyspKdF1HVVUqKyuNcTrGNg32GlFTU0N1dTW6ro8bmwY7Trt372bfvn0kk8lxY9Ngx6mmpoaGhgaCweC4sWko46TrOrt27crcf4fLpnS/TIxd6LpOVyhqpvIJQSCSyDi0+4JjnAuf67qgoSOCrk/cg8HkYAAcTAB9KTCuCclk8rDXhPEOk4PRw4EkRroH4wzpkoidnZ1kZWUN64y0FgrR8s47+HJysXTngB6riClJVdESCfRkEimVQtc0JAlDt8lqRXa7sfh8YLcjOxwoTieiu0+yLBNNRtkX3sf+yH4kIWG32Hls92O8sPcFBAKv1ct5c8/j5EknGzPh3VFSqq7SHmnHZrUxyTOJIlcRDqsxo5Hmo7OzE5/Ph9VqHfQsuxqNogWCiEAXyfZ2RDSKJMvgdCG7XCgWy6iPmAIIxGN47Q4sQ4z8GqpNmqYhQiFENAouJ7biYiwFBUgu13GPxFFVlUAgQHZ2dub8G4sRHkdzjejJQXo/Y92mwY6TqqoEg0GysrIAxoVNgx0nTdMy9570NXis2zSUcQLo7OzE7/djsViGzabOzk5ycnIGVOrYxNFhMGWlBwNd1/l4+5sk2vbiLZg0bNsdaxBCEEuqOG2HlgRXNUE4kWJuiQ+PbfwmVOhC0BVJkuW2jUqdzuMBk4PeHCQ1qAkqTJs8GYejO2JQVw1tKZtn3GtMpaPND74mTBSYHBw9B+nJxWnTpuFw9I7GHMx93XRMDTOO1UMVgBYKEd22DSUre9h0e4SmZXSgRDKJUFOAhGS1INlsyA4Hss+H4nIhORzIdjuSw4Gk9D2jJoSgNdZKbaCWYDJIlj2LHa07+ONHf6QzYUQEnTLpFM6bdx4+2wF+dKHTlegipRlpe2W+sl7fHwvoySR6MIja2Yna1mY4W4RAcrqQ3e5jqo001pCpsBeLofi8WEpKsObnjzvtLhMmTJg4GMfyvm6iN44l17Ufb6Nz3248+RPXMXU4RBMqAlhQ6h+VOpYmTBwrxFXRh2MqBYoNrOZzrgkTR8JwOabMN+8xBF3XaUwmKRGDr8ondB2RSmUcUKSSRuSOrCDZbEgOO5a83Ew1u4wTahCV1KKpKPWhevaH92NRLFhkC79671e82/IuAEXuIi5aeBHz8+b3+l0kFSGYMJxYs7Nnk+fMQ+4ndFbXdRoaGigtLc3Mvg8Vss2GnJeHJS8PMXWqIZjeFUBta0XraEdoGnLaSTUK8m7T0IWgKRyiyOM95jNdx6vC3lAwnMfCWIXJgckBmBykYfJgoj/ouk5HMNJvVfiJAiOVL4nfbTtkVjypCrLc1nHvlDJSuKKU5riYyBXpTA4OcNAnhABpfKe1wuipxjaSMDkYPRyYT25jCJIk4VGUIxSQEOjJJFo4jNrRQaqpiVTjfrSWFvRIBEmSsOTmYps5E+fCE3AtXYJr+TJcS5fimD0b26RJWPLzUbzeATuldKHTFGnig9YP2Bfah9fm5Y39b3Dly1fybsu7KJLCl2Z+iV+c8oteTqmklqQ53ExKSzEzayYn5J9AgaugX6dUmgOv1zvsJ41ktWLJycE+fRquJUtwnngi9lmzkBwOtEAXqcZG1I4O9ERiWPc7pL4CHpvtmBZT0RMJUs3NaJ0dKFl+nCecgGvxIqwlJaPCKQXH7lgYSzA5MDkAk4M0TB5M9AdJknDYRs8E00jCbu37ZVsVGl7H+J+vliTwOq3jOTvriDA5OBIH40f4/KmnnqK8vBxFUbjiiiv6XOfgiRwhBBdffDE5OTlIksT27dv7XLZ69ep+tznasGnTpozkQ18YDZNZN954I4sXLz7sOuvWrePcc889JvsfDRyM/zvQOIIkSXh75H4KVc1EQOnJJOia4aywWpFsNhSfD8XnRXY6e6fhDeOBF0lFqAvW0RhpxK7YiagRNr63kZqAIRY7O2c2Fy28iEneA6Hz6Wp7qq5S5C6izFeG1+YdMAeHu7AMBySLBUt2NpbsbGxlZeihEFoohNrSYkRVdbQj2ezILteIpLJJkoTPfmyqqeixGHqgCywWrIWFWIuLULKzh/WYGS4cj2NhtMPkwOQATA7SMHkw0R8kScLlsJGYwC/iYPDgtPfx6C8AJOyW8R8hIkkSWe7RMcE2UjA5OJiDg0Iphyh8ruka77a8S2u0lXxXPksKlqDIx/acWrduHX/84x8BsFqtTJ48mfPPP5/rrrsOi8XCd7/7XS644AJ+8IMf4PUe+q4lSRKWg6RLnn32WTZt2sTmzZuZPn06eXl5fS7729/+NuyV3DZt2sQFF1yQ6VtJSQlnnnkmd9xxBwUFBcO6rzT64iC9/Mknn+zlCLrxxht56qmn2L59e691p06dyt69ewFwOp3MmDGDH/7wh3znO98ZcD+uvPJKLr/88iHZcLToj4PjjZHvgYkBQ9d19ieTFDY3ISsKkpJOw3NgK8hHcbsNx5PdgeywH1ONJE3XaIm2UBusJapGcVlcPLnnSZ6teRaBwG1184053+C0yaf1ioAKJ8OEkiGy7FlM9k0+bNpeX9B1nfr6esrKyo6LZ1eSZRS/H8Xvx1paih6JoAcCpNrb0boCaF2dSBZDDF5yOo/LTL0uBPtDQUq8vmFJ5RNCGHaFgkh2B9ayMqyFhcjdQsqjFcf7WBiNMDkwOQCTgzRMHkz0B13XaQ9EkMxUPrrCCbI89l7396SmY1VkHJbxf97ouqC+PUJZrntCp7GZHBzg4BAI3XBKDeI+8sLeF7j97dtpjjZnlhW6CrlmxTWcMeWM4ehyvzjrrLN46KGHSCQSPPPMM3z/+9/HarVy+eWX09LSwpo1aygpKenzt+lqbDbbgfTeqqoqiouLWbVqVWa9vpbl5OQcE3t8Pl+m6vaOHTu44IIL2L9/P//617+GtL1UKnXY7/viYCj42c9+xkUXXUQ0GuXxxx/noosuorS0lM9+9rMD+r3H48Hj8Qx5/0eD4eLgaDH+70DjCLLDQW5xMc65c43UqqVLcS1fjnvZUhyzZmEtLcWSm4viObbC3aFkiF0du/io/SMAGsINXPvqtfyz5p8IBKtKVnHX6rv49JRPZ5xO6bQ9VVcHnLbXFyRJIjs7e0ROGkmSUDwerKWlOBcuxL10Cc6FC7Hk5yOSSdSmRlItLWiRCKJHlahh7weQ5XAcdSqf0HW0QAC1sRE0FfuMGbiWnIhj9myUrKxR7ZSCkT0WRgtMDkwOwOQgDZMHE/1BkiTcjokdIZJGXxFTSVXHbpEnSMQUZHtsEz6NzeTgMBwIHeSBv0e9sPcF1m9e38spBdASbWH95vW8sPeFo+zt4WG32ykqKmLKlClceumlnHHGGfz973/PREidfvrpSJLE5s2baW9v5+tf/zqlpaW4XC5OOOEEnnjiicy21q1bx+WXX05dXR2SJDF16tQ+lwGHpPI9/PDDLFu2DK/XS1FREd/4xjdoaWnJfL9582YkSeLFF19k2bJluFwuVq1aRUVFRS97JEmiqKiIkpISPvvZz/KDH/yAF154gVgsxrPPPsunPvUpsrKyyM3N5Qtf+AJVVVWZ39bW1iJJEo8++iinnnoqDoeDP//5z33y9r//+78sWbIEp9PJ3Llzuemmm1BVFSBj4xe/+MWMzZs2beKmm25ix44dmQq+mzZtymwvbff06dO5+uqrycnJ4fnnn89839XVxXe+8x3y8/Px+Xycfvrp7NixI/P9wal8mqaxfv36jK1XXXUVx7JmnRkxZWJQUOx28hYuHLH9q7pKY7iRulAdCTWBIiv8/oPf83bT2wAUuAq4cMGFLC5YnPlNz7S9Yk8xk7yTBpy21xckSRoVVZEkSUJyu5HdbqxFReixGFowhNbZgdrRgdbSjJAkZJcb2eXqt4rhUPftsdmH/PueFfZkrwf7nNlY8/KQXf0IQI5SjJZjYSRhcmByACYHaZg8DC/q6+v51re+RUtLCxaLhf/8z//kq1/9aub7e+65h9///vcIITjjjDPYuHEjkiRRU1PDhRdeSHNzM4qi8Oabb+J29xGVcBwhSRIOu5XYBH4Rh7TWVt+OqSyXfTABImMWkiThc05sJ6XJwcEc9H7ZF0IQ0xOQOvIks6Zr3Pb2bYg+Kiukl93+9u2sLFo5oLQ+p+Xosy+cTietra1UVFQwe/Zs/vrXv7Jq1SpycnJobW1l6dKlXH311fh8Pv7xj3+wdu1aZs6cyYoVK9i4cSMzZszgwQcfZOvWrSiKgs1mO2RZX0ilUtx8883Mnj2blpYW1q9fz7p163jmmWd6rfeTn/yEu+66i/z8fC655BIuvPBCtmzZclh7dF1HVVUikQjr16/nhBNOIBwOc8MNN/DFL36R7du394qUvuaaa7jrrrs48cQTcTgch0Rbvfrqq5x//vnce++9nHzyyVRVVXHxxRcjSRI//elP2bp1KwUFBTz00EOcddZZKIqCx+Phww8/5Nlnn+WFFwxno9/vP6S/uq7z5JNP0tnZia2HLu9Xv/pVnE4n//znP/H7/fz2t7/l05/+NLt37+4z+uyuu+5i06ZN/OEPf2Du3LncddddPPnkk5x++un9cjVUSJLU77geT5iOqTEEXdepra1l6tSpxz1NIZAIsDe4l5ZoCy6ri+1t2/mfXf9DTI0hSzKfn/55vjLrK9iVAw6TdNpetj2byb7J5DpzBx0hdTBGkoPDQXY6kZ1OrIUF6MkkeiCA2tWF2taG1tYKQiClK/wdpUdaF4J9wQCTfP5BpfKJVMpwSCWTKFn+UVVhbygYrcfC8YTJgckBmBykYfIwvLBYLGzYsIHFixfT1NTE0qVL+dznPofb7aa1tZVf//rXfPTRR1itVk455RTefPNNTjrpJNatW8fPf/5zTj75ZDo6OrDbhz6RMlzQdZ22rjCymcpHZzhB9kGpfBo67r60p8YhdF1Q2xpmar5nQqexmRwc4KA3DKfUysfPHLZ9NUebWfU/q468IvDWN97CZR3aRLEQghdffJF//etfXH755RlNppycHIqKigAoLS3lyiuvzPzmsssu45///CePPvooK1aswO/34/V6URQl8xugz2UH48ILL8y0p0+fzr333svy5csJh8O9UtRuueUWTj31VMBwIH3+858nHo/jcByqn1tZWckDDzyQicT68pe/3Ov7P/zhD+Tn57Nz504WLFiQWX7FFVfwpS99qd++3nTTTVxzzTWsXbsWIQSlpaX87Gc/4+qrr+anP/0p+fn5AGRlZfWy2ePxYLFY+uTh6quv5vrrryeRSKCqKjk5ORmNqddee423336blpaWzD3xl7/8JU899RRPPPEEF1988SHb27BhA9dee23GjgceeGDI6YxHwmhJ5ZsYd6FxAkmSKCgoOK4HTEpPZaKkklqSmBrjvu33sadrDwAzsmZw8QkXM8U3JfObpJakI9aBw+JgVvYsitxF2JThcX6MBAeDhWyzIefnGyl+U6caguldXaitrWgd7QhdR3Y4DSfVEEQDJSDP5RpwKp+eSKAFAkgIlOxsrCWlWHKyh7Tv0YSxcCwca5gcmByAyUEaJg/Di+LiYoqLiwEoKioiLy+Pjo6OTPSTqqrE43HAmCkvKCjIOKpOPvlk4NhpkAwWkiThdTmIhEa6JyMPj6P3vV/XQUbGMQHS+MBI4SrwOyZ8GpvJQT8cCJ2xpnTz9NNP4/F4SKVS6LrON77xDW688cY+tZU0TePWW2/lscceo6GhgWQySSKRGBZto23btnHjjTeyY8cOOjs70btlTerq6pg3b15mvRNOOCHTTt9jWlpamDx5MgCBQACPx4Ou68TjcT71qU/x+9//HjAcVTfccANvvfUWbW1tvfbR0zG1bNmyw/Z1x44dbNmyhVtuuSWzTNM04vE40WgU1xCySH784x+zbt06Ghsb+fGPf8z3vvc9ysvLM/sLh8Pk5ub2+k0sFuuViphGIBCgsbGRlStXZpZZLBaWLVt2zNL5zFQ+E4OCJEnHVRStK95FbbCWtlgbNsXGi3Uv8o/qf6AJDafFyb/P+XfOnHJmJgpKFzqd8U40XaPEU3LUaXt94XhzcLSQrFYsOTlYcnKwTZ5sOKmCQdTWNrRAFyKlGhUTXS7kAc4qS5KEy3pkR58ei6EHAyDLWAsKsBYVGhX2RkGo5nBgrB0LxwImByYHYHKQxkTj4ZVXXuHOO+9k27ZtNDY2HlI9COC+++7jzjvvpKmpiUWLFvGrX/2KFStWDHpf27ZtQ9M0ysrKAMjPz+fKK69k8uTJWCwWLrnkEmbMmMFTTz2Fx+Ph7LPPpqGhga985Stcd911w2HuUUGSJOw2C9EJ/CIOBg82a+9ngKSmYbPI2K1j62V8qJAk6RDn3ESDycHBHPR40Rc6TquLt77x1oC2s615G9978XtHXO83n/4NSwuXHnE9p2Xw1b5PO+007r//fmw2GyUlJRkHQ1dX1yHr3nnnnWzcuJENGzawcOFC3G43V1xxBclkctD77YlIJMKaNWtYs2YNf/7zn8nPz6euro41a9Ycsu2elfzSE0l6D21er9fLu+++iyzLFBcX4+xRAf3ss89mypQp/O53v6OkpARd11mwYMEh+zhS+ng4HOamm27qM6qqr8itgSAvL4/y8nLKy8t5/PHHWbhwIcuWLWPevHmEw2GKi4vZvHnzIb8bDdWEzVQ+E4OGpmnU1NQwbdq0Y3rwpLQU+8L7qA/VowudpkgTD330EC1RQ8BuRdEK1s1fR47zwExoOBkmlAiR7Ri+tL2+cLw4OBaQLBYs2dlYsrOxlZWhh0JooRBqS4vhsOpoR7LZkd1u5MNcFHUhqAt0MdmfdUgqnxACPRpFDwaQ7HZDEL+wcEyImQ8WY/lYGC6YHJgcgMlBGhONh0gkwqJFi7jwwgv7fLh+9NFHWb9+PQ888AArV65kw4YNrFmzhoqKikyKx+LFizNirz3x3HPPZao4dXR0cP755/O73/0u831nZydPP/00tbW1OJ1OPvvZz/LKK6+gqiqvvvoq27dvp6CggLPOOovly5dz5pnDlxYzFGiaRmtnCGWCp/LpQtAZipPtdWSeH1KqwGGVsU+AinwAmi6oaQkxrcCLMkHT2EwOenPQC0IgWay4LAObLF5VsopCVyEt0ZY+daYkJApdhawqWTUgjamhwO12ZyJzjoQtW7ZwzjnncN555wHGtbGiooL58+cfVR927dpFe3s7t99+e2YC45133hnStmRZ7tOe9vZ2Kioq+N3vfpeJyn3ttdeGtI8lS5ZQUVFBeXk5QggSiQR2e+8UZ6vViqZpvX5ns9kOWdYXysrK+NrXvsa1116bEVlvamrCYrFkhNUPB7/fT3FxMW+99RannHIKYEQpb9u2jSVLlgzO2AGgPw6ON0zH1DFC2vOb/ivL8mHbaXX//tqapiFJEqWlpQghEEJklqe1NHRd79VWFMVwVPTTFkIgy3Kvdlu0jb2BvXQmOxFC8MTuJ3i98XUAchw5XLjgwl4e/0QqQUe8A6fVycysmRS5i7Bb7ei6jkAc0SZZlvtt92WTLMuUlJRkwhgHYlPP9kDH42jGaaA2yT4fdFf508Jh1K4u9PYO1ECAVEc7itWG5HKB04mStgMjla/Q7TY4kCR0IYwqgJEIajiM7HRim27oRyleb6bv/XEwnDYdzbE32HECIwR4PNk02GMPoKSkBFmWx41Ngx0nIQQlJSWZ5ePBpsGOExi6Eel9jQebhjpO6bSA9H6Gy6bRiM9+9rOHLUN99913c9FFF3HBBRcAhj7FP/7xD/7whz9wzTXXALB9+/bD7iORSHDuuedyzTXX9CoT/sILL1BeXp5J1fv85z/Pm2++ycknn8yyZcsyLyaf+9zn2L59e7+OqUQiQSKRyPw/GAwCw/8MJYTA53YQCRvOGQljhjjdBjL313Rb7v5df226tzFS7b7sOJJNEuB1WjPPD0IIEqpKvtfVfX6BLEv9tnUhoL92Nze6LkDquy1J3X3sp63pAvkwbQBd0KutdPexv/YhdkhQkuUEYTAyLmwa9DhBcZYzc1SMD5sGN06yBMV+J1I3B8Ymu9tIhoOqxznXFyRJQpZkrl5+Nf/x8n8gIfVyTkndZ99Vy6/KTNYP97UgDXFQfw9eJ92eOXMmTzzxBFu2bCE7O5u7776blpYW5s+ff8g2ev6uv/2kl5WVlWGz2bj33nu55JJL+Oijj7j55pt7rdPz3a2/7fRc52A7srOzyc3N5cEHH6S4uJi9e/dy7bXX9vrtwfvoj4v//M//5Oyzz6asrIyvfOUrSJLE+++/z4cffsgtt9yCEIKpU6fy4osvsmrVKux2Ozk5OUyZMoWamhq2b99OaWkpXq83E2F1cN9/+MMfsmDBArZu3coZZ5zBSSedxLnnnssvfvELZs6cyf79+3nmmWc499xze6Ueprn5wQ9+wO233055eTlz5szh7rvv7hUFN9zHUlqo/XDH0pGOsfT/h/oMNTGmR44D7rvvPubNm8fy5csBMuUx29raaGtrA6C5uZmOjg4AGhsbMwdXQ0MDgUAAMKrghEKGCEJtbS2RSASAmpoaEokETqeT6urqTMhiZWUlqqqi6zqVlZWkqxZUVlYCkEwmM7mr8XicmpoawJhpra2tBSAUClG9t5qqzip21O+grbmNne07uX7L9bze+DoSEmeWnMnPTvgZy4qWEe2KEumM0B5rp621jWwtm0X5i7BELERCkUHZlNanqKqqGpBNkmSEGlZXVx/Rpvr6esDI021oaACMsNbGxkbAmAVubm4e9nEaik2azUZdLIZz0QkoC+bT3K1RFY3HqNtXT6qlhWAgQEMwgCRJpHSd5kgYoWl0trbStL8BJIiWFBMum4Rjxgw6E4kRs2kwx95Qx6mlpYVYLIYkSePGpsGO0969ezMvX+PFpsGO0549e7Db7WiaNm5sGuw47d27F6fTSTgcHjc2DWWcJEkiEonQ3t4+rDal+zWWkEwm2bZtG2eccUZmmSzLnHHGGbzxxhsD2oYQgnXr1nH66afzrW99q9d3ZWVlvP7668TjcTRNY/PmzcyePZvly5fT0tKS0Rd55ZVXmDt3br/7uO222/D7/ZlP2qE13M9Q6RLikgQdwTiabjw8twVi6MY7Lm2BGALjJbotEAOMqIqOoHEcqJpOZ6hbU0vV6QwbDrVESqOrux1PagQixvEfS6oEo0Y7mlAJxwy9l0g8RSRutMOxFNGEEbEWjCaJJY12IJIknjQe5rvCCRIpo90ZTpBSDadcZyiOqhntgdokSRKyLNMZSmRsisZSOG0WIgmV2tYwAKF4ivp2g7tANEVDR9ToSyRJY5fR7gglaO7mqS0Yp62bp+ZAjI7u7Td2Renq5qOhI0ogathd3x4h1M1BbWuYSDdUd+XhAAEAAElEQVQHNS2hjN1VTUGS3bZWNgZQdcORUdkYQBeg6oLKRmPck6pOVVMwMwY1LcYx0JdNkiSR1AT7O2PjxqbBjpMkSQRjKTrDyXFj02DHSZIkmoNxot12qN0TuEgSiZSaecGOx+O92mBcG3u2Ty46mbtX302By4hETaPAVcDdq+/m9LLTM/dFTdMy2k8926qq9mqnI1lTqVSvdvolv2db1/WMsz6ZTGbaPZ3+iUQCIQTXX389ixYt4qyzzuK0004jLy+Pc889t5dNabvSf3tuJ21Hz31qmkZWVhabNm3iiSeeYP78+dx+++3cfvvtmd+pqtqr72mbekbspjWyDrYj3ZZlmT/96U9s27aNBQsW8KMf/Yg77rgjs05fTrSe49Rz+erVq3n66ad57rnnWLFiBatWreKee+6htLQ0Y9Ptt9/O888/z+TJkzNRSueccw6f+cxnOO200ygoKODPf/5zZrvp/qbHZt68eZxxxhnccMMNSJLEk08+ycknn8wFF1zA7Nmz+frXv87evXvJysrq06H2/e9/n/POO49169axatUqvF4v5557bobHnmPTs63req9xGuixJ8vyoI+9nuOkaRrRqHGODvUZShKHcwWbGDSCwSB+v5/Ozk6ysrKGdUZaCEF1dTVTp07FarUOy4y0JEm0xdqo7aolkAoQSUV4ZOcj7OrcBcBU31QuOuEipvungwBJlgglQoQSIXKcOZR5y8h15KIoynGZZQfYs2cP06ZNw2az9WnTeIqG0KJR1EAQEegi1d6OFomCLFEvYJLFgqKqSH4ftuJirAUF0J23PZptGq5xSqVSVFdXU15ejiRJ48KmwY5TTw7S6451mwY7TqlUipqaGmbMmJFxXI91mwY7TqqqUlNTw/Tp05FleVzYNJRxEkKwZ88epk+fjtVqHTabOjs7ycnJIRAI4PP5GI1IP/SmNab2799PaWkpr7/+OieddFJmvauuuoqXX36Zt946sn7Ka6+9ximnnNJLqPbhhx9m4cKFgFHy+29/+xuyLPPpT3+ajRs3IkkS//znP7nqqqsQQvCZz3yGu+++u9999BUxVVZWNuzPUMlkknfffg1btBl3fumEjZgCaA/EyPY5sMgyKVUnGE8xv9SPx6YgjnPUysHt4xGJI4A9jQGmF/qwWuRxYdNgx0mIbg6KfFgVeVzYNNhx0rs5mFHkQxUS1QGFaZNLcTrsCKsbJKnXOdcXDj4nVU3l3ZZ3aYu1kefMY0nBEiyKZVRcLw4X5ZJMJjOV4kZDv47WpiON08Ht0c7BUGwabDvNQboq32C3k0gkqK6uZtq0aTidziE/Q5mOqWFG2jF1LB5gDz5ojhZxNU5dqI6GUAO60Hl538v8vervaELDrtj5t9n/xllTz8rkRPestjfZO5kidxFW5fiKJw43B2MJeiKBHgyS6ugg1taG3enEVlqKJSdnzFfYGwom8rGQhsmByQGYHKRxrHg4lvf14cKxcEyNBI4V10II9ny4lVBjFd6CScO23bEGIQSaLlBk48UjltTQhGBBqR/rBNEaEkKQVHVsFnnCXi9NDnpzkNCgJqgwrawEh9MNtsFXZBurSDsl0s6IiQiTg6PnIB31Pm3atEPE4wdzXzc1psYQJEnKeHOPBkIIWmOt1AZqCSaDNEWa+NPOP9EYMdIiTiw4kQsXXEi+Kx/oXW2v1FvKJM8kPLaRqXw0XByMRch2O3J3ip9j+nRQFCR54mbjTuRjIQ2TA5MDMDlIw+ThAPLy8lAUJZO2mUZzczNFRUUj1KuRgyRJWC0KE/SdIwNJkrAoB0hIqjo+p3XCOKWg+zphHf/FEQ4Hk4ODOeiO0RACjpFA+WjFRHbGpGFyMHo4mLhvtWMQmqaxa9euoxJijaaiVHRW8FHbR3TEO3hqz1PcsfUOGiONZNuzuWLJFVy1/KqMUyqcDNMcbsZj9bAwfyGzs2ePmFMKhoeDsQ5N06ioqsqEL09UmMeCyQGYHIDJQRomDwdgs9lYunQpL774YmaZruu8+OKLvSKoJgo0TaOpLcAEv22iC0FLVzTz/JDSdLyOiTVHremCXQ1dGU2uiQiTgz44SFNxDCqKj2YIIYjFYodNGxvvMDkYPRxMrLvRGIcsy8yYMSOj0zEY6EKnJdrC3sBeQskQH3d+zH/v+m9CyRASEmdMOYOvz/k6LqsRvtozbW92zuwRSdvrC0fDwXiByYEBkweTAzA5AJODNCYaD+FwmD179mT+n64UlJOTw+TJk1m/fj1r165l2bJlrFixgg0bNhCJRDJV+iYSZFkmP9tLINZ85JXHMSQg1+c0dKeE8Y/dOjHOlzRkCWYU+ZhAQWKHwOSgLw6E4ZSaYI4pwIw0xuQARgcHpmNqjGEoD9yRVIS6YB2NkUa6El08XvE4H7Z/CECZt4yLTriIWdmzAMOB1RHvQOhixNP2+sNEeek4HEwODJg8mByAyQGYHKQxkXh45513OO200zL/X79+PQBr165l06ZNfO1rX6O1tZUbbriBpqYmFi9ezLPPPkthYeFIdXlEMRrSFEYD0jSkNB2LIuOwTKzUJTAEsSc6TA4O4kAI4+SYgI4p89pocgCjg4OJd/aNYfQsuT0QaLrG/vB+drTsoC5Yx6v7XuXnb/6cD9s/xCpb+fc5/85tJ9+WcUqFkiFaIi14rV4W5C8Y8bS9vjBYDsYjTA4MmDyYHIDJAZgcpDHReFi9enVGsLTnZ9OmTZl1LrvsMvbu3UsikeCtt95i5cqVI9fhEYSu67R0BEe6GyMOAbQFYgggoerYFQX7BHNM6QIqGwNM4Cw2kwP64kCApDARheji8fhId2HEYXIwOjgwI6bGEGRZZubMmQOaEQ4lQ+wN7qU50sz+yH7+8vFf2BfeB8DCvIV8e+G3KXIbAqhJLUlHvAOH4mBW9qxRk7bXFwbDwXiFyYEBkweTAzA5AJODNEweTPQHWZYpyPHR1WCm8uX5jVS+lKbj99hQJtjpIksws9g/4dPYTA4O5kBMyGgp4JAqahMRJgejgwPTMTXGoOv6YR+6VV2lMdxIXaiOrngX/9r7L16qfwkAn83H+fPO55Oln0SSpEzanq7rlHpKKfOW4ba6j5cpQ8aROJgIMDkwYPJgcgAmB2BykIbJg4n+MNKirqMF6YwlTQjc9on5GqALMeFT2UwOenCga4AyYR1TQohRkcY1kjA5GB0cTMwzcIxC13Wqqqr6TVMIJALsbN9JRUcF77a8y21bb8s4pVaXreau1XfxqUmfQpIkQskQzZFmfFZfptreWHFKHY6DiQCTAwMmDyYHYHIAJgdpmDyY6A+6rtPaGRrpbow4BNAejKELI3pqoqXxgZHCVdUUnPBpbCYHPTjQEoAEE3RSI5FIjHQXRhwmB6ODg4l5Bo5RKIrCnDlzUJTeDxIpPUVdsI4P2j5gd8duNu3cxIPvP0ggEaDEXcINJ93AJYsuwWvzktASNEWa0HWd2dmzWZC/gDxn3oh7SAeK/jiYSDA5MGDyYHIAJgdgcpCGyYOJ/qAoCkV5/okoH9MLsiRRkOVC1QRWi4zDOvHOFUWWmFOahTKB89hMDg7iQE1OaOFzp9M57O+BTU1NnHnmmbjdbrKysgb8u6eeeory8nIUReGKK67oc9mmTZsGtc0j4Vhx0HP7Tz311DHZ9nCgtrYWWZapqKjol4PNmzcjSRJdXV3HtC8T7wwcwxBCkEgkeoWjd8Y7+ajtIz5u/5j/q/s/bnv7Nna07sAiW/jKrK9wxyl3MC93HrrQaYu1EUwEKfWUsqhgEWW+Mqzy6NSS6g99cTDRYHJgwOTB5ABMDsDkIA2TBxP9QQhBStWY6IeGEAJV00moGnaLjN0y8V4DhBAkUtqEvk6YHBzEgZoYFqeU0DQib71N4Ol/EHnrbYSmDUNPD49169YhSRKSJGG1Wpk2bRpXXXXVgIWshRDout7vsTB16lQ2bNjQa1naSZH+FBYW8uUvf5nq6urMOvfccw+NjY1s376d3bt3D9ie7373u3zlK1+hvr6em2++uc9lX/va1wa1zSMhzUFPm/x+P5/85Cf5v//7v2Hbz0Cxbt06zj333F7LamtrkSSJ7du391p+4403ZvqsKAplZWVcfPHFdHR0DHh/ZWVl7N+/n3nz5o34NWHi3ZHGMHRdZ+/evei6TlJLUh2o5oO2D9jeup1fbf8Vj+9+nKSeZG7OXO445Q6+MusrWBVrJm3Pb/OzIG/BmEnb6ws9OZioMDkwYPJgcgAmB2BykIbJg4n+oOs6HcHISHdjxCGArnCCpKrjc1gnZASZLmBva3jCp7GZHBzEwVE6poLPPceeT59B3dq17L/ySurWrmXPp88g+NxzR9/ZI+Css86isbGR6upq7rnnHn7729/y05/+dMC/TyaTQ9pvRUUF+/fv5/HHH+ejjz7i7LPPRut2xlVVVbF06VJmzpxJQUHBgLYXDodpaWlhzZo1lJSU4PV6+1zmdDoHvM2BIs3BQw89RGNjI1u2bCEvL48vfOELvRxuQ9nmscb8+fNpbGykrq6Ohx56iGeffZZLL710wL9XFIWioqJR8exkOqbGCDRd493Wd6m0VPLSvpd4v/V9drbt5G+Vf+Pud+5mb3Avbqub757wXW446QZKPaVG2l74QNre/Lz5Yyptry8oisKsWbMmdKqGyYEBkweTAzA5AJODNEweTPQHRVEozPFNSEdMT8iSRJ7fCRI4bRPzPFFkiVkl/gmfxmZy0M2BSIFs4WguDsHnnqPhh1egNjX1Wq42N9PwwyuOuXPKbrdTVFREWVkZ5557LmeccQbPP/880HfE0+LFi7nxxhsz/7/99tuZMmUKdrudkpISfvCDHwCwevVq9u7dy49+9KNMVE5PFBQUUFxczCmnnMINN9zAzp072bNnD1OnTuWvf/0rf/rTn5AkiXXr1gFw9913s3DhQtxuN2VlZXzve98jHA4DRhSW1+sF4PTTT0eSpH6XHZzKV1VVxTnnnENhYSEej4fly5fzwgsv9Orr1KlTufXWW7nwwgvxer1MnjyZBx98EDBS7dIV6bKysigqKmLBggXcf//9xGIxnn/+edrb2/n6179OaWkpLpeLhQsX8t///d+99rF69Wouu+wyrrjiCvLy8lizZk2f41VfX8+//du/kZWVRU5ODueccw61tbWAEQH1xz/+kf/93//NcL5582amTZsGwIknnogkSaxevTqzPYvFQlFREaWlpZxxxhl89atfzYx/Gr///e+ZO3cuDoeDOXPm8Jvf/CbzXTqVb9euXZkxfuaZZ5g1axZOp5PTTjst079jjYlZjmOM4YW9L3D727fTHD1Q5thtdSMhEU4ZJ/SnSj/Ft+Z9C7/djy502mPtCCGY5J3EJO+kMRshdTCEEMTjcRwOx5h2sB0NTA4MmDyYHIDJAZgcpGHyYKI/CCFIplQzlU8IkikdSYBjAgqfQ/d1IqnhsCkT9jphctCDAz0GFjukpF7fiVhsYNvRNJp/fgt9XlyEUWWg+ZZbcZ90EtIAJk2ko9Q6+vDDD3n99deZMmXKgNZ/4oknuOeee/jv//5vFixYQFNTEzt27ADgb3/7G4sWLeLiiy/moosuOux2nE4nYEQJbd26lfPPPx+fz8fGjRsz38myzL333su0adOorq7me9/7HldddRW/+c1vWLVqFRUVFcyePZu//vWvrFq1ipycnD6XHewkCYfDfO5zn+OWW27Bbrfzpz/9ibPPPpuKigomT56cWe+uu+7i5ptv5rrrruOJJ57g0ksv5dRTT2XWrFl9prD1tCkej7N06VKuvvpqfD4f//jHP/jWt77FjBkzWLFiReY3f/zjH7n00kvZsmVLnzylUinWrFnDSSedxKuvvorFYuHnP/85Z511Fu+//z5XXnklH3/8McFgkIceegiAnJwc3n77bVasWMELL7zA/PnzsdlsfW6/traWf/3rX72+//Of/8wNN9zAr3/9a0488UTee+89LrroItxuN2vXrs2sl07p3LdvH1/60pf4/ve/z8UXX8w777zDf/zHf/Q79sMJ0zE1yvHC3hdYv3k9gt4nTCRlhKT7bX6+f+L3OSH/BACCySDRZJRcZy5l3jJyHDnj6qaj6zoNDQ1MmzZtws6KmxwYMHkwOQCTAzA5SMPkwUR/0HWdQDjGRD8qBNAZTuB2WrFbJ2bShC6goTPKtAIvyvh5PB4UTA56cOCKg7MA1B6OqViMiiVLh2dHwoic2r18xZHXBWa/uw3J5RrULp5++mk8Hg+qqpJIJJBlmV//+tcD+m1dXR2FhYWcccYZ2Gw2Jk+enHG05OTkoCgKXq+XoqKifrfR2NjIL3/5S0pLS5k9ezY2mw273Y7T6ez1u7SYORgRTD//+c+55JJL+M1vfoPNZsuk5+Xk5GR+19eyg7Fo0SIWLVqU+f/NN9/Mk08+yd///ncuu+yyzPLPfe5zfO973wPg6quv5p577uGll15i1qxZh6TdRaNRrr/+ehRF4dRTT6W0tJQrr7wy8/3ll1/Ov/71Lx577LFejqmZM2fyi1/8ol+uHn30UXRd5/e//33m/fyhhx4iKyuLzZs385nPfAan00kikehlb35+PgC5ubmH8PDBBx/g8XjQNC2jLXb33Xdnvv/pT3/KXXfdxZe+9CUApk2bxs6dO/ntb3/byzGVSqUAuP/++5kxYwZ33XUXALNnz+aDDz7gjjvu6Neu4YLpmOoH0WiUuXPn8tWvfpVf/vKXI9IHTde4/e3bD3FK9YQiKyzIW0BCS9AZ68RpcTIrexZFnqIxJ2w+ECiKQnl5+Uh3Y0RhcmDA5MHkAEwOwOQgDZMHE/1BURTys710RhpHuisjClmScDqsuOwWbMrEdEwpskR5kW+kuzGiMDnowUEgRMrhh+jx0QM6FjjttNO4//77iUQi3HPPPVgsFr785S8P6Lf/9m//xsaNG5kxYwZnnXUWn/vc5zj77LOxWI7sIpg0aRJCCKLRKIsWLeKvf/1rv5E8AC+88AK33XYbu3btIhgMoqoq8XicaDSKa5DOuJ4Ih8PceOON/OMf/6CxsRFVVYnFYtTV1fVa74QTTsi0JUmiqKiIlpaWXql8X//611EUhVgsRn5+Pv/1X//FCSecgKZp3HrrrTz22GM0NDSQTCZJJBKH9Hvp0sM7NHfs2MGePXsyKYppxONxqqqqhmT/7Nmz+fvf/048HueRRx5h+/btXH755QBEIhGqqqr49re/3SvqTVVV/H5/r+3Y7XYkSeLjjz9m5cqVvb476aSThtS3wcJ0TPWDW265hU984hMj2od3W97tlb7XFzriHbzZ+CYzs2YyyTuJMm8ZLuvQT+7RDiEEkUgEt9s9riLBBgOTAwMmDyYHYHIAJgdpmDyY6A9CCBJJM5VPCEEspVLks490V0YMQggiCRW33TJhrxMmB90cxFO4ASxO4IBjSnI6mf3utgFtJ/rOO9Rf/N0jrlf24G9xLVt2xPWk7vSxwcDtdmcmZf7whz+waNEi/uu//otvf/vbyLJ8SJpaOjIGDOfSzp07+b//+z9eeOEFvve973HnnXfy8ssvY7UePsDh1VdfxefzUVBQcIij5WDU1tbyhS98gUsvvZRbbrmFnJwcXnvtNb797W+TTCaPyjF15ZVX8vzzz/PLX/6S8vJynE4nX/nKVw6JgjrYHkmSMulraeHve+65hzPOOAO/35+JUgK488472bhxIxs2bMjoZF1xxRWH7MPtPrx0TjgcZunSpfz5z38+5Lue+xsMbDZbZvxvv/12Pv/5z3PTTTdx8803ZzS8fve73x3ibDo4slzTRr5S58ScLjkCKisr2bVrF5/97GdHtB+t0dYBradqKgvzFjIre9a4dkqBcSNpaWkZ8RNnJGFyYMDkweQATA7A5CANkwcT/UEIQSg6sPLp4x3Jbm2hiQohoCUQn9BOSpODbg66wgjFBtbejlpJkpBdrgF93J/8JJaiov7F0yUJS1ER7k9+ckDbO1pHoSzLXHfddVx//fWZqJ/GxgORosFgkJqaml6/sVqtnH322dx7771s3ryZN954gw8++AAwnB7pSnsHY9q0acyYMeOITimAbdu2oes6d911F5/4xCeYNWsW+/fvPwpLD2DLli2sW7eOL37xiyxcuJCioqJBi3WrqgpAUVER5eXlhziJtmzZwjnnnMN5553HokWLmD59Ort37x50X5csWUJlZSUFBQWUl5f3+qQjmPriPB2J1t9Y9MT111/PL3/5S/bv309hYSElJSVUV1cfsr+0oHoa6W3PnTuXt99+u9d3b7755qBtHQrGnGPqlVde4eyzz6akpARJknjqqacOWee+++5j6tSpOBwOVq5ceQi5R8KVV17JbbfdNkw9HjryXQPznC4uWEyuM3dCzHrIssz06dOR5TF36A4bTA4MmDyYHIDJAZgcpGHyYKI/yLJMXpZnwlfl03TwuW0TtiIfgCxLTC/0Ik/ginQmB90cZMnIVmd3xNTQICkKhddd2/2fg/js/n/hddcOSPh8uPDVr34VRVG47777OP3003n44Yd59dVX+eCDD1i7dm2vSJk//vGPPPLII3z00UdUV1fzyCOP4HQ6M+LpU6dO5ZVXXqGhoYG2trYh96m8vJxUKsWvfvUrqqurefjhh3nggQeO2lYwdJ3+9re/sX37dnbs2ME3vvGNTATUQCBJEnb74aNIZ86cyfPPP8/rr7/Oxx9/zHe/+12amw+f1dQXvvnNb5KXl8c555zDq6++Sk1NDZs3b+YHP/gB+/btAwzO33//fSoqKmhrayOVSlFQUIDT6eTZZ5+lubmZQCDQ7z5OOukkTjjhBG699VYAbrrpJm677Tbuvfdedu/ezQcffMBDDz3US4cKDOeXJElccsklVFZW8uMf/5iKigr+8pe/sGnTpkHbOhSMuVS+SCTCokWLuPDCCzMiXj3x6KOPsn79eh544AFWrlzJhg0bWLNmDRUVFRkBtcWLF2c8oz3x3HPPsXXrVmbNmsWsWbN4/fXXj7k9h8OSgiUUugppibb0qzNV5CpiRdHABPXGA4QQhEIhvF7vhHDE9QWTAwMmDyYHYHIAJgdpmDyY6A9CCOKJFFoqQTzYMdLdGTEkVYEiSdhSEugT04ErhCCU0PHa5Ql7nTA56OYgGMRbNAOOcjLD95nPwMYNNN96G2pTU2a5pbCQwuuuNb4/jrBYLFx22WX84he/oLKykpqaGr7whS/g9/u5+eabe0VM+f1+br/9dtavX4+maSxcuJD/9//+H7m5uQD87Gc/47vf/S4zZswgkUgMOSJ50aJF3H333dxxxx1ce+21nHLKKdx2222cf/75R23v3XffzYUXXsiqVavIy8vj6quvJhgMDvj3PVP5+sP1119PdXU1a9asweVycfHFF3Puuece1kHUF1wuF6+88gpXX301X/rSlwiFQpSWlvLpT38an8/QfbvooovYvHkzy5YtIxwO89JLL7F69Wruvfdefvazn3HDDTdw8skns3nz5n7386Mf/Yh169Zx9dVX853vfAeXy8Wdd97Jj3/8Y9xuNwsXLuwlRg8HUvkm///snXd4FFXbxu+Z3fTeE0JIQoJA6CUgCCYUDSgo2BB9pSmI9KZg+QBBBRUpKvYXgoqvolRBQbo06VUghJCEkN57ts35/lhm2E02yW5Issnu8+PKxdkzZ888z31mZ88+c0qrVti8eTNmz56Nzz77DL169cIHH3yACRMmmORrXeBYMx7zznEctm7dihEjRkh5vXv3RmRkpLQbgSAICAoKwvTp07FgwYJa63zzzTfx448/QiaToaSkBCqVCnPnzsXChQsNllcoFFAoFNLroqIiBAUFIT8/H+7u7tKFzvN8jWmO46S5rrrp/bf3Y+5h7RaNusEpDtovkhUPr8AjIY9IvopPigVBgEwmkz5shtKMMWnusaG0sbab6pOY1mg04Hm+2rQhnziOw+3btxEYGAgbGxuL8MnUdgK0u2i0bNkScrncInyqSzup1WrcuXNHbyvY5u6Tqe2kq4F4nubuk6ntpFarkZqaiqCgIACwCJ9MbSeNRoPU1FS0bNlSOwXBAnyqSzsBxt8bTfEpPz8fnp6eKCwslDqORMNQVFQENze3etdaEARcPncKfEWO1f4QB7Q/wNQChy6B1jtaRhAYUvIVCPKwIw2sXYMCBYLCIqC090JiYiJCQ0OlRbDrAtNoUHbmLNTZ2ZD7+MCxZ49GHSlVFxhjUCqV0mgZa4Q0uH8NKioqqv0MmfS9zpoxANjWrVul1wqFgslkMr08xhgbM2YMe+KJJ0yuf/369Wzu3Lk1llm0aBGDdgdevb+4uDjGGGOZmZksMzOTMcZYWloay87OZowxdufOHZabm8sYY+z27dssPz+fMcZYUlISKywsZIwxlpCQwIqLi9nepL0s6qco1jG2o/Q3aNMgtjdpL7t27RpTKpVMrVaza9euMbVazZRKJbt27RpjjLGKigrJlrKyMhYfH88YY6y4uJglJCQwxhgrLCxkSUlJjDHG8vPz2e3btxljjOXm5rI7d+4wxhjLzs5maWlp9eYTY4zFx8ezsrIyxhhjcXFxrKKigjHGyCfyiXwin8gn8qnJ+HT27FkGQCpHNByFhYWkNUEQjUp5eTm7evUqKy8vN7cpBNEsqekzZMr3ukWNmEpLS0NgYCCOHz+ut63hG2+8gcOHD+PkyZMm1R8bG4srV65gxYoV1ZZp6BFTYlqpUuJ89nmk5KWgpUdL9PTvCblMbvGjISr7xPM8CgoK4OLiArlcbhE+mdpOHMehoKAArq6ukMlkFuFTXdpJo9GgqKgI7u7u0kiy5u6Tqe2kq4Fob3P3ydR20mg0KC4uhpubGxhjFuGTqe0kCAKKi4ulJ1GW4FNd2smUeyONmGqaNNSIKcYYCgsL4ebmZrVPxAHSASANANIA0NdAoVDUy4ip5gi7O+paJpNZ9bVAGtyfBvU1YqrZrTHVmIwbN67WMnZ2dgYXTBM74OL/95u2tbFFpH8kWmhaIDAgUDqmu4CdoTTHcdWmxQuvunR92V5dujbbDaUFQUBJSYm0c4El+GTIj5p8qqyBJfhUOW2MXRzHSTpYik+mpnU1sBSfTG0nnueraNDcfapLO4mBKfFcluBTTWlDttTnvbE624nmCWNM+oxY6w8PgHQASAOANAD0NbB2xIdC1gxp0DQ0sKiVD729vSGTyaqskp+ZmQl/f/9GtUV8OisIglFpccRHdWmNRgOO4xAUFCQ9NRbzxdeV0wBqTIvnry5trO3341NNaUM+8TyPli1bSmUtwSdT20nUQMQSfKpLOwFAYGCgNALCEnwytZ0AoGXLluB53mJ8MrWdGGPS2kqW4pOp7QQAQUFBUuDaEnyqSzvxPI/AwECI1KdPRPOG53kEBQXpBR+tEdKBNABIA4A0EOE4zqrXVgJIA6DpaGBRn0ZbW1v06NED+/fvl/IEQcD+/fv1pvY1BGvXrkVERAQiIyMBAFlZWQCAnJwcaXvNzMxM5OXlAQDS09NRUFAAAEhNTZVW9U9JSUFxcTEAICkpCaWlpQCAxMRElJWVIS8vDzdv3oRSqQQAxMfHQ61WQxAExMfHQxAEqNVqxMfHAwCUSiUSEhIA3BtmB2h3N0xKSgIAFBcXIyUlBQBQWFiI1NRUAEBBQQHS09MBAHl5eVLArz59qqioAAAkJCQY5ZMgCMjMzMTNmzctxidT20kQBKSkpEj+WYJPdWmnjIwMJCUlQRAEi/HJ1HZKTExEWloaBEGwGJ9MbacbN24gNzcXSqXSYnwytZ0SExORl5eHoqIii/GpLu0kfg7E79/68kl3ByOieSIIAvLy8vQebFgjpANpAJAGAGkgwhiDWq3We+BpbZAGTUeDZrfGVElJiRSU6NatG1auXIkBAwbA09MTrVq1wi+//IKxY8fi66+/Rq9evbB69Wps2rQJ169fh5+fX4PbJ86jrO81psQnthkZGfD19YVcLreK9WMq+8RxHNLS0uDn52fVu/KlpaXB39/f6nfly8jIQIsWLaTPX3P3ydR20tVAPE9z98nUdlKr1cjMzERAQAAA692VTxwZzHHWvSufsfdGU3yiNaYaj4bclS89PR0BAQFWPUKCdCANANIA0NdAqVQiMTERISEhcHBwMLdpjQpjDCqVCjY2NmYfLWMuSIP716CsrAzJycn3vcZUswtMHTp0CAMGDKiSP3bsWMTGxgIAPv/8c3z88cfIyMhA165d8emnn6J3796NYl9DdaoIgiAIgmh86Hu98SCtCYJobDQaDeLj4+Ho6AgfHx+rDU4QhKkwxqBUKpGdnQ2NRoM2bdpUCXZbdGCqqdPQI6by8/Ph5uZm1SOmcnNz4e7ubtUjpnJzc+Hh4WH1I6by8/Ph5eUlff6au091GTElamDNI6YKCgrg6ekJwHpHTBUUFMDDw8PqR0wZe2+kEVNNk4YcMZWXlwdPT0+rHSECkA4AaQCQBkBVDUpKSnDnzh2pn20tiN+94vedNUIa3L8Gjo6OCAgIgK2tbZVjtCufGVi7di3Wrl0rBZCysrLg7u4urd/h6+uLzMxM2NjYwNvbG+np6XBwcICnpydSU1Ph4uICd3d3pKSkwMPDA66urkhKSoKvry+cnZ2RmJiIgIAAqFQq3Lp1CyEhIbCzs0N8fDzCwsLA8zzi4+PRpk0bCIKAhIQEtGvXDkqlEsnJyXjggQdQUVGB1NRUhIeHo7S0FFlZWWjdujWKi4uRn5+P4OBgFBYWori4GEFBQSgoKEB5eTkCAwORl5cHlUqFgICAevUpMDAQDg4OSEhIQHBwcK0+PfDAAygvL0deXh7atm1rET6Z2k5BQUEoLCxEWVkZgoODLcKnurRTVlYWiouL4eXlZTE+mdpOycnJ4HkeXl5eFuOTqe108+ZNuLq6Qq1WIzEx0SJ8MrWdMjMz4ejoiJKSEhQUFFiET3VpJz8/P+Tk5ECj0cDf37/efKI1piwDlUplbhOaBKQDaQCQBoC+Bs7OzmjTpo3V6SIIAnJycuDt7W3VQUrSoO4ayGQyacDM/UIjpuqZhhwx1RSeSFviU3byiXwin8gn8ol8qs4nGjHVeNBUPoIgCIKwHGgqnxlpyE4VRXRJA4A0ECEdSAOANABIA5GG0oGCJY1HQ07lo88I6QCQBgBpAJAGIqQDaQA0rAamfK9bp/qNgPh0VhAEo9JifLC6tEajqTEtrjOimwZQY1o8f3VpY20nn8gnc/mka6+l+GSJ7UQ+kU+N5ZOxfpvqE0EQBEEQBNFwUGCqnli7di0iIiIQGRkJQLvGFADk5ORI63hkZmYiLy8PAJCeno6CggIAQGpqKgoLCwEAKSkpKC4uBgAkJSWhtLQUAJCYmAilUglfX18pDQDx8fFQq9UQBAHx8fEQBAFqtRrx8fEAAKVSiYSEBABARUWFtFZGaWkpkpKSAADFxcVISUkBABQWFiI1NRUAUFBQgPT0dABAXl4eMjMz692niooKAEBCQoJRPvE8D3d3d8kPS/DJ1HbieR52dnaSH5bgU13aKTs7GzKZDDzPW4xPprbT7du34eTkBJ7nLcYnU9spISEB3t7ekn+W4JOp7XT79m34+vqitLTUYnyqSzuJU+9EP+rLJ1pjqvnD8zx8fX2t9mm4COlAGgCkAUAaiJAOpAHQdDSgqXz1TGFhIdzd3ZGcnNwgu/JlZ2fDy8vLqnfly8zMhLe3t1XvypeZmQkfHx+r35UvOzsbfn5+0uevuftkajvpaiCep7n7ZGo7qdVq5OTkwNfXF4D17sqXk5MjbXNtCT7VpZ0A4++Npq4xFRISgoKCAri5uYFoOMQ+VEpKSr1P5cvKymoSHW9zQjqQBgBpAJAGIqQDaQA0rAZFRUXSpjW19aFoV756RnzyGhwcbGZLCIIgCIKoL4qLiykw1cCIfaigoCAzW0IQBEEQRH1hTB+KRkzVM4IgIC0tDS4uLuC4+982URcx4ljfTxKbE6QBaSBCOpAGAGkAkAYiDaUDYwzFxcVo0aKF1T5NbSwaqg9FnxEtpANpAJAGAGkgQjqQBkDDamBKH4pGTNUzPM+jZcuWDXoOV1dXq/3giJAGpIEI6UAaAKQBQBqINIQONFKqcWjoPhR9RrSQDqQBQBoApIEI6UAaAA2ngbF9KHr0RxAEQRAEQRAEQRAEQZgFCkwRBEEQBEEQBEEQBEEQZoECU80IOzs7LFq0CHZ2duY2xWyQBqSBCOlAGgCkAUAaiJAORHXQtaGFdCANANIAIA1ESAfSAGg6GtDi5wRBEARBEARBEARBEIRZoBFTBEEQBEEQBEEQBEEQhFmgwBRBEARBEARBEARBEARhFigwRRAEQRAEQRAEQRAEQZgFCkwRBEEQBEEQBEEQBEEQZoECUwRBEARBEARBEARBEIRZoMBUM2XkyJHw8PDAM888Y25TzEJKSgqio6MRERGBzp0749dffzW3SY1OQUEBevbsia5du6Jjx4749ttvzW2S2SgrK0NwcDDmzZtnblPMRkhICDp37oyuXbtiwIAB5jbHLCQmJmLAgAGIiIhAp06dUFpaam6TGpW4uDh07dpV+nNwcMC2bdvMbVajs2rVKnTo0AERERGYMWMGaPNhQhdr7z8B1IcCqA+li7X3oaj/RP0ngPpQIubsQ3GMemzNkkOHDqG4uBgbNmzAb7/9Zm5zGp309HRkZmaia9euyMjIQI8ePXDjxg04OTmZ27RGQ6PRQKFQwNHREaWlpejYsSPOnDkDLy8vc5vW6Lz99tu4efMmgoKCsGLFCnObYxZCQkJw5coVODs7m9sUsxEVFYX33nsP/fv3R15eHlxdXSGXy81tllkoKSlBSEgIkpOTreq+mJ2djQcffBD//vsvbGxs8PDDD2PFihXo06ePuU0jmgjW3n8CqA8FUB9KF2vvQ1H/ifpPlaE+lHn6UDRiqpkSHR0NFxcXc5thNgICAtC1a1cAgL+/P7y9vZGXl2deoxoZmUwGR0dHAIBCoQBjzCpHBsTHx+P69esYOnSouU0hzIj4Jdq/f38AgKenp1V3qnbs2IFBgwZZVYdKRK1Wo6KiAiqVCiqVCr6+vuY2iWhCWHv/CaA+FEB9KBHqQxHUf6oK9aHM04eiwFQTZdmyZYiMjISLiwt8fX0xYsQIxMXFmdusRsVYDc6ePQuNRoOgoCAzWNmw1KZBQUEBunTpgpYtW+L111+Ht7e3Ga1tGGrTYN68eVi2bJkZLWwcatOB4zhERUUhMjISGzduNKOlDUdNGsTHx8PZ2RnDhw9H9+7d8cEHH5jZ2obB2Pvipk2bMGrUKDNY2PDUpIGPjw/mzZuHVq1aoUWLFhg8eDDCwsLMbDHRmFD/SQv1oagPBVAfCqD+E0D9JxHqQzXtPhQFppoohw8fxtSpU/HPP/9g7969UKlUePTRR61qzq8xGuTl5WHMmDH45ptvzGhpw1GbBu7u7rh48SISExPx008/ITMz08wW1z81abB9+3Y88MADeOCBB8xtZoNT27Vw9OhRnD17Fjt27MAHH3yAS5cumdni+qcmDdRqNY4cOYIvvvgCJ06cwN69e7F3715zm1zvGHNfLCoqwvHjx/HYY4+Z0dKGoyYN8vPzsXPnTiQlJSE1NRXHjx/H33//bW6TiUaE+k9aqA9FfSiA+lAA9Z8A6j+JUB+qifehGNEsyMrKYgDY4cOHpbyDBw+yp59+2oxWNS6VNaioqGD9+/dn33//vZktazwMXQcir732Gvv111/NYFXjoqvBggULWMuWLVlwcDDz8vJirq6u7N133zW3iY1CTdfCvHnz2Pr16xvfqEZGV4Pjx4+zRx99VDr20UcfsY8++siM1jUOhq6D77//nr344otmtKpx0dVg06ZNbMqUKdKxjz76iH344YdmtI4wN9R/0kJ9KOpDMUZ9KMao/8QY9Z9EqA/VtPpQNGKqmVBYWAhAO+/XWtHVgDGGcePGYeDAgXjppZfMbFnjoatBZmYmiouLpfy///4bbdu2Nad5jYKuBsuWLUNKSgqSkpKwYsUKTJw4EQsXLjSzhY2Drg6lpaXStVBSUoIDBw6gQ4cO5jSvUdDVIDIyEllZWcjPz4cgCPj777/Rvn17M1vY8Bj6brDkIeiG0NUgKCgIx48fR0VFBTQaDQ4dOmQV90Wieqj/pIX6UNSHAqgPBVD/CaD+kwj1oZpWH4p25WsGCIKAJ554AgUFBTh69CgAYPDgwbh48SJKS0vh6emJX3/91aJ3HaqswdGjR/Hwww+jc+fOUpkffvgBnTp1MqOVDUtlDU6dOoVJkyZJC3ZOnToVr776qrnNbFAMfRZEYmNjceXKFavYUaayDrdu3cLIkSMBaHcamjhxImbOnGlmKxsWQ9fCn3/+iTfeeAOMMTz66KNYuXKlma1sWAxpUFhYiAceeAApKSmwtbU1s4UNjyEN3n77bWzZsgU8z2PQoEFYs2YNOI4zs6WEOaD+kxbqQ1EfCqA+FED9J4D6TyLUh2qCfahGG5tF1JnJkyez4OBglpKSYm5TzAZpQBowRhqIkA6kAWOkAWOkAVEzdH1oIR1IA8ZIA8ZIA8ZIAxHSoelpQIGpJs7UqVNZy5Yt2a1bt8xtitkgDUgDxkgDEdKBNGCMNGCMNCBqhq4PLaQDacAYacAYacAYaSBCOjRNDSgw1UQRBIFNnTqVtWjRgt24ccPc5pgF0oA0YIw0ECEdSAPGSAPGSAOiZuj60EI6kAaMkQaMkQaMkQYipEPT1kDeOBMGCVOZOnUqfvrpJ2zfvh0uLi7IyMgAALi5ucHBwcHM1jUOpAFpAJAGIqQDaQCQBgBpQNQMXR9aSAfSACANANIAIA1ESIcmroG5I2OEYQAY/LOGLUxFSAPSgDHSQIR0IA0YIw0YIw2ImqHrQwvpQBowRhowRhowRhqIkA5NWwPalY8gCIIgCIIgCIIgCIIwC7y5DSAIgiAIgiAIgiAIgiCsEwpMEQRBEARBEARBEARBEGaBAlMEQRAEQRAEQRAEQRCEWaDAFEEQBEEQBEEQBEEQBGEWKDBFEARBEARBEARBEARBmAUKTBEEQRAEQRAEQRAEQRBmgQJTBEEQBEEQBEEQBEEQhFmgwBRBEARBEARBEARBEARhFigwRRCERREbGwt3d/d6rzckJASrV6+WXnMch23bttX7eeqTQ4cOgeM4FBQUmNsUgiAIgiCaONSHugf1oQiicZGb2wCCIIjaGDduHAoKCozqxIwaNQqPPfZYg9uUnp4ODw+PBj/P/dC3b1+kp6fDzc3N3KYQBEEQBGEGqA9VN6gPRRCNCwWmCIKwGFQqFRwcHODg4NDg5/L392/wc9wvtra2zcJOgiAIgiDMC/Wh9KE+FEE0LjSVjyCIeiM6OhrTp0/HrFmz4OHhAT8/P3z77bcoLS3F+PHj4eLigvDwcPz555/SezQaDV5++WWEhobCwcEBbdu2xZo1a6TjixcvxoYNG7B9+3ZwHAeO43Do0CEkJSWB4zj88ssviIqKgr29PTZu3Kg3DJ0xhsGDByMmJgaMMQBAXl4eWrZsiYULF1brR1ZWFoYPHw4HBweEhoZi48aNVcroDkMXbdm0aRP69+8PBwcHREZG4saNGzh9+jR69uwJZ2dnDB06FNnZ2Xr1fPfdd2jfvj3s7e3Rrl07fPHFF9Ixsd4tW7ZgwIABcHR0RJcuXXDixAmpTHJyMoYPHw4PDw84OTmhQ4cO+OOPPwAYHoa+efNmdOjQAXZ2dggJCcEnn3yiZ09ISAg++OADTJgwAS4uLmjVqhW++eabarUiCIIgCOL+oT4U9aEIwqphBEEQ9URUVBRzcXFhS5cuZTdu3GBLly5lMpmMDR06lH3zzTfsxo0b7LXXXmNeXl6stLSUMcaYUqlkCxcuZKdPn2a3bt1iP/74I3N0dGS//PILY4yx4uJi9txzz7EhQ4aw9PR0lp6ezhQKBUtMTGQAWEhICNu8eTO7desWS0tLY+vXr2dubm6STXfu3GEeHh5s9erVjDHGnn32WdarVy+mUqmq9WPo0KGsS5cu7MSJE+zMmTOsb9++zMHBga1atUoqA4Bt3bqVMcYkW9q1a8d2797Nrl69yh588EHWo0cPFh0dzY4ePcrOnTvHwsPD2eTJk6U6fvzxRxYQECDZv3nzZubp6cliY2Or1Ltz504WFxfHnnnmGRYcHCzZ//jjj7NHHnmEXbp0iSUkJLDff/+dHT58mDHG2MGDBxkAlp+fzxhj7MyZM4znebZkyRIWFxfH1q9fzxwcHNj69eslm4KDg5mnpydbu3Yti4+PZ8uWLWM8z7Pr16+bfkEQBEEQBGEU1IeiPhRBWDMUmCIIot6Iiopi/fr1k16r1Wrm5OTEXnrpJSkvPT2dAWAnTpyotp6pU6eyp59+Wno9duxY9uSTT+qVETscYmdJpHKnijHGNm3axOzt7dmCBQuYk5MTu3HjRrXnjouLYwDYqVOnpLxr164xALV2qr777jvp+P/+9z8GgO3fv1/KW7ZsGWvbtq30OiwsjP30009651+6dCnr06dPtfX++++/DAC7du0aY4yxTp06scWLFxv0pXKn6oUXXmCPPPKIXpnXX3+dRURESK+Dg4PZf/7zH+m1IAjM19eXffnllwbPQRAEQRDE/UN9KOpDEYQ1Q1P5CIKoVzp37iylZTIZvLy80KlTJynPz88PgHaot8jatWvRo0cP+Pj4wNnZGd988w1u375t1Pl69uxZa5lnn30WI0eOxPLly7FixQq0adOm2rLXrl2DXC5Hjx49pLx27doZtUuNru+in5V9F/0uLS1FQkICXn75ZTg7O0t/7733HhISEqqtNyAgAMA9/WbMmIH33nsPDz30EBYtWoRLly7V6NtDDz2kl/fQQw8hPj4eGo3G4Pk4joO/v79eexEEQRAEUf9QH0oL9aEIwvqgwBRBEPWKjY2N3muO4/TyOI4DAAiCAAD4+eefMW/ePLz88sv466+/cOHCBYwfPx5KpdKo8zk5OdVapqysDGfPnoVMJkN8fLyxrpiMIT8r54l+l5SUAAC+/fZbXLhwQfq7cuUK/vnnn1rrFet55ZVXcOvWLbz00ku4fPkyevbsic8++6ze/KhsN0EQBEEQDQP1obRQH4ogrA8KTBEEYVaOHTuGvn37YsqUKejWrRvCw8OrPO2ytbXVexplKnPnzgXP8/jzzz/x6aef4sCBA9WWbdeuHdRqNc6ePSvlxcXF6S1+WR/4+fmhRYsWuHXrFsLDw/X+QkNDTaorKCgIkydPxpYtWzB37lx8++23Bsu1b98ex44d08s7duwYHnjgAchksjr7QhAEQRBE40N9KOpDEYSlIDe3AQRBWDdt2rTB999/jz179iA0NBQ//PADTp8+rdexCAkJwZ49exAXFwcvLy+4ubkZXf+uXbuwbt06nDhxAt27d8frr7+OsWPH4tKlS/Dw8KhSvm3bthgyZAheffVVfPnll5DL5Zg1a1aDbJ/87rvvYsaMGXBzc8OQIUOgUChw5swZ5OfnY86cOUbVMWvWLAwdOhQPPPAA8vPzcfDgQbRv395g2blz5yIyMhJLly7FqFGjcOLECXz++ed6u9gQBEEQBNE8oD4U9aEIwlKgEVMEQZiVV199FU899RRGjRqF3r17Izc3F1OmTNErM3HiRLRt2xY9e/aEj49PlSdW1ZGdnY2XX34ZixcvRvfu3QFoOzJ+fn6YPHlyte9bv349WrRogaioKDz11FOYNGkSfH196+5kNbzyyiv47rvvsH79enTq1AlRUVGIjY016WmfRqPB1KlT0b59ewwZMgQPPPBAtZ2k7t27Y9OmTfj555/RsWNHLFy4EEuWLMG4cePqySOCIAiCIBoL6kNRH4ogLAWOMcbMbQRBEARBEARBEARBEARhfdCIKYIgCIIgCIIgCIIgCMIsUGCKIAiCIAiCIAiCIAiCMAsUmCIIgiAIgiAIgiAIgiDMAgWmCIIgCIIgCIIgCIIgCLNAgSmCIAiCIAiCIAiCIAjCLFBgiiAIgiAIgiAIgiAIgjALFJgiCIIgCIIgCIIgCIIgzAIFpgiCIAiCIAiCIAiCIAizQIEpgiAIgiAIgiAIgiAIwixQYIogCIIgCIIgCIIgCIIwCxSYIgiCIAiCIAiCIAiCIMwCBaYIgiAIgiAIgiAIgiAIs0CBKYIgCIIgCIIgCIIgCMIsUGCKIAiCIAiCIAiCIAiCMAsUmCIIgiAIgiAIgiAIgiDMAgWmCIIgCIIgCIIgCIIgCLNAgSmCIAiCIAiCIAiCIAjCLFBgiiAIohoOHToEjuNw6NAhc5tCEARBEIQFY44+R2xsLDiOw5kzZxrtnAAwbtw4ODs7N+o564PFixeD4zhzm0EQFgkFpgiCqBWx42Lob8GCBeY2jyAIgiAIC4H6HARBENaH3NwGEATRfFiyZAlCQ0P18jp27GgmawiCIAiCsFSoz0EQBGE9UGCKIAijGTp0KHr27Fnv9ZaWlsLJyane660NxhgqKirg4ODQ6OdujpirnQiCIAjrg/ocxhMdHY2QkBDExsbWe93WhFqthiAIsLW1NbcpTR7qQxP1DU3lIwii3jhw4AD69+8PJycnuLu748knn8S1a9f0yojz869evYoXXngBHh4e6NevH3bs2AGO43Dp0iWp7ObNm8FxHJ566im9Otq3b49Ro0ZJr9evX4+BAwfC19cXdnZ2iIiIwJdfflnFvpCQEAwbNgx79uxBz5494eDggK+//hoAcOfOHYwYMQJOTk7w9fXF7NmzoVAojPJb9OnGjRv4z3/+Azc3N/j4+OD//u//wBhDSkoKnnzySbi6usLf3x+ffPJJlToUCgUWLVqE8PBw2NnZISgoCG+88UYVGziOw7Rp0/Drr78iIiICDg4O6NOnDy5fvgwA+PrrrxEeHg57e3tER0cjKSmpyrl+/fVX9OjRAw4ODvD29sZ//vMfpKam6pUR139ISEjAY489BhcXF7z44otYtGgRbGxskJ2dXaXeSZMmwd3dHRUVFUbpRhAEQRB1xVr7HA1BWVkZXn31VXh5ecHV1RVjxoxBfn6+Xpnt27fj8ccfR4sWLWBnZ4ewsDAsXboUGo2mSn0nT57EY489Bg8PDzg5OaFz585Ys2ZNjTZcuHABPj4+iI6ORklJCebMmQMvLy8wxqQy06dPB8dx+PTTT6W8zMxMcBwntYFSqcTChQvRo0cPuLm5wcnJCf3798fBgwf1zpeUlASO47BixQqsXr0aYWFhsLOzw9WrVwEAR48eRWRkJOzt7REWFia1nTFER0ejY8eOuHTpEqKiouDo6Ijw8HD89ttvAIDDhw+jd+/ecHBwQNu2bbFv374qdaSmpmLChAnw8/ODnZ0dOnTogHXr1umVEdcl27RpE959910EBgbCxcUFzzzzDAoLC6FQKDBr1iz4+vrC2dkZ48ePr3KdqdVqLF26VPI/JCQEb731VpVy1V3PUVFR6NKli0Ed2rZti5iYGKN1I6wbGjFFEITRFBYWIicnRy/P29sbALBv3z4MHToUrVu3xuLFi1FeXo7PPvsMDz30EM6dO4eQkBC99z377LNo06YNPvjgAzDG0K9fP3Ach7///hudO3cGABw5cgQ8z+Po0aPS+7Kzs3H9+nVMmzZNyvvyyy/RoUMHPPHEE5DL5fj9998xZcoUCIKAqVOn6p03Li4Oo0ePxquvvoqJEyeibdu2KC8vx6BBg3D79m3MmDEDLVq0wA8//IADBw6YpM+oUaPQvn17LF++HLt27cJ7770HT09PfP311xg4cCA+/PBDbNy4EfPmzUNkZCQefvhhAIAgCHjiiSdw9OhRTJo0Ce3bt8fly5exatUq3LhxA9u2bdM7z5EjR7Bjxw7Jt2XLlmHYsGF444038MUXX2DKlCnIz8/HRx99hAkTJuj5ERsbi/HjxyMyMhLLli1DZmYm1qxZg2PHjuH8+fNwd3eXyqrVasTExKBfv35YsWIFHB0d0adPHyxZsgS//PKLXhsolUr89ttvePrpp2Fvb2+SbgRBEARRGepzNB7Tpk2Du7s7Fi9ejLi4OHz55ZdITk6WAh+Atv/g7OyMOXPmwNnZGQcOHMDChQtRVFSEjz/+WKpr7969GDZsGAICAjBz5kz4+/vj2rVr2LlzJ2bOnGnw/KdPn0ZMTAx69uyJ7du3w8HBAf3798eqVavw77//SlM4xTY6cuQIZsyYIeUBkPpURUVF+O677zB69GhMnDgRxcXF+O9//4uYmBicOnUKXbt21Tv3+vXrUVFRgUmTJsHOzg6enp64fPkyHn30Ufj4+GDx4sVQq9VYtGgR/Pz8jNY0Pz8fw4YNw/PPP49nn30WX375JZ5//nls3LgRs2bNwuTJk/HCCy/g448/xjPPPIOUlBS4uLgA0AbbHnzwQelhpI+PD/7880+8/PLLKCoqwqxZs/TOtWzZMjg4OGDBggW4efMmPvvsM9jY2IDneeTn52Px4sX4559/EBsbi9DQUCxcuFB67yuvvIINGzbgmWeewdy5c3Hy5EksW7YM165dw9atW/XOY+h6dnZ2xsSJE3HlyhW9qbanT5/GjRs38M477xitGWHlMIIgiFpYv349A2DwT6Rr167M19eX5ebmSnkXL15kPM+zMWPGSHmLFi1iANjo0aOrnKdDhw7sueeek153796dPfvsswwAu3btGmOMsS1btjAA7OLFi1K5srKyKnXFxMSw1q1b6+UFBwczAGz37t16+atXr2YA2KZNm6S80tJSFh4ezgCwgwcP1qiP6NOkSZOkPLVazVq2bMk4jmPLly+X8vPz85mDgwMbO3aslPfDDz8wnufZkSNH9Or96quvGAB27NgxKQ8As7OzY4mJiVLe119/zQAwf39/VlRUJOW/+eabDIBUVqlUMl9fX9axY0dWXl4uldu5cycDwBYuXCjljR07lgFgCxYsqOJvnz59WO/evfXyxHapTSuCIAiCqAnqcxysTaIqREVF6fUrjEXUukePHkypVEr5H330EQPAtm/fLuUZ8vvVV19ljo6OrKKigjGm7fuEhoay4OBglp+fr1dWEAQpPXbsWObk5MQYY+zo0aPM1dWVPf7441I9jDGWlZXFALAvvviCMcZYQUEB43mePfvss8zPz08qN2PGDObp6SnVr1armUKh0Dt3fn4+8/PzYxMmTJDyEhMTGQDm6urKsrKy9MqPGDGC2dvbs+TkZCnv6tWrTCaT6V2H1REVFcUAsJ9++knKu379OgPAeJ5n//zzj5S/Z88eBoCtX79eynv55ZdZQEAAy8nJ0av3+eefZ25ublJbHDx4kAFgHTt21Gu/0aNHM47j2NChQ/Xe36dPHxYcHCy9vnDhAgPAXnnlFb1y8+bNYwDYgQMHpLzqrueCggJmb2/P5s+fr5c/Y8YM5uTkxEpKSmqSiiAkaCofQRBGs3btWuzdu1fvDwDS09Nx4cIFjBs3Dp6enlL5zp0745FHHsEff/xRpa7JkydXyevfv7/05Ku4uBgXL17EpEmT4O3tLeUfOXIE7u7uek9ldOe3i09Yo6KicOvWLRQWFuqdIzQ0tMqw4j/++AMBAQF45plnpDxHR0dMmjTJaG0A7VMnEZlMhp49e4IxhpdfflnKd3d3R9u2bXHr1i0p79dff0X79u3Rrl075OTkSH8DBw4EgCrDzwcNGqT3NLh3794AgKefflp62qabL57rzJkzyMrKwpQpU/RGNT3++ONo164ddu3aVcWn1157rUremDFjcPLkSSQkJEh5GzduRFBQEKKiompQiCAIgiCMg/ochlGpVHp9hZycHKhUKigUiir5giAYVeekSZNgY2MjvX7ttdcgl8v1tNT1u7i4GDk5Oejfvz/Kyspw/fp1AMD58+eRmJiIWbNm6Y3ABiCNvNLl4MGDiImJwaBBg7BlyxbY2dlJx3x8fNCuXTv8/fffAIBjx45BJpPh9ddfR2ZmJuLj4wFo20gcAQdo+1/iGlGCICAvLw9qtRo9e/bEuXPnqtjw9NNPw8fHR3qt0WiwZ88ejBgxAq1atZLy27dvb9K0NGdnZzz//PPS67Zt28Ld3R3t27eX+mdA1b4aYwybN2/G8OHDwRjTa8+YmBgUFhZW8WPMmDF67de7d28wxjBhwgS9cr1790ZKSgrUajUASO07Z84cvXJz584FgCr9QkPXs5ubG5588kn873//k6ZdajQa/PLLL9J0VYIwBgpMEQRhNL169cLgwYP1/gAgOTkZgPZLtzLt27dHTk4OSktL9fIr77QDaDuJ6enpuHnzJo4fPw6O49CnTx+9zuORI0fw0EMPgefv3b6OHTuGwYMHS+tM+Pj44K233gIAg53EyiQnJyM8PLxKp8mQPzWh24EBtF/W9vb20tQD3XzdtRvi4+Px77//wsfHR+/vgQceAABkZWXVeh4ACAoKMpgvnqumdmrXrp10XEQul6Nly5ZVyo4aNQp2dnbYuHEjAK3GO3fuxIsvvmiw40kQBEEQpkJ9DsMcO3asSn/h+PHj+Pnnn6vk375926g627Rpo/fa2dkZAQEBeutU/vvvvxg5ciTc3Nzg6uoKHx8f/Oc//wFwz2/xgZUxuydWVFTg8ccfR7du3bBp0yaDC45XbouePXuiZ8+e8PT0xJEjR1BUVISLFy+if//+eu/bsGEDOnfuDHt7e3h5ecHHxwe7du2q0j5A1TbKzs5GeXl5FU0A0/qFLVu2rNLGbm5utfbVsrOzUVBQgG+++aZKe44fPx7A/fULBUGQdEhOTgbP8wgPD9cr5+/vD3d39yr9QkPXM6ANjN2+fVtqq3379iEzMxMvvfSSwfIEYQhaY4ogCLNgaBePfv36AQD+/vtv3Lp1C927d5cWrfz0009RUlKC8+fP4/3335fek5CQgEGDBqFdu3ZYuXIlgoKCYGtriz/++AOrVq2q8rSwIXcPkclkRuUB0FvMUxAEdOrUCStXrjRYtnLHoro6jTmXKdjZ2el1xkU8PDwwbNgwbNy4EQsXLsRvv/0GhUIhdVAJgiAIoilhSX2OLl26SKPHRObOnQt/f3+8/vrrevn+/v71cs6CggJERUXB1dUVS5YsQVhYGOzt7XHu3DnMnz/f6JFZutjZ2eGxxx7D9u3bsXv3bgwbNqxKmX79+uHbb7/FrVu3cOTIEfTv3x8cx6Ffv344cuQIWrRoAUEQ9AJTP/74I8aNG4cRI0bg9ddfh6+vL2QyGZYtW6Y30lukofqFde2riVr+5z//wdixYw2WFddFu99ziRj7ULE6rWJiYuDn54cff/wRDz/8MH788Uf4+/tLwWSCMAYKTBEEcd8EBwcD0C6KWJnr16/D29vbqKG8rVq1QqtWrXDkyBHcunVL6mg8/PDDmDNnDn799VdoNBppgUsA+P3336FQKLBjxw69J0aVp7/VZv+VK1fAGNP7cjbkT0MQFhaGixcvYtCgQQ064ki3ncRpgiJxcXHScWMYM2YMnnzySZw+fRobN25Et27d0KFDh3q1lyAIgiAqY+19Dg8Pjyo/+D08PBAQEFDnQEB8fDwGDBggvS4pKUF6ejoee+wxANrd33Jzc7FlyxY9PRITE/XqCQsLAwBcuXKlVls4jsPGjRvx5JNP4tlnn8Wff/6J6OhovTJim+zduxenT5/GggULAGjb6Msvv0SLFi3g5OSEHj16SO/57bff0Lp1a2zZskVP30WLFhmlhY+PDxwcHKSpgro0Rr/Qx8cHLi4u0Gg0DR7YCQ4OhiAIiI+PR/v27aX8zMxMFBQUGN0vlMlkeOGFFxAbG4sPP/wQ27Ztw8SJE6sNjBGEIWgqH0EQ901AQAC6du2KDRs2oKCgQMq/cuUK/vrrL6ljYwz9+/fHgQMHcOrUKalD0rVrV7i4uGD58uVwcHDQ64CIX3q6T38KCwuxfv16o8/52GOPIS0tTdrGF9BunfzNN98YXcf98NxzzyE1NRXffvttlWPl5eVVpiTUlZ49e8LX1xdfffWV3jbAf/75J65du4bHH3/c6LqGDh0Kb29vfPjhhzh8+DCNliIIgiAaBepz1D/ffPMNVCqV9PrLL7+EWq3G0KFDARj2W6lU4osvvtCrp3v37ggNDcXq1av12qbye0VsbW2xZcsWREZGYvjw4Th16pTe8dDQUAQGBmLVqlVQqVR46KGHAGjbLSEhAb/99hsefPBByOX3xloYsvXkyZM4ceKEUVrIZDLExMRg27ZtelMhr127hj179hhVx/0gk8nw9NNPY/Pmzbhy5UqV49nZ2fV2LvGzsnr1ar18cQS/Kf3Cl156Cfn5+Xj11VdRUlJC/ULCZGjEFEEQ9cLHH3+MoUOHok+fPnj55ZelrZvd3NywePFio+vp378/Nm7cKA3VBrRf0n379sWePXsQHR2ttw7Bo48+CltbWwwfPlz6Mvz222/h6+uL9PR0o845ceJEfP755xgzZgzOnj2LgIAA/PDDD3B0dDRJg7ry0ksvYdOmTZg8eTIOHjyIhx56CBqNBtevX8emTZuwZ88e9OzZ877PY2Njgw8//BDjx49HVFQURo8ejczMTKxZswYhISGYPXu2SXU9//zz+PzzzyGTyTB69Oj7to8gCIIgjIH6HPWLUqnEoEGD8NxzzyEuLg5ffPEF+vXrhyeeeAIA0LdvX3h4eGDs2LGYMWMGOI7DDz/8UCXYxPM8vvzySwwfPhxdu3bF+PHjERAQgOvXr+Pff/81GNhxcHDAzp07MXDgQAwdOhSHDx/WW6Oqf//++Pnnn9GpUyd4eHgAgDTt8saNG3jhhRf06hs2bBi2bNmCkSNH4vHHH0diYiK++uorREREoKSkxCg93n33XezevRv9+/fHlClToFar8dlnn6FDhw64dOmSSdrWheXLl+PgwYPo3bs3Jk6ciIiICOTl5eHcuXPYt28f8vLy6uU8Xbp0wdixY/HNN99I0zVPnTqFDRs2YMSIEXqj6GqjW7du6Nixo7ShT/fu3evFRsJ6oBFTBEHUC4MHD8bu3bvh5eWFhQsXYsWKFXjwwQdx7NixahdLNIT4xLJdu3bw8vKqkl95gcu2bdvit99+A8dxmDdvHr766itMmjQJM2fONPqcjo6O2L9/Px599FF89tlneO+999CvXz989NFHRtdxP/A8j23btmH58uW4fPky5s2bh3fffRenT5/GzJkzpUXQ64Nx48bhl19+gVKpxPz58/H1119j5MiROHr0aJUddGpjzJgxALS7BAYEBNSbjQRBEARRE9TnqF8+//xztG/fHgsXLkRsbCxGjx6N7du3S1PhvLy8sHPnTgQEBOCdd97BihUr8Mgjjxi0OSYmBgcPHsQDDzyATz75BHPmzMH+/fsxfPjwas/v6uqKPXv2wN/fH4888ghu3rwpHRPbQAwcAtrNWfr06aN3XGTcuHH44IMPcPHiRcyYMQN79uzBjz/+aNIDvs6dO2PPnj3w8fHBwoULsW7dOrz77rsYOXKk0XXcD35+fjh16hTGjx+PLVu2YNq0aVizZg3y8vLw4Ycf1uu5vvvuO6nPOWvWLBw4cABvvvkmfv75Z5PrEvuFtOg5URc4VtdVcQmCIAir5uLFi+jatSu+//576oQQBEEQBEFYMWvWrMHs2bORlJRUZadAgqgNCkwRBEEQdWLatGnYsGEDMjIyjFpoliAIgiAIgrA8GGPo0qULvLy8TNoMgCBEaI0pgiAIwiR+//13XL16Fd988w2mTZtGQSmCIAiCIAgrpLS0FDt27MDBgwdx+fJlbN++3dwmEc0UGjFFEARBmERISAgyMzMRExODH374AS4uLuY2iSAIgiAIgmhkkpKSEBoaCnd3d0yZMgXvv/++uU0imikUmCIIgiAIgiAIgiAIgiDMAu3KRxAEQRAEQRAEQRAEQZgFCkwRBEEQBEEQBEEQBEEQZoEWP69nBEFAWloaXFxcwHGcuc0hCIIgCOI+YIyhuLgYLVq0AM/T87yGhPpQBEEQBGE5mNKHosBUPZOWloagoCBzm0EQBEEQRD2SkpKCli1bmtsMi4b6UARBEARheRjTh6LAVD0j7k6VkpICV1fXeq2bMYaKigrY29tb7ZNE0oA0ECEdSAOANABIA5GG0qGoqAhBQUG0+2Qj0FB9KPqMaCEdSAOANABIAxHSgTQAGlYDU/pQFJiqZ8TGdHV1rffAlEajQXZ2Nry9vSGTyeq17uYCaUAaiJAOpAFAGgCkgUhD62CtHdbGRNTY2dkZrq6uEAQBAMDzfI1pjuPAcVy1aaVSiaysLHh7e0vv4zgOGo1GmlogCIJeWiaTgTFWbZoxBp7nq00ba3tdfRJtry5tyCcAyMrKgoeHB2xtbS3CJ1PbiTGGrKwseHp6wsbGxiJ8MrWdatOgOfpkajsJgoDMzEx4eXlBLpdbhE91aSeVSoWsrCx4eXmB4ziL8MnUdlKr1cjOzoaXlxd4nrcIn0xtJ7H/5OnpCZlMVu8+Acb1oWixhGaETCZDeHi4Vf/wIA1IAxHSgTQASAOANBAhHZova9euRUREBCIjIwFogycAkJOTg5ycHABAZmYm8vLyAADp6ekoKCgAAKSmpqKwsBCAdqRVcXExACApKQmlpaUAgNu3b6Nly5aQyWRISEiAUqkEAMTHx0OtVkMQBMTHx0MQBKjVasTHxwMAlEolEhISAAAVFRVITEwEAJSWliIpKQkAUFxcjJSUFABAYWEhUlNTAQAFBQVIT08HAOTl5SEzM7NefUpMTERFRQUAGO2TTCZDq1atJNstwSdT20kmk8HHxwcZGRkW45Op7SSTyeDs7CzZbgk+mdpOMpkMcrlc8sMSfKpLO926dQutW7cGY8xifDK1nVJSUhAeHo6ysjKL8cnUdsrJyUF4eDjy8/Pr3SfRLmPgGGPM6NJErRQVFcHNzQ2FhYUNMpWvtLQUTk5OVvvkljQgDURIB9IAIA0A0kCkoXRoyO91Qh9R6/z8fLi7u9fbE2m1Wo3y8nI4OztLT56tYTREZZ94nkdJSQkcHBwgl8stwidT24njOJSUlMDR0REymcwifDK1nTiOQ3FxMZycnAxq0Bx9MrWdAO2PdmdnZ/A8bxE+1aWdNBoNysvL4eTkBMaYRfhkajsJgoDy8nI4OjpKtjR3n0xtJ8YYysvL4eDgAI7j6tWn/Px8eHp6GtWHohFTzQhx6K01xxJJA9JAhHQgDQDSACANREgHy0HsgIvTKmpLiz80a0pnZ2dLP7zEfDEtTmHRTQOoMS2ev7q0sbbX1SdDftTmE2MM2dnZevY2d59MbSdRA93zN3efTG0nxhhycnKq1aA5+mRqO4kaiFiCT3VpJ/HeKOZbgk+mthPHcdIoXUvxydR2EjUw1m9TfTIWGjFVz9CTVYIgCIKwHOh7vfEwRmtBEKSpDgRBGIeNjQ1NcyYIotExpQ9Fi583IxhjKC4uhouLixSFtDZIA9JAhHQgDQDSACANREgHy0epVCIxMVGaVmAKulMhrBnSwXo1cHd3h7+/PwBY/b2Svi+0kA6kAdB0NKDAVDOCMYb8/Hw4Oztb9QeHNCANANIBIA0A0gAgDURIB8uGMYb09HTIZDIEBQWZFFhgjEGlUsHGxsaqrw3SwTo1YIyhrKxMmq7k5+dn9fdK+r7QQjqQBkDT0YCm8tUzNOSfIAiCICwH+l5vPGpa/FyhUCAhIQGBgYFSO4hrxdxv2hD1Vbe50uRT80g3pk85OTnIyspC27Zt9daFaY6LNZuaJp/IJ/LJPD7R4ucWCmMMBQUFNX6ZWTqkAWkgQjqQBgBpAJAGIqRD82Xt2rWIiIhAZGQkAEgjO3S3487KyoIgCLC1tYVKpYJGowEAvbRSqZQ60LpphUIBtVoNxhgUCoV0jVRUVOilAe11pJtWKBRV0rrrXOmmNRoNVCpVlbRardZLq9VqyXbdtKk+ibYb6xNjDGq12qJ8MrWdGNOOmDLkX3P1ydh2srW1ld5z69Yt5ObmAmie29tnZmYC0L9HmLK9PWMM165dQ0lJicX4VJd2unHjBvLz86FSqSzGp7q0U0FBAYqKiizKJ1PbqaCgANnZ2fXuk2iXMdCIqXqmIZ+sCoKA1NRUBAYGWuXceIA0AEgDEdKBNABIA4A0AACNoMGZjDO4kXoDDwQ+gJ7+PSHj62ehXxox1XjUNGKqrKwMSUlJaN26Nezs7AAYP1JEEASoVCrY2tpK57LGkTiA9seMjY2N9AS9qdjbWKOLRA1sbW0txidj0+Xl5UhMTERISAhycnLQokULyOVyqxzhwRhDSkoKWrZsCZlMZhE+1aWd1Go10tPTERgYCAAW4ZOp7aTRaJCeno4WLVqA4ziL8MmUdlKpVTibeRbxafFo06INevj1gI3cxiwjpigwVc9QB5YgCIJoLDSCBueyziG7LBs+jj7o7tu93gIyzYV9yfuw/NRyZJZlSnl+jn5Y0GsBBgcPvu/66Xu98ahJa/GJcGhoKOzt7c1kIUE0X+gzRBCELg3dfwJM60NZ56PVZoogCMjLy5OiltYIaUAaiJAOpIFG0OBk2klsurwJJ9NOQiNozG1So7IveR9iNsdgwp4JmH9kPibsmYCYzTHYl7zP3KY1GvuS92HOoTl6nSoAyCrLwpxDc6xKC6J6xClsTfFZ7LZt2xAeHg6ZTIZZs2YZ9R7GGCZNmgRPT09wHIcLFy4YzIuOjtarsynrcD8Y8r2mspaogSlYe98BIA1ESAfr1aAp9p8oMNXMKC8vN7cJZoc0IA00gganM07jj8Q/cDrjtNUFJADSQAzKvLL3FSw9txSv7H3FqoIyTbFD0VgwxqASVChTlWHZqWVgqPoDk9399+GpD63us0EYRvzRoREYTiTkYvuFVJxIyIVGaNgAxbhx46TpDba2tggPD8eSJUukNYteffVVPPPMM0hJScHSpUuNqnP37t2IjY3Fzp07kZ6ejo4dOxrM27JlS5U67/fHV2xsrOSP7t93331X5bhMJoOHhwd69+6NJUuWSOuSGNKG4zh4eXlhyJAhuHTpkl453TJubm546KGHcODAgRr1qAlr+wFqCGvvRwKkgQjpYH0aaAQNlp9aXm3/CYBZ+k/yRj0bcV/wPC/NAbZWrF0DadqOIhtpWWk0bQcArtT/sNOmjrVrsC95H2Yfmg0wBnD3trXNLM3A7EOzsSp6VbPTgTEGNVNDYAI0ggYapoHABKiFu3nsbp4gQCko8d4/79XYoVhyYglsZbba9RPuvld8v/Ra0MnXOa94TGDCPZt08yrbVDmvpnprsEE8VlkHqZ675Q35XR0ZZRk4l3UOkf6R9dZWRPNDDArtvpKOd3+/ivTCCulYgJs9Fg2PwJCOAQ12/iFDhmD9+vVQKBT4448/MHXqVNjY2GD69OnIyspCTEwMWrRoYXR9CQkJCAgIQN++fWvM8/T01HufqMP94urqiri4OL08Nze3KscZ025IcPz4cSxbtgzr16/HsWPH9HwVtQGAjIwMvPPOOxg2bBhu376tV//69esxZMgQ5OTk4O2338awYcNw5coVtG7d2qDv1VFfGjRnrL0vDZAGIqSDdWpwLutclQebujAws/SfKDDVjBCHGnp6elrlArdKpQLbDn+F1JwEBHqHYUTUZNja2pnbrEajMeYBN3XEUSKVf5iKo0RWRq+0eC2aQ1CGMQaBCQYDG2KQobpgRuWAR+XghEqjwv8dfrOK/wC0rxnD24cXIL3nTADQD/IYE/gxYJfucUOBldqOV1dW91ymBFuMIV+Rj6n7p9Zrnc2VzJIMc5tAmBnGGHZdTMX0ny9W+aRlFFbgtR/P4cv/dG+w4JSdnR38/f0BAK+99hq2bt2KHTt24K233gIADBw4EABw8OBBdOrUCdOmTcPff/+N/Px8hIWF4a233sLo0aMBaEcZbdiwAYA2yBIcHIzo6OgqeUlJSYiOjkbXrl2xevVqAMD333+PNWvW4MaNG3BycsLAgQOxevVq+Pr6AgAOHTqEAQMGYN++fZg/fz6uXr2Krl27Yv369Wjbtq3kD8dxkj+G0D0eEBCA9u3bY/jw4ejQoQPeeOMN/Pjjjwa18ff3x4IFC9C/f39kZ2fDx8dHKufu7g5/f3/4+/vjyy+/RGBgIPbu3YsTJ04Y9L06xKl8crkcXOXvECtBEATk5ORY7e8JgH5TiZAO1qlBdll2vZarLygw1UwQgzJ3suPR0qeN1QVlvtn+Nv6Xsw058rs3jLSD+PKHbzDaewQmPfm+eY1rBJpDMKKhMXbY6YCgAfUyikwcaSIGEioHLMTgiqGgiqGghvS/oB+s0c2vPDpEt6zABKgEFb45/2WNQZkFh9/AE21G6NunU391o2AM2atmav0gS+WgS6Xgke57G5zqflBwHMqYAh+d/qjhbWgkOHCQcTLwHAcOPBgToGSqWt/nKXOFs8wJPDjwHAeeaf/nGKfNAwcOgAw8OECbx3DvGOPAA3fzdI4zrU08mLZOsQwTXzPIxHIMkOHu+xmDjDHwDJAxDjwTtMcYIBOP3S0nZ0xbj3D3GIS7dTKpbAqfiw99lLXqUJaYCITfRwMQTRLGGMpVxk0zUGsELN113WD4lwHgACzecRUPhXtDxtcerHCwkd1XUMPBwQHZ2dmIi4tD27ZtsXnzZvTt2xeenp7Izs5Gjx49MH/+fLi6umLXrl146aWXEBYWhl69emHNmjUICwvDN998g9OnT0Mmk8HW1rZKniFUKhUWLVqEDh06IDs7G3PmzMG4cePwxx9/6JV7++238cknn8DHxweTJ0/GhAkTcOzYsTr7CwC+vr548cUXsW7dOmg0GoM2lpSU4Mcff0R4eDi8vLxq1A/Q7q5nSI/asOb1pURUqtq/Qywd0kAL6WB9Gnjae9ZeCICPo0/theoRCkw1A6oGZQ5bVVDmm+1v4/P87WAy/U5grozD5/nbge2waB00ggZL//6/aoMRHGNY+vdCDHhxgHaLTp1gQZXgh06wQjdQUe3/1dRRU0DC1LqNPX92WXaNw04B7bSdp7Y/BQcbB4NBoursr6LN3XSTpYagjIKp8OuNXxvXHhPRBjjuBUbEQIj2714AhNPNuxswqWAK5Mhr/zEappDBi9nffR/TBkJwNyhyN3Aiu/uaZwwyQJsnBkugDY6IgRQ57gZEcC9oIpdeC3fzoE3fzZOBwYYxyJgAW2j/l4PBRjwGATZgkj28ZBekII0M2h/Nupy2t8OEAL9aNVhxJx6RFQrTGqcZoQEQ69ECWTIZmIHPBMcY/DQahFRY97QdS6VcpUHEwj31UhcDkFFUgU6L/zKq/NUlMXC0Nb0LzRjD/v37sWfPHkyfPl0aqeTp6SmNGgoMDMS8efOk90yfPh179uzBpk2b0KtXL7i5ucHFxQUymUxv1JKhvMq8/PLLUjosLAyffvopIiMjUVJSAmdnZ+nY+++/j6ioKADAggUL8Pjjj6OiokLaya2wsFCvvLOzMzIyah+Z2K5dOxQXFyM3N1fyfefOnVJdpaWlCAgIwM6dO6sduVBWVoZ33nkHMpkMUVFR1epRHTSVTzt1KSCg4aauNgdIAy2kg/VpkF+Rj3VX1tVYhgMHP0c/dPft3khWaaHAVBPHUoMyuqNRKo9C0R25UaEqx48527T+V/rhwe6OEPkhZxs63nkcvIyHIAgQIBgXVNEJoDAwk8qLrw2NqtELchios0qeoIEgTfUR7qbv/V+uKkeBUFJtMIJxHPKEYnT9oWsjtFzT51bRrUY5jzSKRBpNohNM0MnjGaSghW4ZuRR4uBcskfLuBjzEAIX8bjpNJsM5h9q3eH6kpBRtVaoqwQ6eMchRNU//mHh+nWO69jJ9m6V6KgV7ZLr1VErfD8YGZd7OS7O4oIzAOAjg0KlcBT+1utaATOtyOdI5FzBwEMBDAAdtSI2DwPFSPgMPxnE6x7Wv2d3XYtl7+Xdfc9qwIhOPc/feC53X4CqXvZsHDuB4gLv3HnB3feLufmLuvpfjtO8V88BxkBWnYUHuPszx9QbHmJ4W3N0REfNz8+HULqgRWocgqkcMvqhUKgiCgBdeeAGLFy82+JReo9Hggw8+wKZNm5CamgqlUgmFQgFHR8f7tuPMmTNYtGgRLl++jPz8fGkR8Nu3byMiIkIq17lzZykt/mDLyspCq1atAGiDYOfOnZPKGDv9RRyppDvabMCAAfjyyy8BAPn5+fjiiy8wdOhQnDp1CsHBwVK50aNHQyaToby8HD4+Pvjvf/+rZ6ex0FQ+7dSlrKwseHt7W83UpcqI0xmtWQOAdACsS4N/c/7F7EOzkV6aDjkvh1pQVynD3X0cOr/X/EZfx5gCU00YpVKB/9USlFmfuw1p/70KcBwExrRBGTCdP0GbzzHtui/QL8Pu/q/Rew3tcY7drZOBcWI5SO8RxLKcTvrupCoNx6T0vXL30syUvoC8hpsEx6FAzuHV/a+aJq6VItMJfNwLoDBpOo1uWjf4oFf2btBFNwDB66YrBSOqnqfSOXSO13SeVLkc/3NzqdXHaXkFaKdUSqNNdEfD3Kv3bhCmciBF12cd3+RM3x8eVUexNAan7e0wwYjA1KiiEvSoUEnBCEEMRuBe8EEAD+FucED3uBS4EAMZUlDiXjnGcdCAh1rntRSsAAfG83rBi5oDGTpBDEMBjUr/2yhy4KdOqjUoU8o/jP2+gdpgBicGM+62XKXXHMcDvLYcd/cYx8sATgaO48Hx2rIcL77m773m+bt/MnCcDDzPg+Pl2nIy/m4eB14mByfTLSMDL5NBxsu15XgZeJkcMl6mnYrCaf+XyeXa93I8eJl2+lD82f1YcGZ6rQGZtMFfo/2DQ7W2iLtaWVCnS6NWI+e9B7AiMwcfeXsgU36vS+On0eD1nHx0LHeET+8YM1pJ1AUxYCL+z/PaB09iYIMxBns5j6tLYvSCHdWl/0nIwYQNZ2s97/pxPdEr1LPW+uzlPBhjNZbRnS42YMAAfPHFF7Czs0NAQIAUFMnPz5fKiOU//vhjrFmzBqtWrULnzp3h6OiI2bNnQ6lUVpmCpmuDrjaVyzDGUFpaiiFDhuCRRx7BDz/8AD8/PyQnJ2PIkCFS3eJ75XK5VLdum4hleJ5HWFiYnq+V9dC1Rcy/evUqXF1d4enpKR1zcnJCWFiYVObbb7+Fu7s7vvnmG7z33nuSDStXrsTgwYPh5uYmrT1lzDkNtUdlfWpr74ZMG6Ihzym+FgQBgiBIny3g3udM/L6oLq3RaLTfY9Wkxfp10zKZTPs7pJq0eF1Vl65so6npyn6Idol6WIJPdWknjUYj2SROsW3uPpnaTqINYtoSfKrcNhzH4bcbv2HZqWVQCSr4O/pjdvfZkMvk+Oj0R3ozUnwdfbGg1wIMDBpYb/cIY6HAVBNm2+Gv703fMwTHoUTGYTNuNp5RjYQYAABjUBnxQ8pHrYabIFQJlNxvAOXeKBf9oEZ1gZV7I2WqSRsbtNE5Hmdji6U+tc8F/jAjD50rNNpI9911Xzhw4Jn445uTgg+oFIS4F3jgpOCAUOmY7ggK/Txt++iOspDer/NaNzABDjrBCv33awMH984lpjuWpuGAU26tAYkuZW1R5tIaGo6HEmJQt9LICwPBCf1AhdYuTqeMXprXTrDieF4KanB3y+gFLe4GAqSAhm4wg5NJgQuO15bjORk4mQw8r83jOW3QQgxeVFz7B375n9eqAd/zU5T3elSbJwYkOA7yuwEK3H0vd1ePe2V4qcPWVIMYGrUak1e2xxJfWbVBmUm5avSf8zNkcsv8iuvy8Ejk/D2/9oBMn8ctVgMAkMnlSOuzCIOPz8CA2+W44GCHbJkMPhoNupYrIANwse+H8LdgDSyFtWvXYu3atVIHNisrC+7u7sjJyQGgXZ8oJydH6hyrVCrwPA9HWzmUSiV4nodcLodCoYBcLodMJtNL9w52g7+rPTKLKmAoHMAB8HO1Q/82PuA5QKFQwMHBQbsLplIJezt7vbRGo4FKpYKdnZ12LUC1GnZ2dtBotCOrbW1tpTSgXRMpODgYtra2UKlUUKvVsLGx0RsxJfp07NgxDB8+HKNHj4ZcLkd5eTlu3LiBiIgIKJVKyO9ez7o/OBSKe6NDKyoqYGdnJ/1QEMtevHgRubm5WL58Ofz8/GBvb49Tp05J7xMEQbJH9FX0SUSj0Uiv1Wo1GGOwtbWFWq196m5jY6NXXvRJLpcjNTUV//vf/zBixAhpxJJ4LvEHldhmPM+jpKRELzjm5+eH8PBwVFRUSD6J7SS+Fv9XKpWwt7fXaxvdNMdxUKlUeu0k+mHIJ5VKBY7jpLTok25abBuZTKaXVigUsLW1ldpJTOu2kzhNUtcnXT+M8cnQtWfIJ90f3gUFBfD29kZ6ejocHBzg6emJ1NRUuLi4wN3dHSkpKfDw8ICrqyuSkpLg6+sLZ2dnJCYmIjAwEA4ODkhISEBwcDDs7OwQHx+PsLAw8DyP+Ph4tGnTBoIgICEhAe3atYNSqURycjIeeOABVFRUIDU1FeHh4SgtLUVWVhZat26N4uJi5OfnIzg4GIWFhSguLkZQUBAKCgpQXl6OwMBA5OXlQaVSISAgQO8ekZmZCRsbG6N9KisrQ3l5uUX5ZGo7JSQkWJxPdW2noqIii/OpuLgYGTkZ+CH9B2y7uQ0A0NOvJ6a2nYoA2wAEBgaii1MXnM86D8FBgFwhRyfPTgjwC0B6enq9+JSYmGjgW9cw1FtrwmQV3a69EIA2FTzcmJO0NgsHgGfcvfVZGAeOg86aLvfWbeF0Xt/LF9d34e++j5fytbk8eA7gwYNjHGQcL9UjA393gV5tOQ48ZHdHJGj/AWJKxmmHB2rfc7fs3XLc3QBFYtl1fO5We+BtVEUXtHXvdvdHNy/9j7s/uIG7ox7uBiA4jr9X7m5El8PdNDhwsruBB047ckJ7TKaNS0gjKvh7gQfRZv7uAsVioIK/qwfHS8cg0yrPczx4XgZwHHiZTKuBzvtkd8spLhyGX9qyWoMR/j1Xwav3EB2fIaW5u8Ef3SCF5B8HiEGWpsy/x3ZhwbGXax0l4hK9Ag8+9Li5zGxQgtt0weSVq2sNynQf+4zFBiRkcjnCuryDFRfmVwnK+Go0eCMnHz5dP7RY/wEKyOjSLWYszgNoceJdRFbkSvkZnBfS+yxCt5ix5jOOMJqpU6di6tSpKCoqgpubm7T+kLe3t1TG29sbJSUlALTBAhHdtO7aQbppB3s7vP3YA5jx8yVwgF5wSryLLhreQVr4XFxLieM42NnZVUnzPC/Vr5uWyWTS4tu6aZ7nJTvlOp9LQ360adMGv/32G06ePAlPT0988sknyMzMREREhJ5PnM53vWiXru3iecWybdq0ga2tLT799FO89tpruHr1Kt5//329sqINlX0S0fVJ1w/dtPjEPiMjA4IgoKCgAP/88w8++OADuLm5Yfny5Xp+qFQqZGVlgeM45OXl4fPPP0dJSQlGjBhxry+De9P/dNtG11fdhyo1tZM4skD01RifqrvejLn2dNumunYy5FN9XXuVfRJHPAiCAHd3dwDQW18nMDBQ0jIoKEhKh4SESOnQ0FDp2hJ/OAPaa7dymud5tGnTRtJFHGlnb2+P0NBQANpRcyEhIQC000TFNcfc3Nzg6uoKQLsro2ivp+e9h7W69wg/v3vT/GvzSRAE2NnZSYFNS/AJML2dwsLCkJmZCT8/P4vxydR2atWqFdLT06WgiiX4JLZTIQrx9r9v43redXDgMKrtKEzpOgVutm6SjT5ePhjsMVi7E2orH+mc9eWTaJcxWH6vtRnj69oKKKm93POtX8Zzj8xoeIPMgFKpwM8/dEeujKs2KOOtYRg/cYPF7lLo4fMCJq9cWmswosvYpyz6x3i73jHw3uto1dN2KCijRQxGfH/iXaTa50pBmRYVzsjq86FVBCMoIHOPbjFjoRn0Iq788ycK0m/BPaA12j841CoCc5aK2KHVXe9DnBYAwGDAorb0kA7++OJFOZbsvIr0wgrpmL+bPRYNj8CQjlUXv63LeQyldV/XVv6dd97BrVu3MGTIEDg6OmLSpEkYMWIECgsLa6zTUP26x3x9fbF+/Xq8/fbbWLt2Lbp3744VK1bgiSeeMFhHdfYa40dRURECAgLAcRxcXV3Rtm1bjB07FjNnzpR+7Ins3r0bLVq0AKD9sduuXTv8+uuvGDBggEE/DGFKe1SeotgU0vfrkylp3WBmdZ+z2tKVg5XGpjmOqzZd3bUnpk21sbY0Y0wasWYpPlVOG+uHOIpPN5Dd3H2qnK7JJzEoX1mD5uwTx3H4+87fePPImyhSFsHV1hXTu0/H0+FPw0Z2L6Cua4uNjY0U/Goon2qDY7Rnar0iPu0rLCys8uVrKkqlAjFGBGV2v3TOYoMywL0F4AEYDMpM83iyWS4Abwrn92xAtoFghJ9aLQUjrOGH6Pk9G9Dl+AxogGpGiXxqNTr4nXgXqfYllYIy1hWQ0KjVuH5yD8rzU+HgEYh2vWMsPihXGdKg4anP73WiZmrSuqKiAomJiQgNDdUbbWIqGoHhVGIesoor4Otij16hntJIKYKwZOrrM0QQRNNFI2jw1aWv8PXFr8HAEO4ejjk95qBfYL9aA+INgSl9KOq9NmFsbe0w2nsEPs/fXu1Imee9R1h0UAq4u+vgduB/OduQI7+ngbeG4XnvERYflAJohIgIjRLRIo4QyfvnTzil3oRDYDj8HxyKQCsLSMjkcrTvMxTp6ekICAjQe1pjLZAG9xAEgXQgDMIYg0qlgo2NDWQ8hz5hXuY2ySzo6mCOHyhNAdJAe69MTU216nslfV9oIR0sS4NCRSHmH5mPY6nHAACPBj+KWd1nIci15t2Jm4oG1vUrphlCQRktk558H+OUC7Ht8FdIy72FFl6tMSJqssUH5XTRDUa4ZSTBwT/EKoMRutN2CjOS4OYfYpXTdmRyOSL6Po6CggK4u7s3+y/T+0FcI8KaIQ20kA5EdVjzPVIX0oE0AOheCZAGIqSDZWhwNfcq5hyag9SSVNjytnil8ysYGzEWjjaORr2/KWhAU/nqmYYa8q9UKrDt8NfIKroNX9dWGBH1qlUFZQiCIAjCHNBUvsajMabyEYS1Qp8hgrBMtsRvwfv/vA+loISfox/m9JyDmOAYyHjj13dqKEzpQ9Ejg2aCra0dnhk0DU/2molnBk2z2qCUIAhISUmRtkC2RkgDLaQDaQCQBgBpIEI6ENXBGINSqYS1P4slHUgDgO6VAGkgQjo0bw0UGgUWHV+ERccXQSko0cO3B1ZHr8ZjoY+ZFJRqKhpY19yXZg7HcXBxcbHaOfEAaQCQBiKkA2kAkAYAaSBCOhA1QdO3tJAOpAHdK0kDEdKh+WqQWpKKOYfm4GruVXDg8Fzb5zClyxR4OniaXFdT0YACU80IjuPg7u5ubjPMCmlAGoiQDqQBQBoApIEI6UBUB8dxkFvZOoSGIB1IA4DulQBpIEI6NE8NjqYexYK/F6BQWQgXGxdM7z4dT7d5GrYy2zrV11Q0sOpHBiNHjoSHhweeeeYZvfyUlBRER0cjIiICnTt3xq+//momC/URBAHJyclmH2ZnTkgD0kCEdCANANIAIA1ESAeiOhhjUCgUVj19CyAdANIAoHslQBqIkA7NSwOBCfjy4peYsm8KCpWFCHMLw/KHl+P5ts/XOSgFNB0NrDowNXPmTHz//fdV8uVyOVavXo2rV6/ir7/+wqxZs1BaWmoGC/XhOA4eHh5mH2ZnTkgD0kCEdCANANIAIA1ESIemwYoVK9ChQwd07NgRP/74o7nNkbD2UTIipANpQPdK0kCEdGg+GhQqCjFt/zR8ceELMDAMbjUYnw78FA+3fPi+bW8qGlj1nTk6OhqHDh2qkh8QEICAgAAAgL+/P7y9vZGXlwcnJ6dGtlAfjuOsfkcg0oA0ECEdSAOANABIAxHSwfxcvnwZP/30E86ePQvGGAYMGIBhw4aZfYoAx3GQycy/O5G5IR1IA4DulQBpIEI6NA8NruVew+xDs5Fakgob3gYvd3oZ4zuMh6ONY73U31Q0aLIjpv7++28MHz4cLVq0AMdx2LZtW5Uya9euRUhICOzt7dG7d2+cOnWq3u04e/YsNBoNgoKC6r1uUxEEAbdu3TL7MDtzQhqQBiKkA2kAkAYAaSBCOpifa9euoU+fPrC3t4eDgwO6dOmC3bt3m9usJj19a9u2bQgPD4dMJsOsWbOMeg9jDJMmTYKnpyc4jsOFCxcM5kVHR+vV2ZR1aCxIA7pXAqSBCOnQ9DXYGr8VL/35ElJLUuHr4IulDy3F5M6T6y0oBTQdDZpsYKq0tBRdunTB2rVrDR7/5ZdfMGfOHCxatAjnzp1Dly5dEBMTg6ysLKlM165d0bFjxyp/aWlpRtmQl5eHMWPG4JtvvqkXn+4XjuPg6+tr9mF25oQ0IA1ESAfSACANANJAhHS4f+73oWDHjh1x6NAhFBQUID8/H4cOHUJqamojelA90vQtQQMkHgEu/6b9X9A06HnHjRsHjuPAcRxsbW0RHh6OJUuWQK1WAwBeffVVPPPMM0hJScHSpUuNqnP37t2IjY3Fzp07kZ6ejo4dOxrM27JlS5U673caW2xsrOSPTCaDh4cHevfujSVLlqCwsNCkug4dOgSO41BQUHBfNpkKTeWjeyVpoIV0aLoaKDVKvHviXSw8vhAKjQLdfLth9YDVeLz145Dx9Tvqs6lo0GTvzEOHDsXQoUOrPb5y5UpMnDgR48ePBwB89dVX2LVrF9atW4cFCxYAAC5cuFDn8ysUCowYMQILFixA3759ayynUCik10VFRQAgRRzF/3merzEtfslXl9ZoNOB5Hs7OzlJaN188l25aJpOBMVZtmjEGnuerTRtr+/36VF26Op+cnJwszidT28nJyQmMMen8luCTqe3EGIOjo6NBDZqrT6a2E2MMTk5OFuVTXdpJnGat0WgsxidT28nZ2VnKtxSf6tJOjo6ORt0bTfXJWhAfCk6YMAFPPfVUlePiQ8GvvvoKvXv3xurVqxETE4O4uDj4+voiIiICM2bMwMCBA+Hm5oYHH3ywSUybkqZvXd0B7J4PFOk8oHRtAQz5EIh4osHOP2TIEKxfvx4KhQJ//PEHpk6dChsbG0yfPh1ZWVmIiYlBixYtjK4vISEBAQEBev1TQ3menvrbhtfXNDZXV1fExcWBMYaCggIcP34cy5Ytw/r163Hs2DGTfGlsaCqfVgNnZ2dzm2FWSAMtpEPT1CC9JB1zDs3Bldwr4MDh2bbPYkqXKfBy8GqQ8zUVDZrsiKmaUCqVOHv2LAYPHizl8TyPwYMH48SJE/ddP2MM48aNw8CBA/HSSy/VWHbZsmVwc3OT/sQpf+LIrZycHOTk5AAAMjMzkZeXBwBIT0+XnhClpqZKT5lSUlJQXFwMAEhKSpIWXU9MTERpaSlu3ryJmzdvQqlUAgDi4+OhVqshCALi4+MhCALUajXi4+MlrRISEgAAFRUVSExMBKDtfCYlJQEAiouLkZKSAgAoLCyUnm4WFBQgPT0dgHb0WGZmZr37VFFRAUDboTLGJ41Gg7i4ONy8edNifDK1nTQaDa5cuSL5Zwk+1aWd0tPTcfnyZWg0GovxydR2SkxMxNWrV6HRaCzGJ1PbKS4uDvHx8VAoFBbjk6ntlJiYiJs3b6KwsNBifKpLO2k0Gly6dEnyr758Eu2yBoYOHYr33nsPI0eONHhc96FgREQEvvrqKzg6OmLdunVSmVdffRXnzp3DwYMHYWNjgzZt2lR7PoVCgaKiIr0/QP/hnm5anH4lBimNTQuCAOXFzWCbxoAV6Y+aZ0Xp2vyr26X31PU81aXt7Ozg5+eH4OBgTJ48GYMHD8aOHTvg4uICABg4cCA4jsPBgweRm5uL0aNHIzAwEI6OjujUqRN++uknqc5x48Zh+vTpuH37NjiOQ0hIiME8xhiio6Mxc+ZMyZbvv/8ePXr0gIuLC/z9/fHCCy9InxfGGA4ePAiO47Bv3z707NkTjo6O6Nu3L65fv67nE8dx8PPzg7+/P9q3b48JEybg2LFjKCkpwRtvvCH5rdFo8MEHHyA0NFSa2vnbb7+BMYbExEQMGDAAAKRFd8eNG1ejlob+TG0PxhgqKiqk66oh2ttUe+7XJ1PTGo0G8fHxUKlU0ufD0OesurRGo6kxLZ5DNy2ev7q0bnsYSle20dR0ZT80Gg1u3LghjVy0BJ/q0k5KpVL6rrYUn0xtJ5VKhZs3b0r9FXP7dCz1GJ7b+Ryu5F6Bs40z5veaj3nd58HT3rPBrj1RA5VK1SA+GQ1rBgBgW7dulV6npqYyAOz48eN65V5//XXWq1cvo+sdNGgQ8/b2Zg4ODiwwMFCq78iRI4zjONalSxfp79KlSwbrqKioYIWFhdJfSkoKA8Dy8/MZY4xpNBqm0WhqTQuCUGNarVYzjUbDysrKmEql0ssXBIEJglAlzRirMS2ev7q0sbbfj081pQ35JAgCKy0tZSqVymJ8MrWdRA3EMpbgU13aSa1Ws5KSEul9luCTqe2kVqtZaWmpnr3N3SdT20mlUrHS0lKm0WgsxidT20mtVrOysjI9W5q7T3VpJ0EQWElJiVH3RlN8ysvLYwBYYWEhsyYq970UCgWTyWR6eYwxNmbMGPbEE09IrzMzMxljjF2/fp116tRJ+r42xKJFixiAKn9xcXFSXWJ9ycnJ7PLly6y8vJwpFAqmUioZU5QwRXEeU5UWMKYoYRVFuUxdVlglXZ6fyYQVbZmwyJUxA3/CIjem+bgtE8oKmKa8iJUVZDOmKGGa8iJWXphTJa1WqVhFRQVjTHutiGmVSsUUCoVeeuzYsWz48OFSvlKpZMOGDWNdu3Zlly9fZgDY5s2bWXJyMistLWV37txhy5YtY6dPn2YJCQls5cqVTCaTsZMnT7KKigqWm5vLlixZwgIDA1lqairLyspiGRkZ7N1332UtW7Zkt27dYhkZGUwQBNa/f382Y8YMptFo+4/fffcd+/3339nVq1fZiRMnWJ8+fVhMTIzkx549exgA1qtXL/bXX3+xf//9l/Xr14/16dNH8unbb79lbm5uTKlU6vmkVCrZzJkzmYuLCysvL2eMMfbuu++ydu3asd27d7Nr166x7777jtnZ2bG//vqLKRQKtnnzZgaAXb16laWnp7OMjAzpc1peXi6lxfubIAisrKxMuheUlZUxxrSfXfGcumndthHTgiAwpVJpsM0M+SRe+7pp8ZrWTVdUVEj3Ht20rh8N5VN1115ln4qKitjly5dZWVkZS0pKYllZWYwxxu7cucNyc3MZY4zdvn1b+g2TlJQk3fcSEhJYcXExY4yx+Ph4yc64uDjJhmvXrjGlUsnUajW7du0aU6vVTKlUsmvXrkm6iJ/tsrIyFh8fzxhjrLi4mCUkJDDGGCssLGRJSUmMMcby8/PZ7du3GWOM5ebmsjt37jDGGMvOzmZpaWmMMf17RFpaGsvOzjbKJ0EQ2PXr11lRUZHF+FSXdrp69SorKSlhCoXCYnyqSzuVlZWxgoICs/qkETTs/f3vs06xnVjH2I7ssV8eY/tv7WcqlapRrr2ysjKWkZFR7+109uxZo/tQHGOsya/+x3Ectm7dihEjRgAA0tLSEBgYiOPHj6NPnz5SuTfeeAOHDx/GyZMnzWSpdiqfm5sbCgsLm8Tq9gRBEARB1B1r/V6va9+rT58+KCwshJOTE7766iv06NGj2nMYWg4hKCgI+fn5cHd315uCWVZWhqSkJLRu3Rp2dnaAshTcssAG8Lx22JupgK2TNKUaQLXp8ePHo6CgAFu3bgUA7Nu3D8OHD8f06dPx1ltvwdPTEwcPHkRUVFS19QwfPhzt2rXDxx9/DABYs2YNVq9ejcTERKnM6tWrsWbNGr0RfgMGDECXLl2wevVqg3WfPn0avXr1QnFxMZycnHDo0CEMHDgQe/fuxaBBg8BxHHbt2oVhw4ahvLwcdnZ2iI2NxezZs5Gfn1+lzq+//hqvvfYaMjIy4O7uDk9PT+zduxd9+/aVykycOBFlZWXYuHEjDh8+jAEDBiAvLw8eHh61amkIY9qgKacb06fy8nIkJiaidevWsLW1BdD8p28bmyafyKem7FOJugTvHH0Hh+4cAgAMbDUQs7vNRrBbcLP1SWyb/Px8eHp6GtWHapZT+by9vSGTyaThxyKZmZnw9/c3k1UNj+busFONFa13URnSgDQQIR1IA4A0AEgDEdKhaXDixAlcvXoVp0+frjEoBWinuLm6uur9WSI7d+6Ei4sL7O3t8dhjj2HUqFFYvHixwbIajQZLly5F586d4enpCRcXF+zZswe3b9++bzvOnDmDYcOGITg4GC4uLoiOjgaAKnV37txZSgcEBACA3uZC1aEbBLl58ybKysrw6KOPwtnZGS4uLnBxccH3338vTeE1B4zRrnyau1P5rPleSRpooe9N82sQlx+H53c+j0N3DsGGt8GkzpPwQb8PEOQS1Gg2mFsDkWYZmLK1tUWPHj2wf/9+KU8QBOzfv1/vKZ6lwfM8goODpYipNUIakAYipANpAJAGAGkgQjo0LA35UHDt2rWIiIhAZGQkAMPrdObk5EhPbVUqFTS8HfBWGpTzkqB+4zbwVhoUcxOhmZ9SJa189iej7GAv/AphwR2Uz04A3kqDsOAOKubcqpqW2UtrqQmCIKU1Go20bo9uOjo6GqdOnUJ8fDyKiorw3XffwcnJSTou+aTR4OOPP8ann36KefPm4eDBgzh16hQeffRRKJVKKJVKvfVCxOCK7qiziooKvTU/xLK5ubkYMmQI3NzcsG7dOpw+fRqbN28GAKle0R6ZTKbnn/i/RqORfrio1WqpvFqthlqtxrVr1+Dq6go3NzeUlJQAAHbs2IELFy7g1KlTOHPmDK5evYqNGzdK9eqeQzdgpJvW9Ulc+40xppcWNdBN67aNblomkxlsJ0M+iW2jmxY10E3rto1uurF8qu7aq+yTOPLC0dFRWnevua4rCNR9rURxNEd5ebnF+FSXdkpISECrVq0k/yzBJ1PbKSUlBcHBwVK6MX3akbADL/35Eu6U3IGPgw/mhs3Fy+1ehpONU6Neezk5OQgODpbS9dlOJq3TWetkPzNRXFzMzp8/z86fP88AsJUrV7Lz58+z5ORkxhhjP//8M7Ozs2OxsbHs6tWrbNKkSczd3Z1lZGSY1e7CwkKrXIuCIAiCICwRa/1eR6U1phhjrFevXmzatGnSa41GwwIDA9myZcvq5Zyi1obW6SwtLWX//vsvKy8vl9YrY4wZl1armPBJO8YWuVW7xpTwSXttOVPrriU9duxY9uSTTxosI65fdvDgQSl/2LBhbPz48XrrnbVp00aqQxAEtmrVKhYcHKxX58qVK6U88S8qKorNmDGDCYLATp8+zQCw5ORk6X3ff/89A8DOnz/PBEFgBw4cYABYXl6eVObcuXMMAEtMTGSCILB169YxNze3Kr5mZGQwLy8vNmbMGCYIAisqKmJ2dnZsw4YN1Wpz7NgxBkBax6Q2LQ391Vc7mSvdmD6VlZVJnyFLWFfQlDT5RD41JZ/KleVsyfElrGNsR9YxtiN7cdeL7ELWhWbtU3XtZMo6nU32seKZM2fQrVs3dOvWDQAwZ84cdOvWDQsXLgQAjBo1CitWrMDChQvRtWtXXLhwAbt374afn585zW5QNBoNrl+/bvZhduaENCANREgH0gAgDQDSQIR0uH9KSkpw4cIFXLhwAYD2SeeFCxekqV5z5szBt99+iw0bNuDatWt47bXXUFpaivHjx5vR6tphHA/lwKV3V1fn9I+Jr4csA3hZ4xtXiTZt2mDfvn04fvw4rl27hldffbXKKLW60KpVK9ja2mL16tVISEjAjh078N5779WpLsYYMjIykJ6ejmvXrmHdunV46KGH4ObmhmXLlgEAXFxcMHfuXMyZMwcbNmxAQkICzp07h88++wwbNmwAAAQHB4PjOOzcuRPZ2dnSKKuGhN0dlcSsfCpfXFycVd8rSQMt9L3Z+BpklGZg/J7x2HRjEzhweDr8aayKXoUuPl0a5fyGaCrXQZMNTEVHR0vDlHX/YmNjpTLTpk1DcnIyFAoFTp48id69e5vP4EaA53mEhYVZ9TQF0oA0ECEdSAOANABIAxHS4f4x10PBOk3lM2E6lVKphLzTSOC5DYBLpWmHri2A5zagIvRRAA0znUrQmSZXeYqYiOjHO++8g65du2LIkCGIjo6Gj48PnnzyySo+MROn8rm4uGD9+vXYunUrOnbsiOXLl+Ojjz6S3qdrY2WfRMSpfEVFRWjRogVatmyJPn364Ouvv8Z//vMfnD9/Ht7e3pJ/CxcuxFtvvYVly5YhIiICQ4cOxa5du9CyZUsIgoDAwED83//9H9588034+flhypQpjTLtTS6XW/1UPhcXF6ufyieXy2kqX0ICQkNDrX4qX1hYWKNM5TuQcADP/f4cruRegZPcCW/0egPP+z4PZ865Xn2qy1S+sLAws0/laxa78jUnGnL3HnZ3xX1xXrQ1QhqQBiKkA2kAkAYAaSDSUDpY66585kDU2qhd+VDHHdAEDXD7OLiSLDBnX6BVX4MjpZrCjm31vdtbc/evPvxoahrUh0+m7soXGhoKuVwOnuchk8mscmc0QBuok8lk4HneInyqSzuJgVXRNkvwydR2Em0Qr4uG8ImB4b+X/ovPL34OgQkIcQ3B7B6zMSBogF6/xVzXnu79iOM42pWPqB3diKm1QhqQBiKkA2kAkAYAaSBCOhDVoTsSBbwMCOkPdHpG+38TmL7XmFj7NDaANBAEATdv3rTqeyVpoIW+NxtegyJlEWYenIlPL3wKgQmIDorGmug1GBA0oMk8TGwq1wEFppoRPM+jTZs2Vj1NgTQgDURIB9IAIA0A0kCEdGi+NMZUPltbWwBNYzqVOaeI2draSvZaik+mtpONjY3F+WTqVD5XV1ern8pna2tLU/kSEhAWFmb1U/natGnTIFP5jsYdxfO/P49DKYcg5+QY33Y8lvVbBuSjSX2ecnJy0KZNG5rKZ2k09FQ+tVoNuVzeZCKsjQ1pQBqIkA6kAUAaAKSBSEPpQFP5Go+GnMrHGNO7Lsw1ncqcU8QASDo0BRvNNZWvKWlQHz7VZSqfuMaSNU/lUyqVsLGxsfqpfIIgQC6XgzHrnconvhZtqQ+fdiXuwpITS1ChqYC3gzdmdZuFx1o/BhuZTZP7PInvF89NU/mIWhEj2+YeZmdOSAPSQIR0IA0A0gAgDURIB8tB7IDzPK+XFn9Qip1fY9PAvQXCDZUx9FeX8zSldHU+6S6Ubm4b68snU9NNSQNzXHuCIOiNYqjuc1ZdWiaT1ZjmOK5KWjx/dWnx/NWlK9toarqyH6IGYuDOEnyqSztxHIdbt25JQSlL8MnUdgK0I5XEoM39+qRhGiw7tQxvHX0LFZoKdPbpjFVRq/BkmydhI7NpFJ9MbSdRA93X9dlOxkIjpuoZerJKEARBEJYDfa83Hg29+Hl1aUPUV93mSpNPzSPdmD6JI6Zat24tTW1tKqNWLHEkDvlkfT5llWdh7qG5uJRzCQDwVPhTmNp1KnydfJutT/fbTjRiykJhjOnNT7dGSAPSQIR0IA0A0gAgDURIh+ZLQ68xpVAooNFoqlwj1rbGlPjjxZJ8MrWdGNNO+TXkX3P1yZR2EqftpKamIjc3F0DTWOensdcuYozh5s2bKCkpsRif6tJON27cQEVFBVQqlcX4VJd2UigUKCoqui+f9t/Yj1E7R+FSziU4yh3xeuTrGNtyLGxVtmbxydR2UigUyM7OpjWmLImGfLKq0WikRepMGRZnSZAGpIEI6UAaAKQBQBqINJQONGKq8WioEVPiD3jxfZXLGKIpjKap75E4gDY4YmtrKz1Bbyr2NtbooqamQX34ZOqIqeDgYNy5cwetW7eGjY2NxY1aMWaEhyBod+ULCwuDXC63CJ/q0k4qlQqJiYkICwsDx3EW4ZOp7aRWq6WRhOKUNVN84jgO666sw6fntbvuBbsEY3bP2RgYNBCMsWbxedJoNNL6czKZzGwjpigwVc9QB5YgCIIgLAf6Xm88atJafCIcGhoKe3t7M1lIEM0X+gwRRP1SrCzG/x37P+y/vR8A8HDLhzGv5zyEuoWa2bKmgyl9KJrK14xgjKG8vNyqpymQBqSBCOlAGgCkAUAaiJAORHWIT5Ot/dogHUgDgO6VAGkgQjrUXYP4/HiM3jUa+2/vh5yX45VOr2B5v+XNMijVVK4DCkw1IwRBQGpqqjSczhohDUgDEdKBNABIA4A0ECEdLAexDQVB0EuLnWZxSoIpaXHdDkNlDP3V9Tymprdu3Yrw8HDIZDLMnDnTqPcyxjBx4kR4enqC4zicP38egiBg0qRJennR0dGYOXOmXh3iOkuN5Z+x6djYWLi7u9fqd320U101WLx4Mbp27VpjmXHjxmHEiBFG12mOa08QBNy5c0daN6u6z1l1aXG9turSjLEqafH81aXF81eXrmyjqenKfgiCgJSUFMkGS/CpLu2kUqlw584daDQai/HJ1HZSq9VITU2FRqMx2qc/bv2BF3a9gOSiZHjZe2HRg4vwWufX4GLn0iR8MrWdRA3ENa3qu52MhQJTzQiZTCZ1XqwV0oA0ECEdSAOANABIAxHSofnS0IufK5VK2NraguM4lJWX4VT6Kfxx6w8cu30Mao32x3lDLUA9btw4ad0SW1tbtGnTBosXL5YWpZ48eTKeeeYZJCQkYPHixUb5tHv3bmzYsAE7duxAeno62rRpgz///BOxsbHYvHkzUlNT0bFjR2zcuBFLly6VfOI4Dra2tnpBOlN9+u9//wuO0247LpPJ0LJlS4wbNw5paWmS7XVdKFy0CTBuoXCe57Ft2zY9P8TgUWU/QkNDpXbw9PRE586d8d1335m0+Pm8efPw559/1uqT7o+4prj4uUwmg7Ozs7SAcVNZgBpovEW1ZTIZ5HK53gLNzd2nurTTrVu30Lp1azDGLMYnU9spJSUF4eHhKCsrq9WnzJxMLDy8EPOPzEeFpgIRbhFYFb0KvZ17o6igqMn4ZGo75eTkIDw8HPn5+bT4uSXRkGtRMMZQWloKJycncBxXr3U3F0gD0kCEdCANANIAIA1EGkoHWmOq8Wioxc/FJ8UHUg7gw9MfIrMsUzqnn6Mf5kfOx+DgwXq21Nei0+PHj0dmZibWrVsHpVKJXbt2Ydq0aXj//fcxbdo0uLq64sCBA4iOjja6zrVr1+Ljjz9GUlKSlP/5559jxYoV0g+S6hAEQVqUti4+xcbGYtasWbh+/ToEQcClS5cwfvx4dOnSBXv27KlTnSqVCj/99BNmzZqF/Px8oxcK53keW7duxZNPPimVXbRoEbZv344LFy7o1RESEoIJEyZg4sSJKCkpwebNm/Hmm29i165dGDp0aL22d0FBAbZu3dpkFz8PDQ2FSqWCk5MTZDKZ3udMEKxj8XNA+6Pd2dkZPM9bhE91aSeNRoPy8nI4OTmBMWYRPpnaToIgoLy8HI6OjpIthnzKLs/GvMPzcCH7AgBgRPgITOsyDX7Ofk3OJ1PbiTHtVD4HBwfpwUN9+WTK4uc0YqoZwRhDVlZWjV9mlg5pQBqIkA6kAUAaAKSBCOlgOYgdcHGEi5gWf1CKnV9j0wDwV+JfmHt4rl5QCgCyyrIw9/Bc7L+9X3pPXc9TXdrOzg4BAQEIDg7GlClTMHjwYOzYsUPqpA8cOBA8z+Pw4cPIzc3FCy+8gJYtW8LR0RGdO3fGzz//LNU5fvx4TJ8+Hbdv3wbP8wgJCcH48eMxY8YMKS80NBQcx2HAgAGYPXu2ZMsPP/yAXr16wdXVFf7+/njxxReRnZ0t1X348GFwHIcDBw4gMjISjo6OeOihh3Djxg09nziOQ0BAAAIDAzF06FDMmDED+/btQ3l5Ofbs2YP+/fvD3d0d3t7eGD58OBISEqT3JSUlged5bNq0CVFRUXBwcMBPP/0ktYeufjt27ED37t3h4OCAsLAwLFmyBBqNBhzHITRUu47LyJEjJZ9jY2OxZMkSXLx4UfpxtWHDBqlu0e9WrVph/vz58PT0xL59+6RzFhYWYuLEifDx8YGbmxsGDRok1cVxHBYvXoxu3bpJ5QVBwNy5cyVf58+frxcIMub6MPRXn9eeoTRjDDk5OVJ+dZ+z6tIymazGNMdxVdLi+atLi+evLl3ZRlPTlf0QNRCxBJ/q0k48z0v3AEvxydR24jhOGqVbnU9ns87iuZ3P4UL2BTjKHTGv5zy88+A78HP2a5I+mdpOogbGtqWpPhkLBaaaETzPS1tZWiukAWkgQjqQBgBpAJAGIqSDdcEYQ5mqzKi/EmUJVpxfAYaqQUt299/yU8tRrCg2qr77DX46ODigoqICcXFxAIDNmzcjPT0dffv2RUVFBXr06IFdu3bhypUrmDRpEl566SWcOnUKALBmzRosWbIELVu2RHp6Ok6fPm0wzxBqtRrvvfceLl68iG3btiEpKQnjxo2rUu7tt9/GJ598gjNnzkAul2PChAm1+iNOMyktLcWcOXNw5swZ7N+/HzzPY+TIkXrT9QBgwYIFmDlzJq5du4aYmJgqdR45cgRjxozBzJkzcfXqVXz99deIjY3F+++/DwCSj+vXr5d8HjVqFObOnYsOHTogPT0d6enpGDVqlF69HMfBxsYGW7ZsQX5+PmxtbaVjzz77LLKysvDnn3/i7Nmz6N69OwYNGiRNZ6nMJ598gtjYWKxbtw5Hjx5FXl4etm7dWqNWTQG6V5IGIqRDzRowxhB7JRYT/5qIvIo8tHJphQ/6f4AxEWNgJ7Mzg7UNQ1O5DuRmPTthEowxFBcXw8XFRYpCWhukAWkgQjqQBgBpAJAGIqSDdVGuLkfvn3rXW32ZZZno+3Nfo8qefOEkHG0cTT4HYwz79+/Hnj17MH36dPj6+gIAPD094e/vDwAIDAzEvHnzpPdMnz4de/bswaZNm9CrVy+4ubnBxcUFMplMeg8Ag3mVGT9+vDQlpHXr1vj0008RGRmJkpISODs7S+Xef/99REVFAdAGkB5//HFUVFTA3t6+Sp3x8fH46quv0LNnT7i4uODpp5/WO75u3Tr4+Pjg6tWr6Nixo5Q/a9YsPPXUU9Xa+u6772LBggUYO3YsAKB169ZYunQp3njjDSxatAg+Pj4AAHd3dz2fnZ2dIZfLDeowf/58vPPOO1AoFFCr1fD09MQrr7wCADh69ChOnTqFrKwsaaroihUrsG3bNvz222+YNGlSlfpWr16NN998U/Ljq6++wp49e6r1qanAGENRUZFV3yvp+0IL6VC9BiXKEiw8vhB7k/cCAPoF9sO8nvMQ5h5mLlMbjKZyHVhveLQZwhhDfn6+VU9TIA1IAxHSgTQASAOANBAhHSyH2nYCEtfKMBe65zcmvXPnTjg7O8Pe3h5Dhw7FqFGjsHjxYj0fxPIajQZLlixBp06d4OnpCWdnZ+zZswe3b9+u4ndN5zX0+uzZs3jiiScQHBwMFxcXKfhUue5OnTpJaTHAI06TZYyhsLAQzs7OcHR0RNu2beHn54cff/wRAHDjxg2MHj0arVu3hqurK0JCQgAAycnJerb36NGjiu26Pl28eBFLliyBs7Oz9Ddx4kSkp6ejtLTUoHa67zdU97x583D+/Hns3r0bvXv3xqpVqxAWFgbGGC5evIiSkhJ4eXnpnTMxMRE3b96sUm9hYSHS09PRq1cvKU8mk6Fnz561tk3ldqn8V5drzJQ0Ywx5eXnSwu3NcRcxU9OV/WCMITc3VypjCT7VpZ3UajXy8vIgCILF+GRqO2k0GuTn5+vZcjP/JkbvGo29yXsh42QY32E8Puz/IUJdQ5uFT6a2k6iB7s6E9emTsVBgqhnB8zyCg4PNPszOnJAGpIEI6UAaAKQBQBqIkA7Nl7rsymfL2eLkCydx9NmjOD7qOE6+cBJHnjmCE8+fqJJe8/Aa4+wYuBYnnj+Bw08dxskXTuLE8yfw99N/V0nb8XYm7YwWHR2NU6dOIT4+HkVFRfjuu+/g5OQkHRd90mg0+Pjjj/Hpp59i3rx5OHjwIE6dOoVHH30USqVSb+c33YCDuGMboL/bm27Z3NxcDBkyBG5ubli3bh1Onz6NzZs3A7i3o5xoj0wm0/NP/F/cUt7FxQWnT5/GuXPnUFpaiv3796N169YAgOHDhyM3Nxfffvstjhw5gmPHjgEAysrK9H6gODg46J1bRLS9pKQEixcvxoULF/DPP//g3LlzuHTpEi5fvgx7e/sqgSJdDXT9F/0AAA8PD7Rp0wZRUVHYuHEjZsyYgcuXL0OlUqGkpAQBAQE4deoULly4gNOnT+P06dOIi4vDrFmzpB36dH8A6urTnHbl43kednZ20i5bzXEXsfvd7Y3ntYtBl5eXW4xPdWmnhIQEBAUFSf5Zgk+mtFNRSRF2XdqFfzX/4kjSESTdTsLuxN14YdcLSCpKgqe9J97s8iae8X8GrnauzcKnurRTdnY2goODpR366tMnU3blo6l8zQjxCY2bm5tVD7ckDUgDgHQASAOANABIAxHSofkydepUTJ06VdqVT5zi5u3tLZXx9vZGSUkJAMDGxkb7P2cDJr+32LSD3MFg+uFWD8PP0Q9ZZVkG15niwMHP0Q99W/SFjJfBydZJWiAZtjCYFhd05XleWqdIJpNJ+bppZ2dntG/f/l49dxH90E0fO3YMTzzxBMaMGQOO0+5uFB8fj4iICL31kHQXtRanngHQm26nu+htUlIScnNz8f777yMkJAQcx+mtRcXzvGRDZZ9ERJ94nke7du2kukWfcnNzcePGDXz77bd4+OGHwRjD0aNHAQByuVyvLtE2XZ/E+gCge/fuiIuLQ3h4uJ5mutjY2EiLoYsa2Nra6u0gpVu/uGMVoJ0aOGrUKPzf//0ftm3bhu7duyMjIwMODg4IDQ2VylVuM3GRYTc3NwQEBOD06dMYMGAAbG1toVarpbWpRP9026a6dhLTHMfppXV3nxTTuj4Zc+3J5fd+6snlcikgY2dnBzc3NwBAQECAVCYwMFBqg6CgICktXjMAEBoaKvkXFhYmpdu0aVMlzfM82rRpI7VNWFiY5LO4gL2Tk5M0ss7FxUWaVurm5iZtEODu7g53d3cA2qmvIrr3CD8/Pyldm0+MMbi7u0s7sVmCT4Dp7RQeHi7ddy3FJ2PbaV/yPiw/tVxvQwxHuSPK1GUAgA5eHTCv5zx09+0uHW/qPgF1ayfGGAoKCuDl5SXZVV8+iXYZAz1WbEYwpp3/Wd0XtDVAGpAGIqQDaQCQBgBpIEI6WA617QSkG5QxJi3jZZjXXbtuEwf9oKX4en6v+ZDL5CbXbUxafG2ojO5xjuPQpk0b7Nu3DydOnMC1a9cwefJk6Qm9sXUaeh0cHAxbW1t8/vnnuHXrFnbs2IH33nuvyvmNsbG6tIeHB7y8vPDtt9/i5s2bOHjwIObOnWu07br5CxcuxA8//IB3330XV69exfXr1/HLL7/g//7v/6T3hISEYP/+/cjMzJSe5oeGhiIxMREXLlxAbm6u3ogpsW4xcDVz5kz8/vvvOHv2LAYPHow+ffpg5MiR+Ouvv5CcnIwTJ07g7bffxtmzZw3aOHPmTHz44YfYtm0b4uLiMHXqVMkOY68PQ3/GvO9+0owxlJaWSvnNcRcxU9OV/RA1ELEEn+rSTjzPSwF/S/HJmHY6eOcg5hyaU2WXVjEoFekXiTUD1qCnf89m49P97spXXFxsdFua6pOxUGCqGcHzPIKCgqx6mgJpQBqIkA6kAUAaAKSBCOlAVAfHcRgSNgQro1fC19FX75ifox9WRq/E4ODBZrJOn3feeQfdu3dHTEwMoqOj4e/vjxEjRtx3vT4+PoiNjcWWLVvQoUMHLF++HCtWrLh/g3XgeR4///wzzp49i44dO2L27Nn4+OOP61RXTEwMdu7cib/++guRkZF48MEHsWrVKgQHB0tlPvnkE+zduxdBQUHo1q0bAODpp5/GkCFDMGDAAPj4+OB///ufXr0cx8HW1hYcxyEiIgKPPvooFi5cCI7j8Mcff+Dhhx/G+PHj8cADD+D5559HcnKy3sgBXebOnYuXXnoJY8eORZ8+feDi4oKRI0fWyd/GhO6VpIGINeqgETRYfmq5wdGzIreLb8Pbwbva45ZGU7kOOEaPFusVcThkYWGhNFyuvhAEAQUFBXB3dzf7hWMuSAPSQIR0IA0A0gAgDUQaSoeG/F4n9KlJa3ENjdDQUIO7w9WEuC6QTCaDwAScyzqH7LJs+Dj6oLtvd8h445/oNmd0ddAdAWRNWLMG4mcoODgYFRUVVv2dQd+bWqxRh9MZpzFhz4Ray62LWYdI/8hGsMj8NOR1YEofyjquQAtCXKTPmiENSAMR0oE0AEgDgDQQIR2I6hCnb8l4GSL9I/FY68cQ6R9pNUEpEd2Fxq0V0oDulQBpIGJtOmSXZddrOUuhKVwHFJhqRvA8j8DAQKuJaBuCNCANREgH0gAgDQDSQIR0sBxq26Jad0c6Y9KAdqFscW2ZymUM/dXlPE0pbeiP4zi9BdfNbWN9+GRqHU1NA3NcezzP6y1m3By3tzc1XdkPUQNx1Jwl+FSXdmKMoUWLFuA4zmJ8qq2d8iq0O83Vhpe9V7Px6X7bCdAuaq77uj59Mhar7r2FhISgc+fO6Nq1KwYMGKB3bOTIkfDw8MAzzzxjJuuqIgiC3nbJ1ghpQBqIkA6kAUAaAKSBCOnQfFm7di0iIiIQGamdNpGVlQVAfztu3bZVqVRSZ1c3rVQqpTK6aYVCAZVKBcYYFAqF1GGuqKjQSwPazrtuWqFQVEkLgiAtqq2b1mg0UKlUVdJqtVovrVarJdt106b6JNpurE+MMahUKovyydR2YoxBqVQa9K+5+mRKO4k/MOPj46XPVnPc3l7cEED3HmHK9vaCIODff/+VFv62BJ/q0k43btxAdnY2lEqlxfhUXTvF34zHfy//Fx+frnndOw4cfB184af2a/I+1Vc7ZWRkICcnB1lZWfXuk2iXMVj1GlMhISG4cuWKtI2iLocOHUJxcTE2bNiA3377zeg6G3qNqczMTPj5+VntE2HSgDQQIR1IA4A0AEgDkYbSgdaYajxErfPz8+Hu7i79uOd5HmVlZUhKSkLr1q1hZ2cHANIIqNrSYoded6SMbhlDGFt3U01Xh0qlglwuB8/zZrexPnyqSx0qlUpvBF1z98nYdHl5ORITExESEoL8/Hz4+flBLpfrfc4EQZB2/6ourdFopB24DKUB7f1YNy2TyaQRG4bSjDHpmjSUrmyjqenKfjDGkJ6eDn9/f8hkMovwqS7tpFarkZ2dLS3wbwk+GWqnvPI8vHX0LRxLOwYAaOfRDtfzr4MDp7cIurhL6ydRn2BQq0FN2qf6bCdBEJCdnQ0fHx9pB7768ik/Px+enp5G9aEoMFVNYArQBqc+//zzJhOYIgiCIAiicaHv9cajoRY/JwiCPkOEdXI+6zzmHZ6HrLIs2PA2GN9xPMZGjMWpjFNYfmo5MssypbL+jv6Y32t+k9ml1RKwiMXP//77bwwfPlya97pt27YqZdauXYuQkBDY29ujd+/eOHXqlEnn4DgOUVFRiIyMxMaNG+vJ8oZDEARkZWVZ9TQF0oA0ECEdSAOANABIAxHSgagOcQqbFT+LBUA6AKQBQPdKgDQQsWQdBCbgv5f/i/G7xyOrLAsBTgF4r997mNJlClztXDE4eDD2PL0H3z3yHd7u8ja+e+Q77H56t1UGpZrKdSA369lroLS0FF26dMGECRPw1FNPVTn+yy+/YM6cOfjqq6/Qu3dvrF69GjExMYiLi4Ovry8AoGvXrtKccF3++usvtGjRAkePHkVgYCDS09MxePBgdOrUCZ07d25w3wiCIAiCIAiCIAiCqF/yK/Lx1tG3cDT1KADgoRYPYXaP2Wjr2VavnLhLa6g8FN7e3la9HEJToMkGpoYOHYqhQ4dWe3zlypWYOHEixo8fDwD46quvsGvXLqxbtw4LFiwAAFy4cKHGc4irzwcEBOCxxx7DuXPnTA5MKRQKaUFCQDtcDdBf0R6ov/mnvr6+0kr31jD32ZBPPj4+0rksxSdT28nHx0d62mcpPpnaTgCkLxFL8cnUdgIAHx8fi/LJ1HZijMHHxweAdsFXS/DJ1HYCAF9fXynfEnyqazt5e3tDpD59Ipo3HKe/E5u1QjqQBgCk3xPWDGmgxRJ1qG7qnqud4WlklqiBqTQVDZplWFCpVOLs2bMYPPjeUDue5zF48GCcOHHCqDpKS0ulVeRLSkpw4MABdOjQwWRbli1bBjc3N+kvKCgIgOEdZe53dfuysjKkp6fj5s2bVrNbRGWfBEFASkoKbt68aTE+mdpOgiAgISFB8s8SfKpLO2VkZEjntRSfTG2nxMREJCUlQRAEi/GpLjvKpKWlWcWOMtX5lJiYiPT0dBQVFVmMT3VpJ0EQEBcXJ33/mmNHGaJpwhiTdmSzZkgH0gCA1G8SA/bWCGmgxZJ0EJiAdVfWVTt1r9r3WZAGdaWpaNAsFj/nOA5bt27FiBEjAABpaWkIDAzE8ePH0adPH6ncG2+8gcOHD+PkyZO11nnr1i2MHDkSgPYp+8SJEzFz5kzp+ODBg3Hx4kWUlpbC09MTv/76q965RAyNmAoKCjK4o8z9Pr0FgPz8fLi5uUEul1vFaIjKPnEch9zcXLi7u8PGxsYifDK1nQAgNzcXHh4eBndTaY4+1aWd1Go18vPz4eXlJX3+mrtPpraTrgbieZq7T6a2k1qtRkFBATw9PQFY7o4yNfmk0WhQUFAADw8PcBxnET7VpZ0A4++Npvhkyo4yxP3RUIufM8agVqulvpO1oqtDZmYmXnrpJRw/fhw2NjZS4LY2tm3bhnnz5iExMRHTp0/H6tWrq+R17doVs2bNMrrOxsTQtVD5d0ZTIykpCaGhoTh//jy6du1qsMyhQ4cwYMAA6feHIcTPUHBwMMrKyuDp6Sndl60NQRCQl5dn1RoAlqND5al7fVv0xZwec6pM3TOEpWhQVzQCw8lbObiVnovWAV7o3dobMr7+vidNWfy8yU7la2hat26NixcvVnt83759RtVjZ2cnbVusi3hh617g95OWyWQAoDdNQTe/ujTHcdWmdb+QDaXry/bafDI1LU7bsSSfTG0nXQ0sxSdT20kul+vpYAk+mZquToPm7JOp7WRjY1NFg+buk6ntJJfLq3w3NHef6tpO9XVvrM52onnCcfembzGNBmVnzkKdnQ25jw8ce/YA14BtPG7cOGzYsAGA9p7dsmVLPPvss1iyZEm97IwWEhKCWbNmYdasWVKeGKQQ8fX1Rb9+/fDxxx+jdevWAIBVq1YhPT0dFy5cgJubm9Hne/XVVzF+/HjMmDEDLi4uBvPkcjkee+yx+/atMrpBRVdXV3Ts2BFLly7FwIEDTarjfqfyjRs3DgUFBXobM1UXPFq8eDHeffddANp7TIsWLTB06FAsX75ceqBSG0FBQUhPT69yn68rPM/XW13NFdJAiyXoUHnq3rgO4zCuw7gaR0npYgka1JXdV9Lx7u9XkV5YcTcnAQFu9lg0PAJDOgY0uj3NMizo7e0NmUwmTUcQyczMhL+/v5msangEQUBqaqrZh9mZE9KANBAhHUgDgDQASAMR0sFyENtQEAS9tDhqWHcEsTFpQRCgVCpRtOcv3Bw0CLfHjkXavHm4PXYsbg4ahKI9f0nlTa3bmPSQIUOQlpaGW7duYeXKlfj666+xaNGiBjmXbvr69etITU3Fpk2b8O+//2L48OEoLy+HIGiXBOjRowfCw8OlNepqq6+4uBhZWVmIiYlBQEAAnJ2dUVJSgqysLDz66KNo0aIFnJ2dYW9vb3SdpqbXrVuHtLQ0HD16FN7e3hg2bBgSEhKMroOxe1P5Kk/pM9aW6spXl9+hQwekp6cjOTkZ69atw+7du/Haa69VueaqOyfP8/Dz84NcLq+TXZXTgqBdFkPcIKq6z1l1aXGt2+rS4khe3bR4/urS4vmrS1e20dR0ZT9EDUQbLMGnurSTSqXCnTt3oNFomp1PKrWqyq57Sx9aismdJsPF1sXodlKr1UhNTYVGozG7T4157f1xKQ2v/XgOmQVl6JR9E1F3zqNT9k1kFZThtR/P4Y9LafXmk7E0y8CUra0tevTogf3790t5giBg//79BqfbWRIODg7mNsHskAakgQjpQBoApAFAGoiQDs2TtWvXIiIiApGRkQAMr9OZk5MjdYxVKpXU2dVNK5VKqUzldMm+fUidNQvqDP2HmurMLKTOmoXcXbsAaDvv4vpijDFpuQbdtBjoqpzWaDRQqVRV0jY2NvDy8kJQUBCGDRuGgQMHYu/evVCpVAgNDcXq1av1/OjatSsWLVoEQLtkxKJFi9CqVSvY29sjMDAQM2bMgEKhwIABA5CcnIw5c+ZIU08rKiqkHwSurq4ICAhA//79sWDBAly9ehUJCQkIDQ3F5s2b8f3334PneYwbNw6CIODjjz9Gp06d4OzsjKCgIEyZMgWFhYVQqVQ4dOiQNA1j4MCB4Hke+/btk0ZNDRo0CBzHYd++fVi3bh3c3d0lnxISEvDEE0/A398fzs7OiIyMxF9//aXXTiEhIVi6dCkmTJgAFxcXtGrVCl9//TUA6Pnk6OgIf39/dOjQAStXrkR5eTn++usvpKWlYfTo0WjZsiWcnJzQqVMn/PTTT3rtFBUVhWnTpmHu3Lnw8fFBTEyM3o8mtVoNlUqFlJQUPPvss/Dw8ICnpyeeeOIJaW3ThQsXYsOGDdi+fTt4ngfP8zh06JA0Eq1bt27geR7R0dHSdSCXy+Hv7w9vb28MGjQIzz77LPbu3Sv5VFFRge+++w4RERFwcHBAu3bt8MUXX0jXW2JiIniex4ULF6Tr7Y8//kDbtm3h6OiIAQMG4NatW5Ifutee6JOYFj8TFRUVzX5dQeD+1kosLCxEWVmZRflkajvdvHkT9vb2zc6n/Ip8vLLrFaw+txoapkFPt55YHbUaQ4KH/D975x0eRdX24Xtmd9M7pBFI6CCCdBBUBEQBEQFRkaIUQVFBkY9XUHxRRAWlN0VUwF4R9EVE6SCgdJQWIJ0kpJHed2e+P5YZkpC26dmd+7rQk9nZmfP8zsyZs2ee5zmEhoRa1E4RERE4OjqSkZFRZ9upqq+9pOvJvPHLWXrF/Mum39/h/UPrmHP8K94/tI6Nv79D75h/efOXsyQkJlXaJovydMp1lPT0dPnUqVPyqVOnZEBetmyZfOrUKTkiIkKWZVn+9ttvZXt7e3nTpk3y+fPn5WeeeUb28PCQr127Vqv1Tk1NlQE5NTW1VuuhoaGhoaGhUXm053rNoWidnJwsy7Ism0wm2WQyybIsy5mZmfK5c+fk7OxsWZIk82eZmbIxI0M2ZmSUWs5PTZUv3dNHPt+mbYn/LvW5V85PTS3X8UwmkyxJkizLsixJUqnl8ePHy8OGDVO3//PPP7Kfn5/cs2dPWZIkOSgoSF6+fHmh73bs2FGeN2+eLMuy/P3338tubm7y9u3b5fDwcPmvv/6S169fL0uSJCcmJsqNGzeW58+fL8fExMixsbGyJEnynj17ZEC+fv26etzNmzfLgHzmzBk5Li5OHjRokPz444/LMTExckpKiixJkrxs2TJ5z549cmhoqLxr1y65TZs28tSpU2VJkuTc3Fz54sWLMiBv3rxZjomJkXNycuTg4GAZkH/88Uc5NjZWzsnJkTds2CC7u7ur5z59+rT84Ycfyv/884986dIlee7cubKDg4McERGh7hMUFCR7eXnJa9askS9fviy/++67siiK8sWLF9V9APmnn35S/05KSpIBeeXKlXJUVJS8ePFi+eTJk/KVK1fkVatWyTqdTv7rr7/U9rj33ntlFxcXedasWfKFCxfUYwPyli1bVDtvu+02eeLEifKZM2fk8+fPy2PGjJHbtGkj5+bmymlpafLjjz8uDxo0SI6JiZFjYmLk3Nxc+e+//5YBedeuXXJMTIycmJgoy7Isz5s3T+7YsaNah9DQUPn222+XfX19VTu++OIL2d/fX/7xxx/lkJAQefPmzbKXl5e8ceNGWZZlOTQ0VAbkU6dOyZIkyREREbK9vb388ssvyxcuXJC//PJL2dfXV713Sroms7Ky1Huo4L1VtKzsX1LZaDSWWpYk6ZayUpeSysr5SyqXVt/ylDWbrMemE9dOyPd9f5/cflN7ufPnneWVJ1bKyZnJ9dqmmm6nQ5fj5dFPLpTPtWkrnyvyLDx7Y9voJxfKhy7HV9qm69evl3sMVWdzTB0/frxQfPzMmTMBGD9+PJs2bWLUqFEkJCQwb948rl27RqdOndixYwe+vr61VeVqR7oRphAQEGCTydlA0wA0DRQ0HTQNQNMANA0UNB2sh5LydBbMNyZnZxPcpWuVndMYF8flHj3LtW+bkycQnJzUuiiUVN62bRuurq4YjUZyc3MRRZE1a9aUuH/Bv6OiovDz82PAgAEYDAaCgoLo2dNczwYNGqDT6VTPqKLfVfKyxcbGsnTpUgICAmjevDnOzs7Y29vj6OhY6Hsvv/yyWm7WrBlvv/02U6dO5cMPP8TOzk4dY3t5eanfU5YYb9CggZpOo+D5ATp27EjHjh3VY7/99tts3bqVX375hWnTpqnbH3zwQV544QUA5syZw4oVK9i7dy9t2txMYKzYlJWVxX//+190Oh19+/alcePGzJo1S91v+vTp/P777/zwww/07NlTrUurVq145513MBgMxWr+/fffI0kSn376qfr5xo0b8fDwYN++fTzwwAM4OjqSm5tbSLuCOhRti3///RcXFxdMJpPqRbBs2TL1+G+++SZLly5l5MiRgDkP7vnz51m/fj0TJky45TpZt24dLVq0YNmyZQC0bduWf//9l/fee6+Q7sWVlYUelL4S6ndewYqWC2pQsC712aai5fLYIQgCV69eJSAgoM7bJMkSn134jFUnV2GSTfg7+zOj6wwGBg1EJ1a8nWRZJioqqtDYoa61U1Vfewlp2Uz9Z6t5O4URAQl49t+fSUgbU6U2lUWdnZjq27dvoXjp4pg2bVqhB5q1IwgCrq6utzxIbQlNA00DBU0HTQPQNABNAwVNB426Sr9+/fjwww/JzMxk+fLl6PV6dRKiLB577DFWrFhB8+bNGTRoEA8++CBDhw5Fry97CN+4cWNkWSYrK4uOHTvy448/lppwfdeuXSxcuJCLFy+SlpaG0WgkJyeHrKwsnG5MxFWEjIwM3nzzTX799VdiY2MxGo1kZ2cTGRlZaL877rhDLQuCgJ+fnxrWqTB69Gh0Oh3Z2dl4e3vz6aefcscdd2AymXj33Xf5/vvviY6OJi8vj9zc3Fvq3aVLl1Inrs+cOcOVK1fUEEWFnJwcNWzGUtq0acMvv/xCTk4OX375JadPn2b69OmAOewmJCSEp59+milTpqjfMRqNJSalv3Dhgjo5qWBJKhOtr9Q0UKgvOiTnJDP3z7kcjD4I3Fh1r8tM2jQoe9W9sqgvGlQlwj+n8c5JLfFzEfDJTsEpIhi6BNZYversxJTGrQiCUOISsLaCpoGmgYKmg6YBaBqApoGCpoNtITg60ubkiXLtm3X8OFHPPFvmfk3Wf4RTt27lOrclODs707JlS8CcvLtjx458+umnPP3004iieMuLWCUnEJhXZAsODmbXrl3s3LmT559/nsWLF7N///4yV5c7ePAgbm5u+Pj43DLRUpTw8HAeeughnnvuOd555x28vLz4888/efrpp8nLy6vUxNSsWbPYuXMnS5YsoWXLljg6OvLoo4+quVQUitqjePcUZPny5QwYMAB3d/dCq3AuXryYlStXsmLFCjp06ICzszMzZsy45RwuLi6lTuplZGTQtWtXvvrqq1s+K24V3PJgZ2entv+iRYsYMmQI8+fPZ8GCBWRkZADw8ccf3zLZVF0rgmp9paaBQn3Q4VT8Kf6z/z/EZcVVaNW9sqgPGlQVUdezWPJHMFk7jjOzHPu31OdWe50Kok1M1SOkGytINGnSxGbDFDQNNA0UNB00DUDTADQNFDQdbAtBENRwurJw6t0bna8vpvh4KM4bXxDQ+/rifNddCNU0GaAgiiKvvfYaM2fOZMyYMXh7e6uJdQHS0tJuSRbr6OjI0KFDGTp0KC+88IIautWlSxfs7OxKXPWoWbNmhX5wyTdWorOzs7tl3xMnTiBJEkuXLlXvn++//74KLIZDhw4xYcIERowYAZgnf5TkvJbi5+enTvIUPcewYcMYN24cYO4PLl26RLt27QrtJ99IYm9nZ1esh0SXLl347rvv8PHxUZO9F6U4zRVNy7MC1euvv07//v157rnnaNSoEY0aNSI0NJSxY8eW+V2A2267jV9++aXQtr/++qtc3wWzNhERETbdV2rPCzN1WQdJlth0blOZoXuVPk8d1qCqSM7MY/WeK3x9OIQBIUeYcuG3cn3P7kaIck1hnepbKYIg4OnpaVOuhkXRNNA0UNB00DQATQPQNFDQdNAoCUGnw+fVOTf+KHJ93Pjb97VXq31SSuGxxx5Dp9Oxdu1a+vfvzxdffMHBgwf5999/GT9+fCFPmU2bNvHpp59y9uxZQkND+fLLL3F0dCQoKAiApk2bcuDAAaKjo9UVokqjJG+hli1bkp+fz+rVqwkNDeWLL75g3bp1VWJvq1at+Omnnzh9+jRnzpxhzJgxt3hCVcU5du7cyeHDh7lw4QLPPvusunpWUUrzmBo7diwNGzZk2LBhHDx4kLCwMPbt28eLL77I1atXAbPm//zzD8HBwSQmJpKfn4+Pjw+Ojo7s2LGDuLg4ddWq4ujVqxd33HEH7777LgDz589n4cKFrFq1ikuXLvHvv/+yceNGNYdUUaZOncrly5f5z3/+Q3BwMF9//TWbNm0qp1JaXwmaBgp1VYfknGSm7Z7G8hPLMckmejfqzep+q3mw2YNVOikFdVeDqiA7z8TavVfo894eLn2/lTV/vM8L/2zBNT8HRJGSkibJgN7PD6duVZfHsTxoE1P1CEEQcHNzs8obp7xoGmgaKGg6aBqApgFoGihoOmiUhCAIeAwaRMDKFeiLLJKj9/UlYOUK3B54oMbqo9frmTZtGu+//z5z5szh3nvv5aGHHmLIkCEMHz6cFi1aqPt6eHjw8ccfc9ddd3HHHXewa9cu/ve//9GgQQMA3nrrLcLDw2nRokWZoWZKgtzi7pGOHTuybNky3nvvPdq3b89XX33FwoULq8TeZcuW4enpSe/evRk6dCgDBw6kS5cuVXJshddff50uXbowcOBA+vbti5+fH8OHD79lv9I0AHBycuLAgQMEBgbyyCOPcNttt/H000+Tk5OjelBNmTKFNm3a0K1bN7y9vTl06BB6vZ5Vq1bx0Ucf0ahRI4YNG1ZqfV9++WU++eQToqKimDx5Mp988gkbN26kQ4cO3HvvvWzatIlmzZoV+93AwEA2b97M1q1b6dixI+vWrVMnucqD1ldqGijURR1OxZ/isf89xsHogxhEA1M6TGFxn8VVkk+qOOqiBpXFJMl8dyySfkv28dtX23lr53LmHvuCgMxEBDd3vKZMwXfePLPNxbysEQShRl/WqKeWy8owrmERaWlpuLu7k5qaWqILcEWRJInw8HCaNm1qta6GZaFpoGmgoOmgaQCaBqBpoFBdOlTnc12jMKVpnZOTQ1hYGM2aNSs1gXdxFAphkySyjp/AmJCA3tsbp25da3zwXVsU1MGafoRZgi1roNxDQUFBXLt2zaafGdpz00xd0qGmQvduOW8d0qCyyLLMnovxLPrtIrlXrjDp3K/0jLtg/tDeHveHH8Zr3Fgcbqx0mrbhXeLWfoEx8+Yx9M7g+8KTuE16rUrqZMkYSssxVY8QBAEfHx+be5AWRNNA00BB00HTADQNQNNAQdNBozSU8C1Bp8O5Z49ark3tUZ7V/KwdW9dA6ys1DRTqig7VuepeWdQVDSrLqchkFv52kdDzoYy78Af3Rx1DlGUQRVzvvx/PsWNw6tYNQZl8O/8LbpHv4zpEJivBDmOODr2DCSfvfITI9+F8e2j3cI3aYNs9cz1DEARcXFxquxq1iqaBpoGCpoOmAWgagKaBgqaDRkko4Vu2jqaDpgFofSVoGijUBR2qe9W9sqgLGlSG0IQMFv8ezP5TYTx+aS+vhRzAXjIC4HRnTzzHjMW1X1+EgqueSibYMRuQEURw9s0rclQBdsyBtkOgGr3VilK//dVsDJPJxJUrV8q14oe1ommgaaCg6aBpAJoGoGmgoOmgURKyLJOTk4OtZ6/QdNA0AK2vBE0DhdrUQZIlNpzdwMQdE4nLisPf2Z+3736bFzq9UGOTUlB/r4WE9Fxe3/ovDy7Zg/3W79mwcyGjLu/BXjJi37Ytfu+8Q5MPP8TtgfsLT0oBRByGtJhSji5DWrR5vxpE85iqR4iiSEBAQL2Pf60MmgaaBgqaDpoGoGkAmgYKmg51g+XLl/PJJ58gyzIDBgxg5cqVdSJEws7OrrarUCfQdNA00PpKTQOF2tKhNkP3ilLfroXMXCPrD4TyyYErdA89wYcXfsMvKxkAfUAAXuPG4f7ICPTu7iUfJKP4FUsrvF8VoU1M1SMEQcDR0bG2q1GraBpoGihoOmgagKYBaBooaDrUPgkJCaxZs4Zz585hMBjo06cPf/31F7169arVegk3VhmydTQdNA3ArIGlCwhYG9rzwkxt6FA0dG/87eOZePvEGvWSKkh9uRbyTRLfHo1k5e7LNA49y8Jzv9IqNRoA0dMTz1Gj8HxiFAY/v9IPJEkQd658J3XxLXufKqR+TA1qAGZXw0uXLtU7V8OqRNNA00BB00HTADQNQNNAQdOhbmA0GsnJySE/P5/8/Hx8fHyq9PgVCcHSwrfMaDrYtgaSJKn/t/W+UntemKlJHUoK3ZvWaVqtTUpB3b8WZFlm+7+xPLD8ABs/+4MZf6xh4eH1tEqNRnBwxGP0aIK++AKfGS+VPikly3BlF3zUB/5cVsZZBXALgKDeVWpLWWgeU/UIURQJCgqqN66G1YGmgaaBgqaDpgFoGoCmgYKmQ+U5cOAAixcv5sSJE8TGxrJlyxaGDx9eaJ+1a9eyePFirl27RseOHVm9ejU9ephXufP29mbWrFkEBgai1+uZOnUqLVq0qJK6GQwGBEEgISEBb29vi7xeZFlWJyRs2VtG08E2NZBlmby8PBISEhBFEXt7e5vvK7XnhZma0iElJ4W5h+Zy4OoBoHZD94pSl6+Fv0OTWPjbRWKCQ3nywu/0jzqJiAw6Ha4DB+I1biyOnTrdXGmvJGJOwc43IGy/+W87ZwjsZZ6oQgAKTtTf6BcHLarRxOegTUzVKwRBwN7evrarUatoGmgaKGg6aBqApgFoGihoOlSezMxMOnbsyKRJk3jkkUdu+fy7775j5syZrFu3jp49e7JixQoGDhxIcHAwPj4+JCcns23bNsLDw3F0dGTw4MEcOHCAPn36VLpuOp2Oxo0bc/XqVcLDwyt9PA0NW8PJyYnAwEB0Op22MqH2vABqRofT8aeZtX9WnQndK0pdvBYuxaXz3m8X+fufcJ64tJuHQ//EIJk9upzvuguPMWNwvbcPgr6MqZzkcNi9AM7+aP5bNMDtw6HHs9C4G1z4n3l1voKJ0N0amSel2j1cLbaVhjYxVY8wmUxcvnyZVq1a2ewDRdNA00BB00HTADQNQNNAQdOh8gwePJjBgweX+PmyZcuYMmUKEydOBGDdunX8+uuvbNiwgTlz5rBr1y5atmyJl5cXAEOGDOGvv/4qcWIqNzeX3Nxc9e+0tDSgcMgRmN9oS5KEk5MTrVq1Ur+jbFfyBpVUzsvLIyoqiqZNm6rfEwQBk8mkviWXJKlQWafTIctyiWVZlhFFscRy0bpbWi7LJqXuJZWLswkgPDycJk2aYGdnZxU2WdpOsiwTHh5OYGAgBoPBKmwqTzsZDIZC57506RItW7YsVoP6YlNl2kkJZ2zVqhV6vd4qbKpIO+Xn5xMSEkKrVq0QBKFKbTKajHx2/jNWn1qNSTbh5+THy91e5v4m96O74YlTF649o9FISEgILVu2RBTFWm2n6OuZrNxzhV+OhvFQyJ9svLQHl/xsAOzbt8dz3DhcHrgfg5MTsixjMpmKb6fMRMSDS5GPfYIg5QMgtxyA3G0KYqsBSIIIsozY7mGk1oORwv8kLuQffFvcgdj0bkR96X2jpe1UXuqez5pGiYiiSIsWLeqkq2FNoWmgaaCg6aBpAJoGoGmgoOlQveTl5XHixAkGDBigbhNFkQEDBnDkyBEAmjRpwuHDh8nJycFkMrFv3z7atCk5VGPhwoW4u7ur/5o0aQJAfHw8AImJiSQmJgIQFxfH9evX0el0JCcnk5OTg4ODA0lJSeTm5uLg4EBCQgL5+fk4ODhw7do1TCYTDg4OxMfH06RJE5ycnIiOjkYURRwcHIiKikKv12NnZ0dUVBR2dnbo9XqioqJwcHBAFEWio6PVRNGxsbE4ODhgMpm4du0aDg4O5Ofnk5CQgIODA7m5uSQlJeHg4EBOTg7Jyck4ODiQlZVFamoqDg4OZGRkkJGRgYODA6mpqWRlZeHg4GCxTbGxsQA4ODiU2yYnJyeCgoLUuluDTZa2k5OTE76+vqod1mBTedrJYDCQlJREYmIioiji6upKSkqKemylHB0dTWpqKgBRUVGkp6cD5gnNzMxMAMLCwsjJyQEgJCSEvLw8AC5fvozRaESSJC5fvowkSRiNRi5fvqz2ISEhIQDk5OQQFhYGmD01FS/I9PR0oqKiAEhNTSU62pzcOSUlRdXy+vXrxMXFldhHlMcmURTR6/VkZ2dbjU0VaaeQkBCaNWum2ldVNqXkpPDcH8+x4uQKTLKJng17srDTQh5s9iCJCYnVapOl7RQVFUWLFi3Ucm20U0JKBu/vuMiAJXu5vnkLH+18j6fP/YpLfjb6wEBML04n4NNPcBnyICGRkSXblJdF3u6FsLIT/P0hgpRPtk9neORjUgd9SLTz7aDTF7YpJZUE57b49H+eJNd2JF5PrtJrT9G6PAiyBdn/Lly4wLfffsvBgweJiIggKysLb29vOnfuzMCBAxk5cmSdc4WradLS0nB3dyc1NRU3t6p1UVRmQ5UZSFtE00DTQEHTQdMANA1A00ChunSozud6ZajuMZkgCIVyTMXExBAQEMDhw4cLrbL3yiuvsH//fv7++28A5s6dy08//YQoitx3332sXLmyxPYozmOqSZMmJCcn4+HhUWVvpI1GI2AOByx4jVi7N0RRm0RRVN9e6/V6q7DJ0nZSjqd4h1iDTZa2k3JPiKJYrAb10SZL2wnMCzXodDr1vqjvNlWknZT+QKlbVdh0Ov40rxx8pVDo3vjbxuNm71Yn76eC90VBLWqinfJMEl8cDmft3iu0CP+XSee20yzNPGEkNmiA5xNP4DHqcXQNGpRukykf+dSXiPvfg3Tz92nQErnHs8h3jEJ0dC/VpoLTQYIgVGk7JScn4+XlVa4xVLleK548eZIBAwbQuXNn/vzzT3r27MmMGTNYsGAB48aNQ5Zl5s6dS6NGjXjvvfcKDTI0qo6Cs8C2iqaBpoGCpoOmAWgagKaBgq3oUNfHZO+88w4XLlzg3LlzrFq1qtRJQnt7e9zc3Ar9qw5s5dooC00HTQMwa3DlyhVNAxvXAKr2fpBkiU3nNjHpj0nEZcXh5+THgt4Lan3VvbKojT5BkmR+Ph3NfUv3891XO3ll52oWHPmUZmmxCE5OeD75JE2++BzvaS9g8PYu+UCyDBe3w7q7EbfNgPRYZBdfpL6vwcQd0GMK2LuWoz51o18s18TUyJEjeeSRR7h27Rq7d+9m4cKFTJ8+ncmTJ/PKK6/w+eefExYWxrZt2zh16hRLly6t7nrbJKIo0qpVK5sOU9A00DRQ0HTQNABNA9A0ULAVHWprTNawYUN0Op0axqAQFxeHX2lLVJeDtWvX0q5dO7p37w6UHsoHlocVREZG0qRJE0RRtKkwnaI2iaJ59Sml7tZgk6XtJIoivr6+qh3WYJOl7SSKIm5ubjYfymdnZ6eF8oWE0KJFC9W+itp0IfwC0/dMZ/nJ5ZhkE70b9WZRl0V0ceqCTtTV6fspKiqKVq1a1Vgo35+XExm0fC/vbdjNuD8+ZtX+lXRKDAG9AfmBB/D7+GN8X3uVyLy8Um3KDztM7kcD4NvRCAkXMRlc4c7nyXziZ8IDHwMX73Jfe4mJibRq1UotV2U7VXkoX35+PgaDodwHtXR/a6K6Q/mMRiN6vd5mwzU0DTQNFDQdNA1A0wA0DRSqS4e6FspXU2OyoqF8AD179qRHjx6sXr0aML9lDQwMZNq0acyZM8ficxRF0bo6QvkkSVITPdtKmE5Rm0RRJD8/H1EUbTqULz8/X12ZzhpsqkgoX15eHnq93qZD+fLy8tSk8NZgU0VD+SRJUvuDith0Ku4U/znwn5uhe+3GM7H9RFwMLvXifpIkSf1bqUt1tNPZqym893sw/5wNZ3TwLh4MO4JBNiELAi59+uA5dgyOPXuis7Mr3aaES+j2vg0XfgEAnR1y+5FI3Z9BF9AZGSy+9hQdFD3rdCifpQMaW52Uqm6Ume3adrOrTTQNNA0UNB00DUDTADQNFGxFh+ock2VkZHD69GlOnz4NmN90nj59msgbyVZnzpzJxx9/zGeffcaFCxd47rnnyMzMVFfpq6vYyrVRFpoOmgZg1iA0NFTTwMY1gMrdD5IssfHsRib+PtEcuufsx4K7FvB8x+frdOheUaq7T7ianMXL351m5Io9BGz7lg07FzIs9E8MsgmHjh3xf/99AlatxLVPHwS9vuQDZcTDr/+H+GEvuPALsiAitR4Eo7+Fh9eAf0eo4Eu5utIvltvffebMmcX+mz9/Pt98842WV6oG0Ol0tG3b1qaXwdY00DRQ0HTQNABNA9A0ULAlHaprTHb8+HE6d+5M586d1fN07tyZefPmATBq1CiWLFnCvHnz6NSpE6dPn2bHjh34+vpWyp6aCOVr2rQpOp3OpsJ0itqk0+lo3ry5TYfy6XQ6/P39uXbtmtXYZGk76XQ6PDw81Lpbg02WtpNOp8Pe3r5QuFF9t6ki7RQaGkrr1q2RZdkim64mXuWZ7c+w7MQyTLKJ7l7dWdNvDb08ehEfF1+rNlUklK9t27ZkZWVVaTslZ+bx6nfHGLB4D9lbNvPprvcYf2EHTsZcCAzEY+5rBH76KUm3tSXvxoRQsTZlp5L80yuwqjPC8U8RZBME3kn+sPVc6fIGtLyPnLz8Sl17iYmJtG3bluTk5LofygfQr1+/YrenpKRw5coVfH192bNnD4GBgeU+uTVS3aF8eXl52N1w8bNFNA00DRQ0HTQNQNMANA0UqkuHuhbKB9Y7JqvOUD6j0Yi9vX2hcAVrD9MpapMoiuTm5qLX6206lC83NxeDwWDToXw5OTnY2dnZdChfTk4O9vb2Nh/KZzQasbOzK3co3z+J/zBr/6xbVt3zcCx/n12X7idlEkvxLq5sO2Xl5rPpcDgf7gvh9vAzTDy/ncB082SdzscHzzFjcBv5CHYNG5ZuU14O4ukvYP97CJkJAMjebZF6PIvujseR7Zyr7NqT5cKpEGorlK8Uf7HC7N27t8TP0tLSGDt2LHPmzOHrr78u7yE1LESSJCIiImjRooVNvBEuDk0DTQMFTQdNA9A0AE0DBVvSQRuTWYZybbRs2bK2q1KrKDo0a9astqtSaygaNG/e3Or7iZKQJInIyEhNg8hIWrRooU5i2CIFn5tlvdCRZInPzn3GqlOrMMkm/Jz8mNF1BgODBiIK9VfDgn1CZa4FkyTz48kolu+8hHvYRead+5X2SWZvIcHFBfdHH8Vr9BPYBwWpEz3FIstw/mfE3W8hXDd7ecluAdB9MnR+Chw9Qacz71dFFHw21GafUCVXkZubG//97385dOhQVRxOowR0Oh2tW7e22YcIaBqApoGCpoOmAWgagKaBgqaDmfo4JquJUL7AwEAtlE+no2nTpjYfyufr62vzoXxubm42H8pnMBi0UL7QUFq2bFlmKF9KTgrP73xeXXWvp09P5rebz5DmQ8hIz6hTNlUklK9169YVDuWTZZmf/rrEoBX7WblxF5P++IjlB9bQPikM2WDA4eGhBH3+GblPjCLX07NUm2KO/ID8yQD4YTzC9RBkBw+k3i8S3O8TpN4vYbR3r5ZrLzExkdatW9efUL6yCA0NpWPHjmrl6gNLlixh48aNCILAnDlzGDdunPrZtm3b+L//+z8kSWL27NlMnjy5XMes7lC+nJwcHBwcbDZcQ9NA00BB00HTADQNQNNAobp0qIuhfGVRH8dkUL2hfHl5eTg6OqphHrYQplPUJlEUyc7Oxs7OzqZD+bKzs7G3t7fpUL6srCwcHBxsOpQvKysLR0dHmw/ly8vLw8HBocRQvpNxJ5nz5xyuZV5TQ/cmtJuAq51rnbTJ0naSJIm8vDzs7e3VupTXpjNRKSzaEcylC+GMvbiTQRF/o5MlEARc+vfHfcwYXHr2QNTrS7cpMRhh93y4tAMA9A5IHR5H6DEFfNsj3ahLdV17slw4FUKdD+Uri7/++osWLVpU1eGqnX///Zevv/6aEydOIMsy/fr146GHHsLDwwOj0cjMmTPZu3cv7u7udO3alREjRtCgQYNarbMkSURHR9e6m11tommgaaCg6aBpAJoGoGmgoOlwk/o2JiuKMgAvGFZRmbIgCMTExNxybZRVFgShxLLy47akclXVvaSyJXYoZZPJpOpgLTYVZ0dpNhXVwBpsKlouq14mk4nY2NgKa1AXbbK0XFQDa7CpaLk8dhTXNyp2KKF7K0+uNIfuOfsxo8sMBjUdhE4sfIy6ZJOl7QTcMnYoy6bwxEwW/x7MnpNhjLyyn9lX9uNoMntvOXbriufYcbjd1x/Bzq50m9Ji0O19F05/BbIEgghth0CPZxGD7oIb+xUc0VTHtWcymVQNquL5W1J7lEW5J6b++eefYrenpqZy4sQJ3n33Xd54441yn7i2uXDhAr169cLBwQGAjh07smPHDp544gmOHj3K7bffTkBAAACDBw/mjz/+YPTo0bVZZXQ6nc3nR9A00DRQ0HTQNABNA9A0ULAlHaxtTFYU5e1sVb1lB9QcKrbkDVGcTS1atFDPZS02WdJOigZKwIg12GRpO+l05tUZi95v9dkmS9tJ0UDpH6zBpoq0E6C+xDCZTGrdr2dfZ96ReRy4egCA3o1683Lnl2nt1brO22RpOwmCoIYzKt8tyab4tGxW77nC93+FMyD0CJ8G78QzNwMAu1at8HrySVwfHIzo5IRQmk1ZyQiHVyH89SEYs80N0bQPpm5PI7Z9EEFvZ7apQD9VndeeooEkSeq5qrKdyku5c0x16tSJzp0706lTp0L/7r33Xt59911mzpzJ888/X+4Tl8WBAwcYOnQojRo1QhAEtm7dess+a9eupWnTpjg4ONCzZ0+OHj1a7uO3b9+effv2mZdzTE5m3759atxlTEyMOikFEBAQoH5Wm8iyTEZGhvowtUU0DTQNFDQdNA1A0wA0DRRsSYeaHpNVN9WdYyosLIykpCRkWbap/DFFbZJlmeTkZKuyydJ2kmWZ2NhYrl69ajU2WdpOsiwTERFBUlKS1dhkaTvJskxwcDAZGRlWY1NF2unSpUukp6eTn5+v2nQ85jiP/vwoB64ewCAaGNNkDIv7LKaxQ+N6YVNF2ikjI4O0tLQSbQqJuMrKXZfp+/5ewjb/jzU732faP1vwzM1A5++P3bRpOK9aiefjjxGXmlqyTcmJcOQD5JWdEP5cBsZssr1uI3fwShjzHSF27cgzybVy7WVkZJCQkFA/ckxFREQUu93NzQ3PG4m8qpLffvuNQ4cO0bVrVx555BG2bNnC8OHD1c+/++47nnrqKdatW0fPnj1ZsWIFP/zwA8HBwfj4+ADmgZvRaLzl2H/88QeNGjXio48+4qOPPsLd3Z3AwEA6d+7MjBkz+PHHH9m3bx9r1qwBYPHixQiCwKxZs8qsd3XmopAkifDwcJo2bVpoptuW0DTQNFDQdNA0AE0D0DRQqC4d6mKOqZoek9UU1ZVjKj8/n8jISJo1a6a+MbYFb4iiNgmCQFhYGIGBgRgMBquwydJ2AvMPpaCgIPQ38r7Ud5ssbaeyNKiPNlnaTrIsExoaqoZvWYNNlraTSTJxLPYYF69e5LYmt9HJuxPfXPqmUOjeS51f4oHAB7Az2NULmyrSTiaTicjISIKCghAEoZBNJhm+PRrJyt2X8Qu/wNPnfqVtcqS5zm5uuD/+OF6jR6P39yvdJllG+vcHhL1vI6SYvy97BCL0eAbTHWMQnb1q9dqTJEldJEQUxSptJ0tyTFmc/Dw3Nxej0Yizs7MlX6sUgiDcMjHVs2dPunfvrk4eSZJEkyZNmD59OnPmzLH4HJMnT2bEiBEMGTKEw4cPs3jxYrZs2QLAjBkz6NGjB2PGjLnle7m5ueTm5qp/p6Wl0aRJkyofVNlih6nZpNmk2aTZpNmk2VTbNlkyqKppamNMVp3UxUlADQ0NDWtjV8QuFh1dRFxWnLrNTmdH3o08Sb0a9eL/uvwfbRq0qa0q1ggmSeZo2HXi03PwcXWgRzMvdKJ54vL3c9d4f0cwxtAQJp37lZ5xF8xfsrfH/eGH8Ro3Foc25dAnZC/segNiz5j/dmoAXSdC96fBrVH1GVdHsOS5Xu5XigkJCQwePBgXFxfc3Ny48847uXLlSqUrWxHy8vI4ceIEAwYMULeJosiAAQM4cuRIuY+juIoHBwdz9OhRBg4cCECPHj04e/Ys0dHRZGRk8Ntvv6mfFWXhwoW4u7ur/5o0aVLo2FXpupidnU1aWppNuZgW54aelJRkVTZZ2k6yLBMTE2PTbuiKTQXd8q3FJkvbKS4uDlmWrcomS93QU1NTC7mh13ebKtJOaWlppbqh10ebLG0nWTaHpyQkJFSpTZa4odcUdWlMVh+QZZm0tDTVY8ZW0XTQNABNA7BtDXZF7GLmvpmFJqUAdVLqvsD7WNJnidVPSu04G8s9C3fx7rtf8tOSjbz77pfcs3AXa/ZcZuSHh5n78V6G7tzIh3uXmielRBHXgQMJ/Hg9/vPfLHtSKvYf+GIEfDHcPCllcIJuT8OEX+G+/9apSam6cj+U22Nq0qRJ/Pbbb7z44os4ODjw0Ucf4e/vz969e6u7jrd4TCk5oA4fPkyvXr3U/V555RX279/P33//Xa7j9urVi9TUVJydnVm3bh1du3ZVP/vll1+YNWsWkiTxyiuv8MwzzxR7jJr0mAK4evUqjRo1Qq/XW9UbaUvc0CMjIwkICLBpN/TIyEgaN25ss27ooihiNBq5evUqgYGB6v1X322ytJ0KaqCcp77bZGk7GY1GoqOj1ZcC1mCTpe2krKbSuHFjBEGwCpsq0k5Q/r6xvntM1eaYrDqpzlC+6OjoEvtKsM7+URtDaWOoivSV9dEmS9tJeZERGBhoU6F8kiwxcPPAWyalCuLr5Mv24dvV8L26blNF2um3f2P4askXPPvPVrxzUlXbExzc2dhuMIEZ8YwIOYi9KR8Ax5498BozFue+9yIYDKXbcT0cYe87CP/+AMjIoh6h3TCkblMQmvRA0Onq3P0kSeZVjQMCAhDF2gvlK7fH1M6dO9m0aROvvvoqL7/8Mv/73/84ePBgoUmZ+saRI0c4f/48x44dKzQpBfDwww9z6dIlrly5UuKkFIC9vT1ubm6F/gHqxaM0blllQRBKLet0OnQ6HUFBQRgMhkLblYugaBlKX0pSOX9J5fLWvTI2lVYuziZRFGnatCkGg8FqbLK0nRQN9Hq91dhUkXbS6/VqLhlrscnSdiqogbXYZGk7GQwGmjZtqvaR1mCTpe2k1+sJCgpS+0hrsKki7WRJ32ipTXUNaxuTVXfy84iICHx9fRFF0aY8SovaJIoi/v7+qh3WYJOl7SSKIh4eHqod1mCTpe0kiiL29vaqHdZgk6XtJIrmH+rZ2dlWY1N52ulk/MlSJ6UA4rLi2HZ6W72xydJ2yszK5pfVXzH36Gc0LDApBdAwJ5X/nPyWJy7twd6Uj33btri8MQ/9m2/iNvABktPTS7QpOSYUfp+LsKYbwr/fAzKZjfuQ/tAnMGI9UUIj0m/YUdfup4SEBIKCgrh+/Xr9SH6u0+mIjo7Gz89P3ebs7My5c+do2rRpuU9YEQShsMdUXl4eTk5O/Pjjj4XyTo0fP56UlBR+/vnnaq1PaVRnfgRZlklNTcXd3V0dMNsamgaaBgqaDpoGoGkAmgYK1aVDXcx7VJtjsuqkujymjEYj6enp6jGVSUhr84YoyyZRFElJScHV1RW9Xm8VNlnaToIgkJKSgpubG7obngv13SZL20kQzF4M7u7uxWpQH22ytJ0AtZ8RRdEqbCpPO/0W9huzD86mLBbetZCHWj5UL2yytJ2OXIoj//FhNMxJpaSRglEQSX96Oj2mjEZ0dS297qZcpL/WIRxajnBjokv274xw57NIbR9GsHOq8/eTLMukp6fj6uqqvgSs0x5TcOtbQ8X4msbOzo6uXbuye/dudZskSezevbtQaJ+1oVw0taF5XUHTQNNAQdNB0wA0DUDTQMHWdKgrY7LqoDyefJZ4wImiSEZGBrIs25RHadGyLMtkZGQUqm99t8nSdlI0KHj++m6Tpe0kyzKZmZklalAfbbK0nRQNFKzBprLaKduYza9hv1IefF1864VNFWmnlL+P4V3KpBSAXpbI8G+C3t295PoiI575BlZ3Rdz9pnlSyqs5DHoP4amfoeNoRHvnenE/CYJAenp6udvSUpvKi768O8qyTOvWrdWTAGRkZNC5c2e1ooDq8lVZMjIyCiXyDAsL4/Tp03h5eREYGMjMmTMZP3483bp1o0ePHqxYsYLMzEwmTpxYJeevi4iiqOZRsVU0DTQNFDQdNA1A0wA0DRRsSYeaHpPVd2zp2igNTQdNA9A0ANvT4FziOeYcnEN4Wnip+wkI+Dr50sWnS81UrAaRJJlfzsSwa99ZXijH/l456cV/IMtweSfsehPiz5m3OftA90nQdRK4+lZVlWuMunI/lHtiauPGjdVZj1s4fvw4/fr1U/+eOXMmYA7X27RpE6NGjSIhIYF58+Zx7do1OnXqxI4dO/D1rX8XQ3mRJImUlBTV7dQW0TTQNFDQdNA0AE0D0DRQsCUdanpMVt+xpWujNDQdNA1A0wBsRwOTZGLjuY2sPbUWo2zEy8GL/oH9+fHSjwgIyNz0shVu+BDN7jEbnVj3citWhoOXE1j020USroTzYvDhcn2nze3Nbt0YfQJ2vgHhB81/27lA53HQfQo0bFmFNa5Z6sr9UO6JqfHjx1dnPW6hb9++ZbqkT5s2jWnTptVQjeoG2dnZeHh41HY1ahVNA00DBU0HTQPQNABNAwVb0aGmx2Q1jZLPoirzkmRlZeHh4WHV+WPKskkQBLKysnB1dVXrW99tsrSdALKysnBzc7MamyxtJzAnSC5Jg/pok6XtpGjg7u4OYBU2FS1fTbvK64df50TcCQB6+PXgpS4vcbvX7fT27817x94rlAjdx8mHOT3mcF/gfZhMpjppk6Xt9E9UMkt2XubUuUieCN7Fw2GHMEjmle5lKDacTwKkBt44de2iHo/rYYh7F8C5LeaddAbk2x9B7v4MYuOuSLIMN85bH+8nSZLIzs4utIhbVbZTeSn3lFhycjKrV68mLS3tls9SU1NL/Eyj6hBFUV3G0VbRNNA0UNB00DQATQPQNFCwJR2sbUxWE6vyNWjQAFHUVuXz9va2+VX5XFxcbH5VPr1eb/Or8uXn51vtqny/hf3GyF9GciLuBPY6e55s8iTv9XqPO7zv4PLly/QN6Mv24dt587Y3WXjXQtbft56V7VcyIGhAnbXJknaKSMzgxW9O8tjqA/j9+j0bd77LyJADGCQTdrffDo8+CpgnoQoiYZ6sajhrJjHXrkFGAnlbX0JY2wPObUFGICvoPnjiGxJ6zyfRPhAEod73EQkJCQQEBNSfVfkWLFjAP//8ww8//FDs548//jgdO3Zk7ty55T65NVKdq/dIksT169fx8vKyiYF3cWgaaBooaDpoGoCmAWgaKFSXDnVxVT5rHZNV16p8+fn5pKSk0KBBA/WNcX33hqiox1RSUhIeHh4YDAarsKkiHlNJSUl4enqi1+utwqaKeEwlJibi5eVVrAb10SZL20mWZRITE2nQoAE6nc4qbBIEgbScNBYeW8i20G0AtPRoybTO0+jTqA96nf4Wm4xGIykpKXh5eQHUSZssufauZ+axes9lvvkrnD5hx3jy4u94Z5snUfSBgXg9+SRuwx5GdHYmc/du4t55F2PcTa8xvZ8vvq+9huu9vZGPfIB4eBXk3cg11aQHUvcp0HYoop2jVfURklQ4lK8qbbJkVb5yh/Jt3ryZpUuXlvj5s88+y6xZs+rdIKi+kZ+fX9tVqHU0DTQNFDQdNA1A0wA0DRRsRQdrH5MpA/CCE4yVKet0OoxGo1ouuL20siCUvOqREg5UUrmq6l6aTZaWlTfu1mRTcXaUZpOiQVVfY7VpU9FyWfWSJKnQj15rsMnSsizLmEwm9fjWYNOp+FO8evBVojOiERAY0WoEz3V8Dj9nPwpS1A6j0YggFF69ra7YVLRcUnvkmmQ27L/Cun0h3Bb5L8vPb6dZ2jXzfg0b4jl6NB6jHsfQsKH6HbfGObgOjSMrJBFjjg69gwmn5iDkbofV0xEyzN+nYWvoORXueBzR3rXGbKrpay8/P1+dlKoum8qi3B5Trq6unDt3jsDAwGI/j4yMpH379vXKdbw6qItvVjU0NDQ0NDQqRl18rlvrmKwuaq2hoaFRlzFKRj765yPW/7MeSZbwdvRmWudpDG0+FIPOUNvVq1aMJokfTlxl+c5LeERe5umz27gjKRQAwdkZj5Ej8Rw7BvugoMJfPP8LfP8UUMo0iKs/dJ8MXSeAc8OS99MoFUue6+X2mNLpdMTExJQ4CIqJiSk0U6ZR9UiSRGJiIg0bNrRZrTUNNA0UNB00DUDTADQNFGxJB21MZhm2dG2UhqaDpgFoGoD1aBCVFsWcg3P4J/EfAO4JuIfpnadzW4PbyvX9+qqDLMv8cT6O93dcJCssgqfPb6dPjFkDDAbcHnwQz7FjcOzQQfUSUpFMsGM2pU5K2bnAhF+hQYtqs6EuUVeug3JPTHXu3JmtW7dy5513Fvv5li1b6Ny5c5VVTENDQ0PDckwmk82EM4H5YZqfn09OTk69GlRVJZoGZiqjg8FgsMjdvLbRxmQaGhoatossy/wc8jML/15IljELJ70TkztMZsxtY3A2ONd29aqV4+HXWfjbRUKCIxkdvJMHw/9CL0sgCLj07YvnmDE49+6FUNIzPeIwpMWUfpK8DPM+NjIxVVco98TUtGnTeOKJJ2jcuDHPPfecOoAzmUx88MEHLF++nK+//rraKqphjt308fGp7WrUKpoGmgYKmg6FNZBlmWvXrqmrZtga9S1kqTrQNDBTUR08PDzw8/O79e1qHcTax2RKotWqSi4ryzLe3t71PrFxVSTM9fb2Vs9lLTZZ2k7e3t5qInRrscnSdmpYINeOtdhkSTspGij9fX2yKT0/nfmH57MzcicAbT3bMr3zdO5pfI96/PK2k9I3KhrUtXYqWA5JyGDRbxf5898oHrmyn7lX9uNozAXAoXNnPMeOxfX+AaDXw416FWtHwkXK85SX0mMRi7k/qtKmunQ/+fj4qInQq9qm8lLuiamRI0fyyiuv8OKLLzJ37lyaN28OQGhoKBkZGfznP//h0RtLL2pUD5IkERcXh6+vr82+Fdc00DRQ0HQorEFcXBwpKSn4+Pjg5ORUL35cVwWyLJOfn4/BYLAZm4uiaWCmojrIskxWVhbx8fEA+Pv7V1cVqwxrG5OtXbuWtWvXqgPY+Ph4PDw81GWrfXx8iIuLw2Aw0LBhQ2JjY3F0dMTLy4vo6GhcXV3x8PAgKioKT09P3NzcCA8Px8fHBxcXF0JDQzEYDAQGBhISEkJQUBD29vZcvnyZFi1aIIoily9fplWrVkiSREhICG3btiUvL4+IiAhat25NTk4O0dHRtGzZkszMTOLj42nevDnp6ekkJycTFBREamoq6enpNGnShJSUFLKzs9UluPPz8/H3968ym8LCwggICMDR0bHcNrVu3ZqrV6+SnZ1NmzZtrMImS9upSZMm6vUQFBRkFTZZ2k4NGzbk4sWLNGzYEB8fH6uwydJ2cnFx4Z9//qFFixa4urrWG5suZF5g4ZmFxGfFoxN0PN7mcR72ephA90AEQSAsLMyidrp06RJubm40bNiQsLCwOtdObm5uHD93me/PZ/Lzyas8EP43Gy7uxDPXvFKeoUULvJ58krh2t+F8221QSjtFXTlHy2u/wqGV5XouJebo8AGb6CPy8vLUSSXlpXdV2RQWFlbusUC5k58rHD16lK+++oorV64gyzKtW7dmzJgx9OjRw5LDWC3VmbhTkrQlwTUNNA0UNB1uauDu7s6VK1fw8fGhQYMGtV2tGkWWZYxGI3q93mYnZTQNzFRWh6SkJOLj42ndunWhsL66nJDb2sZkitbJycl4eHhU2Rvp/Px8UlJSaNCggfrGuK56Q1TnW3ZBEEhKSsLDwwODwWAVNlnaTmC+1z09PdHr9VZhk6XtBJCYmIiXl1exGtRHmyxtJ1mWSUxMpEGDBuh0ujpvk0k2serkKj47/xkyMn5OfkzrPI0Hmz+IDl2F28loNJKSkoKXlxdAnWqn9Fwj6w+E8unBULpGnGHChd9onJFgrqevLx5jxuD52KMYvLxKbyfZiHzsUzi4BCErCQBZ1CNIRopHQHZrhPziGUS9wSb6CEmSSElJwcPDA1EUq9Sm5ORkvLy8yjWGsnhiSqN06vIAVkNDwzrJyckhLCyMpk2b4ujoWNvV0dCol2RnZxMeHk6zZs1wcHBQt2vP9ZpD01pDQ0OjMKEpocw5OIcL1y8A0D+wP9M7TaelZ8tarln1kGs08eVfkazZc5lGkcE8fe5XbkuOAEB0c8PjscfwHD0au8YBpR9IkuDcT7D7LUgxfx/3JtDzGXBqCFufv7FjwamQGy+1Hv8c2j1cpXbZKlW+Kl9kZGSJK78UR3R0NAEBZVwsGhYjSRKxsbH4+/vbtIeIpoGmAWg6wE0NPD09AWzSW0YLY9M0UKisDvVFO21MZjna88KMpoOmAWgaQP3QQJZlvg/+niXHl5BjysHV4MozHZ/h8daP42RwqpJz1CUdJEnmf//EsPj3YMSIMF48v507r503f2hvj/vDD+M1dgz2bdqU/bwO2Qu73oDYM+a/Hb2g20To9jS433ge2rmYV+crmAjdrREMWmRzk1J15Too15m7d+/Os88+y7Fjx0rcJzU1lY8//pj27duzefPmKqugRmE0bwhNA9A0UNB0sH4Ntm7dSsuWLdHpdMyYMaPYfYo+RGVZ5plnnsHLywtBEDh9+nSx2/r27VviMesbpQ0kirPdWqntgXVNoI3JKoa195XlRdNB0wA0DaBua5CUncT0PdN5+++3yTHlcEfDO1jadynj242vskkphbqgw8HLCQxd8ydvbdzPyD2f8eHepeZJKVHE9YEHCPx4Pf7z38ShbdvSJ6Vi/4EvRsAXw82TUgYn6DYJJm6H++bdnJQC8+TTjLNIT/2PjIErkZ76H8z41+YmpRTqwnVQrlC+pKQk3nnnHTZs2ICDgwNdu3alUaNGODg4kJyczPnz5zl37hxdunThv//9Lw8++GBN1L1Oormha2ho1DRKKF/REKT6wIQJE/jss88A1OTETz31FK+99hp6vR5fX18mTpzIiy++iKurK66urmUe87fffmPYsGHs27eP5s2b07BhQ3bu3HnLtrS0NAwGQ7mOWV42bdrExIkTb9n+8ccfM3ny5EKfi6KIm5sbrVu3ZsiQIbz00ku4u7ur3ymoDYCXlxfdu3fn/fff54477lC3Fxykubm50b59exYsWED//v1L1EOvL/faJzZDSfdRXXuuW/OYrK5praGhoVHTHLx6kNcPvc71nOvoRT1j2o7h6fZP4+XoVdtVq3LORqfy3o6LnDgfxWOX9zIi5CD2pnwAnHr2xHPMGFz790MwGEo/UHIE7Hkb/v3e/Leoh3bDoMcz0LgH2MBLq7pKlYfyNWjQgGXLlvHOO+/w66+/8ueffxIREUF2djYNGzZk7NixDBw4kPbt21eJARrFI0mS6pJvC2+Fi0PTQNNAQdPhpgZVmfDcJMkcDbtOfHoOPq4O9GjmhU6s3hCnQYMGsXHjRnJzc9m+fTsvvPACBoOB6dOnEx8fz8CBA2nUqFGx3y0ufCskJAR/f3969+6t7lfcNiXZZ1Xj5uZGcHBwoW0FJ5yUz2VZJiUlhcOHD7Nw4UI2btzIoUOHCtmqaANw7do1Xn/9dR566CEiIyMLHf/jjz9myJAhJCUlMXfuXB566CHOnj1L8+bNi7XdGrGVkEZtTGY52vPCjKaDpgFoGkDd1CDHmMOyE8v45uI3ADRxbcK0ztN4IOgB9GL1vEyqLR2irmex5I9gtp+IZEjYYTZe2oVbXhYA9m3b4vnkk7g/OBixLC+erOtwYAkc+xhMeeZtLe6DHlOg5f2gK1u3ungt1DR1RQOLrnJHR0ceffTRerUEsTUhCAKurq5WPeAuC00DTQMFTYeq12DH2Vjm/+88sak56jZ/dwfeGNqOQe39q+QcxWFvb4+fnx8Azz33HFu2bOGXX37htddeA1A9f/bu3UuHDh2YNm0aBw4cIDk5mRYtWjB79mzGjh0LFPYyEgSBoKAg+vbte8u28PBw+vbtS6dOnVixYgUAX3zxBStXriQ4OBhnZ2f69+/PihUr8PHxAWDfvn3069ePXbt2MXv2bM6fP0+nTp3YuHEjbdq0Ue0RBEG1pzgKfu7v789tt93G0KFDuf3223nllVf48ssvi9XGz8+POXPmcM8995CQkIC3t7e6n6enJ35+fvj7+/Phhx8SEBDAzp07OXLkSLG2Wyu2NKjUxmTlR3temNF00DQATQOoexoEXw9m9oHZhKSGADC42WCmdZpGoFv58wlWhJrW4XpmHqv3XOarI2HcFXGK9Rd+wy8rGQB9QABe48bh/sgI9AVe5hVLXhb8vQ7+XA65aeZtAV2gx7PQbjgYyh89UNeuhdqgrmig+fLXIwRBwMPDo7arUatoGmgaKGg63NQgJyen7J3LYMfZWJ778iRFY7uvpebw3Jcn+XBcl2qdnCqIo6MjCQkJBAcH06ZNGzZv3kzv3r3x8vIiISGBrl27Mnv2bNzc3Pj111+ZMGECrVu3pkePHqxcuZIWLVqwfv16jh07hk6nw87O7pZtxZGfn8+CBQto06YN8fHxzJw5kwkTJrB9+/ZC+82dO5elS5fi7e3N1KlTmTRpEocOHaqUzT4+PowdO5YNGzZgMpmKrWNGRgZffvklLVu2vMVLTqfTqQMKJU9AXl5esXpYK4IgaCGKGsWiPS/MaDpoGoCmAdQdDSRZ4svzX7Li5ArypXzc7d15ruNzjGw1Egd99admqCkdsvNMbDgUxrp9IbSMOs/Sc7/SMjUaANHTE89Ro/B8YhSGUl7qAWAywpmvYe9CSL+RtLxBC+g5FTqMAscyJrSKoa5cC7VJXdFAG8HVIyRJIioqiiZNmtjUW+GCaBpoGihoOtzUoKDnjIIsy2Tnm8p1HJMk88Yv526ZlALzIroC8OYv57mrZcMyw/ocDboKv3GRZZndu3fz+++/M336dNVTycvLS/UaCggIYNasWep3pk2bxm+//cZ3331Hjx49cHd3x9XVFZ1OV8hrqbhtRZk0aZJabt68OatWraJ79+5kZGTg4uKifvbOO+9w7733AjBnzhyGDBlCTk6OmpcoNTW10P4uLi5cu3atTPvbtm1Leno6SUlJqu3btm1Tj5WZmYm/vz/btm275ZrPz883t3l2Nq+//jo6nY577723RD2sEVmWycvLw87Ortbf+mlUDkmSCv1fFMVSy4IgIAhCieX8/Hyio6MJDAxElmVEUUQQBEwmk3ovSZJUqKzT6ZBlucSycpySyuWte0VtUupeUrk4mwRBIDIykoCAAAwGg1XYZGk7gXlly8aNG6PX663CJkvbqSwN6qNNlraTLMtEREQQGBiITqerFZuuZVzjv4f+y1/X/gKgi08XXuryEp28O6ntVN3XntFoJDo6miZNmgBUeTsZTRKbT8WwfOclXKNCmXPuV7okXAJAcHTEbcQIPMeMxrFlSyRJQpbl4m0ChMu/I+98AyHRnCpBdvGFbk8jdJuIybGB2aYb9bWknUwmE9HR0TRu3BhBEKyy3yvLpqKhfFVtU3mxzV9z9RRBEPD09LTpAbemgaaBgqZD6Rpk55toN+/3cv3r8OYfxKXllngeGbiWlkOHN/8o81jlnQwriDL54uDgwODBgxk1ahRvvvlmsfuaTCYWLFhAhw4d8PLywtXVlZ07dxIVFWXxeYty4sQJhg4dSmBgIK6ururkU9F8TgUTj/v7m73I4uPj1W2urq6cPn1a/Xf48OFynV/50VSwPfv166ce5+jRowwcOJDBgwcTERFR6LtPPfWUmhx+8+bNfPrpp4XqaStoHlP1k7Vr19KuXTu6d+8O3LyfEhMTSUxMBCAuLo7r168DEBsbS0pKCgDR0dGkpqYCEBUVRXp6OgDh4eFkZmYCEBERgZOTE4IgEBISQl6eORfJ5cuXMRqNSJLE5cuXzT+kjEYuX74MmL0OQ0LMoTVKcnwwTxIrIbHp6elq/5Oamkp0tNkLICUlhdjYWACuX79OXFxcldoUFhamesuW1yZBEHBxcVHtsAabLG0nQRAwGAzExMRYjU2WtpPyIzI5OdlqbLK0nQRBIDs7m6ysrFqxaXfEbkb+MpK/rv2FnWjHUy2eYt7t8+ji26VGr70rV67g4eGByWSq0naSZZmf/r7C/cv2sfyL/Yzfu5E1+5bTJeESsk6H3cCBBG74FGnSRLJv5PssyabYYz8jbRgE3zyBkBiMbO8Kd77Alfs2ktdrBrj4VKqdIiMj8fT0JCMjw2r7vbJsSkhIwNPTk6SkpCq3SalXeSjXqnwa5UdbUUZDQ6OmKW41saw8I+3m/V7jdTn/1kCc7Mo/OTBhwgSio6P58MMPsbOzo1GjRurkQkpKCp6enuzdu5e+ffsCsGjRIpYsWcKKFSvo0KEDzs7OzJgxA71ez9atWwFYsWIFK1asKJRLqbhtBXNMZWZmEhQUxMCBA5k6dSre3t5ERkYycOBATp06RadOndQcU8nJyarL8+nTp+ncuTNhYWE0bdqUTZs2MWPGDPUBXpTSPn/xxRf57LPPSE5ORhRFJkyYQEpKimoXmCfm3N3dmTFjBm+//TZgnsj68MMPGTBgAO7u7rd40BVnu8at1JdV+awZRWvlHrOmN9KWljWbNJs0m6zPpsy8TN4/9j4/XfkJgGZuzZjWZRr9AvqhE3X10qai7XQ8Ipn3dwQTfPkqTwTvZmjYIQyS+aWl89134z56NC733I3Ozq50m5KuIOx5Cy78DwB0dkjtH0Xo8QxCo06YbtRdu/bqtk3Jycl4eXlV3ap8GnUDSZIIDw+nadOm6sVpa2gaaBooaDrc1KC4EC1Hg47zbw0s13GOhl1nwsZjZe63aWJ3ejQrfSU7R4PlOYycnZ1p2bJlufY9dOgQw4YNY9y4cYB5oiY4OJjbb7/d4vMW5OLFiyQlJbFo0SLVpf348eOVOqYlxMfH8/XXXzN8+PBSr2fFzTw7O7vQ9gYNGtCiRQub9iCUZS2Uz1pQ7oGC90JlyoIgqJPHBfOslVUWBKHEsnKNlVSuqrqXVLbEDqVc8LlpLTYVZ0dpNhXVwBpsKlouq16V1aAu2mRpuaAGBetSnTadTTzL7AOziUyPREBgaIuhPN/peQJcAihITV57xfWNFW2nK/HpvLcjmAP/RDEs9CBzLu3F2Wj2mnG4owOe457EbeADiPb2pdc9/RrivkVw8nOQTSCI0HoQdJ+C2PxeEHXltq88NsmyTGhoaKHfE9bW75VlkyRJt2hQHTaVhcUTU5999hkNGzZkyJAhALzyyiusX7+edu3a8c033xAUFGTpITXKiSAI+Pj42PSAW9NA00BB06F0DQRBKLfn0j2tvPF3d+Baak6xeaYEwM/dgXtaeZeZY6q6adWqFT/++COHDx/G09OTpUuXEh8fX+mJqcDAQOzs7Fi9ejVTp07l7NmzLFiwoIpqXRhZlrl27RqyLJOSksKRI0d49913cXd3Z9GiRYX2zc3NVfNTJScns2bNGjIyMhg6dGih/aw5qbkl2FoonzYmKx/a88KMpoOmAWgaQM1qYJJMfHr2Uz48/SFG2YiXgxcvdHqB4S2HY6ezq/bzl0ZV6BCXlsOKXZf44WgE/cOP8cnFP2iYYw71MgQF4fXkk7gPH4auQO7NYslJg8Or4cgayDeHWBLYG3pMgbYPgb56tNLuh7qjgcVuBu+++6664s+RI0dYu3Yt77//Pg0bNuTll1+u8gpq3EQQzLkBavuiqU00DTQNFDQdqk4DnSjwxtB25mMWPceN/78xtF2tT0oBvP7663Tp0oWBAwfSt29f/P39GT58eKWP6+3tzaZNm/jhhx9o166dGjJYHaSlpeHv709AQAC9evXio48+Yvz48Zw6dUrNWaWwY8cO/P398ff3p2fPnhw7dowffviBvjdCGxUUl2lbRnljaEs6aGOy8qE9L8xoOmgagKYB1JwGMRkxTPp9EqtPrcYoG7nT/07W9F/D420er/VJKaicDmk5+Sz+/SL3vr+H0J93sGb3Ul4+/QMNc1LReXvT8MUXCfr6K7zGjS19UsqYB39/BKs6w4H3zZNSPu1g6CoY9yO0f6TaJqVAux+g7mhgcY4pJycnLl68SGBgILNnzyY2NpbPP/+cc+fO0bdvXxISEqqrrvWC6sxFYTKZ1PwXtvp2XNNA00BB0+GmBv7+/kRGRt6SG8dSdpyNZf7/zhObmqNu83d34I2h7RjU3r+Ub9YesiyTm5uLvb19rT9QawtNAzOV1aE+5piytjFZdWmtPS/MaDpoGoCmAdSMBttDt/P2X2+Tnp+Og86BSR0mMa7tOFztXavlfBWhIjrkGk18+Vcka/ZcxvfqFSad20aHJHOCa8HFBY+RI/EcMwb7oMDSDyRJcH4L7F4AyTcSZLs3MXtIdX4SnEpPHVFVaPdD9WpgyXPdYp93FxcXkpKSCAwM5I8//mDmzJkAODg43JLzQqNqEUVRXcbRVtE00DRQ0HS4qUFVMai9P/e38+No2HXi03PwcXWgRzOvOuEpVRp2drX/1rG20TQwY2s6aGOy8qE9L8xoOmgagKYBVK8G6XnpvPP3O/wa+isArTxa8ULnF+jXpB+iULc0t0QHSZL53z8xLPkjGCkykufPb+fumH/NHxoMuA0Zgte4sTjcfnvZL4dC98OuNyDmlPlvR0/oOgG6PQ0eTSpnlIVo90Pd0cDiian777+fyZMn07lzZy5dusSDDz4IwLlz59QkenWNESNGsG/fPu677z5+/PFHdXtUVBRPPvkk8fHx6PV6/vvf//LYY48BsGTJEjZu3IggCMyZM0dNtFubCIKguuzbKpoGmgYKmg43NVCWZK0KdKJArxYNqux41U3BZI62iqaBGVvUoT6OyWoD7XlhRtNB0wA0DaD6NDgZd5JXD75KTGYMAgIjW41kasep+Dr7Vvm5qoLy6nDwcgKLfrtIdGg0Y4P/YHD43+hkCQQBl7598Rw3Fuc770Qoy9vm2lnzhNSVXea/DY7QcTR0nwK+7arAIsvR7oe6o4HF02Jr166lV69eJCQksHnzZho0MP+AOXHiBKNHj67yClYFL730Ep9//vkt2/V6PStWrOD8+fP88ccfzJgxg8zMTP7991++/vprTpw4wbFjx1izZk2JS3/XJCaTiUuXLmEymWq7KrWGpoGmgYKmg6YBmMO3cnJysDAq3arQNDBjizrUxzFZbaD1lWY0HTQNQNMAql6DfCmf1adWM/H3icRkxuDj6MP8u+bzWs/X6uykFJStw9noVJ789G+eWXeATrt/YMPOhTwUdgSdLOHYtSuNli4lYOUKXO66q/RJqZRI2DIV1t1tnpQSdHD7CBj7Ezy4tNYmpUC7H6DuaGBxjqn6yr59+1izZk0hj6midOzYkW3btnHkyBH279/P2rVrAXj22Wfp168fTzzxRJnnqc5cFNpS2JoGoGmgoOlwUwNl2ePK5piqj8iyjCzLNukto6BpYKayOtTHHFPWRnVprT0vzGg6aBqApgFUrQYRaRG8evBV/k00h7X1adyHFzu9SJsGbaqiqtWGSZI5GpZETHImjTyd6dGsgZq6Iep6Fkv+CGbbySgGh//FmOCdeOZmAGDXsqV5pb2HhiA6O5d+kqzrcHApHP0YTLnmbc37QffJ0Hog6AzVaWK50O6H6tWgWnNMARw8eJCPPvqI0NBQfvjhBwICAvjiiy9o1qwZd999t0XHOnDgAIsXL+bEiRPExsayZcuWW1ZYWrt2LYsXL+batWt07NiR1atX06NHj4pUvUROnDiByWSiSZMmpKenM3/+fFJSUpBlmX379tG6desqPV9FEAQBe3v72q5GraJpoGmgoOlwU4OqDOWrb9j6ZAxoGijYqg5VOSazVrTnhRlNB00D0DSAqtFAlmW2XtnKwqMLyTZm46x3ZvIdkxnTdgxOBqcqqmn1UNJiNzPvb8352DS+PBJOz6gzfHT+NwIyEwHQ+/nhOXYsHo+ORO/pWfoJ8rPh73VwcBnkppm3NeoMPZ6F24ebQ/jqCNr9UHc0sDiUb/PmzQwcOBBHR0dOnjxJbq559jM1NZV3333X4gpkZmbSsWNH1TupKN999x0zZ87kjTfe4OTJk3Ts2JGBAwcSHx+v7tOpUyfat29/y7+YmJhy1eH69es89dRTrF+/HoB27drx4osv0r9/fx555BHuvPPOOpGl32QycfHixVp3s6tNNA00DRQ0HTQNwDwwzM7OtqnwraJoGpixRR2qekxmrWh9pRlNB00D0DSAymuQkpPC/+3/P+Ydnke2MZt2Xu1Y0ncJT7d/ul5MSj335UniUrLokHCFe6+eokPCFeJSsvjPj/9w/OfdvL93JXOPfUFAZiKiuztekycT9PVXNJwyufRJKckEp76E1V1h15vmSSmvFjD4PXjyZ+g0uk5NSoF2P0Dd0cDiUL7OnTvz8ssv89RTT+Hq6sqZM2do3rw5p06dYvDgwVy7dq3ilRGEWzymevbsSffu3VmzZg0AkiTRpEkTpk+fzpw5c8p97JJC+XJzc7n//vuZMmUKTz75ZLHfnTx5MiNGjGDIkCG3fJabm6sOBMHsrtakSROSk5Px8PBAkiTAnO2+tLLypreksslkKvR/nU6n/q1k0JckqVBZp9Mhy3KJZVmWEUWxxHJ5614Zm0RRLLFcnE2iKJKfn48oiuj1equwydJ2EgSB/Px8dDodOp3OKmyqSDuZTCaMRiN2dnbqD9H6bpOl7WQymdR/SgiSo6OjqocgCKX+SC/4eX0sKyj3RV2pV1XYZGk71WUNKmpTRc5TMJTP0uNkZ2erIbEGg0HtF5KTk/Hy8qqToXzVOSar5cCJMwAA5a5JREFUCMHBwYwaNarQ3998880tnvAlUZ2hfEajEb1eb5NedQqaDpoGoGkAldPgr9i/mHtwLvHZ8egEHaPajGJyh8l4O3lXU22rDpMkc/d7e2h24RhT/9mKd06q+tl1excSHdxpnRoNgGBvj9vDD5tX2mtTRliiLMPlP8yTUfHnzdtcfKHbJOg6EVzrbp4t7X6oXg0sea5b7DEVHBxMnz59btnu7u5e5QnC8/LyOHHiBAMGDFC3iaLIgAEDOHLkSKWPL8syEyZMoH///rdMSikeWcHBwRw9epSBAwcWe4yFCxfi7u6u/mvSpEmh7ycmJpKYaHaBjIuL4/r16wDExsaqekVHR5Oaau4YoqKiSE9PByA8PJzMzEwAwsLCyMnJQRRFQkNDycvLA+Dy5csYjUYkSeLy5ctIkoTRaOTy5cuAWcOQkBDgZv4MMHuqhYeHA5Cenk5UVBRgfssaHW3ukFJSUoiNjQXMXmVxcXHVYhNASEhIuW0yGo2EhoZalU2WtlNGRobV2WRpO8XHx6t2WItNlrZTRESEaofRaFR/ZOfm5qrlgsmglX1lWS5UVibXC5YlSVJ1KVg2mUzk5+ffUjYajYXKRqMRgPz8/EJl5W1MwbKSJ6touaAdmk2l26RMVFqTTTXdTvn5+Wq5YB+h3Od1kZock5WHNm3acPr0aU6fPs2ff/6Js7Mz999/f43XozhqexnsuoKmg6YBaBqA5RrkmfJYcmwJU/6YQnx2PI2cG7HgrgX8p/t/6sWkFMDRsOs0u3CM149+RsMCk1IAnrkZtE6NxoRA1j330eTj9fjPf7PsSamrx2HTEPj6cfOklL0r3PkcTPwN+s6p05NSCtr9UDc0sNhjqnnz5qxfv54BAwYUejv3+eefs2jRIs6fP1/xyhTxmIqJiSEgIIDDhw/Tq1cvdb9XXnmF/fv38/fff5fruAMGDODMmTNkZmbi5eXFDz/8QK9evfjzzz/p06cPd9xxh7rvF198QYcOHejVqxepqak4Ozuzbt06unbtWuyxa9JjSpZlrly5QvPmzTEYDPXSw6OyXisAly5dokWLFqqnTH23ydJ2kmWZS5cu0bJlSwwGg1XYVJF2ys/P58qVK7Ru3Vqd3a/vNlnaTooGgYGBRERE2KTHlDKhoSSrrgv1qmnvorquQUVsquh5cnJysLe3V+8/S45THz2mqnNMVlm+/vprfv75Z7777rtyf6e6PKZMJhOXL1+mVatWdSI1Q22h6aBpAJoGYLkGISkhzD4wm+DkYAAGBA5gWudptPBoUd1VrVJ+PhmJ56THaZiTSnF+MTJw3d6VpE++Y1j3ZqUfLCkEds+H8z+b/9YZoP2j0P0ZCOgM9cT7SLsfqleDavWYmjJlCi+99BJ///03giAQExPDV199xaxZs3juuecqXOnqZNeuXSQkJJCVlcXVq1fVSa67774bSZLUt3unT5+mQ4cOABw5coTz589z7NixEielAOzt7XFzcyv0D27OOoqiWK5ywR/WxZWVsK1WrVqpk1LKduVHatEyUGpZOX9J5fLWvTI2lVYuziZRFGndujUGg8FqbLK0nRQN9Hq91dhUkXbS6/W0bt1a3WYNNlnaTgU1UOqqnLdoubh/Je1bl8o///wzLVu2RK/X8/LLLxdrU8EJGYVnn30WLy8vRFHkzJkzyLLMs88+S4MGDRAEgTNnztCvXz9mzJhRZ2ytTDsV1aC27agKmypSdnBwqNRxFIr2C3WVqh6THThwgKFDh9KoUSMEQWDr1q237LN27VqaNm2Kg4MDPXv25OjRo8Ue6/vvvy8U1lebiKJIq1at1D7VVtF00DQATQMovwayLPPNxW8YtW0UwcnBuNq5MqvbLN695916Nyl1KS6dAz/uxLuESSkAAWiQm06jq1dKPlBGPGybCWt73JiUEqD1YBj9HQxbC4271JtJKdDuB6g7Gli8Kt+cOXOQJIn77ruPrKws+vTpg729PbNmzWL69OlVWrmGDRui0+nUkBeFuLg4/Pz8qvRc9YWCXhy2iqaBpoGCpsNNT8KqO6AJIg5DRpw5P0BQbxCr74f5hAkT+OyzzwAwGAwEBgby1FNP8dprr6HX63n22WeZOHEiL774Iq6ursUeQ5blQpMKO3bsYNOmTezbt4/mzZvTsGHDYrf99NNP6iR3VbFp0yYmTpwImB/0bm5utG7dmiFDhvDSSy/h7u5e7mPt27ePfv36qR64pVFUA1vF1nSo6jGZsiDNpEmTeOSRR275XFmQZt26dfTs2ZMVK1YwcOBAgoOD8fHxUfdLS0vj8OHDfPvtt5WyryrRnhdmNB00DUDTAMrWIDE7kXmH5nEw+iAAHb07Mr3zdHr49ahXz5mYlGyW77zElhORPHv6ULm+01Kfe+vG3HQ4vAYOr4Z8c2oMAu+EHs9A24dAX/urulUU7X6oGxpYfHZBEJg7dy7Xr1/n7Nmz/PXXXyQkJLBgwYIqr5ydnR1du3Zl9+7d6jZJkti9e3eh0D5bQZIkQkJCqv6HaD1C00DTQEHToRo0OP8LrGgPnz0Em582/39Fe/P2amTQoEHExsZy+fJl/u///o8333yTxYsXk5GRQXx8PAMHDqRRo0YlTkwVDKcGc94wf39/evfujZ+fH3q9vthtXl5eJR6zMri5uREbG8vVq1c5fPgwzzzzDJ9//jmdOnUq92qxllJUA1vF1nSo6jHZ4MGDefvttxkxYkSxny9btowpU6YwceJE2rVrx7p163BycmLDhg2F9vv555954IEHVE++ksjNzSUtLa3QP7g54S5JUrnKSkhmSWUl7FmSJDU1AqCWZVm+pQyUWlbOX1K5vHWvqE3F2VGWTZIkceXKFTUnmzXYZGk7KRoo+eeswSZL26ksDeqjTZa2k6KBUoeidhyIOsDIX0ZyMPogBtHA+HbjWdl3JT38eqj71DWbipaT0rN5d/sF+i7eS9j2nazas5yHwsuXo1nfsMFNm/Jy4OjHyKs6w/5FkJ+J7N0WachyGLsZ+fZHkERDjdhUHdee0WgkJCRE7SNrup3qwv2kaKDk2a1qm8qLxRNTkyZNIj09HTs7O9q1a0ePHj1wcXEhMzOTSZMmWXo4MjIy1DA6MCcZPX36NJGRkQDMnDmTjz/+mM8++4wLFy7w3HPPkZmZqb6RtiV0Oh1t27at02EF1Y2mgaaBgqZDFWtw/hf4/ilIKzJxkhZr3l6Nk1P29vb4+fkRFBTEc889x4ABA/jll1/USaP+/fsjCAL79u0jKSmJ0aNHExAQgJOTE3fccQdbt25V315OmDCB6dOnExkZiSAING3atNhtAH379mXGjBlqPb744gu6deuGq6srfn5+jBkzRl3IAsweTIIgsHv3brp164aTkxO9e/cmODi4kD2CIODn54e/vz+33XYbTz/9NIcPHyYjI4NXXnlF3U+SJBYuXKjmBuvYsaO6cmx4eDj9+vUDwNPTE0EQmDBhQrH6CYKAo6NjvXqDWx3Yog5VPSYrDUsWpClvGF9NLSATGRlJ06ZN0el09XrBi8ou4qHT6WjevLlad2uwydJ20ul0+Pv7qytWWoNNlraTTqfDw8NDrbs12GRpO+l0Ouzt7QstcpGTk0OOMYc5O+fwwp4XuJ5znUYOjXi719u82OlFEiIT6rRNSjslpaSxbn8I9y7ex76f9/HW/g9YcORTmqXFgqMjsqMjJWWAlAGdry8xHh4gy+Sd/h7T6m6wfRZCZgJ5zo1gwJukP/oDUT73gb1Lve8joqKiaNu2LVlZWVbb75VlU2JiIm3btiU5ObnKbbJkARmLk5/rdDpiY2MLuWyDuXH8/PzU2ffyooQqFGX8+PFs2rQJgDVr1rB48WKuXbtGp06dWLVqFT179rToPDVFdSXuBPNMZ15eHnZ2djY18C6IpoGmgYKmw00NJElSkzarHgqyDPlZ5TuQZDLnCkiPLWEHAdz84fm/yw7rMzhZlFtgwoQJpKSkFMplM2zYMCIjI/nuu+9o06YNmzdvpnfv3nh5eZGQkMA333zDgAEDcHNzY9u2bcycOZNDhw7Rs2dPUlNTWbVqFevXr+fYsWPodDrs7Oxu2ebt7U3fvn3p1KkTK1asAGDDhg34+/vTpk0b4uPjmTlzJh4eHmzfvh24+bzq2bMn7733Ht7e3kydOhWTycShQ2b3+E2bNjFjxoxiV0SbMWMGGzZsIDk5GZ1OxzvvvMOXX37JihUraNWqFQcOHGDq1Kn8/vvv3H333fz888+MHDmS4OBg3NzccHR0LDYUUHmLVjBfki1SWR2UgV2h+4jqfa5XlqoekxVEECq2IE1qaiqtW7cmKioKOzu7Us9RUwvIKKs12tvbI0mSmpevvi14UbBckUU8RFEkNzcXvV6PXq+3CpssbSdBEMjNzcVgMKDT6azCJkvbSRAEcnJysLOzK1aD+miTJe0kyRIn408SkxaDv6s/3fy6gQyXUi4x5+AcQlNDAXiw2YM8d8dzBLkH1XmbBEFAkuGH45Gs3H0Foq8y4fx2+sT8AwAGA26DBuE5bhx5MTHEzpxp3l5wGuDGczNgxQqcW9qj2zMfok+YP3P0RO7yFHLXpxG9gqyqj1AmfJTUDtZgk6XXnuI5ptfrEQShSm2yZAGZcueYSktLUw1KT08vNGgzmUxs3779loFReejbt6/q6lUS06ZNY9q0aRYf29qQJImIiAhatGhhs14imgaaBgqaDjc1CAgIuPXD/Cx4t1EVnUk2e1ItalL2rq/FgJ1zxc4iy+zevZvff/+d6dOnq88ULy8vNa9gQEAAs2bNUr8zffp0duzYwffff0/Pnj1xd3fH1dUVnU5XKBdhcduKUtDDpHnz5qxatYru3buTkZGBi4uL+tk777zDvffeC5hz/AwZMoScnJwyw5batm1Leno6SUlJuLu78+6777Jr1y71R37z5s35888/+eijj7j33nvx8vICwMfHp8wcU3l5edjb19/8DlWFrehQXWOyqsDd3f2W3KAlYW9vXyPtpfSVLVu2rPZz1WUUHZo1a1bbVak1FA2aN29u02OHyMhIm9RgV+Qu3j/2PnFZN/soXydfuvt2Z0fEDoySEQ97D57r+BwjW49Eb3k65hpHlmV2XYhn8e/BJETGMiZ4J4PD/0IvSyAION97Lx5PjMLl7rsR9Xrs29+O+J+xxK39EmPmzePonWR8JwzGNfFjhCN/mI+td0C+4wnEHs+Ab7vCE1lWQsE+obZzLNUWBZ8NtdknlFt9Dw8PvLy8EASB1q1b4+npqf5r2LAhkyZN4oUXXqjOuto8Op2O1q1b29xDpCCaBpoGCpoO1qPBtm3bcHFxwcHBgcGDBzNq1CjefPPNYvc1mUwsWLCADh06qDmidu7cqboqV4YTJ04wdOhQAgMDcXV1VSeflNByhTvuuEMt+/v7AxQK+SsJ5SWMIAhcuXKFrKws7r//flxcXNR/n3/+ueqaXV4EQSi0Gp2tYks61MaYrDoXpFm7di3t2rWje/fuQPWE8gUGBmqhfDodTZs2tflQPl9fX5sP5XNzc7O5UL5dEbv4v/3/V2hSCiAuK45tYdswSka6+XZjXut5jGw+EnudfZ236Xj4dYavPsBLGw7RY/9mNu5ayNCww+ZJqQ4daLBoIY1XreRao0bk38j1E7tnPa6Ri2kxJIbAfok06pVMYL9EWgyJwS3pU4TLfyALOmg3nJzHvyf0tmngd7vV9hFRUVG0bt3a5kP5WrduXX9C+fbv348sy/Tv35/Nmzerb3LBnKQ8KCiIRo2q6u18/aW6Q/mUt/K2MPAuDk0DTQMFTYebGgCVC+WLOAxfPVr2fmN/NK/SVxoVCOWLjo7mww8/xM7OjkaNGqHXm99QpqSk4Onpyd69e+nbty8AixYtYsmSJaxYsYIOHTrg5OTEjBkzMBgMajjgihUrWLFihfpgLmlbwVC+zMxMgoKCGDhwIFOnTsXb25vIyEgGDhzIqVOn6NSpU7Gr5J0+fZrOnTsTFhZG06ZNSw3le/HFF/nss89ITk7m2LFj3Hnnnezbt+8Wjzd7e3uaNGlS7lX5tFA+M7YUylcTY7KioXwAPXv2pEePHqxevRowv2UNDAxk2rRpzJkzp1Lng5taV0coX15eHo6OjmpIRH0KParKUL7s7Gzs7OxsOpQvOzsbe3t7mw7ly8rKwsHBwWZC+SRZYtBPg26ZlCqIs8GZ7SO2427nXudtCo5NZcnOy+w5G8Pg8L8YG7wTj9wMAOxatMDzySdxHfIgeheXwu0kS8jL20N6DCU9JWWdPdKI9ehuG4Is6q2+j5AkqZC3tTXYVJFQvoLpUep8KJ/y5jgkJISmTZva9OC3tpAkiejo6Fp3s6tNNA00DRQ0HW5qoHjtFEIQyh9S16I/uDUyJzovNiWmYP68Rf+yc0xVAGdn53KH2Bw6dIhhw4Yxbtw4wOxBdenSJW6//fZK1eHixYskJSWxaNEiNQHz8ePHK3XMgsTHx/P1118zfPhwRFGkXbt22NvbExkZqT5fi6Lk5ynPiia2EsJWFraiQ3WNyTIyMrhy5Yr6t7IgjZeXF4GBgcycOZPx48fTrVs3evTooU7q1vUFaZS+snnz5rVdlVpF0SEoKKi2q1JrKBooyfBtEUmSiImJsSkNTsafLHVSCiAzP5OQ1BC6eHepoVpZTmxqNqt2h/DD8Ujuij7DR+d3EJBp9nDR+/nhMWYMHo+OxODlVfzYIeIwQnrpqwMLplxw9ASdwSpD94pSsE+w5VA+5dlQL0L5FPr378+CBQtuCW3QqH50Oh0tW7a0mYdIcWgaaBooaDpUoQaiDga9d+OPoj9wb/w9aFG1TEpZSqtWrdi5cyeHDx/mwoULTJ06tVxhdGURGBiInZ0dq1evJjQ0lF9++YUFCxZU6FiyLHPt2jViY2O5cOECGzZsoHfv3ri7u7No0SLAnPNq1qxZvPzyy3z22WeEhIRw8uRJVq9ezWeffQZAUFAQgiCwbds2EhISyMjIKPZ8thTCVhq2qENVj8mOHz9O586d6dy5M2BeGblz587MmzcPgFGjRrFkyRLmzZtHp06dOH36NDt27MDX17dS562JUL7GjRtroXw6HYGBgTYfyuft7W3zoXwuLi42FcoXmVS+PjIhK6FO2pSalc+8H0/Qf+l+Lvy2l+X7VvLasS/Nk1JubjhPnEjQ11+RPuA+cm+81Cq2nUpc5KYw8SH/VLtNUDeuvaioKFq2bGnzoXwtW7asP6F8CitWrGDTpk2cPXuWfv368fTTTzNixAibeENZHqo7lC8zMxNnZ2ebGngXRNNA00BB0+GmBjqd7tZQvopw/hfYMduc6FzBLcA8KdXu4cpXuBiKW5VPobhQvuvXrzNp0iR2796Nk5MTU6ZMITIykrS0tEqF8gF88803vPbaa8TGxtKlSxdeffVVHn74YYtD+RTvEUEQcHNzo02bNjz00EO89NJLhZ4LsiyzatUqPvzwQ0JDQ/Hw8KBLly689tpr9OnTB4AFCxbwwQcfEBcXx1NPPaWuVlsQxYVbcZu2VSqrQ30K5VOwtjFZdYbyZWdn4+LiUugaqathOtUV/iGKIhkZGTg6Otp0KF9GRgZOTk42HcqXnp6Os7OzzYTy7Y3ay4x9M27tdIqwYeAGunh3qTM2Zefm8/lfEXywLxTPaxFMOvcr3eODze3o4ID7sGG4jxmNY+vWpbeT0YgYshNh+yuQWvYknenJX9C1uNcm+ghJksjOzsbJyUmtS323qSKhfNnZ2Tg6OtZqKJ/FE1MKJ0+eZNOmTXzzzTeYTCbGjBnDpEmT6NKl7ro/1gTVOYCVJPOS8LbuaqhpoGkAmg5wUwM/Pz91NY1KTUwBSCZzzqmMOHDxNeeUqgOeUiVRNC7eFtE0MFNZHerjxJSCtYzJqmtiKj8/n8jISJo1a6YOzOvCj86a/jEjCAJhYWEEBgZiMBiswiZL2wnMb/CDgoLQ6/VWYZOl7VSWBvXRptLKf4T9wdt/v01ybjIlISDg6+TLjpE7QKbWbTJJMltPx7Bs5yVMsTE8eeF3+kedREQGnQ6XAQPwGjsGp27dkKH0drp6DHnnPITIIwDICOp/i1NCdmuENP00OoOdTfQRJpOJyMhI1UvdGmyytJ0kSVIXCRFFsdYmpir8a65Lly6sWrWKmJgY3njjDT755BO6d+9Op06d2LBhg9r5a1Qdoija9FKWoGkAmgYKmg7VpIGog2b3QIdHzf+vw5NSYB6M2dvb2/SEjKaBGVvWob6Pyao7lC8iIoJGjRohimKdDNOpiE0VCf8QRZHGjRurdliDTZa2kyiKNGjQQLXDGmyytJ1EUcTJyUm1wxpsKq6dwuLC+L99/8f/Hfg/knOTaeDQgOIQEJCRebnTy+jE2g33lWWZLUevMHD5ft76+ghD/vyeT3a9x4CoE4jIGO7sScDKFcgvzyC/dWsEUSyxna6e3oP0zRj49H6EyCPIOjvoNIbYzv8HCLdMTSlPCeOABYSEhddYO9X2tRcZGUnz5s3VsD5rsMnSdkpISKB58+ZqWF9V2lStoXwK+fn5bNmyhY0bN7Jz507uvPNOnn76aa5evcratWvp378/X3/9dUUOXa+p7lC+9PR0XF1dbXLgDZoGoGmgoOlwUwODwVA1oXz1EOUtkfJmxhbRNDBTWR3qs8eUtYzJqjOULzMzEzc3t0LXSF318Kiut+yiKJKWloazs7NNh/KlpaXh4uJi06F8qampuLq6WmUonyAI/Bb2G4uOLiI5NxlREBnWYhiTO0zm4vWLvH/s/UKJ0P2c/PhPt/9wf9P7a9Wmk5HJvL/jEqdD4hgWcpBRl/fgnG/+ce/Qvj3uY8fiNvAB9E5OpbdTxjWEfYuQT32JIJtAEJFaDULoPhmhRV9MMojB22DHHIQCqRtktwCEQYuQbxtqVf1eeUL5MjMzcXFxUetS322ytJ1kuXB6lNrymCr3qnwKJ0+eZOPGjXzzzTeIoshTTz3F8uXLadu2rbrPiBEj1LdeGlWHLMskJyfjcmPpT1tE00DTQEHT4aYG3t7etV2VWsVoNKor2NkqmgZmbE0Hax2TKQPwgt6glS2npKSoP8QVyioLglBiWXnulFSuyroXV7bEDqUsSZKqg7XYVJwdpdlUVANrsKlouax6SZJU6EeiNdiklBOzE3n7r7fZHbkbgEDXQJ7r9BwDmw7EIBoIdAvkvsD7OH7tOMFXg2nTuA3d/LqhE2vPpivxGSz+/SI7/41hQORxPg3+g4bZZo8UQ1AQnuPG4T58GPob12yJGuSkIh5aCUc+AGO22R8q6C7oMQWxzRDQm5+NOoB2w6DtQ0jhh0iKOEeDoNsRm94Fog6hFPustY9Qfk8o57IGm0orF62LJEm3aFAdNpWFxR5TOp2O+++/n6effprhw4djMBhu2SczM5Np06axceNGSw5tFdSHN6saGhrWRUmeHhoaGuWnPnpMWduYrLo8purCG2lLy5pNmk2aTZZ5gf0v5H+8d+w90vLS0Ak6hrcczpQ7puDv5F8nbYpJzmLVnit8fyyS7rHnmXh+O0HpZk8uXcOGeI4ejdtjj2Jo2LD0dsrLRjj+KcLBJZB9I4+Wb3tM3Z9B7DASwd6lzrSTNV57mk21mGMqNDSUHTt28NhjjxU7AAJwdnauFwOg+oYsy6SkpGDhXKJVoWmgaaCg6aBpAGYNjEajpoGNawC2qYO1jMmqO8dUWFiYmr+lLufEqe68JLIsk5CQYFU2WdpOsixz9epVrl69ajU2WdpOsiwTGhpKUlKSVdh08epFpu+ZztxDc0nLS6OpW1Pm3j6X51s/T4BLQLE2ybLMhQsXyMjIqHGbLoZG8v6Oi/Rbup8zOw7y3sEPePPvjQSlxyG6uGA3ZjTOH6zF+4XnuW4ylXztJV+HM98ireqC8MdcyE4mz6UJ2f3mw/hthHncRY6kK9WmS5cukZycTH5+vtX2e+WxKSUlhbS0NKuyydJ2SklJISEhoX7mmDp+/DgXLlwA4LbbbqNbt24VOYzVUd2r8kVHRxMQEFDIXc6W0DTQNFDQdLipQYMGDapuVb56hizL5OfnYzAYVBdlW0PTwExldaiPHlMK1jImq85V+WJjY2ncuLH6xtia3khbsirf1atX8ff3t+lV+a5evUqjRo1selW+0jSoLzYJgsDWK1tZfHwx6Xnp6AU9j7R6hMkdJuPr5FuqTbIsExUVRePGjdHpdDViU55J5osj4azdG4JLfDQTz2+nd+xZc4MYDLgNGYLXuLHY3XYbglBKnh9BQLr0B8Ke+Qhx5wCQnRsidJ2E1GU8gntAudvJaDQSGxtLQEAAgFX2e2XZZDKZiI2NpVGjRqru9d0mS9tJkiRiY2Px9/dHFGtvVT6LJ6auXr3K6NGjOXToEB4eHoB51q137958++23NG7c2JLDWR31YQCroaFhXWihfBoalac+TkxZ25isLmutoaFRd7iWeY35R+bzZ/SfALRwb8HUTlMZEDgAvWhxCuVqxSTJbD0VzbKdl8iOvca4i38wMPIooiyDIODSvz+eY8fi3LMHQln5eK6egF1vQPhB8992ztBpLHSfDN5tqt8YDQ0LseS5brGbweTJk8nPz+fChQtcv36d69evc+HCBSRJYvLkyRWutEbZSJLE9evXC73xsDU0DTQNFDQdNA3ANsO3iqJpYMYWddDGZOVD6yvNaDpoGkD91kCWZX689CPDfx7On9F/YhANjGk7ho/u/4hBTQeVe1KqJjSQZZm9F+MZsuog//36LwYc/okNuxYxOOJvRFnGsXt3Gi1bRuPly3Dp3av0SamkEPj+Kfikv3lSSmeAO0bBU7/A4PcrPClVn6+FqkLToO5oYPGU8v79+zl8+DBt2ty8Adq0acPq1au55557qrRyGreSnZ2tvhW1VTQNNA0UNB3MGti6l5TivmzLaBqYsTUdrHVMpgyOqzJUIisrCw8PjzoTTlVboXxZWVm4urqq9a3vNlUklC8rKws3NzersakioXyZmZklalBXbYrJiOGtv97iSOwRAFp5tOLZjs/Sv3F/DHqDRe2kaODu7g5Q5TadjEjmvR0XOXklniFhh5l/aTdueeb8O3Zt2uA1bhyugwchOjkhlNZmabEIB95HOPEZyCZkBITWA5G6TUZo0Q9BZw7FFKBC7aT0je7u7phMJqvs98qySZIksrOzcXd3V79b322qSChfdnZ2oZU6q9Km8mKxx1STJk3Iz8+/ZbvJZKJRo0aWHk7DAkRRtOl8OqBpAJoGCpoOtqHB1q1badmyJTqdjhkzZtzyuSAI2NnZqQNNML+lfOaZZ/Dy8kIQBE6fPl3str59+xZ7zLrIpk2bSpyELU6D2uDNN9+kU6dOpe4zYcIEhg8fXi3nrys61CTWMiar7uTnERERNGjQAFEU60Sy5tpKmCuKIt7e3qod1mCTpe0kiiIuLi6qHdZgk6XtJIoier1etaOu2yTJEptOb+KRXx7hSOwRDKKBx4MeZ92AdXR26kzy9WSL20kURfLz88nOzq5Smw6cCua5L08w8oM/cTqwi493v8+zZ3/BLS8TQ0AALi/PQPf+e3g+9ihpeXkltlNSTBjseQdWdUY4vgFkE9n+PUh78EN4/HOiHduSmp5R6XYKCQnB399fta+6rz1L26kmrr3IyEgCAgLIzMy0GpssbaeEhAQCAgK4fv16rSY/R7aQrVu3yj169JCPHTumbjt27Jh85513ylu2bLH0cFZHamqqDMipqalVfmyTySQnJCTIJpOpyo9dX9A00DRQ0HS4qUFmZqZ8/vx5OTs7u9LHNJqM8tHYo/KvIb/KR2OPykaTsQpqWjLjx4+XARmQDQaD3KJFC3n+/Plyfn6+LMuy7OPjI8+ePVuOjo6W09LSbvm+JElyXl6eLEmSum379u2ywWCQDx06JMfGxsr5+fnFbktKSir2mJVh48aNqj2CIMgBAQHyhAkT5Li4uEof193dvdjPitNAlmUZuOW5/MYbb8gdO3a85RhBQUFqvR0dHeX27dvLH3/8sUV1TE9PlxMTE0vdZ/z48fKwYcMsOm55KUmH8pKdnV3sfVSdz/XKYm1jMkXr5ORkWZbNfZzSx5dWVtq8pHJeXp4cHx8vm0wm2Wg0qtuVsiRJt5RlWS61rJy/pHJ5615Rm4qzoyybTCaTHB8fL+fl5VmNTZa2k6KB8oyxBpssbSeTySTHxcWVqEFdsikiJUKeuGOi3H5Te7n9pvbyyJ9Hyn+E/yHn5edVqp0UDZQ6VNamuNRs+dXNZ+Tmr/4qj5i4VP5fj/7y+TZt5fNt2soX7+wlX1u2XM6LiSm7nfJzZNPhD2TpvWay/IabLL/hJktr75Tl4xtlU1ZqlbeT0jcajUar7ffKsik/P19OSEhQ+0hrsMnSdlI0yM/Pr3Kbrl+/Xu4xVLlC+Tw9PQu9gczMzKRnz57o9eavG41G9Ho9kyZNqrY3oRpminszamtoGmgaKGg6VK0GuyJ2sejoIuKy4tRtvk6+zOkxhwFBA6rsPEUZNGgQGzduJDc3l+3bt/PCCy9gMBiYPn068fHxDBw4sFTvD7lITiHlDWDv3r1L3ebl5VX1xgBubm4EBwcjSRJnzpxh4sSJxMTE8Pvvv1foeOVp46IaVIS33nqLKVOmkJWVxQ8//MCUKVMICAhg8ODB5fq+i4sLLi4ula5HZagKHeo6tjAmU7xAC3qDVqas0+kwGo1queD20sqCIJRYVtqgpHJV1b00mywtK2/crcmm4uwozSZFg6q+xmrTpqLlsuolSVKhMKG6aJMkS3xz8RtWnFxBjjEHe509T7R5gontJ9LAsYFF9S2uLN9YjU05b0VtSs818tH+ED79M4zGCZG8de5XuiSYPVoER0fchw/Ha9xY7Fu0UL9bbDsBnN0MexYgpkSYN7o3gR5TEDo/CU5ehcKcqrKdjEYjgiCo37W2fq8smxTvuaIa1GebKtJO+fn5iKJYJX1jSXUvi3JNTK1YsaLcB9SoPkRRxN/fv7arUatoGmgaKGg63NRAcZetDLsidjFz30xkCv+wj8+KZ+a+mSzru6zaJqfs7e3x8/MD4LnnnmPLli388ssvvPbaawD0798fgL1799KhQwemTZvGgQMHSE5OpkWLFrz22muMHj0aMIeKffbZZ4D5IRwUFETfvn1v2RYeHk7fvn3p1KmT+oz74osvWLlyJcHBwTg7O9O/f39WrFiBj48PAPv27aNfv37s2rWL2bNnc/78eTp16sTGjRsL5fgRBEG1p1GjRrz44ov897//JTs7m/379/P2229z9uxZdDodvXr1YuXKlbS4MWgNDw+nWbNmfPvtt3zwwQf8/fffrFu3rljdfv75Z+bPn8/58+dp1KgR48ePZ+7cuej1epo2bQrAiBEjAAgKCuLNN99k/vz5ah0BNm7cyIQJEwBwdXVV6z179mzef/99du7cqU5MpaSkMGvWLH7++Wdyc3Pp1q0by5cvp2PHjoA5lG/r1q2cPn0aMIeT/ec//2HDhg3odDqefvrpap04UkL5rB1tTGY52vPCjKaDpgHUfQ0i0iKYd2geJ+NPAtDOqx3PdHyGfk36IQpVk7qgshrkGk18cSSCtXuvYJ9wjZfO/0bf6NPmD3U63AYNwnPcWBw7dSo7vPzKbvNKe9f+Nf/t1AC6ToBuT4N7QIXrWB7q+rVQE2ga1B0NyjUxNX78+Oquh0Y5kCSJxMREGjZsaNU5ZUpD00DTQEHT4aYGxXmpyLJMtjG7XMcxSSYWHl14y6QUoG5bdHQRPf16ohNLf/PhqHesdI4fR0dHEhISCA4Opk2bNmzevJnevXvj5eVFQkICXbt2Zfbs2bi5ubFt2zaefPJJmjdvTs+ePdVJnvXr13Ps2DF0Oh12dna3bCuO/Px8FixYQJs2bYiPj2fmzJlMmDCB7du3F9pv7ty5LF26FG9vb6ZOncqkSZM4dOhQqfYob+kzMzOZOXMmd9xxBxkZGcybN48RI0Zw+vTpQtfxnDlzWLp0KZ07d8bBweEWb6uDBw/y1FNPsWrVKu6++24uXbrE888/D8Abb7zBsWPH8PHxYePGjQwaNAidToeLiwtnz55lx44d7Nq1C0BN/FoQSZLYsmULycnJhSZ6HnvsMRwdHfntt99wd3fno48+4r777uPSpUvFep8tXbqUTZs2sWHDBm677TaWLl3Kli1b1InGqka+sSqfXq+36jxT2pjMcrTnhRlNB00DqLsamCQTX174kjWn1pBjMntJjW07lvG3j8fLsWo9nCuqgUmS+fl0NEv/uERGXAKjg3cxJPwIesmc4Nn5nnvwHDsGl7vvRtCX8TM75hTsfAPC9pv/NjhDp9HQfTL43FZR0yyirl4LNYmmQd3RwOJV+TQ0NDQ06j7Zxmx6ft2zyo4XlxVH7297l7nf32P+xsngVKFzyLLM7t27+f3335k+fbrqqeTl5aV68gQEBDBr1iz1O9OnT+f333/n+++/p2fPnri7u+Pq6opOp1O/AxS7rSiTJk1Sy82bN2fVqlV0796djIyMQpN/77zzDvfeey9gnkAaMmQIOTk5xa6OePnyZdatW0e3bt1wdXVl5MiRhT7fsGED3t7enD9/nvbt26vbZ8yYwSOPPFJiXefPn8+cOXMYP348siwTGBjIW2+9xezZs3njjTfw9vYGwMPDo5DNLi4u6PX6YnWYPXs2r7/+Orm5uRiNRry8vJg8eTIAf/75J0ePHiU+Ph57e3sAlixZwtatW/nxxx955plnbjneihUrePXVV1U71q1bV+FwRg3bQpKqflU+xVvPVEdWRqsKm4raUZZNgiCoIUxKfeu7TRVZlU/Zx1pssrSdlPOUpEFt2BSaEsobR97gTMIZADo07MCUDlO4J+Ae9DdWnqvKdlLqVVq/ULAsyzJ7L8az+I9LhF9NZMSVAzx2ZR+OxlwAHDp1wnPMGJzvH4DB0bHQNXZLOyWFIu59G879ZG4M0YDcbhhyt2cQA7sjmStXI9ee0jcq/YI19nvlWZWvaL9Q322ytJ2q45lb0I7yYpvTgvUUURTx8fGx2dlc0DQATQMFTQfr0WDbtm24uLjg4ODA4MGDGTVqFG+++Wax+5pMJhYsWECHDh3w8vLC1dWVP/74Q111pDKcOHGCoUOHEhgYiKurqzr5FBkZWWi/O+64Qy0rrs/KKmJgXvnExcUFJycn2rRpg6+vL1999RVgnqgaPXo0zZs3x83NTQ25K3qObt26lVrXM2fO8NZbb+Hi4oKrqyuenp4888wzxMbGkpWVVSH7//Of/3D69Gn27NlDz549Wb58OS1btlTPl5GRQYMGDdRcUi4uLoSFhamrwhQkNTWV2NhYeva8OTmq1+vLtKsyCIKAwWCwam8pa6UmVuVzc3NDFLVV+Tw8PGx+VT57e3ubX5VPluU6sSqfUTLy0cmPeOx/j3Em4QwOOgfGBY7jg/s+oLNbZ2JjqqedRFEkKyurXKvynQhPYvTHf/PMpqM0P/I7G3Yt4qmLv+NozEXfrBnSzJcJ/OQT7O8fQMSNNii2nTISyNv6EsLaHnDuJ2QEsgL7wxNfkXTPu8TZB4Io1ui1FxISQsOGDdU2q+5rryZsqsiqfD4+Pja/Kp+Pj0+tr8onyLaQKbQGSUtLw93dndTUVNzc3Kr02JIkERcXh6+vb73/IVpRNA00DRQ0HW5q4O7uTkREBM2aNVO9diwJ5TsRd4Lndz9f5n4f3PcBXX27lrqPpaF8EyZMIDo6mg8//BA7OzsaNWqkJnFOSUnB09OTvXv30rdvXwAWLVrEkiVLWLFiBR06dMDJyYmXXnoJOzs7tm7dCpg9dVasWKE+mEvaVjDHVGZmJkFBQQwcOJCpU6fi7e1NZGQkAwcO5NSpU3Tq1EnNMZWcnIyHhwcAp0+fpnPnzoSFhdG0aVM2bdrEiy++yMmTJxFFc8y+o6Ojes62bdsSFBTEK6+8QqNGjZAkifbt27NlyxaGDx+u5phSzqmwadMmZsyYoQ4MHB0dmT9/Po888giyLJOfn69OyjRv3lx9U6UcV+HNInmgFJo2bcqMGTOYMWMGYB5sdOjQgcOHD9OuXTvee+89Vq9ezb59+25pQw8PDxo2bFjo2KmpqXh4eLB//3769Omj7jtixAhkWVbbqiopqoOlKAO7gvcRVO9zXaMwitbKPVZVb2/z8/NJSEjAz89PfWNc214rteUxde3aNby9vTEYDFZhU0U8pq5du4aPjw96fdV74tRFb4iiZTD/0PT19S1Wg5qy6dL1S7x55E3OJp0FoKN3R56941l6+fdCr9NX67UnyzKxsbH4+fmh0+mKtSMsMZPFv1/kt3+vcVfMv0y48BuNMxIA0Pv64jF6NO6PjkTn6Vl6O+WkIR9Zi3hkDeRlmBugSQ+k7lOgzUOI9k61du0ZjUYSEhLw9fUFsMp+ryybTCaTOjEjCIJV2FQRj6mEhAS8vb0RRbFKbUpOTsbLy6tcYygtlK+eYTAYarsKtY6mgaaBgqZDyRoIglDukLrejXrj6+RLfFZ8sXmmBAR8nXzp3ah3mTmmKoKzs7PqmVMWhw4dYtiwYYwbNw4we1BdvnyZ22+/vVJ1uHjxIklJSSxatIgmTZoAcPz48QodSxTFYu1JSkoiODiYjz/+mHvuuQcwh8hVhC5duhAcHEzLli2R5eJzKxkMhltcqO3s7MrlVt2kSRNGjRrFq6++ys8//0yXLl24du1aocTqpeHu7o6/vz9///23OjFlNBo5ceIEXbp0scxYC9C8pawDZQBe8KVDZcpKrjmlXHB7aWVBsK7VqSRJws7OzqpsKs6Oslbls7Ozq/JrrDZtKlouq16SJGFvb19hDSprU76Uz8azG1l3Zh35Uj5OeieeavcUY28bi4eDh/q96rr2TJLM36FJhMam0zzbjp7NGxaqb1JmPit3X+bbY1HcFn+F5ed+pW2y2atZdHXF47HH8BwzBrvGhROT39JOpnw4/hnC/vcQMs0TWni3gR7Pwh2jEO1vpgiozWvPzs5OnZApzg5r7yNEUVRfaBXUoD7bVJF2MhgM6qRUddlUFjYxMTVixAj27dvHfffdx48//ljos7CwMCZNmkRcXBw6nY6//voLZ2dnli9fzieffIIsywwYMICVK1fW+oBXFEUaNmxYq3WobTQNNA0UNB1ualDZVfl0oo45PeYwc99MBIRCk1MC5n5vdo/Z1TIpZSmtWrXixx9/5PDhw3h6erJs2TLi4+MrPTEVGBiInZ0dq1evZurUqZw9e5YFCxZUUa3NeHp60qBBA9avX4+/vz+RkZHMmTOnQseaN28eDz30EIGBgTz66KOIosiZM2c4e/Ysb7/9NmD2gtq9ezd33XUX9vb2eHp60rRpU8LCwjh9+jSNGzfG1dVVzRlVlJdeeon27dtz/PhxBgwYQK9evRg+fDjvv/8+rVu3JiYmhl9//ZURI0YUG6L30ksvsWjRIlq1akXbtm1ZtmyZ6vFVHQiCoE1WaxSL9rwwo+mgaQC1q0Hw9WD+e+i/XLh+AYAuPl3MXlKNetXI76wdZ2OZ/7/zxKYq46YQ/N0deGNoO+5q2ZD1B0L55GAYPklX+e+57fSMM9dTsLfHbehQvMaOwb5t29LrKklwfgvsXgDJN8KY3AKgxxTo/BQ4N6heIy1Aux80DaDuaFCuianSErAW5aeffqpwZaqLl156iUmTJqnLhRdkwoQJvP3229xzzz1cv34de3t7EhISWLNmDefOncNgMNCnTx/++usvevXqVQu1v4kkScTGxuLv719oVtKW0DTQNFDQdLipgaenZ6WPNSBoAMv6LmPR0UXEZcWp232dfJndYzYDggZU+hxVweuvv05oaCgDBw7EycmJKVOm8PDDD6sx7hXF29ubTZs28dprr7Fq1Sq6dOnCkiVLePjhh6uo5uYH/7fffsuLL75I+/btadOmDatWraLvjTBFSxg4cCDbtm3jrbfe4r333sNgMNC2bVs1WTmYV8WbOXMmH3/8MQEBAYSHhzNy5Eh++ukn+vXrR0pKChs3bmTChAnFnqNdu3Y88MADzJs3j+3bt7N9+3bmzp3LxIkT1bCoPn36qCEARfm///s/YmNjGT9+PKIoMmnSJEaMGKHmJqhqKhvKV1+o72Oy2kB7XpjRdNA0gNrRIN+Uzyf/fsL6f9djlIw4G5yZ0G4CY24bg5t9zYRI7zgby3NfnkSQJTokhuKVm851e1fOy82Z+uVJXOz1OCQnMvXiDgZEnkBEBlHEdcAAPMeNxalbN4Sy9ArdZ15pL/a0+W9HT+g6AbpOAs/AarbQcrT7QdMA6o4G5coxNXHiRLUsyzJbtmzB3d1dfUN64sQJUlJSeOSRR9i4cWP11bYS7Nu3jzVr1hTymDp37hwvvfSSumy2QkJCAt26dePMmTM4ODjQp08fvvnmG1q0aFHmeao7x1RKSgoeHh42feNoGmgagKYD3NTAwcHhlhxTFcUkmTgZf5KErAS8nbzp4tOlTnhKlUTBlWSseTKiNDQNzFRWh/qSY8oaxmQlUV1aa88LM5oOmgZQ8xpcSLrA64de51LyJQC6+3bn2Y7P0sOvR409s0ySzN3v7aHZhWNM/Wcr3jk3X5AkOLizqd1gmqZdY3jonxgkIwBOd96J55gxuPbri1CWN27sP7DrTQjZbf7b4AgdR0O3yeBXOY/u6kS7HzQNoHo1sOS5Xi6PqYIDm9mzZ/P444+zbt06NWbQZDLx/PPPV2gQceDAARYvXsyJEyeIjY29JVErmFdrWbx4MdeuXaNjx46sXr2aHj16WHyuoly+fBkXFxeGDh1KdHQ0jz76KK+99hre3t7MmjWLwMBA9Ho9U6dOLdekVHUjiiJeXl61XY1aRdNA00BB0+GmBpUN5SuITtTR3a97lR2vuhEEQU2WbqtoGpixFR2qc0xWV1ASrVZVcllZlvH09KxTCagra1NFE+Z6enqq57IWmyxtJ09PTzURurXYZGk7KQt4FKdBVdlklI2s/2c9n579FJNswsXgwsR2Exl922hc7Fxq9No7GnadZheO8frRW6NnGuakMuvktyhTZPa33Ybnk0/i/uBgZIMBbtSl2Ha6Hoa85x3Esz+Y7ylRj3Dbw8jdJiM36Ymo19fp+0npGwH1xY419nul2QTg5eVVqI3ru00VaScvLy8kSVLPVZU2lReLp8Q2bNjArFmzbklqNXPmTDZs2GDp4cjMzKRjx46sXbu22M+/++47Zs6cyRtvvMHJkyfp2LEjAwcOLLQ0d6dOnWjfvv0t/2JiYko9t9Fo5ODBg3zwwQccOXKEnTt3snPnTpKTk9m2bRvh4eFER0dz+PBhDhw4YLFtVY0kSURFRakXhy2iaaBpoKDpoGkA5kFVXl6eOriwRTQNzNiiDlU9Jqst1q5dS7t27eje3Twprozxqmo57tDQUEJDQ5EkqdaW464LS4xLkkRYWBhXrlyxGpssbSdJkrh06ZJqnzXYZGk7SZLEuXPnVPuqw6Ydp3Ywatso1v+7HpNs4k7/O1lx9wr6OvXF1d61xq+98NhEpv6zFYCiPlrCjX9GQSRiwovkzX8TpyEPIjo4lNhOof8ehd/mwJru6qSUsVk/Ivp9AI+sJ9O7I+GRkdVqU1W006VLl4iMjCQvL89q+72ybAoLCyMqKoq0tDSrscnSdrp27RpRUVHEx8dXuU1KvcpDuUL5CuLp6cmmTZsYNmxYoe0///wzEyZM+H/2zjs+qir9/+97Z9J7ISEJSehNegmCa0MUQUFEBBERhLXt4ldFV939ufYOAgqs2BD7Yq8rKk1AejQgQkJ6QggppNfJzD2/P4Y7JJCETEidOZ/Xixcnd2buPZ/3c2fmzrnneQ6FhYX27K5uZ5Szl7YeM2YMo0ePZtWqVYD1h1hkZCT33HOPXUVj60vl27VrF0888QQ//vgjAEuWLAGsBWO3bt1qGyxbsmQJQggeeuihs/ZbXV1NdXW17e+SkhIiIyNbfKlji8WCoiiUlJTg7e1tS1Vo7zsubT1CrKoqRUVF+Pj4YDx1F6Kze7I3ToqiUFRUhK+vr22Vnc7uqTlxslgslJSU4O/vb/sh2tk92RsnnYG7u7stBcnDw8PGQ58p0JBqP94Z27r0u3wdpV8t4cneOHVkBs311Jzj1E7ls3c/lZWVpKWl0aNHD9vqNIpi31LHba3WvCZrD+lT/lv6GspsNlNaWmrbZ2f9zJfXUPIaqiXipH+u+fn51cvgfDzViBpei3uNdYfXoQkNX1dfFgxcwE0Db8LT6Nlu76cNH/yPHs/9o8HPHl1lz7/KiKnjG46TuRJ2/wd+fQXFVAaAiBiFMuYORP+paAbXTvV+slgslJaW4ufnhxDCIT/3zuVJ0zRKS0tt3++O4MneOAkhKC0txcfHB0VRWtSTPddQds+Yuu2221i4cCHLli1jx44d7Nixg5dffpm//vWvdeoetIRMJhOxsbFMmHC66K6qqkyYMIFdu3ad9/5Hjx5Nbm4uhYWFaJrGtm3bGDBgAJGRkezcuZOqqiosFgtbt26lX79+9e7j+eefx8/Pz/ZPX2a8pe/2paamUl1djb+/PykpKR3ijktLeLJ3hFhRFDw9PUlJSXEYT/bGSX/T6zMCHcFTc+KUm5trG7B1FE/2xik9Pd1W6NlsNtt+ZFdXV9vaVVVVddpgnVlSu60Prtdua5pm41K7bbFYqKmpOattNpvrtM1ma42GmpqaOm19Sm/ttslksn3p1W7X9tGYJ/2L2JE82Rsno9HocJ7sjZM+0NRcTzU1NbZ2c+/2tbXa8pqsLaVfgKuq2qS2oiiNto1Goy2Vr3YNMr1de7vehnMvMd5Yu6l9b66n+nycy5OiKAQEBNhSXh3Bk71x0hnoz3EET/bGSVEUAgMDG2TQXE+HCg4x87uZrP1zLZrQGBc+jtXjV7NgyAK8XLza5f2UVVTJw5//wSc/xdEU9TZW1x8nzYzht3UoK0egbHnWOigV1AcmL0W59SsYMgvF1aPTvZ/0z0ZVVR32c+9cngwGg622kqN4sjdOOgODwdAqnpoqu2dMaZrG0qVLeeWVV2w/ssLCwrj33nt54IEH7Dr4WZ1R6s6YOn78OBEREezcubPOingPPfQQv/zyC3v27GnSfidMmMCBAwcoLy8nMDCQTz/91La/H374gYceegghBFdddRXLli0D4P/9v//HF198gaqqXHHFFbzyyis2wLXVljOmAI4dO0Z4eDhGo9G2XT9R2vqOS0t40k/ipo4QK4pCRkYGERERuLi4OIQne+MEkJGRQbdu3Ww/Rju7p+bEyWw2c+zYMaKiomzvv87uyd446QxCQkJsMz2cbcaUENaV2FxdXTtMv87XU3PiZDKZOiyD5npqznF0Ds3ZT2ecMdWa12TtodYsfp6ZmUlkZKTtc90ZJTlIBtDyDKrMVaz6fRXvH3kfTWj4ufnx18F/ZWbfmXi6eLZAj+1XYbmJ1VuSeG93Ol0LjnPP758xqDDtnK+LevddvMbUqmMsBBz+GjY/DSetKbD4hMPohTBiHnh3aR0DbST5fpAMoHUZ2PO9bvfA1JkHAlrs4qG1BqbaUq25eo84Y5qdM0oykAx0SQ6nGbi4uNh+UJ/vqnydTfoAYe07Nc4mycCq8+XQWVbla0gtfU3WHmot1vL7wirJQTKAlmXwW85vPLbzMdJL0gG4OOJi7hp6F0O6DGmJrtqt8moza3ek8vq2FNwL87kl/ieuzNyHeurnroCzakzp2126dqX3po0o+oB+2g74+THIirX+7e5nHYwavRACureBm9aXfD9IBtC6DFp8Vb4zZTab2bp1K8nJydx8882AdRDJ19cXb2/v5uyyXgUHB2MwGGwpL7pycnLo2rVrix2ns0hRlE59wdkSkgwkA12Sw2kGLbkqX2eToiidblZIS0sysMpZObTVNVlnlvy+sEpykAygZRhU1FSw8veVfHjkQwSCALcA/jrkr8zoM6NdZkmZzBr/3ZfBq5uSqCooZObRzUxL3YGLxZrO7RkTg9sFF1C4bp31BbXnZSgKChD6r39aB6VOHIJNT0LiT9bHje4wZBaM/it0HQwONHgh3w+SAXQcBnYPTKWnp3P11VeTkZFBdXU1V155JT4+Prz44otUV1ezZs2aFuucq6srI0eOZNOmTbZZVJqmsWnTJhYtWtRix+ks0jSNtLQ0unfv7tRTDSUDyQAkBzjNwBkH6nUJIeqkbzmjJAOrnJFDW16TdWbJ7wurJAfJAM6fwb4T+3js18c4VnYMgMu6XcadQ+5kUJdBLd3Vc0rTBN8cOM7LPyeQk1fCdcnbmZW0BS9TJQBuAwYQcMst+E2ehOrhgWcXMzmr38dcfnofRk9B6N/n4hvTH768Cw78FxCgGGDAFIi5HaLGgQOeL/L9IBlAx2Fg98DUvffey6hRozhw4ABBQUG27ddffz2333673R0oKyuzLVsL1iKjcXFxBAYGEhUVxeLFi5k3bx6jRo0iJiaGFStWUF5e3qmLejZXiqIQEhLiNBfc9UkykAx0SQ6SgS69kK8zSzKwytk4tPQ1maNKflZaJTlIBtB8BhU1FSyPXc5/E/4LQKB7IHcMuYPpfabjYfRoja42KCEEWxPyeHFDPEePF3Flxn6eT/iJoErrQjEuUVEEzJmD3/XTMOozQQ5/g2/GS/hcI6jIc8VcZcDobsGzSw1Kxovw6sugWWdY0fNya8pe36vB4NKm3tpS8v0gGUDHYWD3kNj27dt59NFHbUVWdXXv3t22+pQ92r9/P8OHD2f48OEALF68mOHDh/PYY48BMGvWLJYuXcpjjz3GsGHDiIuLY8OGDYSGhtp9rM4uRVHw9vZu95OmPSUZSAa6JAfJAE6nb7U0gxMnTnDllVfi5eWFv79/k1/31Vdf0bt3bwwGA/fdd1+929atW2fXPs+l1mJQe/9fffVVq+y7JZSWloaiKBw4cKBBDlu3bkVRFNtKl46ilr4mc1TJz0qrJAfJAJrHYHf2bqZ/M902KHVF1BW8PuF15gyY0+aDUrHpBcx6Yze3vbOXwN928vqWl7kv7lOCKosxBAcTvGgR0R9+QNC8W08PSmkW2PAwIFBU8Ao14RddiVeoCUU9ldanmSFsGExbA7M/ts6WcuBBKZDvB5AMoOMwsHtgStM02wpxtXXs2DF8fHzs7sBll11mW7mq9r91eg4wsGjRItLT06murmbPnj2MGTPG7uM4giwWC0lJSfXydxZJBpKBLsmhdRgIi4XyPXsp/u57yvfsRbQy3/nz56Mo1lUGXVxc6NGjBw899FCT62YJIaiqqmpwBbju3buzYsWKOtv0QQr9X2hoKDfccAMpKSm25yxfvpzs7Gzi4uI4evRok/3ceeedzJgxg8zMTJ5++ul6t82aNcuufZ5LOoPanvz8/LjooovYvHlzix2nqZo/f74t/V6XPngUFxdXZ/sTTzxh67PBYCAyMpI77riDgoKCJh8vMjKS7OxsLrjggkbPBUdUS1+TdRTpq5Jqmtakth7zhtomk4nExEQsFgsWi8W2XW8LIc5qA4229eM31G5q35vrqT4f5/JksVhITEzEZDI5jCd746QzqKmpcRhP9sbpXAxq+yitLuXJXU9y+0+3k1WWRbBHMP+K+RfP/+V5+gf1b1NP8dnF/PXd/dzw2i4q9u1j+fZV/Hvvu3QrzUX18cF/3jwiP/yALov+jiEoqK6n9F+h5Djn1GX/xDJ4JsLo3u5xOle7Jc49/bPRbDY7jCd741RTU0NSUhJms9lhPNkbJ51BTU1Nq3hqquwemLrqqqvqXOQrikJZWRmPP/44kydPtnd3UnZIVVUiIiKcNv8VJAOQDHRJDi3PoOSnn0i6YgIZ8+Zx/MEHyZg3j6QrJlDy008tsv+GdPXVV5OdnU1KSgrLly/n9ddf5/HHH2/y68+cLdJUJSQkcPz4cT799FP+/PNPpkyZYvsCTU5OZuTIkfTp04eQkJAm7a+srIzc3FwmTpxIeHg4Pj4+9W7z8PBo8j6bKp3BO++8Q3Z2Nr/++ivBwcFce+21dQbc7JH+47W1dcEFF5CdnU1GRgbvvPMOGzZs4O67727y6w0GA127dsVoNDb7XOiscpRrstWrVzNw4EBGjx4NQG5uLgD5+fnk5+cD1oVv9AHL7Oxs2+y3rKwsiout6TuZmZmUlpYC1sHQ8nJrIZmMjAyCg4NRVZXk5GTbua3/INM0jcTERDRNw2w2k5iYCFjfA8nJycDpVRsBysvLSUtLA6C0tJTMzEwAiouLbTPVioqKyM7OBqCgoMC2kE9LeUpNTbUN4DfVk6qqdOnSxdZ3R/Bkb5xUVcXX19fmwxE82RsnVVVxdXW1+WjI01cHvuL6r6/ns6OfAXBFxBWsmbCG0S6j4VTGW1t4OlZYwb0f7WfSKztI2v07T+56iyU7XqN/QTq4uuIydSpR766D+fMo9/Kq11NFjvVY55SprMPECVr/3EtOTiY8PNzmzxE82RunzMxMIiIibG1H8GRvnPLz84mIiLC1W9KT3q8mSdipzMxMMXDgQDFgwABhNBrFhRdeKIKCgkS/fv1ETk6OvbtzOBUXFwtAFBcXt3dXpKSknESVlZXi8OHDorKystn7KP7xR3G4/wBxuF//uv/6DxCH+w8QxT/+2II9Pq158+aJ6667rs626dOni+HDhwshhIiOjhbLly+v8/jQoUPF448/LoQQQtM08fjjj4vIyEjh6uoqwsLCxD333COEEOLSSy8VWFeBtv0TQogtW7YIQBQWFtr2+eGHHwpAxMfHi+jo6DqvmTdvnhBCiJdfflkMGjRIeHp6im7duom7775blJaW1tln7X8NbXvnnXeEn5+f7dhJSUli6tSpIiQkRHh5eYlRo0aJn3/+uY7n6Oho8eyzz4rbbrtNeHt7i8jISPH666/XeQ4gvvzyS9vfWVlZAhBr1qwR+fn54qabbhLh4eHCw8NDDBo0SHz00Ud1Xn/ppZeKv//97+Lee+8VQUFB4rLLLqt3vxkZGeLGG28Ufn5+IiAgQEydOlWkpqYKIYR4/PHHm8Th0ksvtT1/6NChdfqxePFiERAQUGfbm2++Kfr37y/c3NxEv379xOrVq22PpaamCkD8/vvvtm3ff/+96NOnj3B3dxeXXXaZeOedd86K+Zlq6H3Ukb/XHe2aTGetx8lisQiLxXLOtqZpjbbNZnOjbU3TzmoLIRpt68dvqN3UvktP0lNH81RUVST+vePfYtC6QWLQukFi/Cfjxfoj60VlTWWbesorqRRPfHNI9P7X92L0ovfEqxPmiD/7nbpOGTBQZN7zf6Jk1y5hrqk5d5x2vCrE477n/peyrdPEyRHPPenJ8TwVFBQ0+RrK7iqh3bp148CBA6xfv54DBw5QVlbGwoULmTNnDh4ebZtj7GyyWCwkJyfTq1cvp1wSGyQDkAx0SQ6nGURERJz1mBACUVnZpP0Ii4WcZ56tu3zy6R2BAjnPPofX2LHWpZQbkeLhcV456ocOHWLnzp1ER0c36fmfffYZy5cv5+OPP2bQoEGcOHGCAwcOAPDFF18wdOhQ7rjjjnMWgta/v0wmE/v27ePWW2/F19eXV155xfaYqqq8+uqr9OjRg5SUFP72t7/x0EMP8Z///Idx48aRkJBAv379+Pzzzxk3bhyBgYH1btPvZOkqKytj8uTJPPvss7i5ufHee+8xZcoUEhISiIqKsj3v5Zdf5umnn+Zf//oXn332GXfffTeXXnopffv2pbq6ulFPVVVVjBw5kocffhhfX1++//575s6dS69evYiJibG95t133+Xuu+/m119/rZdTTU0NEydOZOzYsWzfvh2j0cgzzzzD1VdfzcGDB3nwwQc5cuQIJSUlvPPOOwAEBgayd+9eYmJi2LhxIxdccEGDM5vS0tL48ccf6zz+4Ycf8thjj7Fq1SqGDx/O77//zu23346Xlxfz5s2zPU8Ia0pjbm4u06dP5+9//zt33HEH+/fv54EHHmgw9p1ZjnpNps8CrT0b9HzaYL37fOb3xbnaeoppfW39c66hdkv1vaG2PT70du3vTUfxVJ+PxjydycARPJ3ZPle/GmOw4/gOntz5JLmVuSgoTOw+kTuH3EnvgN5t5qncZOHt7cm8uT0FtaSY245uZErqLoynCpN7jhtHwOzZ+Fx2KYrL6RpQ9fo+/jvqxichZQuNSwHfcIgeh0HtGHE633ZTYgNnfzZ2dk/2xknTNI4ePXoWg87syd44WSyWsxi0hqdzye6BqW3btjFu3DjmzJnDnDlzbNvNZjPbtm3jkksusXeXUk2UqqpER0c7feqSZCAZgOQApxlop/K+a0tUVpIwYmTLHEiAOSeHo6NjzvnUfr/Fonh62rX77777Dm9vb8xmM9XV1aiqyqpVq5r02oyMDLp27cqECRNwdXUlKirKNtASGBiIwWDAx8eHrl27NriP7Oxsli5dSkREBP369cPV1RU3Nzc8PDzqvE4vZg7W2lXPPPMMd911F//5z39wdXW1pecFBgbaXlfftjM1dOhQhg4davv76aef5ssvv+Sbb75h0aJFtu2TJ0/mb3/7GwAPP/wwy5cvZ8uWLfTt2/esgZ6KigoeffRRDAYDl156KRERETz44IO2x++55x5+/PFHPvnkkzoDU3369OGll15qkNX69evRNI233nrLdoHzzjvv4O/vz9atW7nqqqvw8PCgurq6jt8uXboAEBQUdBaHP/74A29vbywWi23q97Jly2yPP/7447z88stMnz4dgB49enD48GFef/31OgNTYE1pfO211+jVqxcvv/wyAP369eOPP/7gxRdfbNBXZ5W8Jmua5PeFVZKDZGDRLMTmxpJNNkW5RYwMHYlBNVBcXcyLe1/k25RvAejq1ZW7ht7FtT2vxc3g1iZ9qzZb+GhPBqs2J1FWXMr1yduZmbQVjxrr94L7oEEE3HILvldPRHV3b3xnJ5Nh89Pw55fWv1UjRIyEzD2AgnXyrq5TN9OufgHUpv+IdgQ5+/sBJAPoOAzsHpi6/PLLyc7OPqs+RnFxMZdffrlTFyJubSmKgptb23w5dFRJBpKBLsnhNIOmFgrvqLr88st57bXXKC8vZ/ny5RiNRm644YYmvXbmzJm88sor9OrVi6uvvprJkyczZcoUjMZzf71169YNIQQVFRUMHTqUzz//vNEaRRs3buT5558nPj6ekpISzGYzVVVVVFRU4GnnYFxtlZWV8cQTT/D999+TnZ2N2WymsrKSjIyMOs8bMmSIra0oCl27diU3N7fOXbDZs2djMBiorKykS5cuvP322wwZMgSLxcJzzz3HJ598QlZWFiaTierq6rP6PXJk44OZBw4cICkp6azC2lVVVbZaB/aqX79+fPPNN1RVVfHBBx8QFxfHPffcA1hrJSQnJ7Nw4cI6s97MZjN+fn519qMoCqqqEh8ff9YiKWPHjm1W3zq65DVZ0yS/L6ySHJybwcb0jbyw9wVyKnJs20I9Q7mm5zV8k/wN+ZX5KChM7jGZO4bcQU//nm3SL4sm+Doui2U/HyX7ZBlXp+/hlqMb8a8sAcC1e3frgNR1UzGea1GH0hPwy4vw23vWVfZQoPcVMPqv0PtKSPifdXW+2oXQfcOtg1IDp7aeyQ4qZ34/6JIMOg4DuwemhBD1pmmcPHkSr1MF56RaR5ZTq2j06dPHqVOXJAPJACQHOM0gMjLyrMcUDw/6/RbbpP1U7N9P5h13nvN5kW+8jueoUY0+R2lG+pCXlxe9e1vTBNauXcvQoUN5++23WbhwIaqqnrXKmr6SEFgHl+Li4tixYwcbN27kb3/7G0uWLOGXX37BxaXxZZ63b9+Or68vISEh51zBLC0tjWuvvZa7776bZ599lsDAQHbs2MHChQsxmUznNTD14IMP8vPPP7N06VJ69+6Nh4cHM2bMOKv4+Jl+9CnoegobWFcTnDBhAn5+frZZSgBLlizhlVdeYcWKFQwePBgvLy/uu+++s45xru/xsrIyRo4cyYcffnjWY7WPZ49cXV1t8X/hhRe45pprePLJJ3n66acpKysD4M033zxrsOnM970Qgsompq86iuQ1WdMkvy+skhycl8HG9I0s3roYQd3v05yKHNYeWgtAuFc4dw27i2t6XIOrofUXkhBCsDk+lyU/JhCfXcLFxw/w9JEf6VqWB4AxNBT/2bPxv3EGLkFBje+ssgh+fQV2vwbmU98DkRdCzF+h/xRwOTXDauBU6H8NltQdnEiKo2vvYRh6/MXpZkrpctb3Q21JBh2HQZMHpvQp9IqiMH/+/DqjahaLhYMHDzJu3LiW76GUTaqq0qtXr3afZteekgwkA12Sw2kGZrP5rMcURWlySp3XRRdh7NoVc05O/XWmFAVjaCheF110zhpT5ytVVfnXv/7F4sWLufnmm+nSpYtt5RCAkpKSs1b48Pf3Z8qUKUydOpW///3v9O/fnz/++IMRI0bg6ura4KyRHj164O/v36R+xcbGomkaL7/8su2c++STT5pn8gz9+uuvzJ8/n+uvvx6wDv6cWYfqXNK/k7t27Wob5DnzGNdddx233HILgK2mwsCBA+06zogRI1i/fj0hISH4+vrW+5z6mOsz0Zoyg+fRRx9l/Pjx3H333YSHhxMeHk5KSkqdVLWG5ObmRv/+/fn222/rbN+9e/c5X9uZJK/J7JP8vrBKcnBOBhbNwgt7XzhrUKq23A3urLlyDT38erRJn/anFfDihnj2pRUyLC+RlYf/R+9C6+phqp8f/jNmEDB7Nq7dzq6hWUc1lbD3Tdj+MlQVWbeFDIQxd8KgGeDmffZrVANqz0sIiRqHajTCedTF7OxyxvfDmZIMOg6DJh/dz88PPz8/hBD4+PjY/vbz86Nr167ccccdfPDBB63ZVynOLubpjJIMJANdkkPLMFAMBkL/9c9Tf5xxgXbq79B//bPVB6V03XjjjRgMBlavXs348eN5//332b59O3/88Qfz5s2rczdn3bp1rF27lkOHDpGSksIHH3yAh4eHrXh69+7d2bZtG1lZWbYlcJuj3r17U1NTw8qVK0lJSeH9999nzZo15+0VrHWdvvjiC+Li4jhw4AA333xzvXXDGtO5Cs736dOHn3/+mZ07d3LkyBHuvPNO25LH9mjOnDkEBwdz3XXXsX37dlJTU9m6dSv/93//x7FjxwAr84MHD5KQkEB+fj41NTWEhITg4eHBhg0byMnJsS01XJ/Gjh3LkCFDeO655wB48sknef7553n11Vc5evQof/zxB++8806dOlS1Odx1110kJibyj3/8g4SEBD766CPWrVtnt9eOLHlNZr/k94VVkoPzMfgt97c66Xv1qcpSRX5l878jm6r4EyX89d19zFizi4K4Qzy3802e//V1ehdmori74z9zJtHvvUvoPx5sfFDKYram660cCT//2zooFdAdrnoG5n8PI+fXPyhVS852HjQkyUEygI7BoMkzpvTVdbp3786DDz4op4i3gzRN6xDT7NpTkoFkoEtyOM2gvlQ+e+V71VXwygpynnse84kTtu3G0FBC//VP6+NtJKPRyKJFi3jppZdITEwkNTWVa6+9Fj8/P55++uk6M6b8/f15/vnneeCBB7BYLAwePJhvv/2WoFPT/p966inuvPNOevXqRXV19VlpgU3V0KFDWbZsGS+++CL//Oc/ueSSS3j++ee59dZbz9vvsmXLWLBgAePGjSM4OJiHH36YkpISu/Zxrjpjjz76KCkpKUycOBFPT0/uuOMOpk2b1ugAUX3y9PRk27ZtPPzww0yfPp3S0lIiIiK44oorbDOobr/9drZu3cqoUaMoKytjy5YtXHbZZbz66qs89dRTPPbYY1x88cVs3bq1wePcf//9zJ8/n4cffpi//vWveHp6smTJEv7xj3/g5eXF4MGD6xSjr80hKiqKzz//nPvvv5+VK1cSExPDc889x4IFC+zy2pElr8nsk/y+sEpycE4GeRV5Lfq85iizoILlPx/ly7gsupbl8/CRH7ns2O/WBw0GfK66isBb5uAxfDhKYz+QhYAj31oLm+cftW7zCoFRt8HI28A3rEn9ccbzoD5JDpIBdBwGimjuVbpUvSopKcHPz4/i4uIG0xyaKyEEmqahqup5LcfemSUZSAa6JIfTDEwmE2lpafTo0QP3c61Uc659WixU7I/FnJeHsUsXPEeNbLOZUs1R7a8wZz4PdDkrAzh/DlVVVaSmpp71PmrN73Wpumot1vL7wirJwTkZfHzkY57b+9w5n7d24lpGdx3dosfOL6tm1eYkPtyTjld5CbMTNnJN+m4MmjWt2+svfyHg5tl4X3IJyrkWLUndBhufgKxT9TPdfGH4LdbC5kG97OqXM54H9UlykAygdRnY871ud/FzgM8++4xPPvmEjIyMswqn/vbbb83ZpVQTpZ80zizJQDLQJTlgd8rXuaQYDHiNiWnRfba2GioA7UySDKxyRg7ymqxpkt8XVkkOzsOguLqY5bHL+Tzx80afp6AQ6hnKiJARLXbs0qoa3tqeylvbU9DKy5mV9AszUrbhVlMNgMewYfjPmYPvVVeinms1sOwDsPFJSN5k/dvoDoNvtA5IhQ1tdo0oZzkPziXJQTKAjsHA7qO/+uqr3HbbbYSGhvL7778TExNDUFAQKSkpTJo0qTX6KHVKmqaRnJzc4j9EO5MkA8lAl+QgGeiqrq5u7y60uyQDq5yNg7wma5rkZ6VVkoNzMBBC8HXS10z5coptUGpgkHWhC4W6gzj63w/HPIyhBVamqzZbWLsjlUuXbGX1z0e44sgvvLvpReYk/IxbTTWuvXsR+sQTRL39Fv5Trm18UKogBT5bCK9fYh2UUgwwcBrc8jlMeRXCh53XoJSjnwdNkeQgGUDHYWB3Kl///v15/PHHmT17Nj4+Phw4cICePXvy2GOPUVBQwKpVq1qrr51Ccsq/lJRUW6uhFCQpKammqzOm8nXEa7LU1FQWLFhATk4OBoOB3bt3N7kGVkdmLSXVGZRUmMQze54hNsea7tbNuxsLBy/k2p7XsiNrBy/sfaFOIfSunl15OOZhJkRPOK/jWjTBl79nsfznoxwvLOfSY3EsSPiRLmUnATCGhxEw+2b8Z9yAMSCg8Z2V5sC2lyB2HWinVh3udQWMXgh9rgKDy3n1VUpKqu3Uqql8GRkZtiWIPTw8KC0tBWDu3LlceOGFTj8w1ZoSQmAymXB1dXW6VAVdkoFkoEtyOM3AmUsFCiFs6VvOfB44OwNwTg4d8Zps/vz5PPPMM1x88cUUFBTgdq40nTaQ/L6wSnJwXAaV5kpeP/A67/75LmZhxs3gxg19bmDeBfMI9w4HYEL0BC6PvJzYnFiyS7MJ8wljZOjI85opJYRg45FclvwYz9ETpYzMTeDR+B/oXpgFgCEgAP8bb8T/plm4hoc3vrOqYti5EnathpoK67bIGBh9OwyYCi4td+PNUc8DeyU5SAbQcRjYncrXtWtXCgoKAIiKimL37t2A9Q6ZM/84agtpmkZ6enq7T7NrT0kGkoEuyUEy0HVmXR1nlGRglbNx6GjXZH/++ScuLi5cfPHFAAQGBmI8V0HjNpD8rLRKcnBMBlsztzLtq2m8fehtzMLMyNCRLLt0GQ+Nfsg2KKXLoBoYGTKSAQxgZMj5DUrtTS1gxppd3P7efog/zEu7XueZXW/RvTALxdMD/9mziXrvPUIW39/4oFRNFexcBa8Mg21LrINSXQbAtcvhli9hyMwWHZQCxzwPmiPJQTKAjsPA7quF8ePH88033zB8+HBuu+027r//fj777DP279/P9OnTW6OPUqdkMBjo27dve3ejXSUZSAa6JIfTDKqqqgCc8uaAoihOn74oGVh1vhw64/unpa/Jtm3bxpIlS4iNjSU7O5svv/ySadOm1XnO6tWrWbJkCSdOnGDo0KGsXLmSmBjrggmJiYl4e3szZcoUsrKymDFjBv/6179awup5SX5fWCU5OBaD7LJsnt/7PFsytwAQ7BHM/AvmM6PvDLxcGk6fPV8GR7JLeGlDPFsS8ogoy+PRIxu4KOuA9UGjEd9JVxMwZw4eQ4c2PvtCs8CBj2HL81ByzLrNP8o6Q2r4LeAZ2Ow+nkuOdB6cjyQHyQA6DgO7B6beeOMN22ja3//+d4KCgti5cydTp07lzjvvbPEOSp2WEIKqqirc3d2deqqhZCAZgOQApxm4uFjrLVRUVODh4dHOvWpbOWP61pmSDKw6Xw4VFdbUEf391BnU0tdk5eXlDB06lAULFtQ7sLV+/XoWL17MmjVrGDNmDCtWrGDixIkkJCQQEhKC2Wxm+/btxMXFERISwtVXX83o0aO58sorz9vr+Uh+X1glOTgGgxqthvcPv89rB16jylyFQTFwTc9ruO2C2+gd0Pucr28ug4yTFSz7OYGvDxzHv7KEe+J/4ur0vahCA0XB69JLCLj5ZrzHjUNpbKakEJDwP9j0FOTFW7d5BcPI22DUAvA9R8pfC8gRzoOWkOQgGUDHYWB38XOpxtWahTstFoutMKvBcP4rZ3RGSQaSgS7JoS6D3NxcioqKCAkJwdPT02m+XDtKXnx7SjKwqrkchBBUVFSQm5uLv78/YWFhdR531oLciqKcNWNqzJgxjB492la7StM0IiMjueeee3jkkUfYtWsXTzzxBD/++CMAS5YsAeAf//hHvceorq6us5JiSUkJkZGRFBYW4u/vbxt0U1W10bY+GNlQ22QykZ6eTs+ePW2vUxQFi8ViWx679lLZmqZhMBgQQjTYFkKgqmqD7ab2vbme9L431K7PE0BKSgrR0dG4uro6hCd74ySEICUlhe7du+Pi4tLpPMWeiOWZPc+QVJQEQP+A/iwcvJDxUeMxKsYm9f1cDM70kV9mYuWmRD7el4FLVQU3Jm7lhpTtuJitqdMeI0cQcPMcPMdfjvHUrNUGPaXuwLD5KTi21/qmd/NBDJuDGLkANaRfm517+ipkPXv2xGg0tsm51xHfTzU1NaSnp9OjRw8URXEIT/bGyWw2k56eTvfu3VFV1SE82Rsni8VCeno60dHRGAyGFvVUWFhIYGBg6xQ/f+edd/D29ubGG2+ss/3TTz+loqKCefPm2btLqSbKYDDQu/e574Q4siQDyUCX5FCXQdeuXQHIzc1tzy5JSXVa+fv7295HnUVteU1mMpmIjY3ln//8p22bqqpMmDCBXbt2ATB69Ghyc3MpLCzEz8+Pbdu2NTpz6/nnn+fJJ588a7s+SJifnw9ASEgIOTk5uLi4EBwcTHZ2Nh4eHgQGBpKVlYWPjw/+/v5kZmYSEBCAr68vaWlphISE4O3tTUZGBt26dcNgMHD06FGio6Nxc3MjMTGRXr16oaoqiYmJ9OnTx/aDtX///rYBLT1lOisri969e1NeXk5ubi49e/aktLSUwsJCoqOjKS4uprS0lMjISIqKiqisrCQiIoKCggJqamoICwtrMU+pqalERETg4eFBcnJykz1FRUWRlpbmUJ7sjVOXLl04ceJEp/J0JO0IXxZ8yVdJXwHg4+rDrJ6zuDLwSgb2GEhRUZFdcfL29qa4uLhRT/HJaXwdX8b7+45TU1nFtak7uSVpM55V5QC49e1L5XXXEXrDdDz8/YmPj2/Yk38N2k+PY0jZBIAwuFHYcwqBl99DuU8vcvPy6BlCm557RqORqqqqNj33Otr7KSUlxeYpKSnJITw1J069e/empKTEoTzZG6fevXvbfkO0pKfU1NQmX2fYPWOqb9++vP7661x++eV1tv/yyy/ccccdJCQk2LM7h1Nr3lkVQlBeXo6Xl5fT3hWXDCQDXZJD/QwsFgs1NTXt3LO2kz7bxZlmiZ0pycCq8+Hg4uLS4MzLjjxjqjWvyc6cMXX8+HEiIiLYuXMnY8eOtT3voYce4pdffmHPnj0A/PDDDzz00EMIIbjqqqtYtmxZg8doqxlTZrOZyspKvL29bXeenWE2xJmeVFWlrKwMDw8PjEajQ3iyN06KolBWVoanpycGg6HDe1JUhS8Sv2BF7AqKTcUAXN7tchYMWcCQoCG2vtgTJ0VRKC0txcvLq14GJrPGB3syWL0lieLyasZnxnLb0Z8JLLMutGCMiCBgzhz8p1+P4uPTuKfCNMTmZ1EPfQYIhKKi9L8WMeqvaFFjMbi4tsu5B9ZBMG9vb1RV7RCzVtrj3LNYLFRWVuLl5YUQwiE82RsnTdOorKzE09OzWe+njujJ3jgJIaisrMTDwwNFUTrPjKmMjAx69Ohx1vbo6GgyMjLs3Z2UHRJCkJubS/fu3Z32x4dkIBnokhzqZ2AwGJwqtVHTNLKzswkICLB9aTubJAOrnJFDR7wmmzRpEpMmTWrSc93c3HBzc2vlHp3+rPTyarggtDNI5xAVFdXeXWk36Qyio6Pbuyvn1NHCozy39zni8uIAiPKJYuGghUzqMQkPFw/bD017ZNEE+9JO8mfyMQb0iGBs7y4otR77LPYYr2xM5HhRJTE5R7g9fgPdio4DYAgKwn/mTHxvnIFbWJjtB2i9KsuFHS9D7DpUzXqzTPS8HG3kAgz9J4FqBK39VgCTnwlW1b6OdFbV/kxw9t8TUVFR7crA7iu3kJAQDh48eNb2AwcOEBQU1CKdkqpfqqrSs2dPp7ngrk+SgWSgS3KQDEAyAMlAlzNyaMtrsuDgYAwGAzk5OXW25+TknHcK5OrVqxk4cCCjR48GTqck5+fn29IlcnJyKCiwztjIzs6mqKgIgKysLIqLrTNJMjMzKS0tBSAtLY3ycmvKUXp6OuHh4aiqSnJyMiaTtTZOYmIiZrMZTdNITExE0zTMZjOJiYmANX0xOTkZgKqqKltKQnl5OWlpaYB11kVmZiYAxcXFZGVlAVBUVER2djYABQUFNm4t5Sk1NdW2ImtTPamqSrdu3Ww+HMGTvXFSVZWgoCCbj47oqaKmgpf2vMRN399EXF4cbgY3bgi/gbUT13JV+FVkZ2Y3K06f7jrKRS9s4ua39vLsluPcsnYff3lxMx9vP8yX+1K4esU2Hv78D/xS4lmx8zWe3L2WbkXHUb28UG6cQZe33iTk3v/jWEVFw57KCxGbn0VZORxl35soWg1lwcPg+tcxTV9Hskt/MLi0+7mnqtZaQpWVlW127rW2p+ace8nJyXTv3t3mzxE82RunjIwMevbsSXl5ucN4sjdOeXl59OzZk4KCghb31KqpfA8//DDr16/nnXfe4ZJLLgGsU8YXLFjAjBkzWLp0qT27czi1dipfaWkpPj4+Tj2iKxlIBiA5gGQAkgFIBrpai0NHTuVrzWuyM1P5wFr8PCYmhpUrVwLWWWpRUVEsWrSIRx555Ly8wGnWrZHKV15ejq+vr9On8pWUlODl5eXUqXwlJSV4e3t3uFQ+IQSb0jfx4v4Xyamw/viN6RrDggsWENM1BhejS7Pj9NPhHO7+4DcUoXFBfgqB1aUUuPnwZ3BPNMXaj6iSEyxM2EBM1iEAFBcXfCZPJmDOzbhdcEGjPhSLCW3vmyg7lqFUnARAdOkPo29HG3wjBg+/DvV+Amyf6c6eyldeXo6Pj49Tp/KVl5fj7e1t60tn99ScVL7apUE6TSrf008/TVpaGldccQXGU0uBaprGrbfeynPPPWfv7qTskBCCwsJCvL29nfbHh2QgGeiSHCQDkAxAMtDljBxa+pqsrKyMpKQk29+pqanExcURGBhIVFQUixcvZt68eYwaNYqYmBhWrFhBeXk5t912W4t5ag3p54aPj097d6VdpXPQa6k4o3QGHS2F61jpMV7Y+wLbsrYB0MWjC7cNvI0b+t2Ah9HD9sOwObJogie/PczY439w18Gv6FJVbHssz92Pj/pfSf+CDK7M3IcqBCgK3uPH4zd7Nt4XjkE1Ghs+vmaBg/+Frc+jFltnZgi/SLRRC1GHzwWvoHZN2WtI8jPBqtrfm86q2p8JznLtcKZqfzd0qlQ+V1dX1q9fT3x8PB9++CFffPEFycnJrF27FldX19bo43kpMzOTyy67jIEDBzJkyBA+/fTTOo9/99139OvXjz59+vDWW28BkJCQwLBhw2z/PDw8+Oqrr9qh93WlqirR0dFOlaZwpiQDyUCX5CAZgGQAkoEuZ+TQ0tdk+/fvZ/jw4QwfPhyAxYsXM3z4cB577DEAZs2axdKlS3nssccYNmwYcXFxbNiwgdDQ0PPy0RapfKGhoTKVT1UJCwtz+lQ+f3//DpPKV11TzYtbX+T6b65nW9Y2DIqB63tfz2uXvcYY1zF4unied5x++j2ZHkf28ejedwmuNSgFEFxVzP/FfcbEjL2oQqCMGIHfiy/QbfkyCiO7UVZRUb+nykpI+AHzqgtRvv4bFGdS4xaI+aLFaPN/ILHLJDSPgA77ftJnkMhUvmQiIyOdPpUvOjra6VP5oqOjO18qX23pL+3Io4vZ2dnk5OQwbNgwTpw4wciRIzl69CheXl6YzWYGDhzIli1b8PPzY+TIkezcubNOXYaysjK6d+9Oenp6k+6utHYqX3FxMX5+fh2aeWtKMpAMdEkOkgFIBiAZ6GotDh05la+2OsM12bnUmql8paWltn06S5pOfal8RUVF+Pj4OHUqX1FREb6+vu2eyhebG8sze54htdj6w21g4EAWDFrAFdFXYFAMLXbuffN7JoELZxFcVUxDnw4m1cCxux5m4sLpGE7NmmjQU+qvqJufQsncDYBw9UYZdjOWkQtQQ/p3ivcTYPuccfZUvtLSUvz8/Jw6la+0tNT2/e4InpqTyle7FEJ7pfI167bie++9x+DBg/Hw8MDDw4MhQ4bw/vvvN2dXra6wsDCGDRsGQNeuXQkODraN/u3du5cLLriAiIgIvL29mTRpEj/99FOd13/zzTdcccUVHWLKr37SnMdYYqeXZCAZ6JIcJAOQDEAy0OWsHDrTNVl7yVnPjTMlOXQMBicrT/Lor4+y8KeFpBan4uvqy9+G/o01E9YwIWoCRtXuSisNKq+0moPfb6NLI4NSAK6ahZDIrqgeHg0/KedP+GgWhncnWwelDK5oQ2bD3G9g0ksQ3LfF+t3a6gjnQUeQ5CAZQMdhYPfA1LJly7j77ruZPHkyn3zyCZ988glXX301d911F8uXL7e7A9u2bWPKlCmEh4ejKEq9KXOrV6+me/fuuLu7M2bMGPbu3Wv3cQBiY2OxWCxERkYCcPz4cSIiImyPR0RE2Ka46frkk0+YNWtWs47X0lJVlcjISKdKUzhTkoFkoEtykAxAMgDJQJczcmjpa7L2Uluk8nXp0kWm8qkqoaGhTp/K5+vr2y6pfIlJiXx0+COmfDWF71K/Q0FhQtQEnurzFHcMvgNvo3eLnXvxKZk8/8MRLlmylZSEpqXS9DZW1++pMJ3yD26BNX+BoxsQioq57zVw86ckXXA/ppBBoCid6v2kz5KSqXzJREREOH0qX2RkpNOn8kVGRna+VL4ePXrw5JNPcuutt9bZ/u677/LEE0/YdXCAH374gV9//ZWRI0cyffr0s1aAWb9+Pbfeeitr1qxhzJgxrFixgk8//ZSEhARCQkIAGDZsGGaz+ax9//TTT4SHhwNW6BdffDFvvvkm48aNA+Czzz5j69atrFq1CoAlS5agKAoPPvggYJ1S3rt3bzIyMnB3d2+Sn9ac8q9pGkVFRbZpp84oyUAy0CU5SAYgGYBkoKu1OHTkVL6WviZrb7VWKl9NTQ0lJSUEBATYUhmcIU3nTE96WoWvry8uLi4O4cneOIE1hcvPzw9jraLere0pviCep3Y9xaGT1hXvuvt2Z+HghUzqPgmjYmyxc6/cZOGt7Sm8vSONsqoaRufEc8/hb+hSknfO91/Uu+/iMXrUaR+luSjbl6LsXwtajfVJPS/DMuI21H6TUFzcOm3amxCCgoICAgICMBgMHSKdqj3eT2azmZKSEvz9/QEcwpO9cbJYLLbvHj2NrbN7sjdOmqZRUlJiW6WyvVL57J4rmp2dbRvYqa1x48bZRt7s0aRJk5g0aVKDjy9btozbb7/dtuLLmjVr+P7771m7dq1taeK4uLhGj1FdXc20adN45JFH6vQ9PDy8zgyprKwsYmJibH9//fXXXHXVVY0OSlVXV1NdXW37u6SkBMAWwJY8aQEqKytt+Z/O8IFZ30VVRUUFPj4+tv52dk/NuaiqqKiwfXg4gqfmxqmioqLeHy+d2ZO9cdIZOJIne+JksVioqKjAz88Pi8XiEJ7sjZOmaVRWVuLn52d7bWf31Jw4QdM/G+311FHV0tdkHUX6uaL/f75tg8Fgu3trMBjqbG+srShKg21FURptt1TfG/Nkb1vTNKqqqggICHAYT/X5aMzTmQxa21OlpZLVsav5KP4jNKHhYfRgZt+ZzB04l1CvsxcNaO65V1Wj8d6uNNb8kkxhRQ0DT6ZyV+KP9DlxepVNAfWm8wnApWtXPEeNRFFVqC6FXatRd64EU5n1SREjYPQdcME0DC6n0/066/tJCEF1dbVt/21x7rW2pzPbTfVRVVWFoii21zqCpzPbjXlSVZXKyso6N7U6u6fmxOlMBq3h6Vyy+5Zi7969+eSTT87avn79evr06WPv7hqVyWQiNjaWCRMm2LapqsqECRPYtWtXk/YhhGD+/PmMHz+euXPn1nksJiaGQ4cOkZWVRVlZGT/88AMTJ060Pd6UNL7nn38ePz8/2z89TbClp6GnpqZiMpmIiIiwtcHxp5jWNw29S5cuTj8N3dvbu8OsKNNe515eXh7u7u6oquownuyNU0ZGhu1LxFE8NWcaelhYmM2fI3hqzjT0iIgIp56GnpOTg6qquLq62ny0xzT0tlZbXpO1pfSBRE3TmtTWb9o01BZCEB4ejqpa03f07Xpbv2teu62/rqG2fvyG2k3te3M91efjXJ5UVSU8PLwOl87uyd446Qx0tZYnTdPYkLaBqV9N5YMjH6AJjQvDLuSVy19h8ajFBLsHt4inSlMN7+1K45IlW3j+h3j8s9N5Yf86Xt6+mj4nklBcXPCZMoUuixdbf5QqZwxNnfqxGvLPR1CEGW3Xa4hXhsHW58FUhgjuA5OXot3yFWLoTeDi0SZxau1zT1WtK1TqP9QdwdOZ7aZ40j8ba9+E6eye7I0TWMv56APXjuDJ3jjpDGr/3ZKemixhpz777DNhMBjExIkTxVNPPSWeeuopMXHiRGE0GsUXX3xh7+7qCBBffvml7e+srCwBiJ07d9Z53j/+8Q8RExPTpH1u375dKIoihg4davt38OBB2+Nff/216NOnj+jVq5d4/fXXbduLiopESEiIqK6ubnT/VVVVori42PYvMzNTAKKwsFAIIYTFYhEWi+WcbU3TGm2bzWZhNptFXl6eMJlMdbZrmiY0TTurLYRotK0fv6F2U/t+Pp4aa9fnyWKxiNzcXGEymRzGk71x0hnU1NQ4jKfmxKmmpkbk5ubatjmCJ3vjVJuBo3iyN04mk0nk5ubaPiMdwZO9caqpqRF5eXm2z0hH8NScONnz2WiPp4KCAgGI4uJi0dHUmtdkbalVq1aJAQMGiL59+wpAJCQkCCGEyMnJETk5OUIIIY4fPy7y8vKEEEIcO3ZMnDx5UgghREZGhu2aKy0tzRan5ORkUVpaKoQQ4ujRo+LYsWPCYrGIhIQEUVVVJYQQ4siRI8JkMgmz2SyOHDkizGazMJlM4siRI0II6zWe3peKigqRmJgohBCitLRUJCcnCyGEKC4uFmlpaUIIIQoLC0VGRoYQQoiTJ0+KY8eOCSGEyMvLE8ePH29RT4mJiaKiokIIIZrsyWKxiKysLBEfH+8wnuyNk8ViEampqTZ/reFpx6EdYuEPC8WgdYPEoHWDxBXrrxAfHv5QHDp8qMU81ZgtYt22BDHmmR9F9MPfiQsXrRNvTZwj/uw/QBzu118cHjBQZCxaJDJ/3iiOn/KX/eq/xNER/ayPn/p3dER/cWzFw6L017eEWD5IiMd9rf9eHiByv3tWFJ9Ia5c4tfa5Z7FYxMGDB0VJSYnDeGpOnA4fPixycnJEVVWVw3iyN05JSUkiLy9PFBUVOYwne+OUlZUl8vLyRHZ2dot7io2NbfI1lN01psBaRHz58uUcOXIEgAEDBvDAAw8wfPhwe3dVR4qi1KkxpRcn37lzJ2PHjrU976GHHuKXX35hz54953W81lBr15jKyckhNDS0znQ5Z5JkIBnokhwkA5AMQDLQ1VocOnKNKWi9a7L2UGvWmMrLy6Nr16622RLOkOp8pidFUThx4gRdunRx6hpTJ06cICQkpMVrTNVoNaz9cy1vHXwLk2bCqBqZ2nMqCwYtINovukU8WSwa3x08ziubkkjJLyewspjbkjczPmU3qmadmeA5bhx+s2bhN/5yxKk0GjX+O8QntyI0QWWeK+YqA0Z3C55dTKCeTvETnkEw4laUUQvRfCM6dPr2+Zx7Qgiys7Pp2rWr09eYysvLIzTUmlbqCJ7sjZPFYiEvL4+QkBBbal9n92RvnDRNIy8vz7ZISEt6sqfGVLMGplpLZw5MmUwmPD09+eyzz+oURJ83bx5FRUV8/fXX7dPRRtTRL2ClpKSkpKSkmi75vd52kqylOqt2Hd/Fs3ueJb0kHYBBwYNYMGgBl0dejlG1u6TvWRJCsPFILi//lED8iVK8TRXMSf2Fa5O2Y6yxpk97DB+O/+zZ+E68CtXN7fSLNQusGAQlxxs5ggKjFkDMHRDS/7z7KyUlJQX2fa836ZNSL+jdFLXkhYSrqysjR45k06ZNtoEpTdPYtGkTixYtarHjdBZpmkZ+fj7BwcFOe1dcMpAMdEkOkgFIBiAZ6HIWDu11TdaZ5SznxrkkObQ8g7yKPJbsW8IPaT8A4O/mz60Db2Vmv5n4ufmd9/6FEPyadJKlPyUQl1mEm7maW9J+5cakrbhWVQDg1q8fAXPm4HfNZFQvr7N3kr7zHINSAAIumOY0g1LyvWCV5CAZQMdh0KSBKX9/f1txuIYkhKhTOK2pKisrIynp9IoRqampxMXFERgYSFRUFIsXL2bevHmMGjWKmJgYVqxYQXl5uW2VPikpKSkpKSkpZ1FrXpN1FOlpAy2ZKqEnCDhTmk59qXx66ore387uqTmpfPpzzseTQPDf+P+yKm4VZTVlKChcFX0VCwcvpF9AvzpFtZvraV/qSZZtTGR3SgFGzcy0jL3MTdqEZ5l18QaXqCj8b74Z/+unYfD1rVOEuE5/S7ObttpVWW6HiVNrn3t6vxr7XOhsnpoTJ/2zUf9ccARP9sbJ9p6u9bnQ2T01J5VP33dreGqqmvQ5tWXLFjZv3tzoP/059mr//v0MHz7cVgth8eLFDB8+nMceewyAWbNmsXTpUh577DGGDRtGXFwcGzZssOXCOpNUVSUkJMRpR3NBMgDJQJfkIBmAZACSgS5n4dCa12TtpdWrVzNw4EBGjx4NtPzKxunp6fj6+qKqqlOtWlrfysb+/v5Ov7Kxm5vbea1svDttNzf/72Ze2PcCZTVl9PLrxT8H/JN/DvsnA4IGnLenQ1nFzF+7h5lv7GFvcj5XHovlg1+WcmfcF9ZBqS5dCP6//yPwzTcov/wyjKfSZOqLU1H6IUz73qdJ8g7tMHGC1j33VFWloqKCyspKh/HUnDglJycTHBxs8+cInpqzsnFISIhTr2ys19gqKChocU/2rGzcoWpMOYJk8fPWlWQgGeiSHCQDkAxAMtDVWhxk3aO2kyx+Louft8WMqeYWPy8zl/Hqb6/yScInCASeRk9m9ZvFLQNuIdgj+Lw9JeWWseznBH44lANCMDbnMH9L/pngvGMAGPz98ZsxA7+ZM3GPimw8TmW5qL8uR+xfi2Kx/tAVnC5yXlsCBXzDUe77Aw2lQ8Sptc89IWTxc5DFz/WZYrL4eccoft6kVL6DBw825WkADBkypMnPlbJfLi4u7d2FdpdkIBnokhwkA5AMQDLQ5QwcnOGaTL8Arz3AeD5tg8GAq6urrV17e2NtRVEabOvpQA21W6rvjXmyt61pGq6urg7lqT4fjXnSGdhzjimKwv9S/8eSfUs4WXUSgIvCL2LBoAWM7jradozmesoqqmbFpqN89XsWmoAheUnck7qRbsetpU5ULy98p11HwE2zce/Tu06/zopTZSHqr6/CnjVQU2EdiAobBhGjUPa/feqVteckKNbnXP0CqIY6qTTtGacz2y19vgkhcHNzs+3fETyd2W6qD1dXV9uAjKN4OrPdmCdVVXFxcTmLQWf21Jw4ubi42AalWsvTudSkGVP6iNe5nqqPkDmz5J1VKSkpKSkpx1FH+1535GuyjsZaSiq1OJVn9zzLnuw9AIR5hbFw0EKm9p6Kh9HjvPZ9oriKVzcn8sm+TMyaoHfRMe5N/Zne6X8CoLi64nvNNfjPvgmPwYPPGgCro+pS2L0Gdr4K1SXWbV0GwOiFMHgmePjB4W9gw8N1C6H7RlgHpQZOPS8vUlJSUvWpxVflsyc3UKr1pGka2dnZhIWF1RmVdCZJBpKBLslBMgDJACQDXc7CQV6T2S9nOTfOJcmh6QyqzFW89cdbrD20lhqtBhfVhem9p3PrBbcS5Rt1Xn04WVbNf7Ym8/7udExmjYjSXO5N38zgpP3WJxgM+EyYQMDNs/EcNQqlsRkHNVWw/23YvgwqrLVhCOgBo/8Kw24Gz8DTzx04Ffpfg5b2K0WZ8fhH9kftfhGoTZ/R4CiS7wWrJAfJADoOgyYNTEVHR7d2P6SaKA+P87s74wiSDCQDXZKDZACSAUgGupyBgzNck+n1LFqyhoe7uzsgV+Vzd3d3+lX53N3dbfupr787s3fy7O5nOVZmre00NHgotw2+jcu6XYaCUue1dtVaKavirV/TeOfXNCpMFoIriliUsYWYo7tQNA0UBc+//IXA2Tfh9Ze/IAwGlIY8CQvi9w9g20sop2ZACd8IlFEL0IbNBe8uDfhToPtf0HwHovn7o6qGDhmn1j73ANzc3GznhCN4ak6c9M9GvdaSI3iyN06apuHh4WFrO4Kn5tSY8vDwaDVPTVWzh8QOHz7Mhg0b+Oabb+r8k2o9qapKYGCg047mgmQAkoEuyUEyAMkAJANdzsyhs1+TtcWqfJ6enqiqXJXP29vb6VflMxgM9a7Kl3A8gUU/LeLujXdzrOwYAa4B3D/ifp4c/CRDPYdiUA3N8nSypIzVW5K4+KUtrN6SjLG0hAcSv+PdzS8yJv5XFE3DY+RIQpcsoeK+e/EZP54aIer3VFpC/ub/wKrRKN/dZx2U8gqhYsz9HJv8IVzyIEVml0bjpKoqNTU1Nh8dMU6tfe6pqkpJSYlclS852bbQhKN4as6qfIGBgU6/Kl9gYGDnW5UvJSWF66+/nj/++KNOjQN99Lmz1TNoabX2qnxZWVlEREQ45YU3SAYgGeiSHCQDkAxAMtDVWhw6ct0jR7sma81V+bKzs+nWrZvtjrEzzIY405OiKBw7doywsDCnXJXPbDHzW+5vJGQl0De8L6PDRqOgYNbM/Dfhv6yOW02FuQJVUZkYPZEFAxfQv0v/ZnuqNmt8sCuN17alcLLMhEdNFfOzdjI5fgvGKuuAiNuAAfjPmYPfpKtRPT0b9mSxYEj8AbH5WZS8IwAIjwDE0JtRRy9EBPZscpwAjh07Rnh4eL0rE7Z3nNri3BNCkJmZSbdu3Zx+Vb7s7GwiIiIA512VLzs7m/DwcBTFeVflq53K15KeWnxVvtq699576dGjB5s2baJHjx7s3buXkydP8sADD7B06VJ7dydlhxRFwcfHx3bB6YySDCQDXZKDZACSAUgGupyRg6Nek+kX4LUHGM+nbTQa8fX1tf3o0OUMK27Vbgsh8PX1xWg0Ooyn+nzU52lTxiZe2PsCORXW2Q4chlDPUG7qfxMbUjeQUJgAQG//3tw+5HaujLoSF4NLs3xYBHy6L5OVmxPJLq7CxVLD3Oz9zIj/Gdcya2Fy1x498L/5Zvyum4qx1o+1s3wIgZK8GcPmZ+D4b9YV9Fy9YehNKKMWooQOtD4fmhwn/TzQj9WR4tSW556fn5/tb0fxZG+c9M9GfRDBETzZGyeDwYCPj89ZDDqzJ3vjpF8/GQyGFvHdqqvy1VZwcDCbN29myJAh+Pn5sXfvXvr168fmzZt54IEH+P333+3ZncOpI99ZlZKSkpKSkrJPHfl73dGuyToya6nOq43pG1m8dTGChn/yeLl4cXP/m5kzYA5BHkHNOo5FE3xzIIsVGxNJP1mBqlmYlhvHLfE/41FkTY8xhoURMHs2fjdMxyXoHMfJ2A2bnob0Hda/je4weAaMvh3ChoITDcJLSUl1TtnzvW73XHeLxYKPjw9gvSA6ftxacC86OpqEhIRmdFeqqdI0jfT09DpTcZ1NkoFkoEtykAxAMgDJQJczcpDXZE2TM54b9ckZOVg0Cy/sfaHRQSk3gxurxq/inuH3NGtQSgjBhkPZTHplG/evP0B6fjlX5v/Jx7tf5fbdH+NRlI8hMJCgO++k+0cfEnzH7Y0PSh2Pgw9mwNqJ1kEp1QUGzYBbvoQpKyF82HkNSjnjeXCmJAOrJAfJADoOA7tT+QYNGsSBAwfo0aMHY8aM4aWXXsLV1ZU33niDnj17tkYfpU5JURQCAgKcKk3hTEkGkoEuyUEyAMkAJANdzshBXpM1Tc54btQnZ+TwW+5vp9P3GlC1pRqBsJuLEIJfjubx8k9H+SPLWgz4wsIkFiX/TNAxa1Fi1dsbv+nTCZh9E249ejS+w7wE2PIsHP7a+reiQr/JMGoB9LgUDHb/bKtXzngenCnJwCrJQTKAjsPA7k+4Rx991FZx/amnnuLaa6/l4osvJigoiPXr17d4B6VOS1EUp5/aLhlIBrokB8kAJAOQDHQ5IwdHvSbT79q2VHFZTdNs9cecqbBxfZ58fHwczlNjccotz23SOZdXkWeXp31phSz5MYH96YUADC7O5L70jYSn/AmA4uaG75Qp+N00C4+BA1FVtWFPJ1NRt78EB9ejCA1QEL3Go424DUP/qxGqtUC5AVosTt7e3gghbDFo7zi1x7nn7e1ti7+jeGpOnPRZtxaLxWE82RsnX19f23ZH8WRvnHx9fdE0rUm+7fXUVNmdyjdx4kSmT58OQO/evYmPjyc/P5/c3FzGjx9v7+6k7JCmaaSkpLT7NLv2lGQgGeiSHCQDkAxAMtDljBwc5Zps9erVDBw4kNGjRwOQm2sdTGip5bhTUlJISEhA0zSnWgr+TE/6tqSkJIfx1FicCksK2ZK4haaoi2eXJnnaHJfMzW/sZNYbu9mfXkjP8hz+E/9fXtryinVQymiECRMIfu01wp56kmx3d6qrq+v3VJiJ+P4B1P+MRjnwMYrQKA0dAzPexjR9Hcku/cDg0uJx0jSNgwcP2vy1d5za49zTNI3Y2FjKysocxlNz4nT06FHbY47iyd44paamkpKSQklJicN4sjdOJ06cICUlhdzc3Bb3pPerKbK7+LlU42rNwp1CCMrLy/Hy8mr3qXbtJclAMtAlOUgGIBmAZKCrtTjIgtxtJ511YWEh/v7+LXZH2mw2U1lZibe3t+3Os7PMhjizXVZWhoeHB0aj0SE8NbT8+9asrby8/2WOlR1r9JxTUAjxDOHHG35E4fRqVGf2Pf5EKSs2JvLTYeuP0rDKQh48/gsD/tyJommgKHhdeikBN8/G88ILUV1cGvZUWYi2fRnKvjdRzNYfbyJiFIxagNb/Ogwe3q167imKQmlpKV5eXhgMhk47w+N8zj2w/mj39vZucDZbZ/PUnDhZLBYqKyvx8vJCCOEQnuyNk6ZpVFZW4unpaetLZ/dkb5yEEFRWVuLh4YGiKC3qqbCwkMDAwCZdQ8mBqRaWvICVkpKSkpJyHMnv9baTZC11vooviOelfS+x78Q+APzd/BnTdQw/plsHnmoXQdcHopZdtowJ0RPq3V9qfjnLfz7KtwePIwQEVpeyOHcnI+K2oFjMAHiOGYP/TTfhe8V4FFfXhjtXVQK7Vlv/mayzDAgdBKMXwuAbwc2nBQhISUlJdRzZ873eMlX0pNpEFouF1NRUevTogcFgaO/utIskA8lAl+QgGYBkAJKBLslBqiHJc8MqR+aQX5nPqt9X8UXiFwgELqoL1/a8lrkD59InoA9Xp1/NC3tfqFMIPdQzlIdjHq53UCqrqJJXNyby2W/HsGgCz5pK7ju5l4t+/xm12jrLyX3wYAJuvhnfqyeieng03DlTBex7E3Ysh0prTSqCesPov8KQm8AzoEVZnEuOfB40VZKBVZKDZAAdh4GcMdXCau1UvqqqKtzd3Z02XUMykAx0SQ6SAUgGIBnoai0OchZP26m1WMv3iFWOyMFkMfHBkQ944+AblNdY65uMDRvL3IFzGRc+DoN6+keWRbMQmxPL8ZLjhPuGMzJ0ZJ3HAXJLq/jPlmQ+3JNOjUXgaqnh7sLfuDJuA4Yy6ywn1969CLh5Dn5Tp2Lw9mq4c2YT/PYubFsKZSes2/wirTOkhs8Fr+CWhdFEOeJ5YK8kA6skB8kAWpeBnDHloFIUBY/G7sg4gSQDyUCX5CAZgGQAkoEuyUGqIclzwypH4iCEYFPGpjp1pHr69WTeBfOY1GMSHsb6fKpYKnqhVEZgMbpTew2oogoTa35J4d2daVTWWDBoFhaW/MF1BzbgUmgtBuzSrRv+s2fjP/16jAGNzHKymOHgevjlBSjKsG7zDoWR863/fMNbhEFz5UjnQXMlGVglOUgG0HEYyIGpTiSLxUJycjK9evVy6qmGkoFkAJIDSAYgGYBkoEtykGpI8tywylE41FdH6ub+NzOz30yCPILqfc2GQ9k8+e1hsourbNvC/Nx5aGI/MgoqeXN7CmXVZhShMassgZv++AH33OMAGIKD8Z81i4CZN+ISGtpwxzQNjnwNW56D/KPWbR6BMGIujFwAgd1bxP/5ylHOg/ORZGCV5CAZQMdhIFP5WlitncpnMplwdXV16qmGkoFkAJIDSAYgGYBkoKu1OMhUvrZTa6byyfdI5+dwrjpSDWnDoWzu/uA3FKFxQX4KgdWlFLj58GdwTzTl1KwpIbimMo35R37AOzMFANXXF/8bbiBg9k24RkU13DEhIPFn2Pw0nDho3ebmC0NnW9P2uvRrKQQtos5+HrSEJAOrJAfJAFqXgUzlc1ApioKbm1t7d6NdJRlIBrokB8kAJAOQDHRJDlINSZ4bVnVWDvbUkTpTFk3w5LeHGXv8D+46+BVdqoptj+W5+7FmyDSK3b35f8e3EJB0GADF0xO/KVMIuHk2bn37Nv5DLW0HbHoaMndb/3bxgMEzYdQCCBsKHfCHbmc9D1pSkoFVkoNkAB2HgXrup0h1FFksFuLj47FYLO3dlXaTZCAZ6JIcJAOQDEAy0CU5OI40TbP935S2Pvm/obbJZOLIkSNYLBYsFottu94WQpzVBhpt68dvqN3UvjfXU30+zuXJYrFw5MgRTCZTp/CkaRob0zdy3VfXsTx2OeU15fT07ckTY59gxeUrGBdmHZRqLE57UvLpcWQfj+59l+Bag1IAwVXFPLr3XZZuW20dlHJxwWfKFKLWvk3Ivx/FtU8fFEWp31NWLOK9abDuGsjcjTC4IobMgrnfoE1ehjg1KNWcOLX2uaefBzU1NW127rW2J3vPPZ2B2Wx2GE/NiZP+2Wg2mx3Gk71xqqmpIT4+HrPZ7DCe7I2TzqCmpqZVPDVVcmCqE0lVVXr16oWqOm/YJAPJQJfkIBmAZACSgS7JofNq9erVDBw4kNGjRwOQm5sLQH5+Pvn51sLTOTk5FBQUAJCdnU1RUREAWVlZFBdbBxwyMzMpLbWunJaWlkZ5uXV2TUZGBhEREaiqSnJysm1gJjEx0fZjJDExEU3TMJvNJCYmAtYBreTkZACqqqpITU0FoLy8nLS0NABKS0vJzMwEoLi4mKysLACKiorIzs4GoKCggJycnBb1lJqaSlWVtV5SUz2pqkpkZKSt7x3Z08aDG1nw4wLu33o/x8qO4e/mz91D7uax3o8xrdc0XHBpUpwOJKRz18GvADhz7pJy6p8ACmIuwWfZyxjuuxfPYcM4WVBQr6e8P7dh/mAWvDkeJWULQjHAwOvImvgOpVe8BFExpGVknFeczuXpfOOkqio+Pj622LTFudfans6M07k8qaqK0WiksrLSYTw1J07Jycn06NHD5s8RPNkbp8zMTHr16mVrO4Ine+OUn59Pr169bO2W9KT3qymSNaZaWK1dY0rTNFRVdeocWMlAMgDJASQDkAxAMtDVWhxkjam2k866sLAQf39/2x1aVVUbbSuKYpvZUl9bnxVhMBjqnCMWi8U2kKlv19sGg8F2TtXXFkKgqmqD7ab2vbme9L431K7Pk6qqtrvXRqOxQ3oqrC5kVVzdOlLX9LjGVkeqqXGqMgs+2J3Olv/+wONbVp/z3Ct7Zjkjp1/VsI+CFNRfXkT88SkKAhQV0XsCjLwNpc+VaIqhxeLU2uee/p5QVdX2nmjtc6+jvZ8AzGYzBoPB9r7o7J6aEyf980DvmyN4sjdOtd8XtVl0Zk/2xqn2cJCiKC3qqbCwkMDAwCZdQ8nbip1ItUdMnVWSgWSgS3KQDEAyAMlAl+TgONIvwFVVbVK79g+K+tqKopCUlGS7cNe3621FUc5q669rqK0fv6F2U/veXE/1+TiXJ03TSEpKqsOlo3gyWUy8e+Rdrv3qWj5P/ByBYGzYWF65/BWeGPcEfQP7NilOpdVmXvslhb+8uJnnf4jHrbSIpqi3m7n+vhdnoX5/P+rqGPjjE+ugVI9LYcY7KLM+QOk/GQwuLRqn+mLTknHSNM0208LeOHVUT+dqn+lDZ6D/IHcET82Jk/7ZqA9KOYIne+ME1tlJ+qCNI3iyN046g9p/t6SnpsrhZ0xlZmYyd+5ccnNzMRqN/Pvf/+bGG2+s85yKigoGDBjAjTfeyNKlSwHrtLMFCxaQk5ODwWBg9+7deHl5nfN4csZU60oykAx0SQ6SAUgGIBnokjOmOr9ac1U++R7pmByEEGzK2MTL+1/mWNkxAHr69WTewHlM6jkJD6NHk/ZTVGFi7a9prPs1lZIq6wy5fq4mHk74lrADu875+qh338VrTMzpDWV5sGMZ7HsbLNXWbZFjrKvsDZhqLXLeSdURz4O2lmRgleQgGUDrMpCr8tWS0WhkxYoVDBs2jBMnTjBy5EgmT55cZ5Dp2Wef5cILL6zzuvnz5/PMM89w8cUXU1BQ0CEq1UPdqXzOKslAMtAlOUgGIBmAZKBLcpBqSPLcsKojcYgviOelfS+x78Q+APzd/Jndfzaz+s0iyCOoSfs4WVbNWztSeX9XOmXV1gGpAe5m/i9vN913/ADV1kElwdk1pvTtLl274jlqpHVDZRHsXAm7X4NTKwASNtQ6IHXBDeDm3XzDHUgd6TxoL0kGVkkOkgF0DAYOH4GwsDCGDRsGQNeuXQkODrYV8gLrtLX4+HgmTZpk2/bnn3/i4uLCxRdfDEBgYCBGY/uP4enTTp05TUEykAx0SQ6SAUgGIBnokhykGpI8N6zqKBzyK/N5YucTzPx2JvtO7MNFdWFa72msnbiWvw37W5MGpXJLqnjmu8P85cUtvLY1mbJqMxd4aayp3MWyr56g+6avoLoa1z598JsxwzoodeZMgFOpMaH/+ieKpQq2vwyvDIHtS62DUsF9YfISuPUbGDHPoQalOsJ50J6SDKySHCQD6DgM2j2Vb9u2bSxZsoTY2Fiys7P58ssvmTZtWp3nrF69miVLlnDixAmGDh3KypUriYmJqX+HjSg2NpZ58+Zx6NAh27brrruOJUuWsHPnTg4dOsTSpUv56quvWLduHRaLhaysLGbMmMG//vWvJh1DTvmXkpKSkpJyHMnv9baTZO3YMllMfHDkA944+Ablp2YjjQ0by9yBcxkXPg6Deu5aJMeLKlnzSzL/3ZeJyWz9ETXYBxbl7yX6l+8QFRUAuPbqhf+sWfhdNxWjnx8la58jZ/X7mMtP78voBaF3z8Z3UIh1MKo8z/pAQHcYtRCGzQGvps3ckpKSkpI6W50qla+8vJyhQ4eyYMECpk+fftbj69evZ/HixaxZs4YxY8awYsUKJk6cSEJCAiEhIQAMGzbMtuJKbf3000+Eh4cD1qUQb731Vt58803b419//TV9+/alb9++7Ny507bdbDazfft24uLiCAkJ4eqrr2b06NFceeWVLW3fLgkhMJlMuLq6OnUOrGQgGYDkAJIBSAYgGeiSHKQakjw3rGovDi1RRyqzoIL/bE3is9hj1Fis99SH+av8/eQ+Ir/4BlFejgBce/SwDkhNuw6jv7/1xYe/wTfjJXyuEVTkuWKuMmB0t+DZxYRy7GU4duogPuEwaj6MmA8+oS2NocNIvh8kA12Sg2QAHYdBuw9MTZo0qU4a3ZlatmwZt99+O7fddhsAa9as4fvvv2ft2rU88sgjAMTFxTV6jOrqaqZNm8YjjzzCuHHjbNt3797Nf//7Xz799FPKysqoqanB19eXK6+8klGjRhEZGQnA5MmTiYuLa/eBKU3TSE9Pp1evXnZVuHckSQaSgS7JQTIAyQAkA12Sg1RDkueGVe3B4XzrSKXklbF6SzJfxWVh0awDUqOCjNxVsJ9un32FKCuz1onqHo3/zFn4Xz8NY0DA6R1oFtjwMCBQVPAKNZ19EEWFi+6FkQsgIKoFXHdsyfeDZKBLcpAMoOMwaPdUvtpSFKVOKp/JZMLT05PPPvusTnrfvHnzKCoq4uuvvz7nPoUQ3HzzzfTr148nnniiweetW7fOlspnNpsZPXo0mzdvxs/Pj+uuu44777yTa6+99qzXVVdXU32qsCJYp6tFRkZSWFiIv7+/LVdTX561oba+BGRDbYvFYquUX18b6hYt05dE1qvs19fWl8VsqN3UvktP0pP0JD1JT9KTo3oqLCwkMDBQppe1gWQqn+MovzKfVb+v4ovELxAIXFQXrul5DXMHzqVvQN9zvv5oTimrNifx3cHjnBqPIibUnbtO7iP8py8RJSUAuERGWmdIXT8Nl6B6BrpSt8O7Z1+/n6V530GPi+2xKCUlJSV1Dtnzvd6hi5/n5+djsVgIDa07nTY0NJQTJ040aR+//vor69ev56uvvmLYsGEMGzaMP/74o9HXGI1GnnvuOS655BKGDBlCnz596h2UAnj++efx8/Oz/dNnWeXm5to85OfnA5CTk2MrvJ6dnU1RUREAWVlZFBcXA5CZmUlpaSkAaWlplJdbk+FTU1OprKyksrKS5ORkTCbrHZ/ExETMZjOappGYmIimaZjNZhITEwHr4F5ycjIAVVVVpKamAtYUyrS0NABKS0vJzMwEoLi4mKysLACKiorIzs4GrKmQOTk5Le6pqqoKoMmehBAUFxc7lCd74ySEIDc3l2PHjjmMp+bGKTs7GyGEQ3myN04FBQUIIRzKkz1xOnr0KBUVFdTU1DiMp+bEqbKykpKSEofyZG+chBBkZWWRl5fXop70fkl1XgkhqKyspAPdi20XtQUHk8XE2kNrufbLa/k88XMEgrFhY3nl8ld4YuwT5xyU+vN4MXd/EMtVy7fxzQHroNS4MA/WuR7h6f/+P8I+exdRUoJLRARdFt9P9H8/JvivC+sflAIozW5ax8ty7HTaeSXfD5KBLslBMoCOw6BDz5g6fvw4ERER7Ny5k7Fjx9qe99BDD/HLL7+wZ8+edurpabXljCkhBGlpaURFReHi4uJQd6SbepcdICUlhejoaFxdXR3Ck71xEkKQkpJC9+7dcXFxcQhPzYlTTU0NaWlp9OzZ05YP3dk92Run2gz053Z2T/bGqaamhvT0dHr06IGiKA7hyd44mc1m0tPT6d69O6qqOoSn5sTJns9GOWOqY6q1ZkxZLBZSU1Pp0aOH06ZqQOtyEEKwOWMzS/cvbVYdqbjMIlZtTmTjkVzbtosjvfjryd/o+sNnaIWFABjDwvCfeSP+N9yAy6las/XKYoY/PoHNT0PJ8XMbcKIZU/L9IBnokhwkA2hdBvZ8r3fogamWSOVra8lp6FJSUlJSUo4j+b1un7p3746vry+qqhIQEMCWLVua/FrJunPqfOpI7Usr4NVNiWxPtM7eVBW4NNqXBQW/E/LderRTsx6NoaGnB6S6dm14h2YTHPgYdiyDwrRTGxWgoZ87CviGw31/QBNWBZSSkpKSaro61ap8jcnV1ZWRI0eyadMm28CUpmls2rSJRYsWtW/n2kFCCMrLy/Hy8rLNEHE2SQaSgS7JQTIAyQAkA12SQ8fRzp078fb2bu9u2CTPDatamkNz60gJIdiVfJJXNyeyO8U68KQqML6nH7cVHKDLB//Fkp+PBhhDQvC7cQYBM2bgEhbWcGfM1fD7+7BjBRRb039x94chs8A/Cn56VD96rRedYnD1C041KCXfD5KBLslBMoCOw6DdB6bKyspISkqy/Z2amkpcXByBgYFERUWxePFi5s2bx6hRo4iJiWHFihWUl5fbVulzJum1hbp37+7UbxzJQDIAyQEkA5AMQDLQJTlINSR5bljVUhxMFhMfHPmANw6+QXmNtS7b2LCxzB04l3Hh4zA0MMgjhOCXo3ms3JxEbPqp1DxVYULvAOYVHSTogyVYcnKwAIYuXfC/4Qb8Z96Ia3h4w52pqYTYd+HXV6D0VMqeRyAMvQlG3Apd+oOiWAenNjxcN63PN9w6KDVwarNZdEbJ94NkoEtykAyg4zBo91S+rVu3cvnll5+1fd68eaxbtw6AVatWsWTJEk6cOMGwYcN49dVXGTNmTBv3tGmS09ClpKSkpKQcR870vb5t2zaWLFlCbGws2dnZdcor6Fq9erXtmmzo0KGsXLmSmJgY2+M9evQgMDAQVVW57777mDNnTpOP70ysO6PqqyPVw68H8wfOb7SOlBCCjUdyWbk5kYPHrAsPuBgUJvYNYm7RHwR++SHmU4saGYKCTg9IdevWcGdM5bD/HeuAVPmpulRewTD0ZuuAVHCfs1+jWSB9p7XQuXcoRI9zqplSUlJSUm2tTpXKd9lll52zAvyiRYucMnXvTAkhKC0txcfHx6lHdCUDyQAkB5AMQDIAyUCX5HD+Ki8vZ+jQoSxYsIDp06ef9fj69etZvHgxa9asYcyYMaxYsYKJEyeSkJBAyKlC1Dt27CAiIoLs7GwmTJjA4MGDGTJkSFtbqSN5blh1PhyaU0dK0wQb/jzBys1JHMkuAcDNqDKpfzBzS/7E992XMR8/jhkwBATgN/16AmbNwjUqquGOVJfCvrdg5yqosNalwjsUht0Mw+dBUI+GX6saEN3/4vTngnw/SAa6JAfJADoOg3YfmJJquoQQFBYW4u3t7dRvHMlAMgDJASQDkAxAMtAlOZy/Jk2axKRJkxp8fNmyZdx+++22cgpr1qzh+++/Z+3atTzyyCMAREREABAWFsbkyZP57bffGhyYqm9lYzi9Cm9LrRxpNpspKCjA29vbtkKkM6xaeqYnRVEoKCjAw8MDFxeXJnnKrzhVRyrpjDpS/efSO6B3vX03WzT+dyiHVZsTScqzpvq5u6hcMyCEuWWH8Vq3DPOxY5gB1d8fv2nTCJh9E8Zu3Wz9PcuTqRT2vgG7/4NSaU0DFD7hKMPnIIbdguYX2aQ4ARQUFODp6YnRaOyQcWrtc+9cDDqjJ3vjJITg5MmTeHl5YTAYHMJTc+KkfzZ6eXkBOIQne+NksVgoLCy01VdyBE/2xknTNAoLC/H09LSt7tySnpoqtcnPlGp3qapKdHS07cR0RkkGkoEuyUEyAMkAJANdkkPrymQyERsby4QJE2zbVFVlwoQJ7Nq1C7DOuCotLQWsNUQ3b97MBRdc0OA+n3/+efz8/Gz/IiMjAcjNtaZm5efnk59vnRWTk5NDwakV2rKzsykqKgIgKyuL4mJrelhmZqbt+GlpaZSXWwdF0tPTCQ0NRVVVkpOTMZlMACQmJmI2m9E0jcTEROugitlMYmKizXNycjIAVVVVpKam2nympaUBUFpaSmamtdh2cXExWVlZABQVFZGdnQ1YBwFycnJa1FNqaipVVVUATfakqiphYWE2H415SklPYe2htVzz5TV8nvQ5AkFMlxieGfoMT4x9gkAReJanGovG25sPc8XLW7lvfRxJeeV4uqjcNCKCdcHp3Ln2EdyWPYf52DEUX18C5t2K8soKvBf9Hbfo6Po9VRRQ+MU/YMVglC3PolQWIvwiMV/yCAnj18H4RzF5hTU5Tqqq4u/vb4tNR4xTa597qqri5uZm8+EInuyNk/5DvbKy0mE8NSdOycnJREZG2vw5gid745SRkUF0dDTl5eUO48neOOXl5REdHU1BQUGLe9L71RS1e40pR1Nr1kcQQlBcXIyfn5/T3g2WDCQDXZKDZACSAUgGulqLg7PWPVIUpU6NqePHjxMREcHOnTsZO3as7XkPPfQQv/zyC3v27CElJYXrr78esM54uf3227n33nsbPEZ9M6YiIyMpLCzE39+/RWdMlZaW2vbpLLMhzvSkqipFRUX4+PhgNBrr9aQoCpsyNvHy/pdP15Hy7cH8C+YzsftEPIweZ/W30lTD57FZrNmWwrFC6w99H3cjUweFMrsiAY+P38V06seJ6uOD73VT8Z85C/c+vW3HPMtHaS7qntdQ9r4JJusPH+EfjRg+F2XYLeDbtVlxUhSFoqIifH19MRgMHTJOrX3uKYpCYWEhfn5+9TLojJ7sjRNg+5xRVdUhPDUnThaLhdLSUvz8/BBCOIQne+OkaRqlpaW273dH8GRvnISom8rXkp4KCwsJDAzsHDWmpJou/aTx9fV12h8fkoFkoEtykAxAMgDJQJfk0P7q2bMnBw4caPLz3dzccHNza8UeWaWfG35+fq1+rI4snYO3t3e9j8cXxLM0dmmdOlI39buJmX1n0sWri+3Hia6qGguf7E/n9W0pZBdb7477e7hw3ZCuzK5KwmXt/8OUkoIJUL298Z0yhYCbZ+PSs6ftR8tZ98fLcmHXStR9a1FOrfgnAnvC8LkwbA7CMxjlPGZF1v4B5qwSQlBWVuZUA+1nSn4mWFX7e9NZdeagjDOq9ndDezKQ8907kVRVJTIy0qnTFCQDyUCX5CAZgGQAkoEuyaF1FRwcjMFgsKUx6MrJyaFr167nte/Vq1czcOBARo8eDbROKl+XLl2cOpUv/mg8sbmx/F71O9/GfYtFs9g85Vfm8+9t/+am729i34l9uKguTO46mbcnvs2cHnOoKqiq46nCZObVH//kLy9u5olvD5NdXEWAh5G/jotmXWQOc958BPGkdVBK8fTE/6ZZuLz6Cu7/dw/uffpw7Nixsz2VZFP66SJ4ZQjsXIlSU44W1AeuepqEy97CfOE9aJ7B5x0nVVXx9fV1+lQ+FxcXp0/ls1gsMpUvOZmIiAinT+WLjIx0+lS+yMhImcrnaGrNKf+aplFUVGSbduqMkgwkA12Sg2QAkgFIBrpai4NM5Ztm2zZmzBhiYmJYuXIlYGUeFRXFokWLbMXPz0c665ZO5aupqaGkpISAgABbKoMzpOnonjamb+TFfS+SU3F6UDHUM5QHRj5AVlkWbx16i/JTs5MuDLuQuQPmMjZsLC5GlzqeiiuqeX93Bmt/TaOg3PrjqYuPGzcMC+fGqmSU99dSHR9vPX88PPC95hr8Z9+Ex8CBdVL26ngqzEDZ+SrKb++B5VRaZ8gALMPmog69CcUrqEXjBNjS2Jy9+Lm/v79TFz8vKCggICDA6Yufl5SU4O/vDzhv8XP9u0dPY+vsnuyNk6ZplJSU4Ovri6q2bPFzmcrnwKqsrLR9eDirJAPJQJfkIBmAZACSgS7J4fxUVlZGUlKS7e/U1FTi4uIIDAwkKiqKxYsXM2/ePEaNGkVMTAwrVqygvLzctkpfR1ZlZSUBAQHt3Y0218b0jTzwywMI6t6HzqnI4aHtD9n+7uHXg3kD5jG512TcDe51UuyKK2tYtzOdd35NpaTKDEBXXzdmjIhgRk062tv/pvrwYcA6IOUzaRKBs2/CdcAAlIZS9orSYcdylN8/RNFqABChg2DErSiDZ4KbL7TSQHtlZaXTp3DJz0rn/Uw4U/JckJ8JYGXQ3jffnPfWaieUqqpEREQ49R1xyUAy0CU5SAYgGYBkoEtyOH/t37+f4cOHM3z4cAAWL17M8OHDeeyxxwCYNWsWS5cu5bHHHmPYsGHExcWxYcMGQkNDz+u4bZHKFxQU5HSpfPFH43lx34tnDUrVloLCnUPu5D9/+Q/DXYbjYfSweSooN/H0Nwe56IXNvLIpkZIqM+G+Ltx/RW/W9Sll6pp/UvmP+62DUm5u+F0/Dc9XX8H1vnvxGDyYEzk5Z3s6mUzFx7fBypEQuw5Fq8EcOhSuXU7yZWuoGnIreAa0WpxUVcXb29vpU/mMRqPTp/LV1NTIVL7kZMLCwpw+lS8iIsLpU/kiIiJkKp+jqbVT+QoKCggMDHTaC2/JQDLQJTlIBiAZgGSgq7U4OGsqX3uoNVP5ioqKCAoKcqpUvj3H93D7xtvPyf3tq95mdNfRtr7nllTxxrYUPtyTQWWNBYDoQE9mjoxgqjkTy9o3qTxV5F5xc8P7qqvwn30TXsOG2YbAzvKUG4+y42WUPz4DcSqlLGIU2vC5KIOmo7j7tklKC8DJkycJCAhw6lS+/Px8AgMDnTqVLz8/n6CgIKdP5SsqKiIwMBBw3lS+oqIiAgICnDqVr3YpBJnKJ9Uk1dTUtHcX2l2SgWSgS3KQDEAyAMlAl+Qg1ZCc8dzIr8y363nZxZW8uT2Nj/dmUG22/hDp1cWLmSMimMoJqt98grLffgdAcXHB+6qrCLx5Nm5DhqAYDCiqiqg1+AFA7mHYsQzl0Bcop4atRLcx1pS9QdeD0QOUtl0FyhnPhTMlGUgGuiQHyQA6BgPnvbXaCaWqKmFhYU59R1wykAx0SQ6SAUgGIBnokhw6r9oilS8gIMCpUvnKTeX8nPBzk/gLsw8Pffo7ly35hXU706g2a/QOcuPxKQN5e2ANl732KEV330Hlb7+D0YjPpEl4v/oKhsX34zlyJCcLC8/2lH2Q6vdnoa65CA59joKgpttYuH4NGZevorT3VHD1avOUFlVV8fT0dPpUPlVVnT6Vr7q6WqbyJScTGhrq9Kl8YWFhTp/KFxYWJlP5HE2tncqXn59PcHCw0154SwaSgS7JQTIAyQAkA12txUGm8rWdWjOVr6CggC5dujh8Kl+VqYovkr/gjYNvcLLq5DmZuxNIYcI/MGvWWUsXhPsya1Q3JmonqHrrDSp277Y+0WjEe/x4/G6ahU9MDOIUq7P6fiwWZdsSlKM/nD5Ij0vRht2CMuBaFFfPdk1pAcjLyyMoKMipU/lyc3MJDg526lS+3NxcunTp4vSpfAUFBQQHBwPOm8pXUFBAUFCQU6fy1S6FIFP5pKSkpKSkpKSknF76BXjtAcbzaRsMBpRT6WIGg6HO9sbaiqI02Nb311C7pfremKfabYtm4X8p/2N13Gqyyqx3xUM8QghzHUJc0cZT/bO9BP22dGHWZMyawtBuftwUE8lV5FG+5hkKdu7Ud47P5Zfjf9MsvC68EMVo/elQO/lOVVXI3Au/vISapM/SUqDXeBh+C/SbjOribrenprbtiZP+46mlz7H29HRm+1z90n/kNpdBR/Rkb7v2ALWjeDqz3VQfep/01zqCpzPbjXmq7bt2uzN7Op84tcRnY0N9P5fkjKkWlryzKiUlJSUl5TiS3+ttp9aaMdUR7kjb226qJ4BN6ZtYdWAVyUXWtA4/Nz+m95rO9D4zuOm1RPK1/Xh0+YaBJ4oIKINCbzjc1Z/KvKkoFYN5dtpgrlDyKX/9Ncq3b7cGw2DA+9JL8Z81E88LL8Tg5lZ/fzN3I7a+iJK6FQChqNDrCpQRt6D1nghGNxkn6Ul6kp6kJyf1ZM+MKeed898JpWka2dnZtpPDGSUZSAa6JAfJACQDkAx0SQ6dV61dYyolJYX09HQ0TXOo+jG/ZvzKLT/cwv2/3E9yUTKeRk+uC72OtRPW8n/D/489v5/kRHEVMQmC1f+x8MRHGvd+o/HERxqr/2MhJkEQdTKT/iufIPeWm62DUqqK2yWXYHzhebq9sgLL0KEcPxUPmychKD34HTVvTYR3JqGkbkUoBug7mbyr3+LklSth4DSy8wo6XK0V/RzQY+YM9WPO9KRpGvHx8TZ/juDJ3jhpmsbBgwcpKytzGE/NidPRo0c5fvw4JpPJYTzZG6fU1FSys7MpKSlxGE/2xunEiRNkZ2eTm5sra0w5klq7xpSzLwkuGUgGuiQHyQAkA5AMdLUWBzljqu3UmjWmioqKCAoKcogaU4cLDvNK7Cvsyt4FgKvBlYnRE5kzYA59/ftiNBgpKDfx+NeHKPjxZx7d+y5QN/1Ov/i3bVMUPC++mICZN+J98cXg4nK2J4sFkjejbl8KmadqT6lGRN9JiBFzUXuNR1MMzY5TW9WYOnnyJAEBAU5dYyo/P5/AwECnrjGVn59PUFCQ09eYKioqIjAwEHDeGlNFRUUEBASgKM5bY6qoqAh/f39Utf1qTMmBqRaWvICVkpKSkpJyHMnv9baTZN24UotTWfX7Kn5K/wkAg2JgfOR4ZvefzYjQERhUA38cK+bdXWl8c+A45hoz6358luCq4jqDUrUlgKoRF9J7/s14X3YpqqtrPU8ScPRH2PYSZMVatxlcoN+1MPJW6H4JGGTZWikpKSmpurLne11+i3QiaZo1TcGZl8OWDCQDXZKDZACSAUgGuiQHqYbU2c+NE+UneO3Aa3yd9DUWYUFBYVz4OG7qdxMXdbsIoRn47mA27+5M47eMItvrJtYcp0tVcaP7VoBedy/E9+K/nP2gpkHC9/DLS3DioHWbwQ0GTLUOSEVfBGrTC9t2BHX2c6ElJBlIBrokB8kAOg4DOTDVyeTh4dHeXWh3SQaSgS7JQTIAyQAkA12Sg2NITxtoyVQJd3frqnCdKU2nqLqINw++yfqE9Zg0a92RESEjuKn/TVwWcRnFlbByUyof7Uknv8z6uFFVGNcriGuHhHNRejUl/2sC8OLiuj40C+Lw16jblkLun9bnGN0RA65DjJiHGn0h2qk5WGoLx6ktUvnc3d1t+3GGNJ0z2wBup4rZO4one+OkM9DPCUfw1Jw46Z+NekqbI3iyN06apuHh4WFrO4Kn5qTyeXh4tJqnpso5hwU7qVRVdfoaIpKBZKBLcpAMQDIAyUCX5NB51drFz9PT0/H09ERV1U5R2DgxPZEVe1Yw6YtJvH/kfUyaif6B/Xmo70MsvXApwcoY7l63j7+8uIVXNyWSX2YiwNOF2TGRrLymK6/NGsSV2XGUrFrZJP7GLl2snlKS4eCnaKvGoH52G+T+iTB6UtJvJsz7jsJLnyPbtTuohk5bBFhVVQwGgy02zlDY+ExPqqra6q45iid746SqKiUlJVRWVjqMp+bEKTk52VbPz1E82RunjIwMAgMDKS8vdxhP9sYpLy+PwMBACgoKZPFzR1JrFz/PysoiIiLCaS+8JQPJQJfkIBmAZACSga7W4iDrHrWdWrP4eXZ2Nt26devQxc+rLdV8lvgZbx58k8LqQgC6+3ZnVr9ZXBl5DZuPlPD+rgwOZ5fYmA0I8+GaQV25fngEXV0FhZ9/TuG772E+fvzcwBUFY2govX/aAH9+BjuWoZxMAkC4eqEMmoEYMR/RdQiqgxQKBzh27Bjh4eFOXfy8MQad0ZO9cRJCkJmZSbdu3Zy++Hl2djYRERGA8xY/z87OJjw8HEVx3uLntVP5WtKTPcXPZSpfJ5KiKPj4+NimoDqjJAPJQJfkIBmAZACSgS7JwXGkX4DXHmA8n7bRaMTX19f2o0OXwWBotK0oSoNt/TxrqG1PH82amW+Tv+U/cf/hRMUJALp6dmVmv5mMCZ7M93ElTPx0H0WVNQC4GlUu6RPM1KHhXDEgFLeyYgref4ukDz9CK7EOWqm+vvhOnIhLZCR5y5ZRr4Qg9KaxKK/FQGGadZubLwy+EWXkPOg6xOrJDtbn0z5XPBpq2xMnIQS+vr625ziCpzPb5+rX+TLoiJ6a0/bz87P97Sie7I2T/tmoDyI4gid742QwGPDx8TmLQWf2ZG+c9Osng8HQIr4b6vu5JGdMtbDknVUpKSkpKSnHkfxebzs5G2shBD+n/8yquFWkFlvTHQLdA7m+9/X0cJ3Mt7+VsCk+B/1KPcTHjcmDunL9iG4MivDDkpHOyXfWUfzll4hT6R/G0FB8p1yL/w034Nq9O8qRbyl5+Q5yfvPFXFnrB6mnmdDhJfhGWtMtcPeHIbNgxK0QegHIAV4pKSkpqfOUXJXPQaVpGpmZmURGRtYZlXQmSQaSgS7JQTIAyQAkA12Sg1RD6mjnhhCCXdm7ePW3V/nzpLW4uLeLN5O6T8G76kq+2VpOSl6i7flDI/2YOiSca4eGE+rrTuWBA2S/9DalGzeij1q59uqJ37Rp+E2diktoqPWFmgU2PIxvZCU+EZVU5LlirjJgdLfg2cWEogIoEHMnjJoPXfo7/IBURzsX2kOSgWSgS3KQDKDjMHD4ganMzEzmzp1Lbm4uRqORf//739x44422x5cvX85bb72FEIIJEybwyiuvoCgK3bt3t01tDAgIYMuWLe3owipFUQgICHDqNAXJQDLQJTlIBiAZgGSgS3JwHOn1LFqqhoemafj7+7drDQ+9HZcTx6u/v8q+nH0AuBvcuajrVWgnJ7B+QzXlJmvhdw8XA5f378KUwWFc1j8Ed6NK6datpK19h8r9+22sPIYPx+e66/C9eiIu/v5YLBZbLSUtdQeGEmutKUUFr1BTPbQFDLgW0aW/te+n0t0cpX7MmT4URcHf3/80IwfwZG+cFEXBz8+vQQad0VNz4uTn52d7FziKp+bEyd/f38bAUTzZG6eAgIA6r3UET/bESWeg76elPTVVDj8saDQaWbFiBYcPH+ann37ivvvus1WMz8vLY9WqVcTGxvLHH38QGxvL7t27ba/duXMncXFxHWJQCqxfJHqNBGeVZCAZ6JIcJAOQDEAy0CU5dF619qp8aWlpuLq6oihKu616tCd5D/duvpe5G+ayL2cfRsXIIK/L6Vr8//hq4zi++b2CcpOFCH8P5o0M5qN5g1k1ewQDPMop+nQ9KVOnkvW3v1sHpQwGGDuWoCUvEbX2bU6OGI7m4VHXk8VCwW9fNy0AZTkOu+LWmZ6UUwNvx08Vh3cET/bGSVEUKisrKSwsdBhP9sZJURQKCgqoqKhwGE/NiVNSUhLe3t5YLBaH8WRvnNLT0/H19aWsrMxhPNkbp9zcXHx9fTl58qRcla8tNXToUL777jsiIyPJy8tj1KhRHDhwAHd3dy655BI+/vhjevXqRffu3Tl06BDe3t527b+1V+VLS0uje/fuTj3VUDKQDEByAMkAJAOQDHS1Fgdnq3vUnmrNVfkyMjLo0aOH7Y5xW92Rzq7IZvXvq/ku5TsEAgWFKLcLyckYT16Bj9WHAiOjA5gyJIxrh4Tj7+mCVlZG8aefcvLd97CcGqhTPNzxuWICfjdMx334cAxubmffna4sQf3zC9j3BkrOn00DP+87RPe/OOxsiNo+wPpDKTo62qlX5WuMQWf0ZG+chBCkpKTQo0cPp1+VLyMjg+7duwPOuypfRkYG0dHRKIrzrsqXkZFBVFQUqurEq/Jt27aNJUuWEBsbS3Z2Nl9++SXTpk2r85zVq1ezZMkSTpw4wdChQ1m5ciUxMTF2Hys2NhaLxUJkZCQAXbp04cEHHyQqKgqj0chdd91Fr169AOud10svvRRVVbnvvvuYM2fOeXs9XymKQkhIiFPfDZYMJANdkoNkAJIBSAa6JAfHkX4BXnuA8XzaRqOR0NBQ248OXa256lFBdQFvHHyDT49+ilkzAxDAUHLSruBQZQgA3m5GJgwIYdrwCMb2CsLNaKAmJ4e8196j6L/r0U7dfTb4++M7eTJ+M27AvX9/lDMGXg0GA5xMhn1vY4j7AKqKT0FwBVUFc1X9oFHANxyixzXJU0vFo6F2W63KFxoa6vSr8p0Pg47oqTntrl272v52FE/2xkn/bNQHERzBU3NW5QsJCTmLQWf2ZG+c9Oun9l6Vr90HpsrLyxk6dCgLFixg+vTpZz2+fv16Fi9ezJo1axgzZgwrVqxg4sSJJCQkEBJi/WIfNmwYZrP5rNf+9NNPhIeHA9Zparfeeitvvvmm7fHCwkK+++470tLS8PDwYNKkSWzbto1LLrmEHTt2EBERQXZ2NhMmTGDw4MEMGTKklSg0TYqi2D2Dy9EkGUgGuiQHyQAkA5AMdEkOUg2pLc+NUlMp7xx6hw+OfECluRIAt5q+FBy7itKqbgD0CPbkmsHhTB8RQfcgL1RVoToxkeNr36H422/h1DWtS0QEvlOn4H/99bhERp496KppkLQR9r4BST+f3u4TDgOvgyEzoSgDPp1/6oHaSRKn9nX1C6A2/YdDZ5f8nJAMQDLQJTlIBtBxGLT7wNSkSZOYNGlSg48vW7aM22+/ndtuuw2ANWvW8P3337N27VoeeeQRAOLi4ho9RnV1NdOmTeORRx5h3Lhxtu0bN26kd+/eBAYGAnDNNdewe/duLrnkEiIiIgAICwtj8uTJ/Pbbb+0+MGWxWEhNTbVNO3VGSQaSgS7JQTIAyQAkA12Sg1RDaotzo9JcycfxH/P2H29TYiqxbqyOpOLEREoremNQFS7qHch1QyO46oJQ/D1dEUJQuX8/J996m7JffrHty61/f/ymXYfvlCm4BAWdfbCKAoj7EPa9BYVpp7d3GwODrodBN4C39eYtESNAeQ82PAynCqED1plSV78AA6e2PIwOLPk5IRmAZKBLcpAMoOMwaPeBqcZkMpmIjY3ln//8p22bqqpMmDCBXbt2NWkfQgjmz5/P+PHjmTt3bp3HIiMj2blzJ1VVVbi4uLB161buuOMOysvL0TQNHx8fysrK2Lx5MzNnzqx3/9XV1VRXV9v+LimxXozouZgtmX+qKAoRERF1VhZx9NznMz2pqkp4eLitToAjeGpOnPSZgPacYx3dk71xAuvAsSN5sjdOAOHh4aiq6jCe7I2TEILw8HDbdkfwZG+cACIiImzHcgRPzY1TWFgYulrSk1TnlqqqRERE1Ek1aCnVaDV8mfglaw6sIa8yDwCtOoTq3ImYywbi7+nKxFGhXD88gpHdA3ExqAiLhZIff+Lk229TdfCgdUeKgufoUfhOm4bvVRMxeHudfbDsg7DvTTj4KZyajYWrN/SdBINvgJ6Xg4v72a8bOBX6X4NI/5WagmO4BHZDib7IqWZK6WrNc6GzSDKQDHRJDpIBdBwGHToC+fn5WCwWQkND62wPDQ3lxIkTTdrHr7/+yvr16/nqq68YNmwYw4YN448//gDgwgsvZPLkyQwfPpwhQ4bQq1cvpk6dSk5ODn/5y18YOnQoF154IbfeeqttpZgz9fzzz+Pn52f7p9evaukVZVJTU6mursbDw4OUlBSnWS3iTE96Dm1KSorDeLI3ToqiYDKZnHpFGbC+xyorK1EUxWE82Run9PR0249pR/HUnBVl3NzcnH5FGQ8PD6deUSYnJwdFUSgvL+fkyZMt6smeFWWkWka1b+41pa0P0DbWdnd3tw006tv1tl4At3YbaLRttpj5X8r/uO7L63h699PkVeahmfypPH4j5Sn30ctrDIuv7Mt39/yF564fREyPQAw1Jgo++pjkSZPJuvde66CUiwveE64g7JUVRLz+OgHTp6N4epzue00V4o/P4O2J8PrF8Nt7YK5EBPRE/OUBuH0TlmlrEH2vBhf3hj0JUHpcgsuI2WhR1kGpMz3pTBtqNzUezY1TfbE53zid6UNRFNzd3escv7N7sjdOiqLg5ubWIIPO6MneOOkMdDmCp+bESf9s1Lc7gid74ySEwOPUqqaO4sneOOkMmurbXk9NluhAAsSXX35p+zsrK0sAYufOnXWe949//EPExMS0ce/qV1VVlSguLrb9y8zMFIAoLCwUQghhsViExWI5Z1vTtEbbZrNZ1NTUiISEBFFdXV1nu6ZpQtO0s9pCiEbb+vEbaje17+fjqbF2fZ7MZrOIj48X1dXVDuPJ3jjpDEwmk8N4ak6cTCaTiI+PF2az2WE82Run2gwcxZO9caqurhbx8fGipqbGYTzZGyeTySQSEhJETU2Nw3hqTpzs+Wy0x1NBQYEARHFxsZBqHa1atUoMGDBA9O3bVwAiISFBCCFETk6OyMnJEUIIcfz4cZGXlyeEEOLYsWPi5MmTQgghMjIybNdcaWlptjglJyeL0tJSIYQQR48eFYcOHRJms1kkJCSIqqoqIYQQR44cESaTSZjNZnHkyBFhNpuFyWQSR44cEUJYr/H0vlRUVIjExEShaZr48eiP4ur/XisGrRskBq0bJAa+daHo/cI/Ra9/fSVueW2r+CL2mDiWnSuOHTtm9ZGcLFJefFEkjB0nDvfrLw736y/iR4wURx94UGRu3Sq0mpqzPBVlxgux+VlR80JPIR73FeJxX6E9ESBMa6cIEbtOJP55QFRUVAghRJM9mc1m8eeff4r4+Pg6noQQorS0VCQnJwshhCguLhZpaWlCCCEKCwtFRkaGEEKIkydP2jzl5eWJ48ePt2icEhMT7fbUUJwa8mQ2m0VcXJzNnyN4sjdOZrNZ7N+/X5w4ccJhPNkbJ7PZLHbt2mXz5wiemhOnP//8Uxw5ckRUVlY6jCd745SUlCQSEhJEYWGhw3iyN07Hjh0TCQkJ4vjx4y3uKTY2tsnXUIoQQjQ2cNWWUhSlzqp8JpMJT09PPvvsszor9c2bN4+ioiK+/vrr9uloI2rNZaWFEJhMJlxdXc8ugOkkkgwkA12Sg2QAkgFIBrpai0Nrfq9L1ZXOurCwEH9/f9sd2vNNNzWbzZjNZtzc3NA0rdnppvuz9/PcnuUklVhn3guLG6aTl+JVfQnXDOrJ9OERDAr3xdXFiKZp1GRlUfje+xR99imi0joDzxAchO811+I/4wZcevRAUWstzS0E6rE9iD1vQPy3KKdW8xMegSgDpqJdMAMlegyK0bXZ5RCqq6sxGo0Yjcaz/AnheKnOZ/pQFIXq6mpcXFwwGAwO4cneOCmKQlVVFa6urvUy6Iye7I0TWGfqurm5OXU5BIvFgtlsxtXVWvPOETzZGydNs87mdnFxsfWls3uyN05CCMxmM0ajEUVRWtRTYWEhgYGBTbqG6tADUwBjxowhJiaGlStXAtZgREVFsWjRIlvx844keQErJSUlJSXlOJLf622njso67sSfPL7jZVLK9wEgNCM1heOINFzFjGEDmTYsklBft9M/eA8f5uTbaynZsAFOpTG4REfjd91U/KZNwyUsrO7gqakcDn4Ce9+E3D9Pb+86GAZeD4NnQEB0m/mVkpKSkpJqCdnzvd7uxc/LyspISkqy/Z2amkpcXByBgYFERUWxePFi5s2bx6hRo4iJiWHFihWUl5fbVulzJllO1VDp06ePU68aIBlIBiA5gGQAkgFIBrokB6mG1Nxz49e0Izy7cwWZNTsBEEJFKxnNYO/J3HLFaCYMCMfD1XDqMUHZr79S8PbblO88vUCP+6BB+F0/Dd/JkzEGBNQ9wMlk2Pc2/P4+VJ9ayc/gBr0nWFfX6zcZXOspgt5MyfeIZACSAUgGuiQHyQA6DoN2nzG1detWLr/88rO2z5s3j3Xr1gGwatUqlixZwokTJxg2bBivvvoqY8aMaeOeNk2tncpXe5qdM0oykAx0SQ6SAUgGIBnoai0OHXUWjyOqtVjbc25omuDrQ4d5JfY18pXtKMqpFIaKoVwYNIW7x45ncEQwBtW6H2E2U/LDBk6uXUv1kSPWnagqnhdeiN+0afhOuALV07PWASyQtBH2vmH9X5dvOAyYBkNmQtiQVlkxT35WSAYgGYBkoEtykAygdRl0qhlTl112GecaG1u0aBGLFi1qox51bLX3Mo4dQZKBZKBLcpAMQDIAyUCX5CDVkM51bhRX1PD+3sOsO/wOVR7bUNQaFMCtpj/jw6dx70XXEuHnZ3u+Vl5O0eefc3Ldu5hPrZKruLnhffnl+F1/PV5jL0R1dT19gIoC+P0D2P82FKad2qhA5Bi44HoYdAN4d2lZ0/VIvkckA5AMQDLQJTlIBtAxGLT7wJRU06VpWoeYZteekgwkA12Sg2QAkgFIBrokB6n6ZNEEu5PzOJiYzpA+0VzYq4ttthPAkewS1u6M5/v0T1H9t6J4VaEAXqI7k7vP4O8x1xPkefourzk/n4IPPqDwo4/RSqzpd6qvL75XX43fDdPxGDQIpfb5l33AWjvqj0/BbC2Ajqu3NU1v0A3Q8zJwcW8DEvI9ApIBSAYgGeiSHCQD6DgM2j2Vz9HU2ql8tVeTcUZJBpKBLslBMgDJACQDXa3FQabytZ1amvWGQ9k88e0h8mqOoBhLEWYfurgM4NFrLkBVFN7ZmURc0QZcgzejGssA8FbDmNH3RhYMvpEAT3/bvkxpaZx8Zx3FX36JMJkAMHYNxffaa/G/4QZcu3c/fd6ZTXDkG2u6Xuae0x0K7AUXTIchN0JwX2jj96v8rJAMQDIAyUCX5CAZQOsy6FSpfFL2qfZykc4qyUAy0CU5SAYgGYBkoEtykNK14VA2i75+D7fQb/F0KbZtL63x475vrwG1Brfgjbh3LQTA2xDMzH7TueWCm+jieTqlrvLAAU6+9TalGzfCqXu5rr164TftOvyuuw6XkJDTBy05DrHrYP87UJ5r3aYYoMclMGg6DJgKHv6tbb1RyfeIZACSAUgGuiQHyQA6BgPnjkAnk6ZpJCcno2lae3el3SQZSAa6JAfJACQDkAx0SQ6OIz2GmqY1qa1P/tfbFk3w6E8f4x7xAYqxuM6+FWMx7hEf4RH+KaprIV5GX27tP59PprzHvSP/TrBHMOaaGkq3bCFtzi2kzbqJ0p9/BiFwHz6Mrk89SdRHHxK4cCEuISEITUNL3Q6fzEMsHwS/vAjluQjPILQR82Het2iz16MNuwU8/Jvt6cy2xWJptC2EOKutaRpJSUnU1NQA2Lbrbf34DbWb2ve29FSfj8Y86QzMZrPDeLI3Tudi0Bk92RsnnYHeB0fw1Jw41dTU2Dg4iid742Q2m0lOTrZ9RjqCJ3vjpDMwm82t4qmpkgNTnUgGg4H+/fs7bf4rSAYgGeiSHCQDkAxAMtAlOXRerV69moEDBzJ69GgAcnOts43y8/PJz88HICcnh4KCAgCys7MpKioCICsri+Ji6+BTZmYmpaWl7E7Jo9L3C+DsbDlFsf4TAi70vIb3Jr7D/SPvpTy7HEt1NQWffkbipMkcu/tvVMbGIgwGvC69lKAlL2F+7DECZs6k2mAgPfEw7F+LtvpC1HevhcNfoQgLVUEXwBVPUHjT92SPfAi6X0RBcSk5OTnn5QkgLS2N8vJyAFJTU6mqstasSk5OxnQqvTAxMdH24yIxMdH2oyMxMRGDwUDPnj1JS0sDoKqqitTUVADKy8tt20tLS8nMzASguLiYrKwsAIqKisjOzgagoKCgQ3gCMJlMJCcnN8mTwWAgLCyMEydOOIwne+NkMBjw9/e39d0RPNkbJ4PBgJubm82HI3hqTpxSUlLo27cvQgiH8WRvnDIzM+nfvz//v707j46qvv8//rw3+74nEAgJPzDs+6oUgxUV7A8rLuWctlYooiit9SD68xzPwQVqWn+pSy3aAx7BtYJ1wdqq9VcFikBZ/CJiFWJYTCEEYhbChIRk5vP7Y7xTAgkkmOQmmdfjnJxzMzPMvD+vO8O885n7uVNTU9NtxtTa/VRWVsbAgQOpqKho8zE5dbWEzjHVxtr7HFOnTp0iPDw8qNfAKgNlAMoBlAEoA1AGjvbKQeeY6jhO1hUVFSQmJgY+obVt+5zblmVhWVZg+4mP3+W5ov8DgOUzDCo2JJ2Ailj4IsvCfHvy89k5j7Dw0v+Nt7qaildXU/Hii3iPHfP/u6go4i6/nLiZ1xI3fjyEhuLz+QipPIDZugJ2voxV5z/5uQmNxOp/BWbItZiLrsKOjGtx7S0d05nbXq83cD6Qprah8dIMZ7uuro7Q0FBCQ0MDn6CHhIQEPo23bbvZ7c44Jqf25rbPHIdlWdTV1REWFkZISEi3GFNr95NlWdTW1hIeHt5kBl1xTK3dT+D/Yz4iIgLbtrvFmC5kP3m9XhoaGggPD8cY0y3G1Nr95Ez4hIWFBWrp6mNq7X5yjhwLDQ3Fsqw2HVNFRQXJyck6x1R34/P5OHjwIP369QvaT4SVgTJwKAdlAMoAlIFDOXQfTgN++vkuWrPtnMh8/B4fsz/wkVr93/sui4NVV9hsHWATU1PK0f9bQOXq1fi+/aQ3JCmJ+KuvJuGG64kcMADLtsHnhb3vE7J1ORT9g8C0Z3wvGHwt1vAfQY9hWHZI4LoLrb2l26c/x1u67fV6+frrr+nXrx/gn6BwbuP8QXGu7c44pqbGca4xnZlBdxjTmdvnq8vr9VJcXHzBGXTGMbV2+8wMusOYztxuyTgsywq8HrrLmFq7n4CzeoeuPqbW7iev1xvI4Lu+/56r9vPREVNtTJ+sioiIdB96X+84bZX1lsNbWfGHOdz9xrdHiJx2ne/b33f3gaGHQ7Aa/Oe/COvVi/hrZpB43XWE9e7tb+BryuF/XoRtz0Ll19/egwVZE2DITBh6PcSmISIiImfTt/J1U8YYamtriYyMDMx4BhtloAwcykEZgDIAZeBQDuIYmzYS7//zb5/5THA+0x32NYCXiIEDSbj2h8TPmEFYSor/ysM7YdsK+OzP0OA/TwYRcZA7HYZdD32nQFhkO4+i7ek1ogxAGYAycCgHZQCdJwOd/LwL8fl8HDp0KLDOMxgpA2XgUA7KAJQBKAOHchBH3Sc7ST7uO2tS6kzJt9xC9ksvkTJ7NmEJcbDrNXj2ClieB//zkn9SKqU/XHov3PIhXLcccqd1yUkp0GsElAEoA1AGDuWgDKDzZKClfG1Mh/yLiIh0H3pf7zhtlXXVO3/l8KJF571dZkEBCZNHwo6VsON58Pi/DRA7FPrm+ZfrDZoBUYkXXIuIiEiw0lK+bsoYg8fjISYmJqgPNVQGygCUAygDUAagDBzKQRyhaS0771Po5ytgxwYw/vNMEZ0Cg66BYTdC1ngICWvHKjueXiPKAJQBKAOHclAG0Hky0FK+LsQYw9GjRwnmg9yUgTJwKAdlAMoAlIFDOYgjeuwYQlMSgOaeC4bQ6AaiPR/5J6V6jIDLH4Rb18OMJyBnUreblAK9RkAZgDIAZeBQDsoAOk8GWsrXxnTIv4iISPeh9/WO02ZZ+7wc/9VQDn3gtLinfwLsv6zXpArip06FYdf5zxsVHnPhjyciIiJn0VK+bsoYw/HycmKjooL6UMMTHg+xQX64ZbBnAMoBlAEoA1AGDmMMJ06eJD45OahzEODgJuJTDsOkSEo/SaDhZEjgqtBoLxmjjhOfVQsTboX/ledioR3LGEN1dTVxcXFB+xpRBsoAlIFDOSgD6DwZaGKqC/HW1VH62W6wLOwgfeH4jOHIqTp6hEcogyDOAJQDKANQBqAMHD5jKDWGmIkTCI3smt+aJm3kRCkA8Vm1xPWqpeZYOA21IYRGeolOO4XlnMjCc8y9Gl1gjKGiooLY2Nig/gNMGSgDZeCnHJQBdJ4MNDHVhdjG0NO2scLCsMLD3S7HFTbQm1i3y3CVMvBTDsoAlAEoA4d16hQ96+uxdYYC19XU1DBo0CBuvPFGCgoKOr6A2IzApmVDTMap894uGNi2TXZ2tttluEoZKANQBg7loAyg82SgiakuxBhDdUMD8dHR2BERbpfjCmMM1afqiAuPCOpZ7WDPAJQDKANQBqAMHF5jqD55kmhNTLnu17/+NRMnTnSvgOxLID4TjpfQ9AnQLf/12Zd0dGWuMsZQVVVFQkJC0P5foQyUASgDh3JQBtB5MtC38nUhxhhOeL3NfsdMMDDAiVOnlEGQZwDKAZQBKANQBg4D/vdITUy5qrCwkC+//JLp06e7V4QdAtN+++0vZzbZ3/4+7Tf+2wUR5zwiwfwaUQbKAJSBQzkoA+g8GWhiqguxbZueEcF9DhHbssiMi1cGQZ4BKAdQBqAMQBk4bMvyv0faam0u1IYNG5gxYwaZmZlYlsVbb7111m2WLVtGTk4OkZGRTJgwga1btza6ftGiReTn53dQxecw+Br40QsQ37Px5fGZ/ssHX+NOXS6ybZusrKygfo0oA2UAysChHJQBdJ4MgncPdEE+n4+qhnp8QTyj6zOGytqTyiDIMwDlAMoAlAEoA4fPGP97pM/ndildlsfjYcSIESxbtqzJ61evXs3ChQt54IEH+OSTTxgxYgRXXXUVR48eBWDt2rXk5uaSm5vbkWU3b/A1cNdufD/7CyeuehLfz/4Cd30WlJNS4O8jy8vLg/o1ogyUASgDh3JQBtB5MtDEVBdTG8QvGkdtQ4PbJbhOGfgpB2UAygCUgUPvkd/N9OnTWbp0KTNnzmzy+scee4x58+YxZ84cBg8ezB//+Eeio6N57rnnANiyZQuvvvoqOTk5LFq0iBUrVvDwww83+3h1dXUcP3680Q8QaI59Pl+Ltp3lB01u2yF4sy6mMmsq5HwPryFwG++3Sz+NMWdtA+fcdh6/ue2W1n5BYzqt9ua2mxtTTU1NtxtTa/dTTU1NtxtTa/eTx+PpdmNq7X7yeDzdbkwXsp9qamq63Zhau59OnjzZ7cbU2v108uTJdhtTS2liqguxbZuMIP86cNuy6BEbpwyCPANQDqAMQBmAMnDYluV/jwziw/Hb06lTp9ixYwdTp04NXGbbNlOnTmXz5s0A5OfnU1xczIEDBygoKGDevHksXry42fvMz88nISEh8JOVlQUQOAKrrKyMsrIyAEpLSykvLwegpKSEyspKAA4dOkRVVRUAxcXFVFdXA3DgwAE8Hg8ABw8eJCUlBdu2KSoq4tQp/7f0FRYW0tDQgM/no7CwEJ/PR0NDA4WFhYExFxUVAVBbW8v+/fsB/x+0Bw4cAKC6upri4mIAqqqqOHToEACVlZWUlJQAUF5eTmlpaZuOaf/+/dTW1gK0eEy2bZOWlhYYR3cYU2v3k23bxMbGBsbRHcbU2v1k2zahoaGBcXSHMbV2P9m2TX19PSdPnuw2Y7qQ/VRUVETPnj0D4+sOY2rtfvr666/p1asXHo+n24yptfvp2LFj9OrVi/Ly8jYfk1NXS1jG7bNcdTPHjx8nISGBqqoq4uPj2/S+GzweDm/5F0kJCYRGRrbpfXcVzpKVxMiooP0jTBn4KQdlAMoAlIGjobaWiqoqMidOIDQmps3utz3f1zszy7J48803ufbaawE4fPgwvXr1YtOmTVx88cWB2917772sX7+ef/3rX43+/apVq9i9ezcFBQXNPkZdXR11dXWB348fP05WVhYVFRUkJiYGPqG1bfuc25ZlYVlWs9v19fVUVlaSkpKCMQbbtrEsC6/XG5jI9Pl8jbZDQkICnzA3te3cT3PbLa39Qsfk1N7cdlNjsiyLb775hsTERMLCwrrFmFq7nwC++eYbkpKSCA0N7RZjau1+Av8f1cnJyU1m0BXH1Nr9ZIyhrKyMlJQUQkJCusWYLmQ/NTQ0UFlZSXJyMkC3GFNr95PX66WyspKkpCQsy+oWY2rtfvL5fFRWVpKYmIht2206poqKCpKTk1vUQ4We81rpdBo0j0iDTxkoAz/loAxAGYAycOg9svOYPXv2eW8TERFBRERE+xcD1NfXd8jjdHbKQRmAMgBl4FAOygA6RwY63r0LsW2btPDwoP5E3LYs0mNilEGQZwDKAZQBKANQBg7bsvzvkVrK1y5SU1MJCQkJLGNwlJaW0qNHj+9038uWLWPw4MGMGzcOaJ+lfElJSVrKZ9ukpKQE/VK+6OjooF/KZ9t20C/lq6ur01K+oiIyMjKCfilfz549g34pX8+ePbWUr7tp76V8/9myhZSExKBeyld+sobkqOig/SNMGfgpB2UAygCUgaOhtpZvqirpPXGilvK1gTOX8gFMmDCB8ePH89RTTwH+JQV9+vThF7/4Bffdd993fkwn6/ZYyldeXk5aWlrQL+U7duwYycnJQb2U79ixY6SkpAT1Ur6jR4+Smpoa1Ev5jh49SlpaWtAv5SsvLyc1NRUI3qV85eXlpKSkBPVSvvLycpKTk7WUT0RERETcdeLECb766qvA7/v372fnzp0kJyfTp08fFi5cyM0338zYsWMZP348TzzxBB6Phzlz5rhYtYiIiHR1Ot69C7Ftm5QwLeVLjQ7uJSvKwE85KANQBqAMHLZl+d8jtZTvgm3fvp1Ro0YxatQoABYuXMioUaMC36w3a9YsCgoKWLx4MSNHjmTnzp289957ZGRkfKfH7YilfPHx8VrKZ9skJiYG/VK+iIiIoF/KZ4wJ+qV8NTU1WspXVERqamrQL+VLT08P+qV86enpWsrX3VRVVZGYmEhxcXG7LOUr3rqN1CD/Vr5vTtaQEsRLVpSBn3JQBqAMQBk4GmprKauqImv8uDZfypeVlUVlZSUJCQltdr9yNqeHOnjwYJsv5SsrKyMjIyPol/KVlpaSmpoa1Ev5SktLSUtLC+qlfEeOHCE9PT2ol/IdOXKEjIyMoF/KV1ZWRnp6OhC8S/nKyspIS0sL6qV8ZWVlpKamtstSvpycnBb1UFrK18acWcOsrCyXKxEREZG2Ul1drYmpdub0UNnZ2S5XIiIiIm2lJT2UjphqYz6fj8OHDxMXF4fVxp9cO5/atsfRWF2FMlAGDuWgDEAZgDJwtFcOxhiqq6vJzMzUMsF21l49lF4jfspBGYAyAGXgUA7KANo3g9b0UDpiqo3Ztk3v3r3b9THi4+OD9oXjUAbKwKEclAEoA1AGjvbIQUdKdYz27qH0GvFTDsoAlAEoA4dyUAbQfhm0tIfSR38iIiIiIiIiIuIKTUyJiIiIiIiIiIgrNDHVhURERPDAAw8QERHhdimuUQbKwKEclAEoA1AGDuUgzdFzw085KANQBqAMHMpBGUDnyUAnPxcREREREREREVfoiCkREREREREREXGFJqZERERERERERMQVmpgSERERERERERFXaGJKRERERERERERcoYmpLmrmzJkkJSVxww03uF2KK4qLi5kyZQqDBw9m+PDhvPbaa26X1OEqKysZO3YsI0eOZOjQoaxYscLtklxTU1NDdnY2ixYtcrsU1+Tk5DB8+HBGjhzJZZdd5nY5rti/fz+XXXYZgwcPZtiwYXg8HrdL6lB79uxh5MiRgZ+oqCjeeustt8vqcI8//jhDhgxh8ODB3Hnnneg7XuR0wd4/gXooUA91umDvodQ/qX8C9VAON3sofStfF7Vu3Tqqq6t5/vnn+fOf/+x2OR2upKSE0tJSRo4cyZEjRxgzZgx79+4lJibG7dI6jNfrpa6ujujoaDweD0OHDmX79u2kpKS4XVqHu//++/nqq6/IysqioKDA7XJckZOTw+7du4mNjXW7FNfk5eWxdOlSJk+eTHl5OfHx8YSGhrpdlitOnDhBTk4OBw8eDKr/F48dO8bEiRP5/PPPCQsL49JLL6WgoICLL77Y7dKkkwj2/gnUQ4F6qNMFew+l/kn905nUQ7nTQ+mIqS5qypQpxMXFuV2Ga3r27MnIkSMB6NGjB6mpqZSXl7tbVAcLCQkhOjoagLq6OowxQXlkQGFhIV9++SXTp093uxRxkfMmOnnyZACSk5ODuql6++23ufzyy4OqoXI0NDRQW1tLfX099fX1pKenu12SdCLB3j+BeihQD+VQDyXqn86mHsqdHkoTU51Ufn4+48aNIy4ujvT0dK699lr27NnjdlkdqqUZ7NixA6/XS1ZWlgtVtq/zZVBZWcmIESPo3bs399xzD6mpqS5W2z7Ol8GiRYvIz893scKOcb4cLMsiLy+PcePG8fLLL7tYafs5VwaFhYXExsYyY8YMRo8ezSOPPOJyte2jpf8vrlmzhlmzZrlQYfs7VwZpaWksWrSIPn36kJmZydSpU+nXr5/LFUtHUv/kpx5KPRSohwL1T6D+yaEeqnP3UJqY6qTWr1/PggUL2LJlCx988AH19fVceeWVQbXmtyUZlJeX87Of/Yzly5e7WGn7OV8GiYmJfPrpp+zfv59XXnmF0tJSlytue+fKYO3ateTm5pKbm+t2me3ufM+FjRs3smPHDt5++20eeeQRdu3a5XLFbe9cGTQ0NPDPf/6Tp59+ms2bN/PBBx/wwQcfuF1ym2vJ/4vHjx9n06ZNXH311S5W2n7OlUFFRQXvvPMOBw4c4NChQ2zatIkNGza4XbJ0IPVPfuqh1EOBeihQ/wTqnxzqoTp5D2WkSzh69KgBzPr16wOXffTRR+b66693saqOdWYGtbW1ZvLkyeaFF15wubKO09TzwHH77beb1157zYWqOtbpGdx3332md+/eJjs726SkpJj4+Hjz0EMPuV1ihzjXc2HRokVm5cqVHV9UBzs9g02bNpkrr7wycN2jjz5qHn30URer6xhNPQ9eeOEF85Of/MTFqjrW6RmsWbPG3HHHHYHrHn30UfPb3/7WxerEbeqf/NRDqYcyRj2UMeqfjFH/5FAP1bl6KB0x1UVUVVUB/nW/wer0DIwxzJ49m+9///vcdNNNLlfWcU7PoLS0lOrq6sDlGzZsYMCAAW6W1yFOzyA/P5/i4mIOHDhAQUEB8+bNY/HixS5X2DFOz8Hj8QSeCydOnODDDz9kyJAhbpbXIU7PYNy4cRw9epSKigp8Ph8bNmxg0KBBLlfY/pp6b+jOh6A35fQMsrKy2LRpE7W1tXi9XtatWxcU/y9K89Q/+amHUg8F6qFA/ROof3Koh+pcPZS+la8L8Pl8XHPNNVRWVrJx40YApk6dyqefforH4yE5OZnXXnutW3/r0JkZbNy4kUsvvZThw4cHbvPiiy8ybNgwF6tsX2dmsHXrVm699dbACTsXLFjAbbfd5naZ7aqp14Jj1apV7N69Oyi+UebMHPbt28fMmTMB/zcNzZs3j1/96lcuV9m+mnouvPvuu9x7770YY7jyyit57LHHXK6yfTWVQVVVFbm5uRQXFxMeHu5yhe2vqQzuv/9+3njjDWzb5vLLL+fJJ5/EsiyXKxU3qH/yUw+lHgrUQ4H6J1D/5FAP1Ql7qA47Nksu2Pz58012drYpLi52uxTXKANlYIwycCgHZWCMMjBGGci56fnhpxyUgTHKwBhlYIwycCiHzpeBJqY6uQULFpjevXubffv2uV2Ka5SBMjBGGTiUgzIwRhkYowzk3PT88FMOysAYZWCMMjBGGTiUQ+fMQBNTnZTP5zMLFiwwmZmZZu/evW6X4wploAyMUQYO5aAMjFEGxigDOTc9P/yUgzIwRhkYowyMUQYO5dC5MwjtmAWD0loLFizglVdeYe3atcTFxXHkyBEAEhISiIqKcrm6jqEMlAEoA4dyUAagDEAZyLnp+eGnHJQBKANQBqAMHMqhk2fg9syYNA1o8icYvsLUoQyUgTHKwKEclIExysAYZSDnpueHn3JQBsYoA2OUgTHKwKEcOncG+lY+ERERERERERFxhe12ASIiIiIiIiIiEpw0MSUiIiIiIiIiIq7QxJSIiIiIiIiIiLhCE1MiIiIiIiIiIuIKTUyJiIiIiIiIiIgrNDElIiIiIiIiIiKu0MSUiIiIiIiIiIi4QhNTIiIiIiIiIiLiCk1MiYiIiIiIiIiIKzQxJSLdyqpVq0hMTGzz+83JyeGJJ54I/G5ZFm+99VabP05bWrduHZZlUVlZ6XYpIiIi0smph/ov9VAiHSvU7QJERM5n9uzZVFZWtqiJmTVrFldffXW711RSUkJSUlK7P853cckll1BSUkJCQoLbpYiIiIgL1ENdGPVQIh1LE1Mi0m3U19cTFRVFVFRUuz9Wjx492v0xvqvw8PAuUaeIiIi4Sz1UY+qhRDqWlvKJSJuZMmUKv/zlL7nrrrtISkoiIyODFStW4PF4mDNnDnFxcfTv359333038G+8Xi9z586lb9++REVFMWDAAJ588snA9Q8++CDPP/88a9euxbIsLMti3bp1HDhwAMuyWL16NXl5eURGRvLyyy83OgzdGMPUqVO56qqrMMYAUF5eTu/evVm8eHGz4zh69CgzZswgKiqKvn378vLLL591m9MPQ3dqWbNmDZMnTyYqKopx48axd+9etm3bxtixY4mNjWX69OkcO3as0f08++yzDBo0iMjISAYOHMjTTz8duM653zfeeIPLLruM6OhoRowYwebNmwO3OXjwIDNmzCApKYmYmBiGDBnC3/72N6Dpw9Bff/11hgwZQkREBDk5Ofzud79rVE9OTg6PPPIIP//5z4mLi6NPnz4sX7682axERETku1MPpR5KJKgZEZE2kpeXZ+Li4sySJUvM3r17zZIlS0xISIiZPn26Wb58udm7d6+5/fbbTUpKivF4PMYYY06dOmUWL15stm3bZvbt22deeuklEx0dbVavXm2MMaa6utr86Ec/MtOmTTMlJSWmpKTE1NXVmf379xvA5OTkmNdff93s27fPHD582KxcudIkJCQEavrPf/5jkpKSzBNPPGGMMebGG28048ePN/X19c2OY/r06WbEiBFm8+bNZvv27eaSSy4xUVFR5vHHHw/cBjBvvvmmMcYEahk4cKB57733zL///W8zceJEM2bMGDNlyhSzceNG88knn5j+/fub+fPnB+7jpZdeMj179gzU//rrr5vk5GSzatWqs+73nXfeMXv27DE33HCDyc7ODtT/gx/8wFxxxRVm165dpqioyPzlL38x69evN8YY89FHHxnAVFRUGGOM2b59u7Ft2zz88MNmz549ZuXKlSYqKsqsXLkyUFN2drZJTk42y5YtM4WFhSY/P9/Ytm2+/PLL1j8hREREpEXUQ6mHEglmmpgSkTaTl5dnvve97wV+b2hoMDExMeamm24KXFZSUmIAs3nz5mbvZ8GCBeb6668P/H7zzTebH/7wh41u4zQcTrPkOLOpMsaYNWvWmMjISHPfffeZmJgYs3fv3mYfe8+ePQYwW7duDVz2xRdfGOC8TdWzzz4buP5Pf/qTAcw//vGPwGX5+flmwIABgd/79etnXnnllUaPv2TJEnPxxRc3e7+ff/65AcwXX3xhjDFm2LBh5sEHH2xyLGc2VT/+8Y/NFVdc0eg299xzjxk8eHDg9+zsbPPTn/408LvP5zPp6enmmWeeafIxRERE5LtTD6UeSiSYaSmfiLSp4cOHB7ZDQkJISUlh2LBhgcsyMjIA/6HejmXLljFmzBjS0tKIjY1l+fLlfP311y16vLFjx573NjfeeCMzZ87kN7/5DQUFBVx00UXN3vaLL74gNDSUMWPGBC4bOHBgi76l5vSxO+M8c+zOuD0eD0VFRcydO5fY2NjAz9KlSykqKmr2fnv27An8N78777yTpUuXMmnSJB544AF27dp1zrFNmjSp0WWTJk2isLAQr9fb5ONZlkWPHj0a7S8RERFpe+qh/NRDiQQfTUyJSJsKCwtr9LtlWY0usywLAJ/PB8Crr77KokWLmDt3Ln//+9/ZuXMnc+bM4dSpUy16vJiYmPPepqamhh07dhASEkJhYWFLh9JqTY3zzMuccZ84cQKAFStWsHPnzsDP7t272bJly3nv17mfW265hX379nHTTTfx2WefMXbsWJ566qk2G8eZdYuIiEj7UA/lpx5KJPhoYkpEXPXxxx9zySWXcMcddzBq1Cj69+9/1qdd4eHhjT6Naq27774b27Z59913+f3vf8+HH37Y7G0HDhxIQ0MDO3bsCFy2Z8+eRie/bAsZGRlkZmayb98++vfv3+inb9++rbqvrKws5s+fzxtvvMHdd9/NihUrmrzdoEGD+Pjjjxtd9vHHH5Obm0tISMgFj0VEREQ6nnoo9VAi3UWo2wWISHC76KKLeOGFF3j//ffp27cvL774Itu2bWvUWOTk5PD++++zZ88eUlJSSEhIaPH9//Wvf+W5555j8+bNjB49mnvuuYebb76ZXbt2kZSUdNbtBwwYwLRp07jtttt45plnCA0N5a677mqXr09+6KGHuPPOO0lISGDatGnU1dWxfft2KioqWLhwYYvu46677mL69Onk5uZSUVHBRx99xKBBg5q87d133824ceNYsmQJs2bNYvPmzfzhD39o9C02IiIi0jWoh1IPJdJd6IgpEXHVbbfdxnXXXcesWbOYMGEC33zzDXfccUej28ybN48BAwYwduxY0tLSzvrEqjnHjh1j7ty5PPjgg4wePRrwNzIZGRnMnz+/2X+3cuVKMjMzycvL47rrruPWW28lPT39wgfZjFtuuYVnn32WlStXMmzYMPLy8li1alWrPu3zer0sWLCAQYMGMW3aNHJzc5ttkkaPHs2aNWt49dVXGTp0KIsXL+bhhx9m9uzZbTQiERER6SjqodRDiXQXljHGuF2EiIiIiIiIiIgEHx0xJSIiIiIiIiIirtDElIiIiIiIiIiIuEITUyIiIiIiIiIi4gpNTImIiIiIiIiIiCs0MSUiIiIiIiIiIq7QxJSIiIiIiIiIiLhCE1MiIiIiIiIiIuIKTUyJiIiIiIiIiIgrNDElIiIiIiIiIiKu0MSUiIiIiIiIiIi4QhNTIiIiIiIiIiLiCk1MiYiIiIiIiIiIK/4/94XBwPy1dKIAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig = plot_results(results, strategies, batch_size, device=device)" ] diff --git a/pyproject.toml b/pyproject.toml index af00376..8386951 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -59,6 +59,7 @@ dev = [ "pre-commit>=4.5.1", "maturin>=1.0,<2", "tqdm>=4.68.2", + "seaborn>=0.13.2", ] docs = [ "wheel>=0.45,<0.46", diff --git a/requirements.txt b/requirements.txt index 0218332..46823c3 100644 --- a/requirements.txt +++ b/requirements.txt @@ -178,6 +178,7 @@ markupsafe==3.0.3 # jinja2 # nbconvert matplotlib==3.10.9 + # via seaborn matplotlib-inline==0.2.2 # via # ipykernel @@ -232,11 +233,15 @@ numpy==2.2.6 ; python_full_version < '3.11' # via # contourpy # matplotlib + # pandas + # seaborn # torchpfaffian numpy==2.4.6 ; python_full_version >= '3.11' # via # contourpy # matplotlib + # pandas + # seaborn # torchpfaffian packaging==26.2 # via @@ -247,6 +252,10 @@ packaging==26.2 # pytest # sphinx # twine +pandas==2.3.3 ; python_full_version < '3.11' + # via seaborn +pandas==3.0.3 ; python_full_version >= '3.11' + # via seaborn pandocfilters==1.5.1 # via nbconvert parso==0.8.7 @@ -319,8 +328,11 @@ python-dateutil==2.9.0.post0 # via # jupyter-client # matplotlib + # pandas python-discovery==1.4.0 # via virtualenv +pytz==2026.2 ; python_full_version < '3.11' + # via pandas pywin32-ctypes==0.2.3 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'win32' # via keyring pyyaml==6.0.3 @@ -360,6 +372,7 @@ rpds-py==2026.5.1 ; python_full_version >= '3.11' # jsonschema # referencing ruff==0.15.16 +seaborn==0.13.2 secretstorage==3.5.0 ; platform_machine != 'ppc64le' and platform_machine != 's390x' and sys_platform == 'linux' # via keyring setuptools==82.0.1 ; python_full_version >= '3.12' @@ -446,6 +459,8 @@ typing-extensions==4.15.0 # sqlalchemy # torch # virtualenv +tzdata==2026.2 ; python_full_version < '3.11' or sys_platform == 'emscripten' or sys_platform == 'win32' + # via pandas urllib3==2.7.0 # via # id diff --git a/src/torch_pfaffian/strategies/pfaffian_block_det.py b/src/torch_pfaffian/strategies/pfaffian_block_det.py index 526bd59..dd083ee 100644 --- a/src/torch_pfaffian/strategies/pfaffian_block_det.py +++ b/src/torch_pfaffian/strategies/pfaffian_block_det.py @@ -53,3 +53,11 @@ def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output): grad_matrix = torch.zeros_like(matrix) grad_matrix[..., :n, n:] = grad_block return grad_matrix + + @classmethod + def _pfaffian_adjugate(cls, matrices: torch.Tensor) -> torch.Tensor: + # This strategy's forward only accepts block-antidiagonal matrices, but the Pfaffian minors + # are general skew matrices, so the adjugate is computed with the general Parlett-Reid forward. + from .pfaffian_parlett_reid import PfaffianParlettReid + + return PfaffianParlettReid._pfaffian_adjugate(matrices) diff --git a/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py b/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py index 740465d..07773db 100644 --- a/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py +++ b/src/torch_pfaffian/strategies/pfaffian_parlett_reid.py @@ -12,11 +12,10 @@ class PfaffianParlettReid(PfaffianStrategy): The forward performs a batched skew-tridiagonalization with partial pivoting: the batch is processed together and only the ``n / 2`` column-elimination steps are sequential. The result is the signed Pfaffian, unlike the determinant-based strategies which return only the magnitude. - The backward uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T`` via a single - pseudo-inverse, with no autograd graph over the elimination. It equals the inverse for invertible - inputs (the exact gradient) and returns a finite zero on singular inputs instead of raising. At an - exactly-singular input that zero is the analytic continuation, not the true derivative, but such - points are measure-zero. + The backward uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T`` via the Pfaffian + adjugate, with no autograd graph over the elimination. For invertible inputs this is a single + pseudo-inverse; for singular inputs (``pf == 0``) the adjugate is computed exactly from minor + Pfaffians, so the gradient is correct everywhere (see :meth:`PfaffianStrategy.pfaffian_grad_matrix`). The input is a skew-symmetric matrix of shape ``(..., 2n, 2n)``. """ @@ -90,12 +89,6 @@ def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch. :rtype: torch.Tensor | None """ matrix, pfaffian = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) - grad_matrix = None - if ctx.needs_input_grad[0]: - # Use pinv, not inv: identical to inv for invertible A (exact gradient), but on a - # singular A it returns a finite 0 (since pf = 0) instead of raising. That 0 is the - # analytic continuation, not the true derivative at the exactly-singular point; such - # points are measure-zero and the forward there is also 0, so this is acceptable. - inverse = torch.linalg.pinv(matrix) - grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pfaffian, inverse) - return grad_matrix + if not ctx.needs_input_grad[0]: + return None + return PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) diff --git a/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py b/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py index 2827bd4..426e652 100644 --- a/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py +++ b/src/torch_pfaffian/strategies/pfaffian_rust_parlett_reid.py @@ -13,9 +13,10 @@ class RustPfaffianParlettReid(PfaffianStrategy): The forward moves the input to a contiguous CPU array and calls the compiled ``torch_pfaffian._rust`` kernel at a precision chosen from the input dtype: ``float32`` inputs use the single-precision kernel and every other floating dtype uses the double-precision kernel. - The result is cast back to the input dtype and device. The backward is the same closed form as - :class:`PfaffianParlettReid`, ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T``, computed in PyTorch. - CUDA inputs are evaluated on CPU for the forward; the backward inverse runs on the input device. + The result is cast back to the input dtype and device. The backward is the same as + :class:`PfaffianParlettReid` (the Pfaffian adjugate ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T``, + exact for invertible and singular inputs), computed in PyTorch. CUDA inputs are evaluated on CPU + for the forward; the backward runs on the input device. The input is a skew-symmetric matrix of shape ``(..., n, n)``. """ @@ -55,12 +56,6 @@ def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch. :rtype: torch.Tensor | None """ matrix, pfaffian = cast("tuple[torch.Tensor, torch.Tensor]", ctx.saved_tensors) - grad_matrix = None - if ctx.needs_input_grad[0]: - # Use pinv, not inv: identical to inv for invertible A (exact gradient), but on a - # singular A it returns a finite 0 (since pf = 0) instead of raising. That 0 is the - # analytic continuation, not the true derivative at the exactly-singular point; such - # points are measure-zero and the forward there is also 0, so this is acceptable. - inverse = torch.linalg.pinv(matrix) - grad_matrix = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pfaffian, inverse) - return grad_matrix + if not ctx.needs_input_grad[0]: + return None + return RustPfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) diff --git a/src/torch_pfaffian/strategies/strategy.py b/src/torch_pfaffian/strategies/strategy.py index 7723d9f..236d0c1 100644 --- a/src/torch_pfaffian/strategies/strategy.py +++ b/src/torch_pfaffian/strategies/strategy.py @@ -18,3 +18,65 @@ def forward(matrix: torch.Tensor): @staticmethod def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output): pass + + @classmethod + def pfaffian_grad_matrix( + cls, matrix: torch.Tensor, pfaffian: torch.Tensor, grad_output: torch.Tensor + ) -> torch.Tensor: + r""" + Gradient of the signed Pfaffian with respect to the input matrix. + + Uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T`` via the Pfaffian adjugate + ``pf(A) A^{-1}``. For invertible inputs the adjugate is ``pf(A) * pinv(A)`` (a single inverse); + for singular inputs (``pf == 0``), where that product would be ``0`` and miss the true + derivative, the adjugate is recomputed exactly from minor Pfaffians via + :meth:`_pfaffian_adjugate` (using ``cls``'s own forward). The minor-based path runs only on the + singular batch elements, so invertible inputs keep the single cheap inverse. + + :param matrix: The saved input matrix of shape ``(..., n, n)``. + :param pfaffian: The saved forward Pfaffian of shape ``(...,)``. + :param grad_output: Gradient of the output with respect to the loss, of shape ``(...,)``. + :return: Gradient of the input matrix, of shape ``(..., n, n)``. + :rtype: torch.Tensor + """ + adjugate = pfaffian[..., None, None] * torch.linalg.pinv(matrix) # pf(A) A^{-1}; 0 where pf == 0 + singular = pfaffian == 0 + if bool(singular.any()): + dimension = matrix.shape[-1] + flat_matrix = matrix.reshape(-1, dimension, dimension) + flat_adjugate = adjugate.reshape(-1, dimension, dimension) + singular_index = singular.reshape(-1).nonzero(as_tuple=True)[0] + with torch.no_grad(): + singular_adjugate = cls._pfaffian_adjugate(flat_matrix.index_select(0, singular_index)) + flat_adjugate = flat_adjugate.index_copy(0, singular_index, singular_adjugate.to(flat_adjugate.dtype)) + adjugate = flat_adjugate.reshape_as(matrix) + return torch.einsum("...,...ij->...ji", 0.5 * grad_output, adjugate) + + @classmethod + def _pfaffian_adjugate(cls, matrices: torch.Tensor) -> torch.Tensor: + r""" + Pfaffian adjugate ``P = pf(A) A^{-1}`` of a batch of skew-symmetric matrices. + + The adjugate is a polynomial in the entries of ``A`` (it equals ``pf(A) A^{-1}`` for invertible + ``A`` but stays finite when ``A`` is singular), so it is computed from minor Pfaffians rather + than an inverse: ``P_{ij} = (-1)^{i+j} pf(A^{(ij)})`` for ``i < j``, where ``A^{(ij)}`` is ``A`` + with rows and columns ``i`` and ``j`` removed, and ``P`` is skew-symmetric. The minor Pfaffians + are computed with this class's own :meth:`forward`; subclasses whose forward is not valid on the + minors (e.g. :class:`PfaffianBlockDet`) override this to use a general strategy. + + :param matrices: Skew-symmetric matrices of shape ``(m, n, n)``. + :return: The Pfaffian adjugate, of shape ``(m, n, n)``. + :rtype: torch.Tensor + """ + dimension = matrices.shape[-1] + adjugate = torch.zeros_like(matrices) + indices = torch.arange(dimension, device=matrices.device) + for first in range(dimension): + for second in range(first + 1, dimension): + keep = indices[(indices != first) & (indices != second)] + minor = matrices.index_select(-2, keep).index_select(-1, keep) # (m, n-2, n-2) + minor_pfaffian = cls.forward(minor) # (m,) + sign = 1.0 if (first + second) % 2 == 0 else -1.0 + adjugate[..., first, second] = sign * minor_pfaffian + adjugate[..., second, first] = -sign * minor_pfaffian + return adjugate diff --git a/tests/test_strategies/test_pfaffian_block_det.py b/tests/test_strategies/test_pfaffian_block_det.py index c819f12..a67800f 100644 --- a/tests/test_strategies/test_pfaffian_block_det.py +++ b/tests/test_strategies/test_pfaffian_block_det.py @@ -80,3 +80,15 @@ class _Context: needs_input_grad = (False,) assert PfaffianBlockDet.backward(_Context(), torch.ones_like(pfaffian)) is None + + def test_adjugate_override_delegates_to_parlett_reid(self): + # PfaffianBlockDet.forward is block-only, so its adjugate must defer to the general strategy. + from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid + + matrices = _block_antidiagonal(_RNG.random((3, 3, 3))) + torch.testing.assert_close( + PfaffianBlockDet._pfaffian_adjugate(matrices), + PfaffianParlettReid._pfaffian_adjugate(matrices), + atol=ATOL_MATRIX_COMPARISON, + rtol=RTOL_MATRIX_COMPARISON, + ) diff --git a/tests/test_strategies/test_pfaffian_parlett_reid.py b/tests/test_strategies/test_pfaffian_parlett_reid.py index f30d908..2e6a412 100644 --- a/tests/test_strategies/test_pfaffian_parlett_reid.py +++ b/tests/test_strategies/test_pfaffian_parlett_reid.py @@ -132,17 +132,25 @@ def test_backward_passes_gradcheck_on_skew_parameterization(self, dimension): rtol=RTOL_APPROX_COMPARISON, ) - def test_backward_finite_on_singular_matrix(self): - # Singular skew matrix (pf=0): the guarantee is that backward is FINITE (no LinAlgError), - # which pinv provides over inv. The returned zero is the analytic continuation, not the true - # derivative at this exactly-singular point, so we only assert finiteness here. - matrix = torch.zeros((4, 4), dtype=torch.float64) - matrix[2, 3] = 1.0 - matrix[3, 2] = -1.0 - matrix.requires_grad_(True) - PfaffianParlettReid.apply(matrix).backward() - assert matrix.grad is not None - assert torch.isfinite(matrix.grad).all() + def test_backward_exact_on_singular_matrix(self): + # At an exactly-singular skew input (pf=0) the gradient must be the TRUE derivative, via the + # Pfaffian adjugate. For the rank-2 matrix with only a_{23}=1, pf = a01*a23 - a02*a13 + a03*a12, + # so d pf / d a01 = a23 = 1 and the rest are 0. + parameters = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 1.0], dtype=torch.float64, requires_grad=True) + PfaffianParlettReid.apply(_skew_from_parameters(parameters, 4)).backward() + expected = torch.tensor([1.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=torch.float64) + torch.testing.assert_close(parameters.grad, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) + + def test_backward_gradcheck_at_singular_point(self): + # gradcheck centered at an exactly-singular skew point (would fail with the inverse-only form). + parameters = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 1.0], dtype=torch.float64, requires_grad=True) + assert gradcheck( + lambda values: PfaffianParlettReid.apply(_skew_from_parameters(values, 4)), + (parameters,), + eps=1e-6, + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) def test_backward_returns_none_when_input_does_not_require_grad(self): matrix = _random_skew(4, _RNG) diff --git a/tests/test_strategies/test_pfaffian_rust_parlett_reid.py b/tests/test_strategies/test_pfaffian_rust_parlett_reid.py index 6005a0e..61ad21f 100644 --- a/tests/test_strategies/test_pfaffian_rust_parlett_reid.py +++ b/tests/test_strategies/test_pfaffian_rust_parlett_reid.py @@ -145,17 +145,25 @@ def test_backward_passes_gradcheck_on_skew_parameterization(self, dimension): rtol=RTOL_APPROX_COMPARISON, ) - def test_backward_finite_on_singular_matrix(self): - # Singular skew matrix (pf=0): the guarantee is that backward is FINITE (no LinAlgError), - # which pinv provides over inv. The returned zero is the analytic continuation, not the true - # derivative at this exactly-singular point, so we only assert finiteness here. - matrix = torch.zeros((4, 4), dtype=torch.float64) - matrix[2, 3] = 1.0 - matrix[3, 2] = -1.0 - matrix.requires_grad_(True) - RustPfaffianParlettReid.apply(matrix).backward() - assert matrix.grad is not None - assert torch.isfinite(matrix.grad).all() + def test_backward_exact_on_singular_matrix(self): + # At an exactly-singular skew input (pf=0) the gradient must be the TRUE derivative, via the + # Pfaffian adjugate. For the rank-2 matrix with only a_{23}=1, pf = a01*a23 - a02*a13 + a03*a12, + # so d pf / d a01 = a23 = 1 and the rest are 0. + parameters = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 1.0], dtype=torch.float64, requires_grad=True) + RustPfaffianParlettReid.apply(_skew_from_parameters(parameters, 4)).backward() + expected = torch.tensor([1.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=torch.float64) + torch.testing.assert_close(parameters.grad, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) + + def test_backward_gradcheck_at_singular_point(self): + # gradcheck centered at an exactly-singular skew point (would fail with the inverse-only form). + parameters = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 1.0], dtype=torch.float64, requires_grad=True) + assert gradcheck( + lambda values: RustPfaffianParlettReid.apply(_skew_from_parameters(values, 4)), + (parameters,), + eps=1e-6, + atol=ATOL_APPROX_COMPARISON, + rtol=RTOL_APPROX_COMPARISON, + ) def test_backward_returns_none_when_input_does_not_require_grad(self): matrix = _random_skew(4, _RNG) diff --git a/tests/test_strategies/test_strategy.py b/tests/test_strategies/test_strategy.py index 2ae0e93..f8644e5 100644 --- a/tests/test_strategies/test_strategy.py +++ b/tests/test_strategies/test_strategy.py @@ -1,8 +1,16 @@ import torch +from tests.configs import ATOL_MATRIX_COMPARISON, RTOL_MATRIX_COMPARISON +from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid from torch_pfaffian.strategies.strategy import PfaffianStrategy +def _random_skew(dimension: int, seed: int) -> torch.Tensor: + generator = torch.Generator().manual_seed(seed) + full = torch.randn(dimension, dimension, dtype=torch.float64, generator=generator) + return full - full.transpose(-1, -2) + + class _RecordingContext: def save_for_backward(self, *tensors): self.saved_tensors = tensors @@ -26,3 +34,27 @@ def test_base_forward_is_not_implemented(self): def test_base_backward_is_not_implemented(self): assert PfaffianStrategy.backward(None, None) is None + + def test_grad_matrix_matches_inverse_form_on_invertible(self): + # For invertible inputs the adjugate-based gradient equals the inverse-based closed form. + matrix = _random_skew(6, seed=0) + pfaffian = PfaffianParlettReid.forward(matrix) + grad_output = torch.tensor(1.7, dtype=torch.float64) + expected = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pfaffian, torch.linalg.inv(matrix)) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_grad_matrix_uses_adjugate_on_singular(self): + # Singular batch element (pf=0): the gradient is the exact Pfaffian-adjugate form, not zero. + singular = torch.zeros(4, 4, dtype=torch.float64) + singular[2, 3] = 1.0 + singular[3, 2] = -1.0 + invertible = _random_skew(4, seed=1) + matrix = torch.stack([singular, invertible]) + pfaffian = PfaffianParlettReid.forward(matrix) + assert pfaffian[0] == 0.0 # the singular element really has Pfaffian 0 + grad_output = torch.ones(2, dtype=torch.float64) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + # d pf / d A_{01} = a_{23} = 1, so the gradient of the singular element is nonzero. + assert torch.isfinite(result).all() + assert result[0].abs().sum() > 0 diff --git a/uv.lock b/uv.lock index 3fa6a44..4a86916 100644 --- a/uv.lock +++ b/uv.lock @@ -2,20 +2,49 @@ version = 1 revision = 3 requires-python = ">=3.10, <3.15" resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] conflicts = [[ @@ -438,16 +467,45 @@ name = "contourpy" version = "1.3.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] dependencies = [ { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, @@ -650,7 +708,7 @@ name = "cryptography" version = "48.0.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "(platform_python_implementation != 'PyPy' and sys_platform != 'darwin') or (platform_python_implementation != 'PyPy' and extra != 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cffi", marker = "(python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'emscripten') or (python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'win32') or (python_full_version >= '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version >= '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version >= '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version >= '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version >= '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version >= '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (platform_python_implementation != 'PyPy' and sys_platform == 'darwin' and extra != 'extra-13-torchpfaffian-cpu') or (platform_python_implementation == 'PyPy' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (platform_python_implementation == 'PyPy' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (platform_python_implementation == 'PyPy' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform != 'darwin') or (python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/12/45/870e7f4bef50e5f53b9f51d4428aee5290eedf58ba443f16b1ebb7ab8e66/cryptography-48.0.1.tar.gz", hash = "sha256:266f4ee051abb2f725b74ef8072b521ce1feacf685a3364fa6a6b45548db791a", size = 832989, upload-time = "2026-06-09T22:32:31.8Z" } @@ -710,12 +768,13 @@ name = "cuda-bindings" version = "12.9.4" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ - { name = "cuda-pathfinder", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cuda-pathfinder", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/37/31/bfcc870f69c6a017c4ad5c42316207fc7551940db6f3639aa4466ec5faf3/cuda_bindings-12.9.4-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a022c96b8bd847e8dc0675523431149a4c3e872f440e3002213dbb9e08f0331a", size = 11800959, upload-time = "2025-10-21T14:51:26.458Z" }, @@ -746,12 +805,13 @@ name = "cuda-bindings" version = "13.0.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ - { name = "cuda-pathfinder", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cuda-pathfinder", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/3b/98/0666ee759cd2e5306f911cbc95d2c6c814326906ed6b9c09e817a4b4a7c8/cuda_bindings-13.0.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56e46a9e984bb754e56b9d060cf027fe99f08a97651ce6d8aa1c2032476d01e", size = 11762523, upload-time = "2025-10-21T15:08:45.913Z" }, @@ -1170,16 +1230,45 @@ name = "ipython" version = "9.14.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] dependencies = [ { name = "colorama", marker = "(python_full_version >= '3.11' and sys_platform == 'win32') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, @@ -2075,16 +2164,45 @@ name = "networkx" version = "3.6.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } wheels = [ @@ -2208,16 +2326,45 @@ name = "numpy" version = "2.4.6" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" } wheels = [ @@ -2379,7 +2526,7 @@ name = "nvidia-cudnn-cu12" version = "9.10.2.21" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/fa/41/e79269ce215c857c935fd86bcfe91a451a584dfc27f1e068f568b9ad1ab7/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c9132cc3f8958447b4910a1720036d9eff5928cc3179b0a51fb6d167c6cc87d8", size = 705026878, upload-time = "2025-06-06T21:52:51.348Z" }, @@ -2392,7 +2539,7 @@ name = "nvidia-cudnn-cu13" version = "9.15.1.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/ff/93/b3c9db2c35d6183361333d2dcfea50e094c012d012c8a4d7effbfb53ef62/nvidia_cudnn_cu13-9.15.1.9-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:44cd2ec83c3ef62a7357614bd02ce7f3dac35ffcbb04ad20999e730741f0ba17", size = 415636241, upload-time = "2025-11-12T20:22:26.582Z" }, @@ -2405,7 +2552,7 @@ name = "nvidia-cufft" version = "12.0.0.61" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" }, @@ -2418,7 +2565,7 @@ name = "nvidia-cufft-cu12" version = "11.3.3.83" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/60/bc/7771846d3a0272026c416fbb7e5f4c1f146d6d80704534d0b187dd6f4800/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:848ef7224d6305cdb2a4df928759dca7b1201874787083b6e7550dd6765ce69a", size = 193109211, upload-time = "2025-03-07T01:44:56.873Z" }, @@ -2469,9 +2616,9 @@ name = "nvidia-cusolver" version = "12.0.4.66" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "nvidia-cusparse", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparse", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" }, @@ -2484,9 +2631,9 @@ name = "nvidia-cusolver-cu12" version = "11.7.3.90" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "nvidia-cusparse-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cublas-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-cusparse-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c8/32/f7cd6ce8a7690544d084ea21c26e910a97e077c9b7f07bf5de623ee19981/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:db9ed69dbef9715071232caa9b69c52ac7de3a95773c2db65bdba85916e4e5c0", size = 267229841, upload-time = "2025-03-07T01:46:54.356Z" }, @@ -2499,7 +2646,7 @@ name = "nvidia-cusparse" version = "12.6.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink", marker = "(extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu130') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" }, @@ -2512,7 +2659,7 @@ name = "nvidia-cusparse-cu12" version = "12.5.8.93" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "extra == 'extra-13-torchpfaffian-cu128' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128') or (python_full_version < '3.11' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/bc/f7/cd777c4109681367721b00a106f491e0d0d15cfa1fd59672ce580ce42a97/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b6c161cb130be1a07a27ea6923df8141f3c295852f4b260c65f18f3e0a091dc", size = 288117129, upload-time = "2025-03-07T01:47:40.407Z" }, @@ -2625,6 +2772,175 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, ] +[[package]] +name = "pandas" +version = "2.3.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version < '3.11' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "python-dateutil", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pytz", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "tzdata", marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/f7/f425a00df4fcc22b292c6895c6831c0c8ae1d9fac1e024d16f98a9ce8749/pandas-2.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:376c6446ae31770764215a6c937f72d917f214b43560603cd60da6408f183b6c", size = 11555763, upload-time = "2025-09-29T23:16:53.287Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/66d99628ff8ce7857aca52fed8f0066ce209f96be2fede6cef9f84e8d04f/pandas-2.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e19d192383eab2f4ceb30b412b22ea30690c9e618f78870357ae1d682912015a", size = 10801217, upload-time = "2025-09-29T23:17:04.522Z" }, + { url = "https://files.pythonhosted.org/packages/1d/03/3fc4a529a7710f890a239cc496fc6d50ad4a0995657dccc1d64695adb9f4/pandas-2.3.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5caf26f64126b6c7aec964f74266f435afef1c1b13da3b0636c7518a1fa3e2b1", size = 12148791, upload-time = "2025-09-29T23:17:18.444Z" }, + { url = "https://files.pythonhosted.org/packages/40/a8/4dac1f8f8235e5d25b9955d02ff6f29396191d4e665d71122c3722ca83c5/pandas-2.3.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd7478f1463441ae4ca7308a70e90b33470fa593429f9d4c578dd00d1fa78838", size = 12769373, upload-time = "2025-09-29T23:17:35.846Z" }, + { url = "https://files.pythonhosted.org/packages/df/91/82cc5169b6b25440a7fc0ef3a694582418d875c8e3ebf796a6d6470aa578/pandas-2.3.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4793891684806ae50d1288c9bae9330293ab4e083ccd1c5e383c34549c6e4250", size = 13200444, upload-time = "2025-09-29T23:17:49.341Z" }, + { url = "https://files.pythonhosted.org/packages/10/ae/89b3283800ab58f7af2952704078555fa60c807fff764395bb57ea0b0dbd/pandas-2.3.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28083c648d9a99a5dd035ec125d42439c6c1c525098c58af0fc38dd1a7a1b3d4", size = 13858459, upload-time = "2025-09-29T23:18:03.722Z" }, + { url = "https://files.pythonhosted.org/packages/85/72/530900610650f54a35a19476eca5104f38555afccda1aa11a92ee14cb21d/pandas-2.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:503cf027cf9940d2ceaa1a93cfb5f8c8c7e6e90720a2850378f0b3f3b1e06826", size = 11346086, upload-time = "2025-09-29T23:18:18.505Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" }, + { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" }, + { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" }, + { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" }, + { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" }, + { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" }, + { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" }, + { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" }, + { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" }, + { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" }, + { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" }, + { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" }, + { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" }, + { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" }, + { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" }, + { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" }, + { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" }, + { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" }, + { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" }, + { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" }, + { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload-time = "2025-09-29T23:27:51.625Z" }, + { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload-time = "2025-09-29T23:28:21.289Z" }, + { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload-time = "2025-09-29T23:28:58.261Z" }, + { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload-time = "2025-09-29T23:32:27.484Z" }, + { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload-time = "2025-09-29T23:29:31.47Z" }, + { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload-time = "2025-09-29T23:29:54.591Z" }, + { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload-time = "2025-09-29T23:30:21.003Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload-time = "2025-09-29T23:30:43.391Z" }, + { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload-time = "2025-09-29T23:31:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" }, +] + +[[package]] +name = "pandas" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", +] +dependencies = [ + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "python-dateutil", marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/16/b5c76b838fd9bf6ce84d3a53346b8874ec05c5f0040d75ef2c320100cd2a/pandas-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:455f6f8139d4282188f526868dbc3c828470e88a3d9d59a891bd46a455f21b98", size = 10338495, upload-time = "2026-05-11T18:52:11.558Z" }, + { url = "https://files.pythonhosted.org/packages/5a/b0/a4ffc4ae74d2d822200dcc46898987d8eb6032d1e2b219cae39da6f5cbcc/pandas-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4e15135e2ee5df1063313e2425ceef8ac0f4ae775893815b0923651b806a5639", size = 9938250, upload-time = "2026-05-11T18:52:17.005Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b2/3323601a52caee42c019e370090ca4544b241437240ca04f786cce82b0cf/pandas-3.0.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:05f1f1752b8533ea03f7f39a9c15b1a058d067bb48f4748948e7a8691e0510f2", size = 10770558, upload-time = "2026-05-11T18:52:19.865Z" }, + { url = "https://files.pythonhosted.org/packages/32/f1/bbecd2f867b97abebe0f9b53d750f862251b40337e061b36676ded3d920f/pandas-3.0.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a1e45c80cceb3b4a21bc5939d52e8cbd8d9b7305309219d59e9754d9ce09e27", size = 11274611, upload-time = "2026-05-11T18:52:22.622Z" }, + { url = "https://files.pythonhosted.org/packages/7f/4f/eafabf2d5fae5adf143b4d18d3706c5efdc368a7c4eb1ee8a3eddabbd0f6/pandas-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:14da8316da4d0c5a77618425996bfb1248ca87fc2c1486e6fde4652bd18b5824", size = 11784670, upload-time = "2026-05-11T18:52:25.4Z" }, + { url = "https://files.pythonhosted.org/packages/49/44/1eb20389301b57b19cc099a1c2f662501f72f08a65f912d05822613c1532/pandas-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a55066a0505dae0ba2b50a46637db34b46f9094c65c5d4800794ef6335010938", size = 12353708, upload-time = "2026-05-11T18:52:28.139Z" }, + { url = "https://files.pythonhosted.org/packages/eb/62/c321f13b5ba1819fc8dca456c7fce578da2dcfecff1abbf0eaddf8406c0f/pandas-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6674ab18ad8c57802867264b00e15e7bb904700cdd9046e3b2fa1fce237439ea", size = 9907609, upload-time = "2026-05-11T18:52:30.982Z" }, + { url = "https://files.pythonhosted.org/packages/53/85/1b7f563ebc6357c27233a02a96b589bcce1fa9c6eb89fb4f0e56421d277e/pandas-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:5cc09a68b3120e0f54870dede8287a7bb1fa463907e4fcec1ea77cab6179bf7a", size = 9165596, upload-time = "2026-05-11T18:52:33.334Z" }, + { url = "https://files.pythonhosted.org/packages/24/f1/392f8c5bfc16f66a0d2d41561c01627c228fe7ed2a0d056ef11315042570/pandas-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fed2ff7fd9779120e388e285fc029bd5cf9490cdd2e4166a9ee22c0e49a9ab09", size = 10357846, upload-time = "2026-05-11T18:52:36.143Z" }, + { url = "https://files.pythonhosted.org/packages/cf/3d/b16412745651e855f357e5e66930248688378853a6e2698a214e331fba1f/pandas-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b168fc218fd80a6cbdbdbc1a97ddc7889ed057d7eb45f50d866ceab5f39904c4", size = 9899550, upload-time = "2026-05-11T18:52:38.976Z" }, + { url = "https://files.pythonhosted.org/packages/31/a8/fa2535168fffcedf67f4f6de28d2dd903a747ca7c8ea6989451aaeb3a92f/pandas-3.0.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0383c72c75cdcca61a9e116e611143902dbfd08bff356829c2f6d1cf40a9ca8c", size = 10412965, upload-time = "2026-05-11T18:52:41.915Z" }, + { url = "https://files.pythonhosted.org/packages/65/b6/09b01cdbc15224e2850365192d17b7bdebb8bdbd8780ed221fcdf0d9a515/pandas-3.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6dc0b3fd2169c9157deed50b4d519553a3655c8c6a96027136d654592be973a9", size = 10894600, upload-time = "2026-05-11T18:52:45.02Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a4/2eb28f2fccb4ced4a2c79ab2a5dee9ade1ebf44922ebad6fea158c9f95d4/pandas-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7e65d5407dc0b394f509699650e4a2ec01c0514f21850f453fa60f3be79a5dbf", size = 11422824, upload-time = "2026-05-11T18:52:48.058Z" }, + { url = "https://files.pythonhosted.org/packages/f8/45/830bb57f533a4604b355e07edcb8ea18cf88b5f94e5fca92f27052d7c597/pandas-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f8894dc474d648fe7b6ff0ca9b0bd73950d19952bc1a6534540762c5d79d305c", size = 11950889, upload-time = "2026-05-11T18:52:50.905Z" }, + { url = "https://files.pythonhosted.org/packages/b9/c5/fc1b368f303087d20e8c9bf3d6ceb186263cfac0ade735cd938538bea839/pandas-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:c7be265b62cef88e253a941e4698604973736dcfe242fdb5198f0f7bc473cdcc", size = 9755463, upload-time = "2026-05-11T18:52:53.386Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/fda8f9705b1b09c6ebe14bfc0fa0e4ec8584d54ea673628f157ff55131af/pandas-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:557409bc4178e70ee8d9ddb494798e51ebf6ea59330f6be22c51bab2a7db6c49", size = 9066158, upload-time = "2026-05-11T18:52:56.038Z" }, + { url = "https://files.pythonhosted.org/packages/c5/90/62d8302883c44308c477e222c3daf7c813a34c8e96985882fbd53d964352/pandas-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:67b3b64c11910cfa29f4e94a14d3bff9ee693b6fc76055e7cad549cee0aec5fa", size = 10331071, upload-time = "2026-05-11T18:52:58.838Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ae/6a6493c783a101f165e4356953ba3c74d6f77f0042fa7d753da9dfbb640c/pandas-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:39436b377d56d2a2e52d0395bdbee171f01068e99af5250509aceeb929f765c7", size = 9875690, upload-time = "2026-05-11T18:53:01.431Z" }, + { url = "https://files.pythonhosted.org/packages/62/7c/5df8e9f56c69a2769fbe9382a5ef8f2658c007e376434e1e2cbb57ad895f/pandas-3.0.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4be06d68f9ddcfc645b87534911da79a8fbffc7573c80e0edcf42a5020624d8", size = 10381634, upload-time = "2026-05-11T18:53:04.393Z" }, + { url = "https://files.pythonhosted.org/packages/99/68/1237369725aa617bb358263d535803e3053fdbc593513ec5ed9c9896b5b6/pandas-3.0.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a4eeb6830daf35a71cc09649bd823e2b542dac246cdee9614c6e4bd65028cd6a", size = 10891243, upload-time = "2026-05-11T18:53:07.643Z" }, + { url = "https://files.pythonhosted.org/packages/25/93/77d108e8af7222b4a503ebde0e30215b1c2e4f8e53a526431890f22d5586/pandas-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1928e07221f82db493cd4af1e23c1bfca524a19a4699887975bff68f49a72bfb", size = 11388659, upload-time = "2026-05-11T18:53:10.634Z" }, + { url = "https://files.pythonhosted.org/packages/d0/bd/eff5b4399f332ac386c853f6cd2bd3fa2ca0061b9f36ecd9c4d7c4265649/pandas-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51b1fe551acb77dac643c6fda86084d8d446c10fe64b06a9cc29c4cc8540e7f2", size = 11942880, upload-time = "2026-05-11T18:53:13.536Z" }, + { url = "https://files.pythonhosted.org/packages/2c/20/559ace4200982c3887d0b86bfd0d856a2143ef8ddab63cc07934951a964c/pandas-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:a82d532a3351d435432cd913edbccaf8b8e01d4dd0e5ced5a8d2e8ecd94c7e44", size = 9757091, upload-time = "2026-05-11T18:53:16.306Z" }, + { url = "https://files.pythonhosted.org/packages/3a/66/69055a09fe200f29f922a3eeec4804611900b95f52d932ece3393c3c0c19/pandas-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:275c14e0fce14a2ec20eee474aecd305478ea3c1e6f6a9d8fe219a165542717e", size = 9057282, upload-time = "2026-05-11T18:53:18.768Z" }, + { url = "https://files.pythonhosted.org/packages/57/0e/efe801b0e6811e8e650cd21b7f2608e30f08a7067e2bf6e8752b0d56ee3c/pandas-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:46997386d528eb40376ecd6b033cf4a8a1e5282580f68f43de875b78cba2199d", size = 10767016, upload-time = "2026-05-11T18:53:21.227Z" }, + { url = "https://files.pythonhosted.org/packages/ea/dc/eb55135a1d5f0f0519f28da1f609a206d2cad1f9c35c32d51e38dd7261ae/pandas-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:261e308dfb22448384b7580cf719d2f998fe2966c92893c3e77d14008af1f066", size = 10420210, upload-time = "2026-05-11T18:53:23.982Z" }, + { url = "https://files.pythonhosted.org/packages/c6/3e/b1d5d955ce33ffecb407465a60bc32769d74fcf68224b7ae67ae11d4dea4/pandas-3.0.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dd1a5d1def6a46002e964510bdc67c368aa0951df5d1d9f8365336f5a1f490cd", size = 10336126, upload-time = "2026-05-11T18:53:26.731Z" }, + { url = "https://files.pythonhosted.org/packages/f5/76/a01261711ab60a22d71b862f0de20e4c504bf80457270ad8cb42110f6abc/pandas-3.0.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d72828c20c6d6e83e1e22a6a3b47b326b71664112fa9705dcbccfd7a39b62085", size = 10728051, upload-time = "2026-05-11T18:53:29.125Z" }, + { url = "https://files.pythonhosted.org/packages/e9/21/ea191195e587b18cf682e97f433f81b2d0fbe341380e80a3e0d6e4403c8e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d26cbe1fcfc12e8fd900e2454163e466b2d3af84f7c75481df7683ffc073d870", size = 11350796, upload-time = "2026-05-11T18:53:32.056Z" }, + { url = "https://files.pythonhosted.org/packages/64/69/f0eaaf54939f0e8c6768fd06be9af2cef9b36048b96dfb9e1b2c685a807e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e91cec1879ada0624fc3dc9953c5cbd60208e59c0db28f540c5d6d47502422f", size = 11799741, upload-time = "2026-05-11T18:53:34.985Z" }, + { url = "https://files.pythonhosted.org/packages/45/a4/865e0e510cae5fc2194de4db28be638952de942571ba9125934fd9c01d47/pandas-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:08d789b41f87e0905880e293cedf6197ce71fe67cc081358b1e148a491b9bd13", size = 10499958, upload-time = "2026-05-11T18:53:37.857Z" }, + { url = "https://files.pythonhosted.org/packages/86/54/effdcc3c0ff7a08037889200e148ebe94c16c4f653be078c7b3675955df1/pandas-3.0.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3650109c0f22879df8bd6179ab9ee3d7f1d1d4e7e0094a3f0032d9f51e2e64ac", size = 10336065, upload-time = "2026-05-11T18:53:41.099Z" }, + { url = "https://files.pythonhosted.org/packages/68/10/bf2d6738d72748b961a3751ab89522d58c54efc36a8e1a12161216cd45cf/pandas-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:bab900348131a7db1f69a7309ef141fd5680f1487094193bcbbb61791573bf8f", size = 9926101, upload-time = "2026-05-11T18:53:43.515Z" }, + { url = "https://files.pythonhosted.org/packages/ae/e9/e35cf11c8a136e757b956f5f0efdcaa50aecde85ea055f1898dfc68262f3/pandas-3.0.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba7e08b9ac1d54569cd1e256e3668975ed624d6826f7b68df0342b012007bddb", size = 10457553, upload-time = "2026-05-11T18:53:46.394Z" }, + { url = "https://files.pythonhosted.org/packages/58/3b/1cdec6772bdbaf7b25dab360c59f03cadf05492dd724c6540af905389b07/pandas-3.0.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d71c63ae4ebdbf70209742096f1fc46a83a0613c99d4b23766cced9ff8cd62a", size = 10914065, upload-time = "2026-05-11T18:53:49.134Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c2/1ef644445fcd72e3627bceec77e3560636f87ddce4ed841afe76b83b5bf9/pandas-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3a2ec42c98ffa2565a67e08e218d06d72576d758d90facb7c00805194d8f360", size = 11459188, upload-time = "2026-05-11T18:53:52.527Z" }, + { url = "https://files.pythonhosted.org/packages/7e/49/4d8d4f42cbc9c4adc7a1870f269c02cbd6cd40d059622c06fb298addcbad/pandas-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:335f62418ed562cfc3c49e9e196375c28b729dcef8543abf4f9438e381bf3c76", size = 11982966, upload-time = "2026-05-11T18:53:55.043Z" }, + { url = "https://files.pythonhosted.org/packages/38/55/792619469bab9882d8bbd5865d45a72f6478762d04a9af4bf0d08c503e95/pandas-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:3c20a521bbb85902f79f7270c80a59e1b5452d96d170c034f207181870f97ac5", size = 9876755, upload-time = "2026-05-11T18:53:58.067Z" }, + { url = "https://files.pythonhosted.org/packages/2a/af/33c469653b0ba03b50c3a98192d4c07f0c75c66b263ceb097fce0ee97d31/pandas-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:a2d2dff8a04f3917b55ab3910c32990f8ddf7eceba114947838cefa976a68977", size = 9198658, upload-time = "2026-05-11T18:54:00.733Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fa/b8c257bd76b8bd060c3a9151c1fca05e9b9c5e3af5d0f549c0356f6d143d/pandas-3.0.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0d589105b3c14645af1738ff279b2995102d8f7a03b0a66dc8d95550eb513e04", size = 10787242, upload-time = "2026-05-11T18:54:03.564Z" }, + { url = "https://files.pythonhosted.org/packages/54/eb/f19206ffb0bf1919002969aa448b4702c6594845156a6f8050674855aac3/pandas-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:13fc1e853d9e04743d11ba75a985ccbc2a317fe07d8af61e445a6fd24dacd6a6", size = 10436369, upload-time = "2026-05-11T18:54:06.311Z" }, + { url = "https://files.pythonhosted.org/packages/fd/24/c7c39fb4fe22b71a0c2d78bf0c585c600092d85f94f086d2b3b2f6ca27e2/pandas-3.0.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:819959dab7bbd0049c15623fbac4e29a191b9528160a61fb1032242d8ced2d9c", size = 10358306, upload-time = "2026-05-11T18:54:09.085Z" }, + { url = "https://files.pythonhosted.org/packages/16/ec/dd2a9eb7fa1204df88c0864164e35b228ac581062ac612ba0a67fd812e4c/pandas-3.0.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:60ae316d3fd75d1858d450d0db0103ea2be3e7d4a95ec2f064f7e2ae63f7b028", size = 10758394, upload-time = "2026-05-11T18:54:11.956Z" }, + { url = "https://files.pythonhosted.org/packages/95/6e/00c61ea8e85b4f6d8d35e11852a1a4998fc7fafc91c6a602d1cc9c972d64/pandas-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd3a518890b400d32f9023722dc9a9a5c969f00b415419a3c06c043f09bb5d7d", size = 11375717, upload-time = "2026-05-11T18:54:14.539Z" }, + { url = "https://files.pythonhosted.org/packages/31/89/8fc1c268969fac43688d65fd92e67df24bd128d53cb4d2eee534cd307399/pandas-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c39be2d709d01fa972a0cabc522389fceca4f3969332ba25a7d6c5802cf976a", size = 11828897, upload-time = "2026-05-11T18:54:17.146Z" }, + { url = "https://files.pythonhosted.org/packages/56/3b/e7d20dea247a3e6dc0bd8a6953854afbedc03951def4e7371e05e7263e25/pandas-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4db8c527972a821cf5286b40ccc57642a39bc62e62022b42f99f8a67fca8c3a1", size = 10900855, upload-time = "2026-05-11T18:54:19.72Z" }, + { url = "https://files.pythonhosted.org/packages/0f/54/68a0978d1ef8502b8492099beaa6e7a0c1b32e3b5d4f677f5810cb08711c/pandas-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b2c95f8bfc1ee412bf482605d7bfd30c12d1d26bd59fdd91efeef1d4718decb1", size = 9466464, upload-time = "2026-05-11T18:54:22.754Z" }, +] + [[package]] name = "pandocfilters" version = "1.5.1" @@ -2657,7 +2973,7 @@ name = "pexpect" version = "4.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ptyprocess" }, + { name = "ptyprocess", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } wheels = [ @@ -3032,6 +3348,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c8/8d/3d316429f65029532bb1e28ff77b797d86b5ac3915bb44ca4e19aa283d43/python_discovery-1.4.0-py3-none-any.whl", hash = "sha256:26ed78d703e234879a66244c7d4114563fb13ec5cd30a2d1357e5fb4850782da", size = 33217, upload-time = "2026-05-28T01:15:36.573Z" }, ] +[[package]] +name = "pytz" +version = "2026.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ff/46/dd499ec9038423421951e4fad73051febaa13d2df82b4064f87af8b8c0c3/pytz-2026.2.tar.gz", hash = "sha256:0e60b47b29f21574376f218fe21abc009894a2321ea16c6754f3cad6eb7cdd6a", size = 320861, upload-time = "2026-05-04T01:35:29.667Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/dd/96da98f892250475bdf2328112d7468abdd4acc7b902b6af23f4ed958ea0/pytz-2026.2-py2.py3-none-any.whl", hash = "sha256:04156e608bee23d3792fd45c94ae47fae1036688e75032eea2e3bf0323d1f126", size = 510141, upload-time = "2026-05-04T01:35:27.408Z" }, +] + [[package]] name = "pywin32-ctypes" version = "0.2.3" @@ -3390,16 +3715,45 @@ name = "rpds-py" version = "2026.5.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and sys_platform != 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version >= '3.12' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", - "python_full_version == '3.11.*' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32' and extra != 'extra-13-torchpfaffian-cpu' and extra != 'extra-13-torchpfaffian-cu128' and extra != 'extra-13-torchpfaffian-cu130'", ] sdist = { url = "https://files.pythonhosted.org/packages/2e/43/25a8dcd3feedd735039a8f0b5b7e3b118232b5eae288c4fd9ab200d41094/rpds_py-2026.5.1.tar.gz", hash = "sha256:07b24fea40541e28570e5b795a4a38fbdcd12550c06bd0748005ecc8116ca256", size = 64459, upload-time = "2026-05-28T12:02:13.232Z" } wheels = [ @@ -3530,13 +3884,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/15/19/016553f86f207450aebebc2b2b5088d086b901cc8186c02ac4284db3bd88/ruff-0.15.16-py3-none-win_arm64.whl", hash = "sha256:8cd61783afb39638a7133ef0d2dfb1e91277593962f81b5a8423eb0b888a6121", size = 11134555, upload-time = "2026-06-04T16:33:00.136Z" }, ] +[[package]] +name = "seaborn" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" }, +] + [[package]] name = "secretstorage" version = "3.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cryptography", marker = "sys_platform != 'darwin' or extra != 'extra-13-torchpfaffian-cpu' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, - { name = "jeepney", marker = "sys_platform != 'darwin' or extra != 'extra-13-torchpfaffian-cpu' or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "cryptography", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra != 'extra-13-torchpfaffian-cpu') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, + { name = "jeepney", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'darwin' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'darwin' and extra != 'extra-13-torchpfaffian-cpu') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'emscripten' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu128') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cpu' and extra == 'extra-13-torchpfaffian-cu130') or (sys_platform == 'win32' and extra == 'extra-13-torchpfaffian-cu128' and extra == 'extra-13-torchpfaffian-cu130')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } wheels = [ @@ -3886,7 +4256,8 @@ name = "torch" version = "2.10.0" source = { registry = "https://download.pytorch.org/whl/cpu" } resolution-markers = [ - "python_full_version >= '3.12' and sys_platform == 'darwin'", + "python_full_version >= '3.14' and sys_platform == 'darwin'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin'", "python_full_version == '3.11.*' and sys_platform == 'darwin'", "python_full_version < '3.11' and sys_platform == 'darwin'", ] @@ -3923,8 +4294,15 @@ name = "torch" version = "2.10.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ @@ -3984,8 +4362,15 @@ name = "torch" version = "2.10.0+cpu" source = { registry = "https://download.pytorch.org/whl/cpu" } resolution-markers = [ - "python_full_version >= '3.12' and sys_platform != 'darwin'", - "python_full_version == '3.11.*' and sys_platform != 'darwin'", + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11' and sys_platform != 'darwin'", ] dependencies = [ @@ -4044,8 +4429,15 @@ name = "torch" version = "2.10.0+cu128" source = { registry = "https://download.pytorch.org/whl/cu128" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ @@ -4104,8 +4496,15 @@ name = "torch" version = "2.10.0+cu130" source = { registry = "https://download.pytorch.org/whl/cu130" } resolution-markers = [ - "python_full_version >= '3.12'", - "python_full_version == '3.11.*'", + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.11'", ] dependencies = [ @@ -4199,6 +4598,7 @@ dev = [ { name = "pytest-timeout" }, { name = "pytest-xdist" }, { name = "ruff" }, + { name = "seaborn" }, { name = "tqdm" }, { name = "twine" }, { name = "wheel" }, @@ -4245,6 +4645,7 @@ dev = [ { name = "pytest-timeout", specifier = ">=2.4" }, { name = "pytest-xdist", specifier = ">=3.7,<4" }, { name = "ruff", specifier = ">=0.9,<1" }, + { name = "seaborn", specifier = ">=0.13.2" }, { name = "tqdm", specifier = ">=4.68.2" }, { name = "twine", specifier = ">=6.1,<7" }, { name = "wheel", specifier = ">=0.45,<0.46" }, @@ -4355,6 +4756,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, ] +[[package]] +name = "tzdata" +version = "2026.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", hash = "sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10", size = 198254, upload-time = "2026-04-24T15:22:08.651Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, +] + [[package]] name = "urllib3" version = "2.7.0" From 4329285761bb038b9ed66e07c90dd4f576cbd3ae Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Thu, 11 Jun 2026 12:23:38 -0400 Subject: [PATCH 5/7] Update strategy selection logic for Pfaffian to handle non-CPU devices and improve documentation --- notebooks/strategies_benchmark.ipynb | 328 +--------------------- src/torch_pfaffian/__init__.py | 22 +- src/torch_pfaffian/strategies/__init__.py | 4 +- tests/test_torch_pfaffian.py | 14 + 4 files changed, 40 insertions(+), 328 deletions(-) diff --git a/notebooks/strategies_benchmark.ipynb b/notebooks/strategies_benchmark.ipynb index dfb24e3..77c3ef5 100644 --- a/notebooks/strategies_benchmark.ipynb +++ b/notebooks/strategies_benchmark.ipynb @@ -14,31 +14,8 @@ }, { "cell_type": "code", - "execution_count": 1, "id": "657871cca9161529", - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-11T11:54:45.638647773Z", - "start_time": "2026-06-11T11:54:44.418952207Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running benchmarks on device: cpu\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/local/USHERBROOKE/ginj2102/github/TorchPfaffian/.venv/lib/python3.14/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "metadata": {}, "source": [ "import os\n", "import sys\n", @@ -70,7 +47,9 @@ "\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "print(f\"Running benchmarks on device: {device}\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -84,280 +63,8 @@ }, { "cell_type": "code", - "execution_count": 2, "id": "6ace4294c6d4b34", - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-11T12:15:32.924961778Z", - "start_time": "2026-06-11T11:54:45.649903607Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Benchmarking PfaffianFDBPf (n: 2 | seed: 0 ): 0%| | 0/640 [00:00" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "fig = plot_results(results, strategies, batch_size, device=device)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", diff --git a/src/torch_pfaffian/__init__.py b/src/torch_pfaffian/__init__.py index c600127..266be90 100644 --- a/src/torch_pfaffian/__init__.py +++ b/src/torch_pfaffian/__init__.py @@ -45,14 +45,17 @@ def pfaffian(matrix: torch.Tensor, *, sign: bool = True, check_input: bool = Fal Strategy selection: - ============================= =========================== =============================================== - Condition Strategy Reason - ============================= =========================== =============================================== - ``sign=True``, Rust available ``RustPfaffianParlettReid`` fastest signed path (native Rust kernel) - ``sign=True``, Rust not built ``PfaffianParlettReid`` pure-Python signed fallback - ``sign=False``, grad needed ``PfaffianFDBPf`` magnitude only; robust analytic backward (pinv) - ``sign=False``, no grad ``PfaffianDet`` cheapest: ``sqrt(|det|)`` only - ============================= =========================== =============================================== + =================================== =========================== ========================================= + Condition Strategy Reason + =================================== =========================== ========================================= + ``sign=True``, Rust built, CPU input ``RustPfaffianParlettReid`` fastest signed path (native Rust kernel) + ``sign=True``, otherwise ``PfaffianParlettReid`` GPU-native and pure-Python fallback + ``sign=False``, grad needed ``PfaffianFDBPf`` magnitude only; robust analytic backward + ``sign=False``, no grad ``PfaffianDet`` cheapest: ``sqrt(|det|)`` only + =================================== =========================== ========================================= + + The Rust kernel runs on CPU, so a non-CPU (e.g. CUDA) input is routed to ``PfaffianParlettReid``, + which runs natively on the input device and avoids a host round-trip. The Pfaffian is only defined for skew-symmetric matrices; the strategies assume this and do not check it. Pass ``check_input=True`` to validate the assumption. For large matrices the Pfaffian @@ -75,7 +78,8 @@ def pfaffian(matrix: torch.Tensor, *, sign: bool = True, check_input: bool = Fal raise ValueError("Input matrix is not skew-symmetric (A != -A^T).") if sign: - if RustPfaffianParlettReid is not None: + # The Rust kernel is CPU-only, so non-CPU inputs use the device-native PyTorch strategy. + if RustPfaffianParlettReid is not None and matrix.device.type == "cpu": result = RustPfaffianParlettReid.apply(matrix) else: result = PfaffianParlettReid.apply(matrix) diff --git a/src/torch_pfaffian/strategies/__init__.py b/src/torch_pfaffian/strategies/__init__.py index d37d1d4..482bc29 100644 --- a/src/torch_pfaffian/strategies/__init__.py +++ b/src/torch_pfaffian/strategies/__init__.py @@ -10,5 +10,5 @@ try: from .pfaffian_rust_parlett_reid import RustPfaffianParlettReid -except ImportError: - RustPfaffianParlettReid = None +except ImportError: # pragma: no cover + RustPfaffianParlettReid = None # pragma: no cover diff --git a/tests/test_torch_pfaffian.py b/tests/test_torch_pfaffian.py index 065f02a..cc98b7e 100644 --- a/tests/test_torch_pfaffian.py +++ b/tests/test_torch_pfaffian.py @@ -76,6 +76,20 @@ def test_pfaffian_routes_sign_true_to_python_when_rust_unavailable(self): pfaffian(self._skew_matrix(), sign=True) fake.apply.assert_called_once() + def test_pfaffian_sign_true_routes_to_python_on_non_cpu_device(self): + # The Rust kernel is CPU-only, so a non-CPU input must use the device-native PyTorch strategy. + pytest.importorskip("torch_pfaffian._rust") + non_cpu_matrix = mock.MagicMock() + non_cpu_matrix.device.type = "cuda" + with ( + mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid") as fake_rust, + mock.patch.object(torch_pfaffian, "PfaffianParlettReid") as fake_python, + ): + fake_python.apply.return_value = torch.zeros(()) + pfaffian(non_cpu_matrix, sign=True) + fake_python.apply.assert_called_once() + fake_rust.apply.assert_not_called() + def test_pfaffian_routes_magnitude_no_grad_to_det(self): with mock.patch.object(torch_pfaffian, "PfaffianDet") as fake: fake.apply.return_value = torch.zeros(()) From 3ea24a84e907dffc8ea0a3df945cc8bfb257896a Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Thu, 11 Jun 2026 13:29:12 -0400 Subject: [PATCH 6/7] Update `strategies_benchmark.ipynb` outputs and metadata to include execution details and results for benchmarking --- notebooks/strategies_benchmark.ipynb | 247 ++++++++++++++++++++++++++- 1 file changed, 239 insertions(+), 8 deletions(-) diff --git a/notebooks/strategies_benchmark.ipynb b/notebooks/strategies_benchmark.ipynb index 77c3ef5..4bdeb88 100644 --- a/notebooks/strategies_benchmark.ipynb +++ b/notebooks/strategies_benchmark.ipynb @@ -15,7 +15,12 @@ { "cell_type": "code", "id": "657871cca9161529", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-11T16:23:48.414931740Z", + "start_time": "2026-06-11T16:23:47.000678649Z" + } + }, "source": [ "import os\n", "import sys\n", @@ -48,8 +53,24 @@ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "print(f\"Running benchmarks on device: {device}\")" ], - "outputs": [], - "execution_count": null + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running benchmarks on device: cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/local/USHERBROOKE/ginj2102/github/TorchPfaffian/.venv/lib/python3.14/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "execution_count": 1 }, { "cell_type": "markdown", @@ -64,7 +85,12 @@ { "cell_type": "code", "id": "6ace4294c6d4b34", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-06-11T16:45:30.960103917Z", + "start_time": "2026-06-11T16:23:48.423661244Z" + } + }, "source": [ "sizes_n = [2, 4, 8, 16, 32, 64, 128, 256]\n", "batch_size = 32\n", @@ -73,8 +99,198 @@ "results = benchmark_strategies(strategies, sizes_n, batch_size, device=device, n_seeds=n_seeds)\n", "results" ], - "outputs": [], - "execution_count": null + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Benchmarking PfaffianFDBPf (n: 2 | seed: 0 ): 0%| | 0/640 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
strategydimensionseedforward_timebackward_timeforward_memoryforward_backward_memory
0PfaffianFDBPf200.0109240.0000004.192000e+031.990900e+04
1PfaffianDet200.0116490.0000004.056000e+031.349800e+04
2PfaffianParlettReid200.0001470.0000553.032000e+031.905000e+04
3RustPfaffianParlettReid200.0004510.0003600.000000e+001.576200e+04
4PfaffianFDBPf210.0059890.0000004.304000e+032.016500e+04
........................
635RustPfaffianParlettReid256180.0078181.2186730.000000e+001.849201e+08
636PfaffianFDBPf256190.0038080.3512908.631040e+061.851625e+08
637PfaffianDet256190.0119550.0224828.630912e+061.261957e+08
638PfaffianParlettReid256190.5630662.2152502.212422e+092.396682e+09
639RustPfaffianParlettReid256190.0069331.0718160.000000e+001.849202e+08
\n", + "

640 rows × 7 columns

\n", + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 2 }, { "cell_type": "markdown", @@ -93,13 +309,28 @@ "iopub.status.busy": "2026-06-10T18:29:48.417741Z", "iopub.status.idle": "2026-06-10T18:29:49.863382Z", "shell.execute_reply": "2026-06-10T18:29:49.862404Z" + }, + "ExecuteTime": { + "end_time": "2026-06-11T16:45:32.958826885Z", + "start_time": "2026-06-11T16:45:31.043008384Z" } }, "source": [ "fig = plot_results(results, strategies, batch_size, device=device)" ], - "outputs": [], - "execution_count": null + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 }, { "cell_type": "markdown", From e4d5163669e3f1a8004a2c8b00cfd258599e2194 Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Thu, 11 Jun 2026 13:41:36 -0400 Subject: [PATCH 7/7] Update .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 840287c..59da262 100644 --- a/.gitignore +++ b/.gitignore @@ -306,3 +306,4 @@ tmp_report_dir coverage.json dist/*.whl dist/*.tar.gz +/.claude