diff --git a/.bumpversion.cfg b/.bumpversion.cfg
deleted file mode 100644
index 0c5332639..000000000
--- a/.bumpversion.cfg
+++ /dev/null
@@ -1,75 +0,0 @@
-[bumpversion]
-current_version = 0.11.7
-commit = True
-tag = True
-tag_name = {new_version}
-parse = 
-	(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)
-	((?P<pre>a|b|rc)(?P<prenum>\d+))?
-serialize = 
-	{major}.{minor}.{patch}{pre}{prenum}
-	{major}.{minor}.{patch}
-
-[bumpversion:file (global):pyproject.toml]
-search = version="{current_version}"
-replace = version="{new_version}"
-
-[bumpversion:file (core):pyproject.toml]
-search = titiler.core=={current_version}
-replace = titiler.core=={new_version}
-
-[bumpversion:file (extensions):pyproject.toml]
-search = titiler.extensions=={current_version}
-replace = titiler.extensions=={new_version}
-
-[bumpversion:file (mosaic):pyproject.toml]
-search = titiler.mosaic=={current_version}
-replace = titiler.mosaic=={new_version}
-
-[bumpversion:file (application):pyproject.toml]
-search = titiler.application=={current_version}
-replace = titiler.application=={new_version}
-
-[bumpversion:file:src/titiler/core/titiler/core/__init__.py]
-search = __version__ = "{current_version}"
-replace = __version__ = "{new_version}"
-
-[bumpversion:file:src/titiler/extensions/titiler/extensions/__init__.py]
-search = __version__ = "{current_version}"
-replace = __version__ = "{new_version}"
-
-[bumpversion:file:src/titiler/mosaic/titiler/mosaic/__init__.py]
-search = __version__ = "{current_version}"
-replace = __version__ = "{new_version}"
-
-[bumpversion:file:src/titiler/application/titiler/application/__init__.py]
-search = __version__ = "{current_version}"
-replace = __version__ = "{new_version}"
-
-[bumpversion:file:src/titiler/mosaic/pyproject.toml]
-search = titiler.core=={current_version}
-replace = titiler.core=={new_version}
-
-[bumpversion:file:src/titiler/extensions/pyproject.toml]
-search = titiler.core=={current_version}
-replace = titiler.core=={new_version}
-
-[bumpversion:file (core):src/titiler/application/pyproject.toml]
-search = titiler.core=={current_version}
-replace = titiler.core=={new_version}
-
-[bumpversion:file (extensions):src/titiler/application/pyproject.toml]
-search = titiler.extensions[cogeo,stac]=={current_version}
-replace = titiler.extensions[cogeo,stac]=={new_version}
-
-[bumpversion:file (mosaic):src/titiler/application/pyproject.toml]
-search = titiler.mosaic=={current_version}
-replace = titiler.mosaic=={new_version}
-
-[bumpversion:file:deployment/aws/lambda/Dockerfile]
-search = titiler.application=={current_version}
-replace = titiler.application=={new_version}
-
-[bumpversion:file:deployment/k8s/charts/Chart.yaml]
-search = appVersion: {current_version}
-replace = appVersion: {new_version}
diff --git a/.github/data/urls.txt b/.github/data/urls.txt
index 4782485da..40b810e3c 100644
--- a/.github/data/urls.txt
+++ b/.github/data/urls.txt
@@ -1,7 +1,7 @@
 PROT=http
 HOST=localhost
 PORT=8000
-PATH=cog/tiles/
+PATH=cog/tiles/WebMercatorQuad/
 EXT=.png
 QUERYSTRING=?url=/data/world.tif
 $(PROT)://$(HOST):$(PORT)/$(PATH)0/0/0$(EXT)$(QUERYSTRING)
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..58f402e47
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,16 @@
+# Set update schedule for GitHub Actions
+
+version: 2
+updates:
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    cooldown:
+      default-days: 7
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"
+    groups:
+      all:
+        patterns:
+        - "*"
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index e2e9bd880..cb374ffc5 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -5,23 +5,32 @@ on:
   push:
     branches:
     - main
+    - dev
     tags:
     - '*'
   pull_request:
 
 jobs:
   benchmark:
+    if: github.repository == 'developmentseed/titiler'
     runs-on: ubuntu-latest
+    permissions:
+      contents: write # Push benchmark results to gh-benchmarks branch
+      pull-requests: write # Leave PR comments when benchmark regressions exceed alert threshold
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          persist-credentials: false
 
       - name: install siege
         run: |
           sudo apt update
-          sudo apt install --yes siege
+          sudo apt install --yes siege jq
+          siege -C
+
       - name: Start containers
-        run: docker-compose -f "docker-compose.yml" up -d --build benchmark
+        run: docker compose -f "docker-compose.yml" up -d --build benchmark
 
       # Let's wait a bit to make sure the docker are up
       - name: Sleep for 10 seconds
@@ -30,12 +39,39 @@ jobs:
 
       - name: Run siege (WebMercator TMS)
         run: |
-          siege --file .github/data/urls.txt -b -c 1 -r 100 > /dev/null
+          siege --file .github/data/urls.txt -b -c 1 -r 100 --json-output 2>&1 | jq -c > results.json
+          echo "Benchmark Results"
+          cat results.json | jq
+          echo "Parse Results"
+          cat results.json | jq '{"name": "WebMercator elapsed_time", "unit": "s", "value": .elapsed_time}, {"name": "WebMercator data_transferred", "unit": "Megabytes", "value": .data_transferred}, {"name": "WebMercator response_time", "unit": "s", "value": .response_time}, {"name": "WebMercator longest_transaction", "unit": "s", "value": .longest_transaction}' > output.json
 
       - name: Run siege (WGS1984Quad TMS)
         run: |
-          siege --file .github/data/urls_wgs84.txt -b -c 1 -r 100 > /dev/null
+          siege --file .github/data/urls_wgs84.txt -b -c 1 -r 100 --json-output 2>&1 | jq -c > results.json
+          echo "Benchmark Results"
+          cat results.json | jq
+          echo "Parse Results"
+          cat results.json | jq '{"name": "WGS1984Quad elapsed_time", "unit": "s", "value": .elapsed_time}, {"name": "WGS1984Quad data_transferred", "unit": "Megabytes", "value": .data_transferred}, {"name": "WGS1984Quad response_time", "unit": "s", "value": .response_time}, {"name": "WGS1984Quad longest_transaction", "unit": "s", "value": .longest_transaction}' >> output.json
 
       - name: Stop containers
         if: always()
-        run: docker-compose -f "docker-compose.yml" down
+        run: docker compose -f "docker-compose.yml" down
+
+      - name: Merge Outputs
+        run: |
+          cat output.json | jq '[inputs]' > benchmark.json
+
+      - name: Check and Store benchmark result
+        uses: benchmark-action/github-action-benchmark@a7bc2366eda11037936ea57d811a43b3418d3073 # v1
+        with:
+          name: TiTiler performance Benchmarks
+          tool: 'customSmallerIsBetter'
+          output-file-path: benchmark.json
+          alert-threshold: '130%'
+          comment-on-alert: true
+          fail-on-alert: false
+          # GitHub API token to make a commit comment
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          gh-pages-branch: 'gh-benchmarks'
+          # Make a commit only if main
+          auto-push: ${{ github.ref == 'refs/heads/main' }}
diff --git a/.github/workflows/check_charts.yaml b/.github/workflows/check_charts.yaml
index e79f20937..2a2d1f5c3 100644
--- a/.github/workflows/check_charts.yaml
+++ b/.github/workflows/check_charts.yaml
@@ -17,57 +17,64 @@ on:
 jobs:
   lint-test:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           fetch-depth: 0
+          persist-credentials: false
 
       - name: Check Version
         run: |
-          current_version=$(grep 'version=' pyproject.toml | cut -f2 -d= | tr -d ' ' | tr -d '"')
-          app_version=$(grep 'appVersion:' deployment/k8s/charts/Chart.yaml | cut -f2 -d: | tr -d ' ')
+          current_version=$(grep '^version=' pyproject.toml | cut -f2 -d= | tr -d ' ' | tr -d '"')
+          app_version=$(grep 'appVersion:' deployment/k8s/charts/Chart.yaml | cut -f2 -d: | tr -d ' ' | tr -d '"' | cut -d'#' -f1)
           if [[ "$current_version" != "$app_version" ]]; then
             echo "❌ current version from pyproject.toml ($current_version) and appVersion from Chart.yaml ($app_version) differs";
             exit 1;
           fi
 
       - name: Set up Helm
-        uses: azure/setup-helm@v1
+        uses: azure/setup-helm@dda3372f752e03dde6b3237bc9431cdc2f7a02a2 # v5
         with:
           version: v3.9.2
 
-      - uses: actions/setup-python@v2
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
         with:
-          python-version: 3.7
+          python-version: '3.x'
 
       - name: Set up chart-testing
-        uses: helm/chart-testing-action@v2.2.1
+        uses: helm/chart-testing-action@6ec842c01de15ebb84c8627d2744a0c2f2755c9f # v2.8.0
 
       - name: Run chart-testing (list-changed)
         id: list-changed
+        env:
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
         run: |
-          changed=$(ct list-changed --chart-dirs deployment/k8s --target-branch ${{ github.event.repository.default_branch }})
+          changed=$(ct list-changed --chart-dirs deployment/k8s --target-branch "$DEFAULT_BRANCH")
           if [[ -n "$changed" ]]; then
-            echo "::set-output name=changed::true"
+            echo "changed=true" >> "$GITHUB_OUTPUT"
           fi
 
       - name: Run chart-testing (lint)
-        run: ct lint --chart-dirs deployment/k8s --target-branch ${{ github.event.repository.default_branch }}
+        env:
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+        run: ct lint --chart-dirs deployment/k8s --target-branch "$DEFAULT_BRANCH"
 
       - name: Build container
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7
         if: steps.list-changed.outputs.changed == 'true'
         with:
           # See https://github.com/developmentseed/titiler/discussions/387
           platforms: linux/amd64
           context: .
-          file: dockerfiles/Dockerfile.uvicorn
+          file: dockerfiles/Dockerfile
           push: false
           tags: "titiler:dev"
 
       - name: Create kind cluster
-        uses: helm/kind-action@v1.2.0
+        uses: helm/kind-action@ef37e7f390d99f746eb8b610417061a60e82a6cc # v1.14.0
         if: steps.list-changed.outputs.changed == 'true'
 
       - name: Load container image in kind cluster
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d44a4ef80..641a0eea5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -5,6 +5,7 @@ on:
   push:
     branches:
     - main
+    - dev
     tags:
     - '*'
     paths:
@@ -15,236 +16,130 @@ on:
       - '.pre-commit-config.yaml'
       - '.github/codecov.yml'
       - 'dockerfiles/**'
+      - '.github/workflows/ci.yml'
+      - 'uv.lock'
   pull_request:
+  workflow_dispatch:
+
 env:
-  LATEST_PY_VERSION: '3.10'
+  LATEST_PY_VERSION: '3.14'
+
+permissions:
+  contents: read
 
 jobs:
   tests:
     runs-on: ubuntu-latest
+    environment: ci
+    permissions:
+      contents: read
     strategy:
       matrix:
-        python-version: ['3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.11', '3.12', '3.13', '3.14']
 
     steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
         with:
+          version: "0.9.*"
+          enable-cache: false
           python-version: ${{ matrix.python-version }}
 
       - name: Install dependencies
         run: |
-          python -m pip install --upgrade pip
+          uv sync
 
       - name: Test titiler.core
         run: |
-          python -m pip install -e src/titiler/core["test"]
-          python -m pytest src/titiler/core --cov=titiler.core --cov-report=xml --cov-append --cov-report=term-missing
+          uv run pytest src/titiler/core --cov=titiler.core --cov-report=xml:titiler-core.xml --cov-report=term-missing
 
       - name: Test titiler.extensions
         run: |
-          python -m pip install -e src/titiler/extensions["test,cogeo,stac"]
-          python -m pytest src/titiler/extensions --cov=titiler.extensions --cov-report=xml --cov-append --cov-report=term-missing
+          uv run pytest src/titiler/extensions --cov=titiler.extensions --cov-report=xml:titiler-extensions.xml --cov-report=term-missing
+
+      - name: Test titiler.xarray
+        run: |
+          uv run pytest src/titiler/xarray --cov=titiler.xarray --cov-report=xml:titiler-xarray.xml --cov-report=term-missing
 
       - name: Test titiler.mosaic
         run: |
-          python -m pip install -e src/titiler/mosaic["test"]
-          python -m pytest src/titiler/mosaic --cov=titiler.mosaic --cov-report=xml --cov-append --cov-report=term-missing
+          uv run pytest src/titiler/mosaic --cov=titiler.mosaic --cov-report=xml:titiler-mosaic.xml --cov-report=term-missing
 
       - name: Test titiler.application
         run: |
-          python -m pip install -e src/titiler/application["test"]
-          python -m pytest src/titiler/application --cov=titiler.application --cov-report=xml --cov-append --cov-report=term-missing
+          uv run pytest src/titiler/application --cov=titiler.application --cov-report=xml:titiler-application.xml  --cov-report=term-missing
 
-      - name: run pre-commit
+      - name: run pre-commit and mypy
         if: ${{ matrix.python-version == env.LATEST_PY_VERSION }}
         run: |
-          python -m pip install pre-commit
-          pre-commit run --all-files
+          uv run pre-commit run --all-files
+          uv run --with mypy --with types-attrs --with types-simplejson mypy -p titiler.core -p titiler.extensions -p titiler.xarray -p titiler.application -p titiler.mosaic  --ignore-missing-imports
 
       - name: Upload Results
         if: ${{ matrix.python-version == env.LATEST_PY_VERSION }}
-        uses: codecov/codecov-action@v1
+        uses: codecov/codecov-action@75cd11691c0faa626561e295848008c8a7dddffe # v5
         with:
-          file: ./coverage.xml
+          files: ./titiler-core.xml,./titiler-extensions.xml,./titiler-xarray.xml,./titiler-mosaic.xml,./titiler-application.xml
           flags: unittests
-          name: ${{ matrix.python-version }}
           fail_ci_if_error: false
-
-  publish:
-    needs: [tests]
-    runs-on: ubuntu-latest
-    if: startsWith(github.event.ref, 'refs/tags') || github.event_name == 'release'
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v1
-        with:
-          python-version: ${{ env.LATEST_PY_VERSION }}
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install twine build hatch
-
-      - name: Set tag version
-        id: tag
-        # https://stackoverflow.com/questions/58177786/get-the-current-pushed-tag-in-github-actions
-        run: echo ::set-output name=tag::${GITHUB_REF#refs/*/}
-
-      - name: Set module version
-        id: module
-        # https://stackoverflow.com/questions/58177786/get-the-current-pushed-tag-in-github-actions
-        run: echo ::set-output name=version::$(hatch --quiet version)
-
-      - name: Build and publish titiler packages
-        if: steps.tag.outputs.tag == steps.module.outputs.version
-        env:
-          TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
-          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
-        run: |
-          scripts/publish
+          token: ${{ secrets.CODECOV_TOKEN }}
 
   publish-docker:
     needs: [tests]
-    if: github.ref == 'refs/heads/main' || startsWith(github.event.ref, 'refs/tags') || github.event_name == 'release'
+    if: github.ref == 'refs/heads/main' || (startsWith(github.event.ref, 'refs/tags') && !startsWith(github.ref, 'refs/tags/helm-')) || github.event_name == 'release'
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write # Push multi-arch images to ghcr.io for this repository
+    strategy:
+      matrix:
+        include:
+          - image: ghcr.io/${{ github.repository }}
+            file: dockerfiles/Dockerfile
+          - image: ghcr.io/${{ github.repository }}-xarray
+            file: dockerfiles/Dockerfile.xarray
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          persist-credentials: false
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@ce360397dd3f832beb865e1373c09c0e9f86d70a # v4
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4
 
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Login to Github
-        uses: docker/login-action@v1
+      - name: Log in to the GitHub Container registry
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Set tag version
-        id: tag
-        # https://stackoverflow.com/questions/58177786/get-the-current-pushed-tag-in-github-actions
-        run: echo ::set-output name=tag::${GITHUB_REF#refs/*/}
-      # Uvicorn
-      # Push `latest` when commiting to main
-      - name: Build and push uvicorn
-        if: github.ref == 'refs/heads/main'
-        uses: docker/build-push-action@v2
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6
         with:
-          # See https://github.com/developmentseed/titiler/discussions/387
-          platforms: linux/amd64
-          context: .
-          file: dockerfiles/Dockerfile.uvicorn
-          push: true
+          images: ${{ matrix.image }}
+          flavor: |
+            latest=false
           tags: |
-            ghcr.io/${{ github.repository }}-uvicorn:latest
+            type=semver,pattern={{version}}
+            type=raw,value=latest,enable={{is_default_branch}}
 
-      # Push `{VERSION}` when pushing a new tag
-      - name: Build and push uvicorn
-        if: startsWith(github.event.ref, 'refs/tags') || github.event_name == 'release'
-        uses: docker/build-push-action@v2
-        with:
-          # See https://github.com/developmentseed/titiler/discussions/387
-          platforms: linux/amd64
-          context: .
-          file: dockerfiles/Dockerfile.uvicorn
-          push: true
-          tags: |
-            ghcr.io/${{ github.repository }}-uvicorn:${{ steps.tag.outputs.tag }}
-
-      # Gunicorn
-      # Push `latest` when commiting to main
-      - name: Build and push
-        if: github.ref == 'refs/heads/main'
-        uses: docker/build-push-action@v2
-        with:
-          # See https://github.com/developmentseed/titiler/discussions/387
-          platforms: linux/amd64
-          context: .
-          file: dockerfiles/Dockerfile.gunicorn
-          push: true
-          tags: |
-            ghcr.io/${{ github.repository }}:latest
-
-      # Push `{VERSION}` when pushing a new tag
       - name: Build and push
-        if: startsWith(github.event.ref, 'refs/tags') || github.event_name == 'release'
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7
         with:
-          # See https://github.com/developmentseed/titiler/discussions/387
-          platforms: linux/amd64
+          platforms: linux/amd64,linux/arm64
           context: .
-          file: dockerfiles/Dockerfile.gunicorn
-          push: true
-          tags: |
-            ghcr.io/${{ github.repository }}:${{ steps.tag.outputs.tag }}
-
-  deploy:
-    needs: [tests, publish]
-    runs-on: ubuntu-latest
-    if: startsWith(github.event.ref, 'refs/tags') || github.event_name == 'release'
-
-    defaults:
-      run:
-        working-directory: deployment/aws
-
-    steps:
-      - uses: actions/checkout@v3
-
-      # Let's wait a bit to make sure Pypi is up to date
-      - name: Sleep for 120 seconds
-        run: sleep 120s
-        shell: bash
-
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v1
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: us-east-1
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v1
-        with:
-          node-version: '14.x'
-
-      - name: Install cdk
-        run: npm install -g
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.x'
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install -r requirements-cdk.txt
-
-      # Let's wait a bit to make sure package is available on pypi
-      - name: Sleep for 120 seconds
-        run: sleep 120s
-        shell: bash
-
-      # Build and Deploy CDK application
-      - name: Build & Deploy
-        run: npm run cdk -- deploy ${{ secrets.STACK_NAME }}-lambda-${{ secrets.STACK_STAGE }} --require-approval never
-        env:
-          TITILER_STACK_NAME: ${{ secrets.STACK_NAME }}
-          TITILER_STACK_STAGE: ${{ secrets.STACK_STAGE }}
-          TITILER_STACK_MEMORY: ${{ secrets.STACK_MEMORY }}
-          TITILER_STACK_OWNER: ${{ secrets.STACK_OWNER }}
-          TITILER_STACK_CLIENT: ${{ secrets.STACK_CLIENT }}
-          TITILER_STACK_BUCKETS: ${{ secrets.STACK_BUCKETS }}
+          file: ${{ matrix.file }}
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
diff --git a/.github/workflows/commitlint.yml b/.github/workflows/commitlint.yml
new file mode 100644
index 000000000..892fb0675
--- /dev/null
+++ b/.github/workflows/commitlint.yml
@@ -0,0 +1,38 @@
+name: Commitlint
+
+on:
+  push:
+    branches:
+      - "**"
+
+jobs:
+  commitlint:
+    name: Lint commit messages
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          version: "0.9.*"
+          enable-cache: false
+
+      - name: Check commit messages
+        env:
+          EVENT_BEFORE: ${{ github.event.before }}
+          EVENT_AFTER: ${{ github.event.after }}
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+        run: |
+          BEFORE="$EVENT_BEFORE"
+          AFTER="$EVENT_AFTER"
+          if [ "$BEFORE" = "0000000000000000000000000000000000000000" ]; then
+            BEFORE="$(git merge-base "origin/$DEFAULT_BRANCH" "$AFTER")"
+          fi
+          uv run --with 'commitizen==4.13.9' --isolated \
+            cz check --rev-range "$BEFORE..$AFTER"
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
new file mode 100644
index 000000000..fbf2c7d60
--- /dev/null
+++ b/.github/workflows/deploy.yml
@@ -0,0 +1,59 @@
+name: Deploy application
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment: deployment
+    if: github.repository == 'developmentseed/titiler'
+    defaults:
+      run:
+        working-directory: deployment/aws
+    permissions:
+      id-token: write # AWS OIDC: exchange JWT for temporary credentials in configure-aws-credentials
+      contents: read
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          persist-credentials: false
+
+      # Let's wait a bit to make sure Pypi is up to date
+      - name: Sleep for 120 seconds
+        run: sleep 120s
+        shell: bash
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@8df5847569e6427dd6c4fb1cf565c83acfa8afa7 # v6
+        with:
+          role-to-assume: ${{ secrets.AWS_IAM_ROLE_ARN }}
+          aws-region: us-east-1
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          enable-cache: false
+
+      - name: Install dependencies
+        run: uv sync --all-packages && npm install -g aws-cdk@^2.232.2
+
+      # Let's wait a bit to make sure package is available on pypi
+      - name: Sleep for 120 seconds
+        run: sleep 120s
+        shell: bash
+
+      # Build and Deploy CDK application
+      - name: Build & Deploy
+        run: uv run cdk deploy "${STACK_NAME}-lambda-${STACK_STAGE}" --require-approval never
+        env:
+          STACK_NAME: ${{ secrets.STACK_NAME }}
+          STACK_STAGE: ${{ secrets.STACK_STAGE }}
+          TITILER_STACK_NAME: ${{ secrets.STACK_NAME }}
+          TITILER_STACK_STAGE: ${{ secrets.STACK_STAGE }}
+          TITILER_STACK_MEMORY: ${{ secrets.STACK_MEMORY }}
+          TITILER_STACK_OWNER: ${{ secrets.STACK_OWNER }}
+          TITILER_STACK_CLIENT: ${{ secrets.STACK_CLIENT }}
+          TITILER_STACK_BUCKETS: ${{ secrets.STACK_BUCKETS }}
diff --git a/.github/workflows/deploy_mkdocs.yml b/.github/workflows/deploy_mkdocs.yml
index f9b537459..ccbc783b8 100644
--- a/.github/workflows/deploy_mkdocs.yml
+++ b/.github/workflows/deploy_mkdocs.yml
@@ -17,49 +17,26 @@ jobs:
   build:
     name: Deploy docs
     runs-on: ubuntu-latest
+    environment: github-pages
+    permissions:
+      contents: write # mkdocs gh-deploy pushes the built site to gh-pages
     steps:
       - name: Checkout main
-        uses: actions/checkout@v2
-
-      - name: Set up Python 3.8
-        uses: actions/setup-python@v2
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
-          python-version: 3.8
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install src/titiler/core src/titiler/extensions["cogeo,stac"] src/titiler/mosaic src/titiler/application
-          python -m pip install nbconvert==6.5.3 mkdocs mkdocs-material mkdocs-jupyter pygments pdocs
-
-      - name: update API docs
-        run: |
-          pdocs as_markdown \
-            --output_dir docs/src/api \
-            --exclude_source \
-            --overwrite \
-            titiler.core.dependencies \
-            titiler.core.factory \
-            titiler.core.routing \
-            titiler.core.errors \
-            titiler.core.resources.enums \
-            titiler.core.middleware
-
-          pdocs as_markdown \
-            --output_dir docs/src/api \
-            --exclude_source \
-            --overwrite \
-            titiler.extensions.cogeo \
-            titiler.extensions.viewer \
-            titiler.extensions.stac
-
-          pdocs as_markdown \
-            --output_dir docs/src/api \
-            --exclude_source \
-            --overwrite \
-            titiler.mosaic.factory \
-            titiler.mosaic.resources.enums \
-            titiler.mosaic.errors
+          persist-credentials: false
 
+      - name: Install uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          version: "0.9.*"
+          enable-cache: false
+    
       - name: Deploy docs
-        run: mkdocs gh-deploy --force -f docs/mkdocs.yml
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git remote set-url origin "https://x-access-token:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"
+          uv run --group docs mkdocs gh-deploy --force -f docs/mkdocs.yml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 000000000..077a02384
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,75 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+  release:
+    types: [published]
+
+env:
+  LATEST_PY_VERSION: '3.14'
+
+jobs:
+  release-please:
+    name: Release Please
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push'
+    permissions:
+      contents: write # Needed for release-please to create PRs
+      pull-requests: write # Needed for release-please to create PRs
+    steps:
+      - uses: googleapis/release-please-action@16a9c90856f42705d54a6fda1823352bdc62cf38 # v4.4.0
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+
+  build:
+    name: Build dist
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          version: "0.9.*"
+          enable-cache: false
+          python-version: ${{ env.LATEST_PY_VERSION }}
+
+      - name: Install dependencies
+        run: |
+          uv sync
+
+      - name: Build
+        run: |
+          scripts/build
+
+      - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        with:
+          path: ./dist/
+
+  upload_pypi:
+    name: Upload release to PyPI
+    needs: [build]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi-release
+    permissions:
+      contents: read
+      id-token: write # OIDC token for PyPI trusted publishing (pypa/gh-action-pypi-publish)
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
+        with:
+          name: artifact
+          path: dist
+          merge-multiple: true
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
new file mode 100644
index 000000000..87bf24ba4
--- /dev/null
+++ b/.github/workflows/scorecard.yml
@@ -0,0 +1,52 @@
+# https://github.com/ossf/scorecard-action
+name: Scorecard analysis
+
+on:
+  push:
+    branches:
+      - main
+      - dev
+  schedule:
+    # Weekly on Saturdays at 01:35 UTC (offset from other scheduled jobs)
+    - cron: "30 7 * * 1"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  actions: read # Required by Scorecard to evaluate workflow security posture
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write # Upload Scorecard SARIF to GitHub Code Scanning
+      id-token: write # GitHub OIDC token used when publish_results is true
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Run analysis
+        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          publish_results: true
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      - name: Upload to code-scanning
+        uses: github/codeql-action/upload-sarif@38697555549f1db7851b81482ff19f1fa5c4fedc # v4.34.1
+        with:
+          sarif_file: results.sarif
diff --git a/.github/workflows/upstream.yml b/.github/workflows/upstream.yml
new file mode 100644
index 000000000..990406d8a
--- /dev/null
+++ b/.github/workflows/upstream.yml
@@ -0,0 +1,39 @@
+name: Upstream
+
+# Only on pushes to main, tags, or workflow dispatches
+on:
+  push:
+    branches:
+    - main
+    - dev
+    paths:
+      # Only run test and docker publish if some code have changed
+      - 'src/titiler/xarray/**'
+  workflow_dispatch:
+
+jobs:
+  test-upstream:
+    runs-on: ubuntu-latest
+    environment: ci
+    permissions:
+      contents: read
+    strategy:
+      matrix:
+        python-version: ['3.14']
+
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
+        with:
+          version: "0.9.*" 
+          enable-cache: true
+          python-version: ${{ matrix.python-version }}
+
+      - name: Test titiler.xarray
+        working-directory: src/titiler/xarray
+        run: |
+          uv run --group test --with-requirements requirements-upstream.txt pytest
diff --git a/.github/workflows/zizmor.yml b/.github/workflows/zizmor.yml
new file mode 100644
index 000000000..3722ac0e9
--- /dev/null
+++ b/.github/workflows/zizmor.yml
@@ -0,0 +1,35 @@
+# https://github.com/woodruffw/zizmor
+name: Zizmor
+
+on:
+  push:
+    branches:
+      - main
+      - dev
+  pull_request:
+    branches:
+      - "**"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+permissions: {}
+
+jobs:
+  zizmor:
+    name: Run zizmor
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write # Upload zizmor SARIF to GitHub Code Scanning
+      contents: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Run zizmor
+        uses: zizmorcore/zizmor-action@71321a20a9ded102f6e9ce5718a2fcec2c4f70d8 # v0.5.2
+        with:
+          persona: pedantic
diff --git a/.gitignore b/.gitignore
index 95640297c..1b41d9cd7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,6 +48,7 @@ htmlcov/
 .cache
 nosetests.xml
 coverage.xml
+titiler-*.xml
 *.cover
 .hypothesis/
 
@@ -107,4 +108,7 @@ ENV/
 
 cdk.out/
 deployment/k8s/titiler/values-test.yaml
-docs/src/api/
+
+.vscode/
+
+dev_notebooks/*
\ No newline at end of file
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 63ed17680..5337be19c 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,29 +1,24 @@
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.12.1
+    rev: v0.24
     hooks:
       - id: validate-pyproject
 
-  - repo: https://github.com/psf/black
-    rev: 22.12.0
-    hooks:
-      - id: black
-        language_version: python
-
   - repo: https://github.com/PyCQA/isort
     rev: 5.12.0
     hooks:
       - id: isort
         language_version: python
 
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.238
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.4
     hooks:
       - id: ruff
         args: ["--fix"]
+      - id: ruff-format
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.991
+    rev: v1.19.0
     hooks:
       - id: mypy
         language_version: python
@@ -31,3 +26,16 @@ repos:
         additional_dependencies:
         - types-simplejson
         - types-attrs
+        - pydantic~=2.0
+
+  - repo: https://github.com/zizmorcore/zizmor-pre-commit
+    rev: v1.23.1
+    hooks:
+      - id: zizmor
+        args: [--min-severity, medium]
+
+  - repo: https://github.com/commitizen-tools/commitizen
+    rev: v4.13.9
+    hooks:
+      - id: commitizen
+        stages: [commit-msg]
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
new file mode 100644
index 000000000..7030e335e
--- /dev/null
+++ b/.release-please-manifest.json
@@ -0,0 +1,4 @@
+{
+  ".": "2.0.1",
+  "deployment/k8s/charts": "2.1.2"
+}
diff --git a/CHANGES.md b/CHANGES.md
index 2481fa831..b5ccc2a3c 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,1165 @@
 # Release Notes
 
+## Unreleased
+
+## 2.0.1 (2026-03-31)
+
+## What's Changed
+
+### titiler.core 
+
+* fix(algorithm): handle mask type compatibility in contours algorithm by @machov in https://github.com/developmentseed/titiler/pull/1327
+
+### titiler.extensions
+
+* add openapi parameters for tile dependencies in WMTS endpoints by @vincentsarago in https://github.com/developmentseed/titiler/pull/1349
+* change: internal of the WMTS extension to increase performance
+
+### titiler.mosaic
+
+* add openapi parameters for tile dependencies in WMTS endpoints by @vincentsarago in https://github.com/developmentseed/titiler/pull/1349
+* change: internal of the WMTS extension to increase performance
+
+### Misc 
+
+* Fix command syntax in AWS Lambda deployment guide by @hamishcampbell in https://github.com/developmentseed/titiler/pull/1346
+* ci: harden github actions workflows against zizmor findings by @lhoupert in https://github.com/developmentseed/titiler/pull/1354
+* ci: setup trusted publishing and update xarray upstream test by @vincentsarago in https://github.com/developmentseed/titiler/pull/1355
+* ci: add conventional commit check and release please by @lhoupert in https://github.com/developmentseed/titiler/pull/1356
+* ci: add security audtit and ossf scorecard by @lhoupert in https://github.com/developmentseed/titiler/pull/1359
+
+**Full Changelog**: https://github.com/developmentseed/titiler/compare/2.0.0...2.0.1
+
+## 2.0.0 (2026-03-16)
+
+### Misc
+
+* change: rio-tiler requirement to `>=9.0,<10.0`
+
+### titiler.xarray
+
+* fix: allow `:` characters in xarray reader's `sel` parameter (e.g. for timestamps) (https://github.com/developmentseed/titiler/pull/1336)
+
+### titiler.mosaic
+
+* fix: `pixel-selection` method initialization to avoid FastAPI caching (author @raster-blaster, https://github.com/developmentseed/titiler/pull/1334)
+* fix: make the point query feature in map.html work for MosaicTilerFactory (https://github.com/developmentseed/titiler/pull/1338)
+
+## 2.0.0b2 (2026-02-22)
+
+### titiler.extensions
+
+* fix: render expression adapter
+
+## 2.0.0b1 (2026-02-22)\
+
+### titiler.core
+
+* change: rio-tiler requirement to `>=9.0.0b1,<10.0`
+* add: asset's options parsing in `AssetsParams` dependency
+
+## 2.0.0a2 (2026-02-13)
+
+### titiler.extensions
+
+* **render**:
+    * change: make `assets` optional in `RenderItem` model
+    * change: add `valid: True|False` key to the `RenderItemWithLinks` model
+    * add: convert old `asset_bix` and `asset_expression` keys to `{asset}|indexes=...&expression=...`
+
+### titiler.mosaic
+
+* fix: tilesize for `/map.html` endpoint
+
+## 2.0.0a1 (2026-02-11)
+
+### Misc
+
+* remove: 256x256 tilesize default
+* remove: `MultiBandTilerFactory` factory
+* remove: `@{scale}x` suffix for tile endpoints
+* remove: `tile_scale` option in `/tilejson.json` and `/map.html` endpoints
+* change: default to TileMatrix's `tileHeight x tileWidth` for tile endpoints
+* change: set `tilesize=512` for `/tilejson.json` endpoints
+* change: set `tilesize=256` for `/map.html` endpoints
+* change: use `band_descriptions` instead of `band_names`
+* add: `tilesize` optional query-parameter for tile and tilejson endpoints
+* remove: titiler-xarray in docker-compose file
+* remove: titiler-xarray single application deployement in AWS lambda deployement
+* change: rio-tiler requirement to `>=9.0.0a4,<10.0`
+
+### titiler.core
+
+* change: `bidx` option is now ignored by `MultiBaseFactory` endpoints
+* change: `assets` option is now **required** for `MultiBaseFactory` endpoints
+* change: users can use `assets=:all:` in `MultiBaseFactory`'s `/info` and `/statistics` endpoints
+* change: `expression` cannot be used to declare `assets` in `MultiBaseFactory` endpoints. Use `assets=Red&assets=Green&expression=b1/b2`.
+* remove: `asset_indexes` and `asset_expression` options in `dependencies.py`
+* rename: `dependencies.AssetsBidxExprParams` to `dependencies.AssetsExprParams` 
+* remove: methods or classes:
+    - `titiler.core.dependencies.AssetsBidxParams`
+    - `titiler.core.dependencies.AssetsBidxExprParamsOptional`
+    - `titiler.core.dependencies.BandsParams`
+    - `titiler.core.dependencies.BandsExprParamsOptional`
+    - `titiler.core.dependencies.BandsExprParams`
+    - `titiler.core.dependencies.parse_asset_indexes()`
+    - `titiler.core.dependencies.parse_asset_expression()`
+    - `titiler.core.routing.apiroute_factory()`
+
+### titiler.extensions
+
+* change: force `tilesize=256` in `cog` and `stac` viewers
+* remove: `tile_scale` option in `/WMTSCapabilities.xml` endpoints
+
+### titiler.mosaic
+
+* remove: `tile_scale` option in `/WMTSCapabilities.xml` endpoints
+
+### titiler.application
+
+* add: titiler.xarray dependency
+* add: `/zarr` endpoints
+
+## 1.2.1 (2026-03-09)
+
+### titiler.xarray
+
+* fix: allow `:` characters in xarray reader's `sel` parameter (e.g. for timestamps) (https://github.com/developmentseed/titiler/pull/1336) [Backported from 2.0.0]
+
+### titiler.mosaic
+
+* fix: `pixel-selection` method initialization to avoid FastAPI caching (author @raster-blaster, https://github.com/developmentseed/titiler/pull/1334)  [Backported from 2.0.0]
+
+## 1.2.0 (2026-02-09)
+
+### Input Validation
+
+* fix: address several instances of validation failures returning 500 instead of 4xx HTTP responses
+
+## 1.1.1 (2026-01-22)
+
+### titiler.extensions
+
+* add: support for `float16`, `int64` and `uint64` datatype in viewers
+* fix: make sure TMS have ids in WMTS XML documents
+
+### titiler.mosaic
+
+* fix: make sure TMS have ids in WMTS XML documents
+
+### titiler.xarray
+
+* fix: add `h5py` in optional dependency
+
+## 1.1.0 (2026-01-12)
+
+### Misc
+
+* add `get_renders` attribute to `wmtsExtension` extensions
+* refactor WMTS endpoints to enable renders metadata (e.g STAC renders)
+* update `wmts.xml` template **breaking change**
+
+### titiler.core 
+
+* Improve `dem` algorithms by using numpy functions (author @manand881, https://github.com/developmentseed/titiler/pull/1294)
+
+## 1.0.2 (2025-12-18)
+
+### titiler.core
+
+* add more TMS utilities 
+* remove `bump-my-version` from dev dependencies
+
+## 1.0.1 (2025-12-18)
+
+### titiler.core
+
+* add `utils.tms_limits` options to avoid code duplication
+
+## 1.0.0 (2025-12-17)
+
+### Misc 
+
+* update rio-tiler requirement to `>=8.0,<9.0`
+* return `UINT8` datatype JPEG/PNG when no output format is specified **breaking change**
+* remove `/{tileMatrixSetId}/WMTSCapabilities.xml` endpoints from factories **breaking change**
+* add python 3.14 support
+* add `linux/arm64` docker image 
+* update/fix type hints 
+* add arm64 docker image
+* add titiler-xarray docker image in  ghcr.io
+
+### titiler.core
+
+* add `band_description` attribute to `Point` output model (returned by /point endpoints) **breaking change**
+
+### titiler.extensions
+
+* update rio-cogeo requirement to `7.0,<8.0`
+* add `wmtsExtension` which adds `/WMTSCapabilities.xml` to factories
+* `WMTSCapabilities.xml` response now support all TileMatrixSets as separate layers **breaking change**
+
+### titiler.mosaic
+
+* change Response model for `/point` endpoint **breaking change**
+
+    ```python
+    # before
+    class Point(BaseModel):
+        coordinates: List[float]
+        values: List[Tuple[str, List[Optional[float]], List[str]]]
+
+    # now
+    class AssetPoint(BaseModel):
+        name: str
+        values: list[float | None]
+        band_names: list[str]
+        band_descriptions: list[str] | None = None
+
+    class Point(BaseModel):
+        coordinates: list[float]
+        assets: list[AssetPoint]
+    ```
+
+* add `/feature`, `/bbox` and `/statistics` optional endpoints 
+* make `cogeo-mosaic` an optional dependency **breaking change**
+* remove default for `MosaicTilerFactory.backend` attribute **breaking change**
+* add `titiler.mosaic.extensions.mosaicjson.MosaicJSONExtension` which adds MosaicJSON specific `/` and `/validate` endpoints
+* add `titiler.mosaic.extension.wmts.wmtsExtension` which adds `/WMTSCapabilities.xml` endpoint
+* add optional OGC Maps API `/map` endpoint
+
+## 0.26.0 (2025-11-25)
+
+### titiler.xarray
+
+* use `sel={dim}={method}::{value}` notation  to specify selector method instead of `sel-method` query-parameter **breaking change** 
+
+    ```python
+    # before
+    .../info?tore.zarr?sel=time=2023-01-01&sel_method=nearest`
+
+    # now
+    .../info?tore.zarr?sel=time=nearest::2023-01-01`
+    ```
+
+* add `/validate` endpoint via `ValidateExtension` extension
+* add `Latitude` and `Longitude` as compatible spatial dimensions (@abarciauskas-bgse, https://github.com/developmentseed/titiler/pull/1268)
+
+### titiler.mosaic
+
+* remove usage of `mosaic_def.center` and calculate from bounds
+
+## 0.25.0 (2025-11-07)
+
+### Misc 
+
+* remove `/bounds` endpoints **breaking change**
+* update docker image to python:3.13
+* switch to `uv` for development
+* switch to `hatch` for python package build-system
+* remove `titiler` metapackage **breaking change**
+* bump minimum python version to 3.11
+
+### titiler.xarray
+
+* add `opener_options` arg to `titiler.xarray.io.Reader` to allow users to pass args through to a custom opener function ([#1248(https://github.com/developmentseed/titiler/pull/1248)])
+* add `obstore` and `zarr-python` as dependency and add `open_zarr` dataset opener
+* default to `titiler.xarray.io.open_zarr` for `titiler.xarray.io.Reader.dataset_opener` attribute
+* rename `titiler.xarray.io.xarray_open_dataset` to `fs_open_dataset`
+* add `FsReader` which use `fs_open_dataset` as `dataset_opener`
+* create offical application `titiler.xarray.main:app`
+
+### titiler.mosaic
+
+* move `/` and `/validate`  to a `MosaicJSONExtension`
+
+## 0.24.2 (2025-10-16)
+
+### titiler.core
+
+* update `TileJSON` spec from 2.2.0 to 3.0.0
+* fix OpenAPI spec for `histogram_range` examples (@guillemc23, https://github.com/developmentseed/titiler/pull/1239)
+
+## 0.24.1 (2025-10-10)
+
+* add `grayscale` and `bitonal` algorithms
+* add `transform` and `crs` for `tiff` outputs
+
+
+## 0.24.0 (2025-09-23)
+
+### Misc
+
+* add attribution in `/tilejson.json` response. Controled with `TITILER_DEFAULT_ATTRIBUTION` environment variable.
+* enable `jinja2.autoescape` for HTML/XML templates (ref: https://jinja.palletsprojects.com/en/stable/api/#autoescaping)
+* remove python 3.9 support
+
+### titiler.extension 
+
+* update rio-stac requirement
+
+### titiler.application
+
+* add `description` in `ApiSettings`
+
+### titiler.core
+
+* delete `titiler.core.templating` submodule **breaking change**
+* move `create_html_response` function to `titiler.core.utils` submodule
+* move all HTML templates in `titiler/core/templates` directory  **breaking change**
+* add HTML responses for tilesets, tilematrixsets, algorithms and colormaps endpoints
+* rename response model `ColorMapsList` -> `ColorMapList` and change it's attibutes to `colormaps` **breaking change**
+* add `templates` in the `BaseFactory` class definition
+
+## 0.23.1 (2025-08-27)
+
+### titiler.core
+
+* add `sum` algorithm
+
+## 0.23.0 (2025-08-26)
+
+### titiler.core
+
+* add OpenTelemetry instrumentation to the tiler factory classes
+* add `OGC Maps API` support (`/map` endpoint)
+
+### titiler.application
+
+* add OpenTelemetry tracing to the FastAPI application
+* update `starlette-cramjam` requirement to `>=0.4,<0.6`
+
+### titiler.xarray
+
+* add `add_preview` in factory attribute (default to `False`)
+
+### Misc
+
+* Add otel-collector and jaeger to the docker network
+* fix layer's bounds for non-wgs84 CRS in WMTS document
+* switch from bitnami to official python:3.12 docker image
+
+## 0.22.4 (2025-07-02)
+
+* fix `rel` values for tiling scheme link (OGC Tiles specification)
+
+## 0.22.3 (2025-06-17)
+
+### titiler.xarray
+
+* use dimension's `dtype` to cast user *selection*
+
+## 0.22.2 (2025-06-02)
+
+### titiler.application
+
+* remove unused templates
+
+### titiler.xarray
+
+* fix `xarray_open_dataset` for cloud hosted files
+
+## 0.22.1 (2025-05-13)
+
+### titiler.xarray
+
+* update `reader` and `path_dependency` type informations
+
+## 0.22.0 (2025-05-06)
+
+### Misc
+
+* rename `/map` endpoint to `/map.html` **breaking change**
+* add `name` attribute to `BaseFactory` to define endpoint's `operationId`
+* add `operationId` on all endpoints
+* add `/preview/{width}x{height}.{format}` endpoints
+* update rio-tiler requirement to `>=7.7,<8.0`
+* allow users to pass only one of `width` or `heigh` size parameters for `preview`, `part` and `feature` requests
+* use `minZoom` instead of `minNativeZoom` in the `/map.html` html template
+* update geojson-pydantic requirement to `>=1.1.2,<3.0` and change featureCollection iteration
+
+### titiler.application
+
+* fix Landing page links when app is behind proxy
+* use `titiler.core` templates for Landing page
+* enable JSON and HTML rendering of the `/` landing page
+* add OGC Common `/conformance` endpoint
+
+### titiler.core
+
+* add `conforms_to` attribute to `BaseFactory` to indicate which conformance the TileFactory implement
+
+* remove deprecated `ColorFormulaParams` and `RescalingParams` dependencies **breaking change**
+
+* remove deprecated `DefaultDependency` dict-unpacking feature **breaking change**
+
+* add `min`, `max`, `mean`, `median`, `std` and `var` algorithms
+
+* Fix TerrainRGB algorithm and param user-controlled nodata-height (@jo-chemla, https://github.com/developmentseed/titiler/pull/1116)
+
+* add `output_min` and `output_max` metadata attributes to `slope` algorithm (@tayden, https://github.com/developmentseed/titiler/pull/1089)
+
+* add point value query on right-click to map viewer (@hrodmn, https://github.com/developmentseed/titiler/pull/1100)
+
+* refactor middlewares to use python's dataclasses
+
+* update `LoggerMiddleware` output format and options **breaking change**
+
+    ```python
+    from fastapi import FastAPI
+
+    from titiler.core.middlewares import LoggerMiddleware
+
+    # before
+    app = FastAPI()
+    app.add_middlewares(LoggerMiddleware, querystrings=True, headers=True)
+
+    # now
+    app = FastAPI()
+    app.add_middlewares(
+        LoggerMiddleware,
+        # custom Logger
+        logger=logging.getLogger("mytiler.requests"),  # default to logging.getLogger("titiler.requests")
+    )
+    ```
+
+    Note: logger needs then to be `configured` at runtime. e.g :
+
+    ```python
+    from logging import config
+    config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "detailed": {
+                    "format": "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+                },
+                "request": {
+                    "format": (
+                        "%(asctime)s - %(levelname)s - %(name)s - %(message)s "
+                        + json.dumps(
+                            {
+                                k: f"%({k})s"
+                                for k in [
+                                    "method",
+                                    "referer",
+                                    "origin",
+                                    "route",
+                                    "path",
+                                    "path_params",
+                                    "query_params",
+                                    "headers",
+                                ]
+                            }
+                        )
+                    ),
+                },
+            },
+            "handlers": {
+                "console_request": {
+                    "class": "logging.StreamHandler",
+                    "level": "DEBUG",
+                    "formatter": "request",
+                    "stream": "ext://sys.stdout",
+                },
+            },
+            "loggers": {
+                "mytiler.requests": {
+                    "level": "INFO",
+                    "handlers": ["console_request"],
+                    "propagate": False,
+                },
+            },
+        }
+    )
+    ```
+
+### titiler.extensions
+
+* update `wms` extension to remove usage of `ColorFormulaParams` and `RescalingParams` dependencies
+* update `render` extension to better validate query-parameters from render expression
+
+### titiler.xarray
+
+* update `rio-tiler` requirement to `>=7.6.1`
+* add `sel` and `sel_method` options to select dimension
+
+    ```
+    # before
+    https://.../0/0/0.png?url=dataset.zarr&drop_dim=time=2023-01-01
+
+    # now
+    https://.../0/0/0.png?url=dataset.zarr&sel=time=2023-01-01
+
+    # method
+    https://.../0/0/0.png?url=dataset.zarr&sel=time=2023-01-02&sel_method=nearest
+
+    # Can use `slice` when providing 2 values
+    https://.../0/0/0.png?url=dataset.zarr&sel=time=2023-01-01&time=2023-01-31
+    ```
+* add support for `bidx` parameter
+* remove `first` **time** dim selection **breaking change**
+* add support for 3D dataset
+* remove `drop_dim` option **breaking change**
+* remove `datetime` option **breaking change**
+* deprecate `VariablesExtension` extension
+* add `DatasetMetadataExtension` extension (`/dataset/keys`, `/dataset/` and `/dataset/dict` endpoints)
+
+### titiler.mosaic
+
+* add `/bbox` prefix to `/{minx},{miny},{maxx},{maxy}/assets` endpoint -> `/bbox/{minx},{miny},{maxx},{maxy}/assets` **breaking change**
+* add `/point` prefix to `{lon},{lat}/assets` endpoint -> `/point/{lon},{lat}/assets` **breaking change**
+* add `/tiles` prefix to `/{tileMatrixSetId}/{z}/{x}/{y}/assets` endpoint -> `/tiles/{tileMatrixSetId}/{z}/{x}/{y}/assets` **breaking change**
+* add `assets_accessor_dependency` dependency to the MosaicTileFactory to pass options to the backend's `get_assets` method.
+
+## 0.21.1 (2025-01-29)
+
+### titiler.core
+
+* add `slope` algorithm (@tayden, https://github.com/developmentseed/titiler/pull/1088)
+
+### titiler.xarray
+
+* Support Zarr-Python >=3 (author @maxrjones, https://github.com/developmentseed/titiler/pull/1082)
+
+## 0.21.0 (2025-01-24)
+
+### Misc
+
+* use `URN` style CRS notation in WMTS document
+
+* Unify Docker images (deprecate `titiler-uvicorn`)
+
+    ```
+    # Uvicorn
+    # before
+    docker run \
+        --platform=linux/amd64 \
+        -p 8000:8000 \
+        --env PORT=8000 \
+        --rm -it ghcr.io/developmentseed/titiler-uvicorn:latest
+
+    # now
+    docker run \
+        --platform=linux/amd64 \
+        -p 8000:8000 \
+        --rm -it ghcr.io/developmentseed/titiler:latest \
+        uvicorn titiler.application.main:app --host 0.0.0.0 --port 8000 --workers 1
+
+    # Gunicorn
+    # before
+    docker run \
+        --platform=linux/amd64 \
+        -p 8000:8000 \
+        --env PORT=8000 \
+        --rm -it ghcr.io/developmentseed/titiler:latest
+
+    # now
+    docker run \
+        --platform=linux/amd64 \
+        -p 8000:8000 \
+        --rm -it ghcr.io/developmentseed/titiler:latest \
+        gunicorn -k uvicorn.workers.UvicornWorker titiler.application.main:app --bind 0.0.0.0:8000 --workers 1
+    ```
+
+## 0.20.1 (2025-01-09)
+
+### titiler.xarray
+
+* pin python `zarr` to `>2,<3.0` to avoid zarr 3.0 breaking changes
+
+## 0.20.0 (2025-01-07)
+
+### titiler.core
+
+* add layer control to map viewer template (author @hrodmn, https://github.com/developmentseed/titiler/pull/1051)
+* improve query string handling in LowerCaseQueryStringMiddleware using urlencode (author @pratapvardhan, https://github.com/developmentseed/titiler/pull/1050)
+* add `titiler.core.utils.bounds_to_geometry` and reduce code duplication in factories (author @PratapVardhan, https://github.com/developmentseed/titiler/pull/1047)
+* simplify image format dtype validation in `render_image` (author @PratapVardhan, https://github.com/developmentseed/titiler/pull/1046)
+* remove `rescale_dependency` and `color_formula_dependency` attributes in `TilerFactory` class  **breaking change**
+* move `rescale` and `color_formula` QueryParameters dependencies in `ImageRenderingParams` class  **breaking change**
+* handle image rescaling and color_formula within `titiler.core.utils.render_image` function  **breaking change**
+* add `render_func: Callable[..., Tuple[bytes, str]] = render_image` attribute in `TilerFactory` class
+* add `castToInt`, `Floor`, `Ceil` algorithms
+
+### titiler.application
+
+* update `/healthz` endpoint to return dependencies versions (titiler, rasterio, gdal, ...) (author @scottyhq, https://github.com/developmentseed/titiler/pull/1056)
+* migrate `templates/index.html` to bootstrap5, remove unused css, reuse bs classes (author @PratapVardhan, https://github.com/developmentseed/titiler/pull/1048)
+
+### titiler.mosaic
+
+* remove `rescale_dependency` and `color_formula_dependency` attributes in `MosaicTilerFactory` class  **breaking change**
+* add `render_func: Callable[..., Tuple[bytes, str]] = render_image` attribute in `MosaicTilerFactory` class  **breaking change**
+
+### titiler.extensions
+
+* use `factory.render_func` as render function in `wmsExtension` endpoints
+* add `stacRenderExtension` which adds two endpoints: `/renders` (lists all renders) and `/renders/<render_id>` (render metadata and links) (author @alekzvik, https://github.com/developmentseed/titiler/pull/1038)
+
+### Misc
+
+* Updated WMTS Capabilities template to avoid inserting extra new lines (author @AndrewAnnex, https://github.com/developmentseed/titiler/pull/1052).
+* Updated WMTS endpoint in titiler.mosaic and titiler.core to return layer bounds in coordinate ordering matching CRS order if WGS84 is not used (author @AndrewAnnex, https://github.com/developmentseed/titiler/pull/1052).
+* Remove `python3.8` support (author @pratapvardhan, https://github.com/developmentseed/titiler/pull/1058)
+* Add `python3.13` support (author @pratapvardhan, https://github.com/developmentseed/titiler/pull/1058)
+
+## 0.19.3 (2025-01-09)
+
+### titiler.xarray
+
+* pin python zarr to >2,<3.0 to avoid zarr 3.0 breaking changes [Backported from 0.20.1]
+
+
+## 0.19.2 (2024-11-28)
+
+### Misc
+
+* drop python 3.8 and add python 3.13 support (author @pratapvardhan, https://github.com/developmentseed/titiler/pull/1058)
+
+* Update package build backend from `pdm-pep517` to `pdm-backend` (https://backend.pdm-project.org/#migrate-from-pdm-pep517)
+
+* Update namespace package from using `.` to `-` as separator to comply with PEP-625 (https://peps.python.org/pep-0625/)
+
+### titiler.mosaic
+
+* Define variable (`MOSAIC_CONCURRENCY` and `MOSAIC_STRICT_ZOOM`) from env-variable outside endpoint code
+
+## 0.19.1 (2024-11-14)
+
+* Add `titiler` links in Map attributions
+
+## 0.19.0 (2024-11-07)
+
+### Misc
+
+* Remove default `WebMercatorQuad` tile matrix set in `/tiles`, `/tilesjson.json`, `/map` and `/WMTSCapabilities.xml` endpoints **breaking change**
+
+    ```
+    # Before
+    /tiles/{z}/{x}/{y}
+    /tilejson.json
+    /map
+    /WMTSCapabilities.xml
+
+    # Now
+    /tiles/WebMercatorQuad/{z}/{x}/{y}
+    /WebMercatorQuad/tilejson.json
+    /WebMercatorQuad/map
+    /WebMercatorQuad/WMTSCapabilities.xml
+    ```
+
+* Use `@attrs.define` instead of dataclass for factories **breaking change**
+* Use `@attrs.define` instead of dataclass for factory extensions **breaking change**
+* Handle `numpy` types in JSON/GeoJSON response
+* In the `map.html` template, use the tilejson's `minzoom` and `maxzoom` to populate `minNativeZoom` and `maxNativeZoom` parameters in leaflet `tileLayer` instead of `minZoom` and `maxZoom`
+
+### titiler.core
+
+* Update `rio-tiler` dependency to `>=7.0,<8.0`
+
+* Update `geojson-pydantic` dependency to `>=1.1.2,<2.0` which better handle antimeridian crossing dataset
+
+* handle `antimeridian` crossing bounds in `/info.geojson` endpoints (returning MultiPolygon instead of Polygon)
+
+* Improve XSS security for HTML templates (author @jcary741, https://github.com/developmentseed/titiler/pull/953)
+
+* Remove all default values to the dependencies **breaking change**
+
+    * `DatasetParams.unscale`: `False` -> `None` (default to `False` in rio-tiler)
+    * `DatasetParams.resampling_method`: `nearest` -> `None` (default to `nearest` in rio-tiler)
+    * `DatasetParams.reproject_method`: `nearest` -> `None` (default to `nearest` in rio-tiler)
+    * `ImageRenderingParams.add_mask`: `True` -> `None` (default to `True` in rio-tiler)
+    * `StatisticsParams.categorical`: `False` -> `None` (default to `False` in rio-tiler)
+
+* Add `as_dict(exclude_none=True/False)` method to the `DefaultDependency` class.
+
+    ```python
+    from typing import Optional
+    from titiler.core.dependencies import DefaultDependency
+    from dataclasses import dataclass
+
+    @dataclass
+    class Deps(DefaultDependency):
+        value: Optional[int] = None
+
+    print({**Deps().__dict__.items()})
+    >> {'value': None}
+
+    Deps().as_dict()  # `exclude_none` defaults to True
+    >> {}
+
+    Deps(value=1).as_dict()
+    >> {'value': 1}
+    ```
+
+* Fix Hillshade algorithm (bad `azimuth` angle)
+
+* Set default `azimuth` and `altitude` angles to 45º for the Hillshade algorithm **breaking change**
+
+* Use `.as_dict()` method when passing option to rio-tiler Reader's methods to avoid parameter conflicts when using custom Readers.
+
+* Rename `BaseTilerFactory` to `BaseFactory` **breaking change**
+
+* Remove useless attribute in `BaseFactory` (and moved them to `TilerFactory`) **breaking change**
+
+* Add `crs` option to `/bounds` endpoints to enable geographic_crs selection by the user
+
+* `/bounds` endpoints now return a `crs: str` attribute in the response
+
+* update `wmts.xml` template to support multiple layers
+
+* re-order endpoints parameters
+
+* avoid `lat/lon` overflow in `map` viewer
+
+* add OGC Tiles `/tiles` and `/tiles/{tileMatrixSet}` endpoints
+
+* add `gif` media type
+
+* `/point` endpoint returned masked values (`None` is nodata)
+
+### titiler.mosaic
+
+* Rename `reader` attribute to `backend` in `MosaicTilerFactory`  **breaking change**
+
+* Add `crs` option to `/bounds` endpoints to enable geographic_crs selection by the user
+
+* `/bounds` endpoints now return a `crs: str` attribute in the response
+
+* Update `cogeo-mosaic` dependency to `>=8.0,<9.0`
+
+* re-order endpoints parameters
+
+* add OGC Tiles `/tiles` and `/tiles/{tileMatrixSet}` endpoints
+
+* `/point` endpoint returned masked values (`None` is nodata)
+
+### titiler.extensions
+
+* Encode URL for cog_viewer and stac_viewer (author @guillemc23, https://github.com/developmentseed/titiler/pull/961)
+
+* Add links for render parameters and `/map` link to **viewer** dashboard (author @hrodmn, https://github.com/developmentseed/titiler/pull/987)
+
+* Update viewers to use `/info.geojson` endpoint instead of `/info`
+
+## 0.18.10 (2024-10-17)
+
+### titiler.application
+
+* update `starlette-cramjam` dependency and set compression-level default to `6`
+
+## 0.18.9 (2024-09-23)
+
+* fix release 0.18.8
+
+## 0.18.8 (2024-09-23)
+
+### titiler.extensions
+
+* Add links for render parameters and /map link to viewer dashboard (author @hrodmn, https://github.com/developmentseed/titiler/pull/987)
+
+## 0.18.7 (2024-09-19)
+
+* fix Hillshade algorithm (bad `azimuth` angle) (https://github.com/developmentseed/titiler/pull/985) [Backported]
+* Encode URL for cog_viewer and stac_viewer (author @guillemc23, https://github.com/developmentseed/titiler/pull/961) [Backported]
+* Improve XSS security for HTML templates (author @jcary741, https://github.com/developmentseed/titiler/pull/953) [Backported]
+
+## 0.18.6 (2024-08-27)
+
+* Switch back to `fastapi` instead of `fastapi-slim` and use `>=0.109.0` version
+
+## 0.18.5 (2024-07-03)
+
+* Set version requirement for FastAPI to `>=0.111.0`
+
+## 0.18.4 (2024-06-26)
+
+* fix Tiles URL encoding for WMTSCapabilities XML document
+
+## 0.18.3 (2024-05-20)
+
+* fix `WMTSCapabilities.xml` response for ArcMap compatibility
+    * replace `Cloud Optimized GeoTIFF` with dataset URL or `TiTiler` for the *ows:ServiceIdentification* **title**
+    * replace `cogeo` with `Dataset` for the `layer` *ows:Identifier*
+
+## 0.18.2 (2024-05-07)
+
+* move to `fastapi-slim` to avoid unwanted dependencies (author @n8sty, https://github.com/developmentseed/titiler/pull/815)
+
+## 0.18.1 (2024-04-12)
+
+### titiler.core
+
+* fix `TerrainRGB` algorithm name (author @JinIgarashi, https://github.com/developmentseed/titiler/pull/804)
+* add more tests for `RescalingParams` and `HistogramParams` dependencies
+* make sure to return *empty* content for `204` Error code
+
+## 0.18.0 (2024-03-22)
+
+### titiler.core
+
+* Add `ColorMapFactory` to create colorMap metadata endpoints (https://github.com/developmentseed/titiler/pull/796)
+* **Deprecation** remove default `WebMercatorQuad` tile matrix set in `/tiles`, `/tilesjson.json`, `/map` and `/WMTSCapabilities.xml` endpoints (https://github.com/developmentseed/titiler/pull/802)
+
+    ```
+    # Before
+    /tiles/{z}/{x}/{y}
+    /tilejson.json
+    /map
+    /WMTSCapabilities.xml
+
+    # Now
+    /tiles/WebMercatorQuad/{z}/{x}/{y}
+    /WebMercatorQuad/tilejson.json
+    /WebMercatorQuad/map
+    /WebMercatorQuad/WMTSCapabilities.xml
+    ```
+
+* **Deprecation** `default_tms` attribute in `BaseTilerFactory` (because `tileMatrixSetId` is now required in endpoints).
+
+### titiler.mosaic
+
+* **Deprecation** remove default `WebMercatorQuad` tile matrix set in `/tiles`, `/tilesjson.json`, `/map` and `/WMTSCapabilities.xml` endpoints (https://github.com/developmentseed/titiler/pull/802)
+
+    ```
+    # Before
+    /tiles/{z}/{x}/{y}
+    /tilejson.json
+    /map
+    /WMTSCapabilities.xml
+
+    # Now
+    /tiles/WebMercatorQuad/{z}/{x}/{y}
+    /WebMercatorQuad/tilejson.json
+    /WebMercatorQuad/map
+    /WebMercatorQuad/WMTSCapabilities.xml
+    ```
+
+* **Deprecation** `default_tms` attribute in `MosaicTilerFactory` (because `tileMatrixSetId` is now required in endpoints).
+
+### Misc
+
+* add `request` as first argument in `TemplateResponse` to adapt with latest starlette version
+
+## 0.17.3 (2024-03-21)
+
+### titiler.application
+
+* Add `extra="ignore"` option `ApiSettings` to fix pydantic issue when using `.env` file (author @imanshafiei540, https://github.com/developmentseed/titiler/pull/800)
+
+## 0.17.2 (2024-03-15)
+
+### titiler.core
+
+* fix OpenAPI metadata for algorithm (author @JinIgarashi, https://github.com/developmentseed/titiler/pull/797)
+
+## 0.17.1 (2024-03-13)
+
+* add python 3.12 support
+
+### titiler.core
+
+* Add `use_epsg` parameter to WMTS endpoint to resolve ArcMAP issues and fix XML formating (author @gadomski, https://github.com/developmentseed/titiler/pull/782)
+* Add more OpenAPI metadata for algorithm (author @JinIgarashi, https://github.com/developmentseed/titiler/pull/783)
+
+### titiler.application
+
+* fix invalid url parsing in HTML responses
+
+## 0.17.0 (2024-01-17)
+
+### titiler.core
+
+* update `rio-tiler` version to `>6.3.0`
+* use new `align_bounds_with_dataset=True` rio-tiler option in GeoJSON statistics methods for more precise calculation
+
+## 0.16.2 (2024-01-17)
+
+### titiler.core
+
+* fix leafletjs template maxZoom to great than 18 for `/map` endpoint (author @Firefishy, https://github.com/developmentseed/titiler/pull/749)
+
+## 0.16.1 (2024-01-08)
+
+### titiler.core
+
+* use morecantile `TileMatrixSet.cellSize` property instead of deprecated/private `TileMatrixSet._resolution` method
+
+### titiler.mosaic
+
+* use morecantile `TileMatrixSet.cellSize` property instead of deprecated/private `TileMatrixSet._resolution` method
+
+## 0.16.0 (2024-01-08)
+
+### titiler.core
+
+* update FastAPI version lower limit to `>=0.107.0`
+* fix template loading for starlette >= 0.28 by using `jinja2.Environment` argument (author @jasongi, https://github.com/developmentseed/titiler/pull/744)
+
+### titiler.extensions
+
+* fix template loading for starlette >= 0.28 by using `jinja2.Environment` argument (author @jasongi, https://github.com/developmentseed/titiler/pull/744)
+
+### titiler.application
+
+* fix template loading for starlette >= 0.28 by using `jinja2.Environment` argument (author @jasongi, https://github.com/developmentseed/titiler/pull/744)
+
+## 0.15.8 (2024-01-08)
+
+### titiler.core
+
+* use morecantile `TileMatrixSet.cellSize` property instead of deprecated/private `TileMatrixSet._resolution` method [backported from 0.16.1]
+
+### titiler.mosaic
+
+* use morecantile `TileMatrixSet.cellSize` property instead of deprecated/private `TileMatrixSet._resolution` method [backported from 0.16.1]
+
+## 0.15.7 (2024-01-08)
+
+### titiler.core
+
+* update FastAPI version upper limit to `<0.107.0` to avoid starlette breaking change (`0.28`)
+
+### titiler.application
+
+* add simple *auth* (optional) based on `global_access_token` string, set with `TITILER_API_GLOBAL_ACCESS_TOKEN` environment variable (author @DeflateAwning, https://github.com/developmentseed/titiler/pull/735)
+
+## 0.15.6 (2023-11-16)
+
+### titiler.core
+
+* in `/map` HTML response, add Lat/Lon buffer to AOI to avoid creating wrong AOI (when data covers the whole world).
+
+## 0.15.5 (2023-11-09)
+
+### titiler.core
+
+* add `algorithm` options for `/statistics` endpoints
+
+* switch from `BaseReader.statistics()` method to a combination of `BaseReader.preview()` and `ImageData.statistics()` methods to get the statistics
+
+## 0.15.4 (2023-11-06)
+
+### titiler.core
+
+* update `rio-tiler` requirement to `>=6.2.5,<7.0`
+
+* allow `bidx` option in `titiler.core.dependencies.AssetsBidxExprParams` and `titiler.core.dependencies.AssetsBidxParams`
+
+    ```python
+    # merge band 1 form asset1 and asset2
+    # before
+    httpx.get(
+        "/stac/preview",
+        params=(
+            ("url", "stac.json"),
+            ("assets", "asset1"),
+            ("assets", "asset2"),
+            ("asset_bidx", "asset1|1"),
+            ("asset_bidx", "asset2|1"),
+        )
+    )
+
+    # now
+    httpx.get(
+        "/stac/preview",
+        params=(
+            ("url", "stac.json"),
+            ("assets", "asset1"),
+            ("assets", "asset2"),
+            ("bidx", 1),
+        )
+    )
+    ```
+
+* fix openapi examples
+
+## 0.15.3 (2023-11-02)
+
+* add `dst_crs` options in `/statistics [POST]` and `/feature [POST]` endpoints
+
+## 0.15.2 (2023-10-23)
+
+### titiler.core
+
+* add `dependencies.TileParams` dependency with `buffer` and `padding` options
+* add `tile_dependency` attribute in `TilerFactory` class (defaults to `TileParams`)
+* add `reproject` (alias to `reproject_method`) option in `DatasetParams` dependency
+
+### titiler.mosaic
+
+*  Change `HTTP_404_NOT_FOUND` to `HTTP_204_NO_CONTENT` when no asset is found or tile is empty (author @simouel, https://github.com/developmentseed/titiler/pull/713)
+* add `tile_dependency` attribute in `MosaicTilerFactory` class (defaults to `TileParams`)
+
+### cdk application
+
+* Support non-root paths in AWS API Gateway Lambda handler (author @DanSchoppe, https://github.com/developmentseed/titiler/pull/716)
+
+## 0.15.1 (2023-10-17)
+
+* Allow a default `color_formula` parameter to be set via a dependency (author @samn, https://github.com/developmentseed/titiler/pull/707)
+* add `titiler.core.dependencies.create_colormap_dependency` to create ColorMapParams dependency from `rio_tiler.colormap.ColorMaps` object
+* add `py.typed` files in titiler submodules (https://peps.python.org/pep-0561)
+
+## 0.15.0 (2023-09-28)
+
+### titiler.core
+
+- added `PartFeatureParams` dependency
+
+**breaking changes**
+
+- `max_size` is now set to `None` for `/statistics [POST]`, `/bbox` and `/feature` endpoints, meaning the tiler will create image from the highest resolution.
+
+- renamed `titiler.core.dependencies.ImageParams` to `PreviewParams`
+
+- split TileFactory `img_dependency` attribute in two:
+  - `img_preview_dependency`: used in `/preview` and `/statistics [GET]`, default to `PreviewParams` (with `max_size=1024`)
+
+  - `img_part_dependency`: used in `/bbox`, `/feature` and `/statistics [POST]`, default to `PartFeatureParams` (with `max_size=None`)
+
+- renamed `/crop` endpoints to `/bbox/...` or `/feature/...`
+  - `/crop/{minx},{miny},{maxx},{maxy}.{format}` -> `/bbox/{minx},{miny},{maxx},{maxy}.{format}`
+
+  - `/crop/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}` -> `/bbox/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}`
+
+  - `/crop [POST]` -> `/feature [POST]`
+
+  - `/crop.{format} [POST]` -> `/feature.{format} [POST]`
+
+  - `/crop/{width}x{height}.{format}  [POST]` -> `/feature/{width}x{height}.{format} [POST]`
+
+- update `rio-tiler` requirement to `>=6.2.1`
+
+- Take coverage weights in account when generating statistics from GeoJSON features
+
+## 0.14.1 (2023-09-14)
+
+### titiler.extension
+
+* add `GetFeatureInfo` capability in `wmsExtension` (author @benjaminleighton, https://github.com/developmentseed/titiler/pull/698)
+
+## 0.14.0 (2023-08-30)
+
+### titiler.core
+
+* replace `-` by `_` in query parameters **breaking change**
+  - `coord-crs` -> `coord_crs`
+  - `dst-crs` -> `dst_crs`
+
+* replace `buffer` and `color_formula` endpoint parameters by external dependencies (`BufferParams` and `ColorFormulaParams`)
+
+* add `titiler.core.utils.render_image` which allow non-binary alpha band created with custom colormap. `render_image` replace `ImageData.render` method.
+
+    ```python
+    # before
+    if cmap := colormap or dst_colormap:
+        image = image.apply_colormap(cmap)
+
+    if not format:
+        format = ImageType.jpeg if image.mask.all() else ImageType.png
+
+    content = image.render(
+        img_format=format.driver,
+        **format.profile,
+        **render_params,
+    )
+
+    # now
+    # render_image will:
+    # - apply the colormap
+    # - choose the right output format if `None`
+    # - create the binary data
+    content, media_type = render_image(
+        image,
+        output_format=format,
+        colormap=colormap or dst_colormap,
+        **render_params,
+    )
+    ```
+
+### titiler.extension
+
+* rename `geom-densify-pts` to `geometry_densify` **breaking change**
+* rename `geom-precision` to `geometry_precision` **breaking change**
+
+## 0.13.3 (2023-08-27)
+
+* fix Factories `url_for` method and avoid changing `Request.path_params` object
+
+## 0.13.2 (2023-08-24)
+
+### titiler.extensions
+
+* replace mapbox-gl by maplibre
+* replace Stamen by OpenStreetMap tiles
+* simplify band selection handling (author @tayden, https://github.com/developmentseed/titiler/pull/688)
+
+## 0.13.1 (2023-08-21)
+
+### titiler.core
+
+* fix `LowerCaseQueryStringMiddleware` unexpectedly truncating query parameters (authors @jthetzel and @jackharrhy, @https://github.com/developmentseed/titiler/pull/677)
+
+## titiler.application
+
+* add `cors_allow_methods` in `ApiSettings` to control the CORS allowed methods (author @ubi15, https://github.com/developmentseed/titiler/pull/684)
+
+## 0.13.0 (2023-07-27)
+
+* update core requirements to libraries using pydantic **~=2.0**
+
+### titiler.core
+
+* update requirements:
+  * fastapi `>=0.95.1` --> `>=0.100.0`
+  * pydantic `~=1.0` --> `~=2.0`
+  * rio-tiler `>=5.0,<6.0` --> `>=6.0,<7.0`
+  * morecantile`>=4.3,<5.0` --> `>=5.0,<6.0`
+  * geojson-pydantic `>=0.4,<0.7` --> `>=1.0,<2.0`
+  * typing_extensions `>=4.6.1`
+
+### titiler.extension
+
+* update requirements:
+  * rio-cogeo `>=4.0,<5.0"` --> `>=5.0,<6.0"`
+
+### titiler.mosaic
+
+* update requirements:
+  * cogeo-mosaic `>=6.0,<7.0` --> `>=7.0,<8.0`
+
+### titiler.application
+
+* use `/api` and `/api.html` for documentation (instead of `/openapi.json` and `/docs`)
+* update landing page
+
+## 0.12.0 (2023-07-17)
+
+* use `Annotated` Type for Query/Path parameters
+* replace variable `TileMatrixSetId` by `tileMatrixSetId`
+
+### titiler.core
+
+* update FastAPI dependency to `>=0.95.1`
+* set `pydantic` dependency to `~=1.0`
+* update `rio-tiler` dependency to `>=5.0,<6.0`
+* update TMS endpoints to match OGC Tiles specification
+
+### titiler.extensions
+
+* use TiTiler's custom JSONResponse for the `/validate` endpoint to avoid issue when COG has `NaN` nodata value
+* update `rio-cogeo` dependency to `>=4.0,<5.0`
+* update `rio-stac` requirement to `>=0.8,<0.9` and add `geom-densify-pts` and `geom-precision` options
+
+## titiler.mosaic
+
+* update `cogeo-mosaic` dependency to `>=6.0,<7.0`
+* remove `titiler.mosaic.resources.enum.PixelSelectionMethod` and use `rio_tiler.mosaic.methods.PixelSelectionMethod`
+* allow more TileMatrixSet (than only `WebMercatorQuad`)
+
 ## 0.11.7 (2023-05-18)
 
 ### titiler.core
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a7105795c..515c77b38 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,44 +2,66 @@
 
 Issues and pull requests are more than welcome: https://github.com/developmentseed/titiler/issues
 
+We recommand using [`uv`](https://docs.astral.sh/uv) as project manager for development.
+
+See https://docs.astral.sh/uv/getting-started/installation/ for installation 
+
 **dev install**
 
 ```bash
 git clone https://github.com/developmentseed/titiler.git
 cd titiler
 
-python -m pip install \
-   pre-commit \
-   -e src/titiler/core["test"] \
-   -e src/titiler/extensions["test,cogeo,stac"] \
-   -e src/titiler/mosaic["test"] \
-   -e src/titiler/application["test"]
+# Install the package in editable mode, plus the "dev" dependency group.
+# You can add `--group` arguments to add more groups, e.g. `--group notebook`.
+uv sync
 ```
 
 **pre-commit**
 
-This repo is set to use `pre-commit` to run *isort*, *flake8*, *pydocstring*, *black* ("uncompromising Python code formatter") and mypy when committing new code.
+This repo is set to use `pre-commit` to run *isort*, *ruff* (linting and formatting), *mypy*, *zizmor* (GitHub Actions security audit), and *commitizen* (commit message linting) when committing new code.
 
 ```bash
-pre-commit install
+uv run pre-commit install
+
+# If needed, you can run pre-commit script manually
+uv run pre-commit run --all-files
+```
+
+### Conventional Commits
+
+This repo enforces [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
+Commit messages must follow the format:
+
+```
+<type>[optional scope]: <description>
 ```
 
+Common types: `feat`, `fix`, `docs`, `chore`, `refactor`, `test`, `ci`.
+
+The `commitizen` pre-commit hook (installed in the `commit-msg` stage via `uv run pre-commit install`) validates each commit message locally. The same check runs in CI via the `Commitlint` GitHub Actions workflow on every push.
+
+Release notes and version bumps are generated automatically from conventional commit history using [Release Please](https://github.com/googleapis/release-please).
+
 ### Run tests
 
 Each `titiler`'s modules has its own test suite which can be ran independently
 
 ```
 # titiler.core
-python -m pytest src/titiler/core --cov=titiler.core --cov-report=xml --cov-append --cov-report=term-missing
+uv run pytest src/titiler/core --cov=titiler.core --cov-report=xml --cov-append --cov-report=term-missing
 
 # titiler.extensions
-python -m pytest src/titiler/extensions --cov=titiler.extensions --cov-report=xml --cov-append --cov-report=term-missing
+uv run pytest src/titiler/extensions --cov=titiler.extensions --cov-report=xml --cov-append --cov-report=term-missing
 
 # titiler.mosaic
-python -m pytest src/titiler/mosaic --cov=titiler.mosaic --cov-report=xml --cov-append --cov-report=term-missing
+uv run pytest src/titiler/mosaic --cov=titiler.mosaic --cov-report=xml --cov-append --cov-report=term-missing
+
+# titiler.xarray
+uv run pytest src/titiler/xarray --cov=titiler.xarray --cov-report=xml --cov-append --cov-report=term-missing
 
 # titiler.application
-python -m pytest src/titiler/application --cov=titiler.application --cov-report=xml --cov-append --cov-report=term-missing
+uv run pytest src/titiler/application --cov=titiler.application --cov-report=xml --cov-append --cov-report=term-missing
 ```
 
 ### Docs
@@ -47,48 +69,20 @@ python -m pytest src/titiler/application --cov=titiler.application --cov-report=
 ```bash
 git clone https://github.com/developmentseed/titiler.git
 cd titiler
-python -m pip install nbconvert mkdocs mkdocs-material mkdocs-jupyter pygments pdocs
+
+# Build docs
+uv run --group docs mkdocs build -f docs/mkdocs.yml
 ```
 
 Hot-reloading docs:
 
 ```bash
-mkdocs serve -f docs/mkdocs.yml
+uv run --group docs mkdocs serve -f docs/mkdocs.yml --livereload
 ```
 
 To manually deploy docs (note you should never need to do this because Github
 Actions deploys automatically for new commits.):
 
 ```bash
-mkdocs gh-deploy -f docs/mkdocs.yml
-```
-
-```bash
-pdocs as_markdown \
-   --output_dir docs/src/api \
-   --exclude_source \
-   --overwrite \
-   titiler.core.dependencies \
-   titiler.core.factory \
-   titiler.core.utils \
-   titiler.core.routing \
-   titiler.core.errors \
-   titiler.core.resources.enums \
-   titiler.core.middleware
-
-pdocs as_markdown \
-   --output_dir docs/src/api \
-   --exclude_source \
-   --overwrite \
-   titiler.extensions.cogeo \
-   titiler.extensions.viewer \
-   titiler.extensions.stac
-
-pdocs as_markdown \
-   --output_dir docs/src/api \
-   --exclude_source \
-   --overwrite \
-   titiler.mosaic.factory \
-   titiler.mosaic.resources.enums \
-   titiler.mosaic.errors
+uv run --group docs mkdocs gh-deploy -f docs/mkdocs.yml
 ```
diff --git a/README.md b/README.md
index 44f4aed17..f48fc53fc 100644
--- a/README.md
+++ b/README.md
@@ -10,8 +10,8 @@
   <a href="https://codecov.io/gh/developmentseed/titiler" target="_blank">
       <img src="https://codecov.io/gh/developmentseed/titiler/branch/main/graph/badge.svg" alt="Coverage">
   </a>
-  <a href="https://pypi.org/project/titiler" target="_blank">
-      <img src="https://img.shields.io/pypi/v/titiler?color=%2334D058&label=pypi%20package" alt="Package version">
+  <a href="https://pypi.org/project/titiler-application" target="_blank">
+      <img src="https://img.shields.io/pypi/v/titiler-application?color=%2334D058&label=pypi%20package" alt="Package version">
   </a>
   <a href="https://github.com/developmentseed/titiler/blob/main/LICENSE" target="_blank">
       <img src="https://img.shields.io/github/license/developmentseed/titiler.svg" alt="Downloads">
@@ -22,17 +22,20 @@
   <a href="https://hub.docker.com/r/developmentseed/titiler" target="_blank">
       <img src="https://img.shields.io/docker/v/developmentseed/titiler?color=%2334D058&label=docker%20hub" alt="Docker">
   </a>
+  <a href="https://scorecard.dev/viewer/?uri=github.com/developmentseed/titiler" target="_blank">
+      <img src="https://api.scorecard.dev/projects/github.com/developmentseed/titiler/badge" alt="OpenSSF Scorecard">
+  </a>
 </p>
 
 ---
 
-**Documentation**: <a href="https://devseed.com/titiler/" target="_blank">https://devseed.com/titiler/</a>
+**Documentation**: <a href="https://ds.io/titiler/" target="_blank">https://devseed.com/titiler/</a>
 
 **Source Code**: <a href="https://github.com/developmentseed/titiler" target="_blank">https://github.com/developmentseed/titiler</a>
 
 ---
 
-`Titiler`, pronounced **tee-tiler** (*ti* is the diminutive version of the french *petit* which means small), is a set of python modules that focus on creating FastAPI application for dynamic tiling.
+`TiTiler`, pronounced **tee-tiler** (*ti* is the diminutive version of the french *petit* which means small), is a set of python modules that focus on creating FastAPI application for dynamic tiling.
 
 Note: This project is the descendant of [`cogeo-tiler`](https://github.com/developmentseed/cogeo-tiler) and [`cogeo-mosaic-tiler`](https://github.com/developmentseed/cogeo-mosaic-tiler).
 
@@ -42,11 +45,13 @@ Note: This project is the descendant of [`cogeo-tiler`](https://github.com/devel
 - [Cloud Optimized GeoTIFF](http://www.cogeo.org/) support
 - [SpatioTemporal Asset Catalog](https://stacspec.org) support
 - Multiple projections support (see [TileMatrixSets](https://www.ogc.org/standards/tms)) via [`morecantile`](https://github.com/developmentseed/morecantile).
+- Multi-Dimensional (Zarr) dataset support via [Xarray](https://github.com/pydata/xarray)
 - JPEG / JP2 / PNG / WEBP / GTIFF / NumpyTile output format support
-- OGC WMTS support
+- OGC RESTful WMTS / OGC Tiles API support
+- Partial support of OGC Maps API
 - Automatic OpenAPI documentation (FastAPI builtin)
 - Virtual mosaic support (via [MosaicJSON](https://github.com/developmentseed/mosaicjson-spec/))
-- Example of AWS Lambda / ECS deployment (via CDK)
+- Example of AWS Lambda / ECS deployment (via CDK) / K8s Helm chart
 
 ## Packages
 
@@ -55,13 +60,20 @@ Starting with version `0.3.0`, the `TiTiler` python module has been split into a
 | Package | Version |  Description
 | ------- | ------- |-------------
 [**titiler.core**](https://github.com/developmentseed/titiler/tree/main/src/titiler/core) | [![titiler.core](https://img.shields.io/pypi/v/titiler.core?color=%2334D058&label=pypi)](https://pypi.org/project/titiler.core) | The `Core` package contains libraries to help create a  dynamic tiler for COG and STAC
+[**titiler.xarray**](https://github.com/developmentseed/titiler/tree/main/src/titiler/xarray) | [![titiler.xarray](https://img.shields.io/pypi/v/titiler.xarray?color=%2334D058&label=pypi)](https://pypi.org/project/titiler.xarray) | The `xarray` package contains libraries to help create a  dynamic tiler for Zarr/NetCDF datasets
 [**titiler.extensions**](https://github.com/developmentseed/titiler/tree/main/src/titiler/extensions) | [![titiler.extensions](https://img.shields.io/pypi/v/titiler.extensions?color=%2334D058&label=pypi)](https://pypi.org/project/titiler.extensions) | TiTiler's extensions package. Contains extensions for Tiler Factories.
 [**titiler.mosaic**](https://github.com/developmentseed/titiler/tree/main/src/titiler/mosaic) | [![titiler.mosaic](https://img.shields.io/pypi/v/titiler.mosaic?color=%2334D058&label=pypi)](https://pypi.org/project/titiler.mosaic) | The `mosaic` package contains libraries to help create a dynamic tiler for MosaicJSON (adds `cogeo-mosaic` requirement)
-[**titiler.application**](https://github.com/developmentseed/titiler/tree/main/src/titiler/application) | [![titiler.application](https://img.shields.io/pypi/v/titiler.application?color=%2334D058&label=pypi)](https://pypi.org/project/titiler.application) | TiTiler's `demo` package. Contains a FastAPI application with full support of COG, STAC and MosaicJSON
+[**titiler.application**](https://github.com/developmentseed/titiler/tree/main/src/titiler/application) | [![titiler.application](https://img.shields.io/pypi/v/titiler.application?color=%2334D058&label=pypi)](https://pypi.org/project/titiler.application) | TiTiler's `demo` package. Contains a FastAPI application with full support of COG, Zarr, STAC and MosaicJSON
 
 
 ## Installation
 
+> [!WARNING]
+>
+> Do not install the package named `titiler` from PyPI.
+> In late 2025, we [dropped support for this metapackage](https://github.com/developmentseed/titiler/issues/294);
+> now you must install TiTiler from the package names shown below.
+
 To install from PyPI and run:
 
 ```bash
@@ -71,9 +83,10 @@ python -m pip install -U pip
 python -m pip  install titiler.{package}
 # e.g.,
 # python -m pip  install titiler.core
+# python -m pip  install titiler.xarray
 # python -m pip  install titiler.extensions
 # python -m pip  install titiler.mosaic
-# python -m pip  install titiler.application (also installs core, extensions and mosaic)
+# python -m pip  install titiler.application (also installs core, extensions, xarray and mosaic)
 
 # Install uvicorn to run the FastAPI application locally
 python -m pip install uvicorn
@@ -88,11 +101,8 @@ To install from sources and run for development:
 git clone https://github.com/developmentseed/titiler.git
 cd titiler
 
-python -m pip install -U pip
-python -m pip install -e src/titiler/core -e src/titiler/extensions -e src/titiler/mosaic -e src/titiler/application
-python -m pip install uvicorn
-
-uvicorn titiler.application.main:app --reload
+uv sync --group server
+uv run uvicorn titiler.application.main:app --reload
 ```
 
 ## Docker
@@ -102,11 +112,11 @@ Ready to use/deploy images can be found on Github registry.
 - https://github.com/developmentseed/titiler/pkgs/container/titiler
 
 ```bash
-docker run --name titiler \
+docker run \
+    --platform=linux/amd64 \
     -p 8000:8000 \
-    --env PORT=8000 \
-    --env WORKERS_PER_CORE=1 \
-    --rm -it ghcr.io/developmentseed/titiler:latest
+    --rm -it ghcr.io/developmentseed/titiler:latest \
+    uvicorn titiler.application.main:app --host 0.0.0.0 --port 8000 --workers 1
 ```
 
 - Built the docker locally
@@ -114,17 +124,16 @@ docker run --name titiler \
 git clone https://github.com/developmentseed/titiler.git
 cd titiler
 
-docker-compose up --build titiler  # or titiler-uvicorn
+docker compose up --build titiler
 ```
 
-Some options can be set via environment variables, see: https://github.com/tiangolo/uvicorn-gunicorn-docker#advanced-usage
-
 ## Project structure
 
 ```
 src/titiler/                     - titiler modules.
  ├── application/                - Titiler's `Application` package
  ├── extensions/                 - Titiler's `Extensions` package
+ ├── xarray/                     - Titiler's `Xarray` package
  ├── core/                       - Titiler's `Core` package
  └── mosaic/                     - Titiler's `Mosaic` package
 ```
diff --git a/RELEASING.md b/RELEASING.md
new file mode 100644
index 000000000..17c674475
--- /dev/null
+++ b/RELEASING.md
@@ -0,0 +1,45 @@
+# Releasing
+
+Releases are automated via [release-please](https://github.com/googleapis/release-please-action). The process is driven entirely by [conventional commits](https://www.conventionalcommits.org/) merged to `main`.
+
+## How it works
+
+1. Every push to `main` triggers the `release-please` job in [`.github/workflows/release.yml`](.github/workflows/release.yml).
+2. release-please opens (or updates) a release PR that:
+   - Bumps the version in `pyproject.toml`, all sub-package `pyproject.toml` files, and `__init__.py` files
+   - Bumps `appVersion` in `deployment/k8s/charts/Chart.yaml`
+   - Updates `CHANGES.md` with the changelog for the new version
+3. When that PR is merged, release-please creates a GitHub release tagged `X.Y.Z`, which triggers the PyPI publish workflow.
+
+## Helm chart releases
+
+The Helm chart (`deployment/k8s/charts/`) is versioned independently from the Python package. release-please opens a separate helm release PR when commits touch files under `deployment/k8s/charts/`. That PR bumps `version:` in `Chart.yaml` and updates `deployment/k8s/charts/CHANGELOG.md`. The resulting GitHub release is tagged `helm-vX.Y.Z`.
+
+**Commit messages matter for chart releases.** A chart version bump only happens when a commit both:
+- touches at least one file under `deployment/k8s/charts/`, **and**
+- uses a bump-triggering type (`fix:`, `feat:`, or a breaking change)
+
+`chore:`, `ci:`, `docs:`, and other non-bumping types that touch chart files are valid conventional commits but will **not** produce a chart release. Use them for housekeeping that doesn't warrant a version bump (e.g. updating CI config, fixing a comment).
+
+Examples:
+
+```
+fix(helm): correct resource limit defaults         → patch bump
+feat(helm): add support for extra environment vars → minor bump
+feat(helm)!: rename required value X to Y         → major bump
+chore(helm): update maintainer list               → no bump
+```
+
+## Commit message convention
+
+Version bumps follow [semantic versioning](https://semver.org/) based on commit type:
+
+| Commit type | Version bump |
+|-------------|-------------|
+| `fix:` | patch |
+| `feat:` | minor |
+| `feat!:` or `BREAKING CHANGE:` footer | major |
+
+## No manual steps required
+
+All version files are updated automatically. Do not manually edit version strings in `pyproject.toml`, `Chart.yaml`, or `__init__.py` files — release-please owns those.
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 000000000..63e114021
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,73 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+If you find any vulnerabilities in `titiler`, don't hesitate to _report them_.
+
+1. Use GitHub's security reporting tools.
+
+see https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing-information-about-vulnerabilities/privately-reporting-a-security-vulnerability#privately-reporting-a-security-vulnerability
+
+2. Describe the vulnerability.
+
+   If you have a fix, that is most welcome -- please attach or summarize it in your message!
+
+3. We will evaluate the vulnerability and, if necessary, release a fix or mitigating steps to address it. We will contact you to let you know the outcome, and will credit you in the report.
+
+   Please **do not disclose the vulnerability publicly** until a fix is released!
+
+4. Once we have either a) published a fix, or b) declined to address the vulnerability for whatever reason, you are free to publicly disclose it.
+
+
+## GDAL
+
+`TiTiler` is built on top of Rasterio which is a python wrapper for the [GDAL](https://gdal.org/en/stable/) C++ library. At the time of writing, GDAL is responsible for most of the I/O and thus is where vulnerabilities could be harmful. For any `I/O` issues please first check [GDAL documentation](https://gdal.org/en/stable/user/security.html#security-considerations).
+
+#### GDAL VRT Driver
+
+There is a known security vulnerability with the VRT Driver:
+
+> It can be used to access any valid GDAL dataset. If a hostile party, with knowledge of the location on the filesystem of a valid GDAL dataset, convinces a user to run gdal_translate a VRT file and give it back the result, it might be able to steal data. That could potentially be able for a web service accepting data from the user, converting it, and sending back the result.
+
+see https://gdal.org/en/stable/user/security.html#gdal-vrt-driver
+
+Thus we recommend deploying titiler in infrastructure with limited access to the filesystem. Users can also `disable` the VRT driver completely by using `GDAL_SKIP=VRT` environment variable.
+
+In GDAL 3.12, new environment variables might be introduced to enable more control over the VRT driver: https://github.com/OSGeo/gdal/pull/12669
+
+#### Limit source's host
+
+If users want to limit the sources that the application can access, they can also create custom `path_dependency` such as this one which limits valid sources to a list of known hosts:
+
+```python
+from urllib.parse import urlparse
+
+from typing import Annotated
+from titiler.core.factory import TilerFactory
+from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
+
+from fastapi import FastAPI, Query, HTTPException
+
+# List of known host where dataset can be read from
+known_host = [
+   "devseed.org",
+]
+
+def DatasetPathParams(url: Annotated[str, Query(description="Dataset URL")]) -> str:
+   """Create dataset path from args"""
+   # validate Dataset host
+   parsed = urlparse(url)
+   if parsed.netloc not in known_host:
+      raise HTTPException(
+         status_code=400,
+         detail="Nope, this is not a valid File - Please Try Again",
+      )
+
+   return url
+
+
+app = FastAPI(title="My simple app")
+app.include_router(TilerFactory(path_dependency=DatasetPathParams).router)
+
+add_exception_handlers(app, DEFAULT_STATUS_CODES)
+```
diff --git a/deployment/aws/README.md b/deployment/aws/README.md
index de6c243f9..742810b87 100644
--- a/deployment/aws/README.md
+++ b/deployment/aws/README.md
@@ -4,4 +4,3 @@ Intro: https://developmentseed.org/titiler/deployment/aws/intro/
 
 AWS lambda: https://developmentseed.org/titiler/deployment/aws/lambda/
 
-ECS/Fargate: https://developmentseed.org/titiler/deployment/aws/ecs/
diff --git a/deployment/aws/app.py b/deployment/aws/app.py
new file mode 100644
index 000000000..449100f4a
--- /dev/null
+++ b/deployment/aws/app.py
@@ -0,0 +1,161 @@
+"""Construct App."""
+
+import os
+from typing import Any, Dict, List, Optional
+
+from aws_cdk import App, CfnOutput, Duration, Stack, Tags
+from aws_cdk import aws_apigatewayv2 as apigw
+from aws_cdk import aws_iam as iam
+from aws_cdk import aws_lambda
+from aws_cdk import aws_logs as logs
+from aws_cdk.aws_apigatewayv2_integrations import HttpLambdaIntegration
+from constructs import Construct
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class StackSettings(BaseSettings):
+    """Application settings"""
+
+    name: str = "titiler"
+    stage: str = "production"
+
+    owner: Optional[str] = None
+    client: Optional[str] = None
+
+    # Default options are optimized for CloudOptimized GeoTIFF
+    # For more information on GDAL env see: https://gdal.org/user/configoptions.html
+    # or https://developmentseed.org/titiler/advanced/performance_tuning/
+    env: Dict = {
+        "GDAL_CACHEMAX": "200",  # 200 mb
+        "GDAL_DISABLE_READDIR_ON_OPEN": "EMPTY_DIR",
+        "GDAL_INGESTED_BYTES_AT_OPEN": "32768",  # get more bytes when opening the files.
+        "GDAL_HTTP_MERGE_CONSECUTIVE_RANGES": "YES",
+        "GDAL_HTTP_MULTIPLEX": "YES",
+        "GDAL_HTTP_VERSION": "2",
+        "PYTHONWARNINGS": "ignore",
+        "VSI_CACHE": "TRUE",
+        "VSI_CACHE_SIZE": "5000000",  # 5 MB (per file-handle)
+    }
+
+    # S3 bucket names where TiTiler could do HEAD and GET Requests
+    # specific private and public buckets MUST be added if you want to use s3:// urls
+    # You can whitelist all bucket by setting `*`.
+    # ref: https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-arn-format.html
+    buckets: List = []
+
+    # S3 key pattern to limit the access to specific items (e.g: "my_data/*.tif")
+    key: str = "*"
+
+    ###########################################################################
+    # AWS LAMBDA
+    # The following settings only apply to AWS Lambda deployment
+    # more about lambda config: https://www.sentiatechblog.com/aws-re-invent-2020-day-3-optimizing-lambda-cost-with-multi-threading
+    timeout: int = 10
+    memory: int = 1536
+
+    # The maximum of concurrent executions you want to reserve for the function.
+    # Default: - No specific limit - account limit.
+    max_concurrent: Optional[int] = None
+
+    model_config = SettingsConfigDict(env_prefix="TITILER_STACK_", env_file=".env")
+
+
+class titilerLambdaStack(Stack):
+    """
+    Titiler Lambda Stack
+
+    This code is freely adapted from
+    - https://github.com/leothomas/titiler/blob/10df64fbbdd342a0762444eceebaac18d8867365/stack/app.py author: @leothomas
+    - https://github.com/ciaranevans/titiler/blob/3a4e04cec2bd9b90e6f80decc49dc3229b6ef569/stack/app.py author: @ciaranevans
+
+    """
+
+    def __init__(
+        self,
+        scope: Construct,
+        id: str,
+        memory: int = 1024,
+        timeout: int = 30,
+        runtime: aws_lambda.Runtime = aws_lambda.Runtime.PYTHON_3_14,
+        concurrent: Optional[int] = None,
+        permissions: Optional[List[iam.PolicyStatement]] = None,
+        environment: Optional[Dict] = None,
+        code_dir: str = "./",
+        **kwargs: Any,
+    ) -> None:
+        """Define stack."""
+        super().__init__(scope, id, **kwargs)
+
+        permissions = permissions or []
+        environment = environment or {}
+
+        # COG / STAC / MosaicJSON / Zarr endpoints
+        lambda_function = aws_lambda.Function(
+            self,
+            f"{id}-lambda",
+            runtime=runtime,
+            code=aws_lambda.Code.from_docker_build(
+                path=os.path.abspath(code_dir),
+                file="lambda/Dockerfile",
+                platform="linux/amd64",
+                build_args={
+                    "PYTHON_VERSION": "3.14",
+                },
+            ),
+            handler="handler.handler",
+            memory_size=memory,
+            reserved_concurrent_executions=concurrent,
+            timeout=Duration.seconds(timeout),
+            environment=environment,
+            log_retention=logs.RetentionDays.ONE_WEEK,
+        )
+
+        for perm in permissions:
+            lambda_function.add_to_role_policy(perm)
+
+        api = apigw.HttpApi(
+            self,
+            f"{id}-endpoint",
+            default_integration=HttpLambdaIntegration(
+                f"{id}-integration", handler=lambda_function
+            ),
+        )
+        CfnOutput(self, "Endpoint", value=api.url)
+
+
+app = App()
+settings = StackSettings()
+
+perms = []
+if settings.buckets:
+    perms.append(
+        iam.PolicyStatement(
+            actions=["s3:GetObject"],
+            resources=[
+                f"arn:aws:s3:::{bucket}/{settings.key}" for bucket in settings.buckets
+            ],
+        )
+    )
+
+lambda_stack = titilerLambdaStack(
+    app,
+    f"{settings.name}-lambda-{settings.stage}",
+    memory=settings.memory,
+    timeout=settings.timeout,
+    concurrent=settings.max_concurrent,
+    permissions=perms,
+    environment=settings.env,
+)
+
+# Tag infrastructure
+for key, value in {
+    "Project": settings.name,
+    "Stack": settings.stage,
+    "Owner": settings.owner,
+    "Client": settings.client,
+}.items():
+    if value:
+        Tags.of(lambda_stack).add(key, value)
+
+
+app.synth()
diff --git a/deployment/aws/cdk.json b/deployment/aws/cdk.json
index 57cc60ce6..787a71dd6 100644
--- a/deployment/aws/cdk.json
+++ b/deployment/aws/cdk.json
@@ -1,3 +1,3 @@
 {
-    "app": "python3 cdk/app.py"
+    "app": "python3 app.py"
 }
diff --git a/deployment/aws/cdk/__init__.py b/deployment/aws/cdk/__init__.py
deleted file mode 100644
index 4955682f0..000000000
--- a/deployment/aws/cdk/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""AWS App."""
diff --git a/deployment/aws/cdk/app.py b/deployment/aws/cdk/app.py
deleted file mode 100644
index 235baa35f..000000000
--- a/deployment/aws/cdk/app.py
+++ /dev/null
@@ -1,212 +0,0 @@
-"""Construct App."""
-
-import os
-from typing import Any, Dict, List, Optional, Union
-
-from aws_cdk import App, CfnOutput, Duration, Stack, Tags
-from aws_cdk import aws_apigatewayv2_alpha as apigw
-from aws_cdk import aws_ec2 as ec2
-from aws_cdk import aws_ecs as ecs
-from aws_cdk import aws_ecs_patterns as ecs_patterns
-from aws_cdk import aws_iam as iam
-from aws_cdk import aws_lambda
-from aws_cdk import aws_logs as logs
-from aws_cdk.aws_apigatewayv2_integrations_alpha import HttpLambdaIntegration
-from config import StackSettings
-from constructs import Construct
-
-settings = StackSettings()
-
-
-class titilerLambdaStack(Stack):
-    """
-    Titiler Lambda Stack
-
-    This code is freely adapted from
-    - https://github.com/leothomas/titiler/blob/10df64fbbdd342a0762444eceebaac18d8867365/stack/app.py author: @leothomas
-    - https://github.com/ciaranevans/titiler/blob/3a4e04cec2bd9b90e6f80decc49dc3229b6ef569/stack/app.py author: @ciaranevans
-
-    """
-
-    def __init__(
-        self,
-        scope: Construct,
-        id: str,
-        memory: int = 1024,
-        timeout: int = 30,
-        runtime: aws_lambda.Runtime = aws_lambda.Runtime.PYTHON_3_10,
-        concurrent: Optional[int] = None,
-        permissions: Optional[List[iam.PolicyStatement]] = None,
-        environment: Optional[Dict] = None,
-        code_dir: str = "./",
-        **kwargs: Any,
-    ) -> None:
-        """Define stack."""
-        super().__init__(scope, id, **kwargs)
-
-        permissions = permissions or []
-        environment = environment or {}
-
-        lambda_function = aws_lambda.Function(
-            self,
-            f"{id}-lambda",
-            runtime=runtime,
-            code=aws_lambda.Code.from_docker_build(
-                path=os.path.abspath(code_dir),
-                file="lambda/Dockerfile",
-            ),
-            handler="handler.handler",
-            memory_size=memory,
-            reserved_concurrent_executions=concurrent,
-            timeout=Duration.seconds(timeout),
-            environment=environment,
-            log_retention=logs.RetentionDays.ONE_WEEK,
-        )
-
-        for perm in permissions:
-            lambda_function.add_to_role_policy(perm)
-
-        api = apigw.HttpApi(
-            self,
-            f"{id}-endpoint",
-            default_integration=HttpLambdaIntegration(
-                f"{id}-integration", handler=lambda_function
-            ),
-        )
-        CfnOutput(self, "Endpoint", value=api.url)
-
-
-class titilerECSStack(Stack):
-    """Titiler ECS Fargate Stack."""
-
-    def __init__(
-        self,
-        scope: Construct,
-        id: str,
-        cpu: Union[int, float] = 256,
-        memory: Union[int, float] = 512,
-        mincount: int = 1,
-        maxcount: int = 50,
-        permissions: Optional[List[iam.PolicyStatement]] = None,
-        environment: Optional[Dict] = None,
-        code_dir: str = "./",
-        **kwargs: Any,
-    ) -> None:
-        """Define stack."""
-        super().__init__(scope, id, *kwargs)
-
-        permissions = permissions or []
-        environment = environment or {}
-
-        vpc = ec2.Vpc(self, f"{id}-vpc", max_azs=2)
-
-        cluster = ecs.Cluster(self, f"{id}-cluster", vpc=vpc)
-
-        task_env = environment.copy()
-        task_env.update({"LOG_LEVEL": "error"})
-
-        # GUNICORN configuration
-        if settings.workers_per_core:
-            task_env.update({"WORKERS_PER_CORE": str(settings.workers_per_core)})
-        if settings.max_workers:
-            task_env.update({"MAX_WORKERS": str(settings.max_workers)})
-        if settings.web_concurrency:
-            task_env.update({"WEB_CONCURRENCY": str(settings.web_concurrency)})
-
-        fargate_service = ecs_patterns.ApplicationLoadBalancedFargateService(
-            self,
-            f"{id}-service",
-            cluster=cluster,
-            cpu=cpu,
-            memory_limit_mib=memory,
-            desired_count=mincount,
-            public_load_balancer=True,
-            listener_port=80,
-            task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageOptions(
-                image=ecs.ContainerImage.from_registry(
-                    f"ghcr.io/developmentseed/titiler:{settings.image_version}",
-                ),
-                container_port=80,
-                environment=task_env,
-            ),
-        )
-        fargate_service.target_group.configure_health_check(path="/healthz")
-
-        for perm in permissions:
-            fargate_service.task_definition.task_role.add_to_policy(perm)
-
-        scalable_target = fargate_service.service.auto_scale_task_count(
-            min_capacity=mincount, max_capacity=maxcount
-        )
-
-        # https://github.com/awslabs/aws-rails-provisioner/blob/263782a4250ca1820082bfb059b163a0f2130d02/lib/aws-rails-provisioner/scaling.rb#L343-L387
-        scalable_target.scale_on_request_count(
-            "RequestScaling",
-            requests_per_target=50,
-            scale_in_cooldown=Duration.seconds(240),
-            scale_out_cooldown=Duration.seconds(30),
-            target_group=fargate_service.target_group,
-        )
-
-        # scalable_target.scale_on_cpu_utilization(
-        #     "CpuScaling", target_utilization_percent=70,
-        # )
-
-        fargate_service.service.connections.allow_from_any_ipv4(
-            port_range=ec2.Port(
-                protocol=ec2.Protocol.ALL,
-                string_representation="All port 80",
-                from_port=80,
-            ),
-            description="Allows traffic on port 80 from ALB",
-        )
-
-
-app = App()
-
-perms = []
-if settings.buckets:
-    perms.append(
-        iam.PolicyStatement(
-            actions=["s3:GetObject"],
-            resources=[
-                f"arn:aws:s3:::{bucket}/{settings.key}" for bucket in settings.buckets
-            ],
-        )
-    )
-
-
-ecs_stack = titilerECSStack(
-    app,
-    f"{settings.name}-ecs-{settings.stage}",
-    cpu=settings.task_cpu,
-    memory=settings.task_memory,
-    mincount=settings.min_ecs_instances,
-    maxcount=settings.max_ecs_instances,
-    permissions=perms,
-    environment=settings.env,
-)
-
-lambda_stack = titilerLambdaStack(
-    app,
-    f"{settings.name}-lambda-{settings.stage}",
-    memory=settings.memory,
-    timeout=settings.timeout,
-    concurrent=settings.max_concurrent,
-    permissions=perms,
-    environment=settings.env,
-)
-
-# Tag infrastructure
-for key, value in {
-    "Project": settings.name,
-    "Stack": settings.stage,
-    "Owner": settings.owner,
-    "Client": settings.client,
-}.items():
-    if value:
-        Tags.of(ecs_stack).add(key, value)
-        Tags.of(lambda_stack).add(key, value)
-
-
-app.synth()
diff --git a/deployment/aws/cdk/config.py b/deployment/aws/cdk/config.py
deleted file mode 100644
index fa016b193..000000000
--- a/deployment/aws/cdk/config.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""TITILER_STACK Configs."""
-
-from typing import Dict, List, Optional
-
-import pydantic
-
-
-class StackSettings(pydantic.BaseSettings):
-    """Application settings"""
-
-    name: str = "titiler"
-    stage: str = "production"
-
-    owner: Optional[str]
-    client: Optional[str]
-
-    # Default options are optimized for CloudOptimized GeoTIFF
-    # For more information on GDAL env see: https://gdal.org/user/configoptions.html
-    # or https://developmentseed.org/titiler/advanced/performance_tuning/
-    env: Dict = {
-        "GDAL_CACHEMAX": "200",  # 200 mb
-        "GDAL_DISABLE_READDIR_ON_OPEN": "EMPTY_DIR",
-        "GDAL_INGESTED_BYTES_AT_OPEN": "32768",  # get more bytes when opening the files.
-        "GDAL_HTTP_MERGE_CONSECUTIVE_RANGES": "YES",
-        "GDAL_HTTP_MULTIPLEX": "YES",
-        "GDAL_HTTP_VERSION": "2",
-        "PYTHONWARNINGS": "ignore",
-        "VSI_CACHE": "TRUE",
-        "VSI_CACHE_SIZE": "5000000",  # 5 MB (per file-handle)
-    }
-
-    # S3 bucket names where TiTiler could do HEAD and GET Requests
-    # specific private and public buckets MUST be added if you want to use s3:// urls
-    # You can whitelist all bucket by setting `*`.
-    # ref: https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-arn-format.html
-    buckets: List = []
-
-    # S3 key pattern to limit the access to specific items (e.g: "my_data/*.tif")
-    key: str = "*"
-
-    ###########################################################################
-    # AWS ECS
-    # The following settings only apply to AWS ECS deployment
-    min_ecs_instances: int = 5
-    max_ecs_instances: int = 50
-
-    # CPU value      |   Memory value
-    # 256 (.25 vCPU) | 0.5 GB, 1 GB, 2 GB
-    # 512 (.5 vCPU)  | 1 GB, 2 GB, 3 GB, 4 GB
-    # 1024 (1 vCPU)  | 2 GB, 3 GB, 4 GB, 5 GB, 6 GB, 7 GB, 8 GB
-    # 2048 (2 vCPU)  | Between 4 GB and 16 GB in 1-GB increments
-    # 4096 (4 vCPU)  | Between 8 GB and 30 GB in 1-GB increments
-    task_cpu: int = 256
-    task_memory: int = 512
-
-    # GUNICORN configuration
-    # Ref: https://github.com/developmentseed/titiler/issues/119
-
-    # WORKERS_PER_CORE
-    # This image will check how many CPU cores are available in the current server running your container.
-    # It will set the number of workers to the number of CPU cores multiplied by this value.
-    workers_per_core: int = 1
-
-    # MAX_WORKERS
-    # You can use it to let the image compute the number of workers automatically but making sure it's limited to a maximum.
-    # should depends on `task_cpu`
-    max_workers: int = 1
-
-    # WEB_CONCURRENCY
-    # Override the automatic definition of number of workers.
-    # Set to the number of CPU cores in the current server multiplied by the environment variable WORKERS_PER_CORE.
-    # So, in a server with 2 cores, by default it will be set to 2.
-    web_concurrency: Optional[int]
-
-    image_version: str = "latest"
-
-    ###########################################################################
-    # AWS LAMBDA
-    # The following settings only apply to AWS Lambda deployment
-    # more about lambda config: https://www.sentiatechblog.com/aws-re-invent-2020-day-3-optimizing-lambda-cost-with-multi-threading
-    timeout: int = 10
-    memory: int = 1536
-
-    # The maximum of concurrent executions you want to reserve for the function.
-    # Default: - No specific limit - account limit.
-    max_concurrent: Optional[int]
-
-    class Config:
-        """model config"""
-
-        env_file = ".env"
-        env_prefix = "TITILER_STACK_"
diff --git a/deployment/aws/lambda/Dockerfile b/deployment/aws/lambda/Dockerfile
index 9e8fc276e..8d732cdd0 100644
--- a/deployment/aws/lambda/Dockerfile
+++ b/deployment/aws/lambda/Dockerfile
@@ -1,19 +1,29 @@
-ARG PYTHON_VERSION=3.10
+ARG PYTHON_VERSION=3.14
 
 FROM --platform=linux/amd64 public.ecr.aws/lambda/python:${PYTHON_VERSION}
 
 WORKDIR /tmp
 
-RUN pip install pip -U
-RUN pip install "titiler.application==0.11.7" "mangum>=0.10.0" -t /asset --no-binary pydantic
+# Install system dependencies to compile (numexpr)
+RUN dnf install -y gcc-c++ && dnf clean all
+
+RUN python -m pip install pip -U
+RUN python -m pip install "titiler-application==2.0.1" "mangum==0.19.0" "cftime" -t /asset --no-binary pydantic,xarray,numpy,pandas  # x-release-please-version
 
 # Reduce package size and remove useless files
 RUN cd /asset && find . -type f -name '*.pyc' | while read f; do n=$(echo $f | sed 's/__pycache__\///' | sed 's/.cpython-[0-9]*//'); cp $f $n; done;
 RUN cd /asset && find . -type d -a -name '__pycache__' -print0 | xargs -0 rm -rf
 RUN cd /asset && find . -type f -a -name '*.py' -print0 | xargs -0 rm -f
+RUN cd /asset && find . -type f -name '*.so*' -not -path "*/numpy.libs/*" -exec strip --strip-unneeded {} \; 2>/dev/null || true
 RUN find /asset -type d -a -name 'tests' -print0 | xargs -0 rm -rf
 RUN rm -rdf /asset/numpy/doc/ /asset/boto3* /asset/botocore* /asset/bin /asset/geos_license /asset/Misc
 
 COPY lambda/handler.py /asset/handler.py
 
+# Ref: https://github.com/developmentseed/titiler/discussions/1108#discussioncomment-13045681
+RUN cp /usr/lib64/libexpat.so.1 /asset/
+
+WORKDIR /asset
+RUN python -c "from handler import handler; print('All Good')"
+
 CMD ["echo", "hello world"]
diff --git a/deployment/aws/lambda/handler.py b/deployment/aws/lambda/handler.py
index 4e66c7b2e..16ae56978 100644
--- a/deployment/aws/lambda/handler.py
+++ b/deployment/aws/lambda/handler.py
@@ -1,12 +1,21 @@
 """AWS Lambda handler."""
 
+import asyncio
 import logging
 
 from mangum import Mangum
 
 from titiler.application.main import app
+from titiler.application.settings import ApiSettings
+
+try:
+    asyncio.get_event_loop()
+except RuntimeError:
+    asyncio.set_event_loop(asyncio.new_event_loop())
 
 logging.getLogger("mangum.lifespan").setLevel(logging.ERROR)
 logging.getLogger("mangum.http").setLevel(logging.ERROR)
 
-handler = Mangum(app, lifespan="auto")
+api_settings = ApiSettings()
+
+handler = Mangum(app, api_gateway_base_path=api_settings.root_path, lifespan="auto")
diff --git a/deployment/aws/package-lock.json b/deployment/aws/package-lock.json
deleted file mode 100644
index ad5226462..000000000
--- a/deployment/aws/package-lock.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
-  "name": "cdk-deploy",
-  "version": "0.1.0",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "cdk-deploy",
-      "version": "0.1.0",
-      "license": "MIT",
-      "dependencies": {
-        "cdk": "2.76.0-alpha.0"
-      }
-    },
-    "node_modules/aws-cdk": {
-      "version": "2.76.0",
-      "resolved": "https://registry.npmjs.org/aws-cdk/-/aws-cdk-2.76.0.tgz",
-      "integrity": "sha512-y6VHtqUpYenn6mGIBFbcGGXIoXfKA3o0eGL/eeD/gUJ9TcPrgMLQM1NxSMb5JVsOk5BPPXzGmvB0gBu40utGqg==",
-      "bin": {
-        "cdk": "bin/cdk"
-      },
-      "engines": {
-        "node": ">= 14.15.0"
-      },
-      "optionalDependencies": {
-        "fsevents": "2.3.2"
-      }
-    },
-    "node_modules/cdk": {
-      "version": "2.76.0-alpha.0",
-      "resolved": "https://registry.npmjs.org/cdk/-/cdk-2.76.0-alpha.0.tgz",
-      "integrity": "sha512-HNfX5c7MU18LxthZRcapqEhG0IFgQeNOhtsTR1QiL/7dhy2TjvK26dYcJ67KIHfzMfm5EUjvOXdP1SPdW+eOOA==",
-      "dependencies": {
-        "aws-cdk": "2.76.0"
-      },
-      "bin": {
-        "cdk": "bin/cdk"
-      },
-      "engines": {
-        "node": ">= 8.10.0"
-      }
-    },
-    "node_modules/fsevents": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
-      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
-      "hasInstallScript": true,
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-      }
-    }
-  },
-  "dependencies": {
-    "aws-cdk": {
-      "version": "2.76.0",
-      "resolved": "https://registry.npmjs.org/aws-cdk/-/aws-cdk-2.76.0.tgz",
-      "integrity": "sha512-y6VHtqUpYenn6mGIBFbcGGXIoXfKA3o0eGL/eeD/gUJ9TcPrgMLQM1NxSMb5JVsOk5BPPXzGmvB0gBu40utGqg==",
-      "requires": {
-        "fsevents": "2.3.2"
-      }
-    },
-    "cdk": {
-      "version": "2.76.0-alpha.0",
-      "resolved": "https://registry.npmjs.org/cdk/-/cdk-2.76.0-alpha.0.tgz",
-      "integrity": "sha512-HNfX5c7MU18LxthZRcapqEhG0IFgQeNOhtsTR1QiL/7dhy2TjvK26dYcJ67KIHfzMfm5EUjvOXdP1SPdW+eOOA==",
-      "requires": {
-        "aws-cdk": "2.76.0"
-      }
-    },
-    "fsevents": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
-      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
-      "optional": true
-    }
-  }
-}
diff --git a/deployment/aws/package.json b/deployment/aws/package.json
deleted file mode 100644
index 040bfa6b4..000000000
--- a/deployment/aws/package.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "name": "cdk-deploy",
-  "version": "0.1.0",
-  "description": "Dependencies for CDK deployment",
-  "license": "MIT",
-  "private": true,
-  "dependencies": {
-    "cdk": "2.76.0-alpha.0"
-  },
-  "scripts": {
-    "cdk": "cdk"
-  }
-}
diff --git a/deployment/aws/pyproject.toml b/deployment/aws/pyproject.toml
new file mode 100644
index 000000000..9f1ff2d09
--- /dev/null
+++ b/deployment/aws/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "titiler-cdk"
+version = "0.0.0"
+
+dependencies = [
+    # aws cdk
+    "aws-cdk-lib~=2.232.2",
+    "constructs>=10.4.2",
+    # pydantic settings
+    "pydantic~=2.0",
+    "pydantic-settings~=2.0",
+]
diff --git a/deployment/aws/requirements-cdk.txt b/deployment/aws/requirements-cdk.txt
deleted file mode 100644
index 973fc3433..000000000
--- a/deployment/aws/requirements-cdk.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-# aws cdk
-aws-cdk-lib==2.76.0
-aws_cdk-aws_apigatewayv2_alpha==2.76.0a0
-aws_cdk-aws_apigatewayv2_integrations_alpha==2.76.0a0
-constructs>=10.0.0
-
-# pydantic settings
-pydantic
-python-dotenv
diff --git a/deployment/aws/uv.lock b/deployment/aws/uv.lock
new file mode 100644
index 000000000..23b5c46e7
--- /dev/null
+++ b/deployment/aws/uv.lock
@@ -0,0 +1,291 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "aws-cdk-asset-awscli-v1"
+version = "2.2.242"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsii" },
+    { name = "publication" },
+    { name = "typeguard" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/84/66/095e92652c175a9c18c98bc358db2c5957897245053fb5d0988c908be355/aws_cdk_asset_awscli_v1-2.2.242.tar.gz", hash = "sha256:a957d679a118f4375307ed90b9aed7127c5c1402989438060eae4ab29ab0d13f", size = 19284036, upload-time = "2025-06-23T17:42:03.275Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/ca/0415b7387c776c0a82a153fe75573e78cbbf1a71d4475636393f5ecfc649/aws_cdk_asset_awscli_v1-2.2.242-py3-none-any.whl", hash = "sha256:d1001bf56a12f7d1162d4211003d1e8f72a213159465e2d0e1c598cc0ea44aad", size = 19282441, upload-time = "2025-06-23T17:42:00.381Z" },
+]
+
+[[package]]
+name = "aws-cdk-asset-node-proxy-agent-v6"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsii" },
+    { name = "publication" },
+    { name = "typeguard" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d5/ab/09ac3ecc0067988d02398328e088d66cbe8555c991563c8ddfa1db5296ae/aws_cdk_asset_node_proxy_agent_v6-2.1.0.tar.gz", hash = "sha256:1f292c0631f86708ba4ee328b3a2b229f7e46ea1c79fbde567ee9eb119c2b0e2", size = 1540231, upload-time = "2024-09-03T09:36:51.634Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/86/1817a6da223aa80aeb94a504f07f930170284694b18f6053729e9930cc6a/aws_cdk.asset_node_proxy_agent_v6-2.1.0-py3-none-any.whl", hash = "sha256:24a388b69a44d03bae6dbf864c4e25ba650d4b61c008b4568b94ffbb9a69e40e", size = 1538724, upload-time = "2024-09-03T09:36:49.8Z" },
+]
+
+[[package]]
+name = "aws-cdk-cloud-assembly-schema"
+version = "48.20.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsii" },
+    { name = "publication" },
+    { name = "typeguard" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a7/b5/1ce2f6bff913ca8c94a001b84290ec4ce3729f54a3af0e3ff0edb303ac20/aws_cdk_cloud_assembly_schema-48.20.0.tar.gz", hash = "sha256:229aa136c26b71b0a82b5a32658eabcd30e344f7e136315fdb6e3de8ef523bfa", size = 208109, upload-time = "2025-11-19T12:19:48.206Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/08/17a35f0b668451484f2254f5e50a0105958bffe90da11c41b7629972e6a9/aws_cdk_cloud_assembly_schema-48.20.0-py3-none-any.whl", hash = "sha256:f5b6cf661cac8690add9461de13aeae3f3742eec71c066032bd045b08d0b7c3e", size = 207669, upload-time = "2025-11-19T12:19:46.614Z" },
+]
+
+[[package]]
+name = "aws-cdk-lib"
+version = "2.232.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aws-cdk-asset-awscli-v1" },
+    { name = "aws-cdk-asset-node-proxy-agent-v6" },
+    { name = "aws-cdk-cloud-assembly-schema" },
+    { name = "constructs" },
+    { name = "jsii" },
+    { name = "publication" },
+    { name = "typeguard" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0c/34/24af9f7bdca0143b09be8d9228901c2b82f4866aab7544eabe2e386600b8/aws_cdk_lib-2.232.2.tar.gz", hash = "sha256:329fd448ba3cc9a83bcd83eee372ed13b5efdd3a5b28a4e6dc513c43d9a746f7", size = 46570425, upload-time = "2025-12-12T20:50:14.095Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/81/94f9a35f3f703ca8f8df9fc8e70b587d3f9fb1e12c8fa54528e145732280/aws_cdk_lib-2.232.2-py3-none-any.whl", hash = "sha256:d1b3a5dbe518fbcbe3a9a06960396d8debdef9472c049fbf42adb3f01d613825", size = 47220640, upload-time = "2025-12-12T20:49:34.941Z" },
+]
+
+[[package]]
+name = "cattrs"
+version = "25.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6e/00/2432bb2d445b39b5407f0a90e01b9a271475eea7caf913d7a86bcb956385/cattrs-25.3.0.tar.gz", hash = "sha256:1ac88d9e5eda10436c4517e390a4142d88638fe682c436c93db7ce4a277b884a", size = 509321, upload-time = "2025-10-07T12:26:08.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/2b/a40e1488fdfa02d3f9a653a61a5935ea08b3c2225ee818db6a76c7ba9695/cattrs-25.3.0-py3-none-any.whl", hash = "sha256:9896e84e0a5bf723bc7b4b68f4481785367ce07a8a02e7e9ee6eb2819bc306ff", size = 70738, upload-time = "2025-10-07T12:26:06.603Z" },
+]
+
+[[package]]
+name = "constructs"
+version = "10.4.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsii" },
+    { name = "publication" },
+    { name = "typeguard" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7a/e1/48a63ea310ac999005368aa72f52be520210526002f3f0cfcb7aaa9477ee/constructs-10.4.3.tar.gz", hash = "sha256:bfe3657b0acb62af7aa1fda9a7e338ae5cae84ddf8f84f71125a2a3800d52ea0", size = 64486, upload-time = "2025-11-06T15:48:25.039Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/97/94/a5ce72d63276d3baa47592d3d12afc33f9e5d8f4ddd7bb2ec0012255037f/constructs-10.4.3-py3-none-any.whl", hash = "sha256:43bbefa1ac1c044577d0b1a30648fe5b49557b8b95de2648186f6b909febf7f9", size = 62659, upload-time = "2025-11-06T15:48:21.966Z" },
+]
+
+[[package]]
+name = "importlib-resources"
+version = "6.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/8c/f834fbf984f691b4f7ff60f50b514cc3de5cc08abfc3295564dd89c5e2e7/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c", size = 44693, upload-time = "2025-01-03T18:51:56.698Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/ed/1f1afb2e9e7f38a545d628f864d562a5ae64fe6f7a10e28ffb9b185b4e89/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec", size = 37461, upload-time = "2025-01-03T18:51:54.306Z" },
+]
+
+[[package]]
+name = "jsii"
+version = "1.121.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cattrs" },
+    { name = "importlib-resources" },
+    { name = "publication" },
+    { name = "python-dateutil" },
+    { name = "typeguard" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/e2/2950c7891f4ccf301be5e4fad8781169aa7dde2d267d4990debb6aeadac3/jsii-1.121.0.tar.gz", hash = "sha256:6c003ae10916bedce0cdf4cf86389435265ee151581e57429d0dd8aecb495be1", size = 625665, upload-time = "2025-12-09T17:25:08.544Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/08/986dfcdb0e7cba3edca74219e3d86b00623ccf0c8d7bdd62dea3947766ff/jsii-1.121.0-py3-none-any.whl", hash = "sha256:e7e10f020cfce01951956750fea50a863955e21aae202ee7f129b873f9d4988b", size = 601786, upload-time = "2025-12-09T17:25:07.194Z" },
+]
+
+[[package]]
+name = "publication"
+version = "0.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/8e/8c9fe7e32fdf9c386f83d59610cc819a25dadb874b5920f2d0ef7d35f46d/publication-0.0.3.tar.gz", hash = "sha256:68416a0de76dddcdd2930d1c8ef853a743cc96c82416c4e4d3b5d901c6276dc4", size = 5484, upload-time = "2019-01-15T07:52:23.914Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/d3/6308debad7afcdb3ea5f50b4b3d852f41eb566a311fbcb4da23755a28155/publication-0.0.3-py2.py3-none-any.whl", hash = "sha256:0248885351febc11d8a1098d5c8e3ab2dabcf3e8c0c96db1e17ecd12b53afbe6", size = 7687, upload-time = "2019-01-15T07:52:22.151Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/ad/a17bc283d7d81837c061c49e3eaa27a45991759a1b7eae1031921c6bd924/pydantic-2.12.4.tar.gz", hash = "sha256:0f8cb9555000a4b5b617f66bfd2566264c4984b27589d3b845685983e8ea85ac", size = 821038, upload-time = "2025-11-05T10:50:08.59Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/2f/e68750da9b04856e2a7ec56fc6f034a5a79775e9b9a81882252789873798/pydantic-2.12.4-py3-none-any.whl", hash = "sha256:92d3d202a745d46f9be6df459ac5a064fdaa3c1c4cd8adcfa332ccf3c05f871e", size = 463400, upload-time = "2025-11-05T10:50:06.732Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/20/c5/dbbc27b814c71676593d1c3f718e6cd7d4f00652cefa24b75f7aa3efb25e/pydantic_settings-2.11.0.tar.gz", hash = "sha256:d0e87a1c7d33593beb7194adb8470fc426e95ba02af83a0f23474a04c9a08180", size = 188394, upload-time = "2025-09-24T14:19:11.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/d6/887a1ff844e64aa823fb4905978d882a633cfe295c32eacad582b78a7d8b/pydantic_settings-2.11.0-py3-none-any.whl", hash = "sha256:fe2cea3413b9530d10f3a5875adffb17ada5c1e1bab0b2885546d7310415207c", size = 48608, upload-time = "2025-09-24T14:19:10.015Z" },
+]
+
+[[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-dotenv"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" },
+]
+
+[[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 = "titiler-cdk"
+version = "0.0.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "aws-cdk-lib" },
+    { name = "constructs" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "aws-cdk-lib", specifier = "~=2.232.2" },
+    { name = "constructs", specifier = ">=10.4.2" },
+    { name = "pydantic", specifier = "~=2.0" },
+    { name = "pydantic-settings", specifier = "~=2.0" },
+]
+
+[[package]]
+name = "typeguard"
+version = "2.13.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/38/c61bfcf62a7b572b5e9363a802ff92559cb427ee963048e1442e3aef7490/typeguard-2.13.3.tar.gz", hash = "sha256:00edaa8da3a133674796cf5ea87d9f4b4c367d77476e185e80251cc13dfbb8c4", size = 40604, upload-time = "2021-12-10T21:09:39.158Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/bb/d43e5c75054e53efce310e79d63df0ac3f25e34c926be5dffb7d283fb2a8/typeguard-2.13.3-py3-none-any.whl", hash = "sha256:5e3e3be01e887e7eafae5af63d1f36c849aaa94e3a0112097312aabfa16284f1", size = 17605, upload-time = "2021-12-10T21:09:37.844Z" },
+]
+
+[[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 = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
diff --git a/deployment/azure/README.md b/deployment/azure/README.md
index 7516cde29..1fb58b8d2 100644
--- a/deployment/azure/README.md
+++ b/deployment/azure/README.md
@@ -1,13 +1,13 @@
 ### Function
 
-TiTiler is built on top of [FastAPI](https://github.com/tiangolo/fastapi), a modern, fast, Python web framework for building APIs. As for AWS Lambda we can make our FastAPI application work on Azure Function by wrapping it within the [Azure Function Python worker](https://github.com/Azure/azure-functions-python-worker).
+TiTiler is built on top of [FastAPI](https://github.com/tiangolo/fastapi), a modern, fast, Python web framework for building APIs. We can make our FastAPI application work as an Azure Function by wrapping it within the [Azure Function Python worker](https://github.com/Azure/azure-functions-python-worker).
 
-If you are not familiar with **Azure functions** we recommend checking https://docs.microsoft.com/en-us/azure/azure-functions/ first.
+If you are not familiar with **Azure functions**, we recommend checking https://docs.microsoft.com/en-us/azure/azure-functions/ first.
 
 Minimal TiTiler Azure function code:
 ```python
 import azure.functions as func
-from titiler.application.routers import cog, mosaic, stac, tms
+from titiler.application.main import cog, mosaic, stac, tms
 from fastapi import FastAPI
 
 
@@ -20,14 +20,12 @@ app.include_router(mosaic.router, prefix="/mosaicjson", tags=["MosaicJSON"])
 app.include_router(tms.router, tags=["TileMatrixSets"])
 
 
-def main(
+async def main(
     req: func.HttpRequest, context: func.Context,
 ) -> func.HttpResponse:
-    return func.AsgiMiddleware(app).handle(req, context)
+    return await func.AsgiMiddleware(app).handle_async(req, context)
 ```
 
-Note: there is a `bug` in `azure.functions.AsgiMiddleware` which prevent using `starlette.BaseHTTPMiddleware` middlewares (see: https://github.com/Azure/azure-functions-python-worker/issues/903).
-
 #### Requirements
 - Azure CLI: https://docs.microsoft.com/en-us/cli/azure/install-azure-cli
 - Azure Function Tool: https://docs.microsoft.com/en-us/azure/azure-functions/functions-run-local
@@ -42,9 +40,9 @@ $ cd titiler/deployment/azure
 
 $ az login
 $ az group create --name AzureFunctionsTiTiler-rg --location eastus
-$ az storage account create --name TiTilerStorage --sku Standard_LRS
-$ az functionapp create --consumption-plan-location eastus --runtime python --runtime-version 3.8 --functions-version 3 --name titiler --os-type linux
-$ func azure functionapp publish titiler
+$ az storage account create --name {your-new-storage-name} --sku Standard_LRS -g AzureFunctionsTiTiler-rg
+$ az functionapp create --consumption-plan-location eastus --runtime python --runtime-version 3.9 --functions-version 4 --name {your-new-function-name} --os-type linux -g AzureFunctionsTiTiler-rg -s {your-new-storage-name}
+$ func azure functionapp publish titiler --python
 ```
 
 or
diff --git a/deployment/azure/app/__init__.py b/deployment/azure/app/__init__.py
index 5aab2727d..46bda7298 100644
--- a/deployment/azure/app/__init__.py
+++ b/deployment/azure/app/__init__.py
@@ -1,107 +1,13 @@
 """Microsoft Azure Function."""
 
 import azure.functions as func
-from fastapi import FastAPI
-from starlette.middleware.cors import CORSMiddleware
-from starlette.requests import Request
-from starlette.responses import HTMLResponse
-from starlette_cramjam.middleware import CompressionMiddleware
 
-from titiler.application import __version__ as titiler_version
-from titiler.application.custom import templates
-from titiler.application.routers import cog, mosaic, stac, tms
-from titiler.application.settings import ApiSettings
-from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
+from titiler.application.main import app
 
-# from titiler.core.middleware import (
-#     CacheControlMiddleware,
-#     LoggerMiddleware,
-#     LowerCaseQueryStringMiddleware,
-#     TotalTimeMiddleware,
-# )
-from titiler.mosaic.errors import MOSAIC_STATUS_CODES
 
-api_settings = ApiSettings()
-
-app = FastAPI(
-    title=api_settings.name,
-    description="A lightweight Cloud Optimized GeoTIFF tile server",
-    version=titiler_version,
-    root_path=api_settings.root_path,
-)
-
-if not api_settings.disable_cog:
-    app.include_router(cog.router, prefix="/cog", tags=["Cloud Optimized GeoTIFF"])
-
-if not api_settings.disable_stac:
-    app.include_router(
-        stac.router, prefix="/stac", tags=["SpatioTemporal Asset Catalog"]
-    )
-
-if not api_settings.disable_mosaic:
-    app.include_router(mosaic.router, prefix="/mosaicjson", tags=["MosaicJSON"])
-
-app.include_router(tms.router, tags=["TileMatrixSets"])
-add_exception_handlers(app, DEFAULT_STATUS_CODES)
-add_exception_handlers(app, MOSAIC_STATUS_CODES)
-
-
-# Set all CORS enabled origins
-if api_settings.cors_origins:
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=api_settings.cors_origins,
-        allow_credentials=True,
-        allow_methods=["GET"],
-        allow_headers=["*"],
-    )
-
-app.add_middleware(
-    CompressionMiddleware,
-    minimum_size=0,
-    exclude_mediatype={
-        "image/jpeg",
-        "image/jpg",
-        "image/png",
-        "image/jp2",
-        "image/webp",
-    },
-)
-
-# see https://github.com/encode/starlette/issues/1320
-# app.add_middleware(
-#     CacheControlMiddleware,
-#     cachecontrol=api_settings.cachecontrol,
-#     exclude_path={r"/healthz"},
-# )
-
-# if api_settings.debug:
-#     app.add_middleware(LoggerMiddleware, headers=True, querystrings=True)
-#     app.add_middleware(TotalTimeMiddleware)
-
-# if api_settings.lower_case_query_parameters:
-#     app.add_middleware(LowerCaseQueryStringMiddleware)
-
-
-@app.get("/healthz", description="Health Check", tags=["Health Check"])
-def ping():
-    """Health check."""
-    return {"ping": "pong!"}
-
-
-@app.get("/", response_class=HTMLResponse, include_in_schema=False)
-def landing(request: Request):
-    """TiTiler Landing page"""
-    return templates.TemplateResponse(
-        name="index.html",
-        context={"request": request},
-        media_type="text/html",
-    )
-
-
-def main(
+async def main(
     req: func.HttpRequest,
     context: func.Context,
 ) -> func.HttpResponse:
     """Run App in AsgiMiddleware."""
-    return func.AsgiMiddleware(app).handle(req, context)
+    return await func.AsgiMiddleware(app).handle_async(req, context)
diff --git a/deployment/azure/host.json b/deployment/azure/host.json
index 8e588272b..6e86c559b 100644
--- a/deployment/azure/host.json
+++ b/deployment/azure/host.json
@@ -10,7 +10,7 @@
   },
   "extensionBundle": {
     "id": "Microsoft.Azure.Functions.ExtensionBundle",
-    "version": "[2.*, 3.0.0)"
+    "version": "[3.*, 4.0.0)"
   },
   "extensions": {
     "http": {
diff --git a/deployment/k8s/README.md b/deployment/k8s/README.md
index 1b2f03f04..ddb08334d 100644
--- a/deployment/k8s/README.md
+++ b/deployment/k8s/README.md
@@ -1,6 +1,6 @@
 ## k8s / Helm Deployment
 
-Try locally
+Try locally:
 
 ```
 minikube start
@@ -11,4 +11,4 @@ helm init --wait
 helm install -f titiler/Chart.yaml titiler
 ```
 
-For more info about K8S cluster and node configuration please see: https://github.com/developmentseed/titiler/issues/212
+For more info about K8S cluster and node configuration, please see: https://github.com/developmentseed/titiler/issues/212
diff --git a/deployment/k8s/charts/CHANGELOG.md b/deployment/k8s/charts/CHANGELOG.md
new file mode 100644
index 000000000..825c32f0d
--- /dev/null
+++ b/deployment/k8s/charts/CHANGELOG.md
@@ -0,0 +1 @@
+# Changelog
diff --git a/deployment/k8s/charts/Chart.yaml b/deployment/k8s/charts/Chart.yaml
index febe06e3e..309c56090 100644
--- a/deployment/k8s/charts/Chart.yaml
+++ b/deployment/k8s/charts/Chart.yaml
@@ -1,9 +1,11 @@
 apiVersion: v1
-appVersion: 0.11.7
+appVersion: "2.0.1"  # x-release-please-version
 description: A dynamic Web Map tile server
 name: titiler
-version: 1.1.0
+version: 2.1.2
 icon: https://raw.githubusercontent.com/developmentseed/titiler/main/docs/logos/TiTiler_logo_small.png
 maintainers:
   - name: emmanuelmathot  # Emmanuel Mathot
     url: https://github.com/emmanuelmathot
+  - name: ciaransweet     # Ciaran Sweet
+    url: https://github.com/ciaransweet
diff --git a/deployment/k8s/charts/templates/deployment.yaml b/deployment/k8s/charts/templates/deployment.yaml
index 9858c13a6..ed4582249 100644
--- a/deployment/k8s/charts/templates/deployment.yaml
+++ b/deployment/k8s/charts/templates/deployment.yaml
@@ -14,10 +14,19 @@ spec:
       labels:
         {{- include "titiler.selectorLabels" . | nindent 8 }}
     spec:
+      securityContext:
+        {{- toYaml .Values.podSecurityContext | nindent 8 }}
       containers:
         - name: {{ .Chart.Name }}
           image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
           imagePullPolicy: {{ .Values.image.pullPolicy }}
+          command: [ {{ .Values.image.command }} ]
+          args: [ {{- range $arg := .Values.image.args }}
+            {{- $arg | quote }},
+            {{- end }}
+          ]
+          securityContext:
+            {{- toYaml .Values.securityContext | nindent 12 }}
           env:
           {{- range $key, $val := .Values.env }}
             - name: {{ $key }}
@@ -33,7 +42,7 @@ spec:
           {{- end }}
           ports:
             - name: http
-              containerPort: {{ .Values.env.PORT }}
+              containerPort: 80
               protocol: TCP
           livenessProbe:
             httpGet:
@@ -49,10 +58,31 @@ spec:
             - mountPath: /config
               name: config
               readOnly: true
+          {{- range .Values.extraHostPathMounts }}
+            - name: {{ .name }}
+              mountPath: {{ .mountPath }}
+              readOnly: {{ .readOnly }}
+            {{- if .mountPropagation }}
+              mountPropagation: {{ .mountPropagation }}
+            {{- end }}
+          {{- end }}
+      terminationGracePeriodSeconds: {{ .Values.env.terminationGracePeriodSeconds }}
       volumes:
         - name: config
           configMap:
             name: {{ include "titiler.fullname" . }}-configmap
+      {{- range .Values.extraHostPathMounts }}
+        - name: {{ .name }}
+          hostPath:
+            path: {{ .hostPath }}
+            type: Directory
+      {{- end }}
+      {{- with .Values.imagePullSecrets }}
+      imagePullSecrets:
+        {{- range . }}
+      - name: {{ .name }}
+        {{- end }}
+      {{- end }}
       {{- with .Values.serviceAccountName }}
       serviceAccountName: {{ . | quote }}
       {{- end }}
diff --git a/deployment/k8s/charts/values-test.yaml b/deployment/k8s/charts/values-test.yaml
deleted file mode 100644
index 47bd601e4..000000000
--- a/deployment/k8s/charts/values-test.yaml
+++ /dev/null
@@ -1,44 +0,0 @@
-# Default values for titiler.
-replicaCount: 4
-
-ingress:
-  enabled: true
-  annotations: {}
-    # kubernetes.io/ingress.class: nginx
-    # kubernetes.io/tls-acme: "true"
-  hosts:
-    - host: titiler.charter.uat.esaportal.eu
-      paths: ["/"]
-  tls:
-   - secretName: domain-tls
-     hosts:
-       - titiler.charter.uat.esaportal.eu
-
-env:
-  PORT: 80
-  CPL_TMPDIR: /tmp
-  GDAL_CACHEMAX: 75%
-  VSI_CACHE: TRUE
-  VSI_CACHE_SIZE: 1073741824
-  GDAL_DISABLE_READDIR_ON_OPEN: EMPTY_DIR
-  GDAL_HTTP_MERGE_CONSECUTIVE_RANGES: YES
-  GDAL_HTTP_MULTIPLEX: YES
-  GDAL_HTTP_VERSION: 2
-  PYTHONWARNINGS: ignore
-  WEB_CONCURRENCY: 2
-
-resources:
-   limits:
-    cpu: 256m
-    memory: 1Gi
-    # ephemeral-storage: 10Gi
-   requests:
-    cpu: 256m
-    memory: 1Gi
-    # ephemeral-storage: 10Gi
-
-nodeSelector: {}
-
-tolerations: []
-
-affinity: {}
diff --git a/deployment/k8s/charts/values.yaml b/deployment/k8s/charts/values.yaml
index b10995183..bb7b3a32e 100644
--- a/deployment/k8s/charts/values.yaml
+++ b/deployment/k8s/charts/values.yaml
@@ -2,13 +2,24 @@
 replicaCount: 1
 
 image:
-  repository: ghcr.io/developmentseed/titiler-uvicorn
-  tag: latest
+  repository: ghcr.io/developmentseed/titiler
+  tag: ""
   pullPolicy: IfNotPresent
+  command: "uvicorn"
+  args:
+    - "titiler.application.main:app"
+    - "--host"
+    - "0.0.0.0"
+    - "--port"
+    - "80"
+    - "--workers"
+    - "1"
 
 nameOverride: ""
 fullnameOverride: ""
 
+terminationGracePeriodSeconds: 30
+
 service:
   type: ClusterIP
   port: 80
@@ -26,8 +37,16 @@ ingress:
   #    hosts:
   #      - titiler.local
 
+extraHostPathMounts: []
+  # - name: map-sources
+  #   mountPath: /map-sources/
+  #   hostPath: /home/ubuntu/map-sources
+  #   readOnly: false
+  #   mountPropagation: HostToContainer # OPTIONAL
+
+imagePullSecrets: []
+
 env:
-  PORT: 80
   CPL_TMPDIR: /tmp
   GDAL_CACHEMAX: 200  # 200 mb
   VSI_CACHE: "TRUE"
@@ -37,7 +56,6 @@ env:
   GDAL_HTTP_MULTIPLEX: "YES"
   GDAL_HTTP_VERSION: 2
   PYTHONWARNINGS: "ignore"
-  WEB_CONCURRENCY: 2
 
 resources:
   limits:
@@ -54,3 +72,17 @@ nodeSelector: {}
 tolerations: []
 
 affinity: {}
+
+securityContext: {}
+  # capabilities:
+  #   drop:
+  #     - ALL
+  # readOnlyRootFilesystem: true
+  # allowPrivilegeEscalation: false
+  # runAsNonRoot: true
+  # runAsUser: 1001
+
+podSecurityContext: {}
+  # fsGroup: 1001
+  # runAsNonRoot: true
+  # runAsUser: 1001
diff --git a/dev_notebooks/rendering.ipynb b/dev_notebooks/rendering.ipynb
new file mode 100644
index 000000000..a38b3d472
--- /dev/null
+++ b/dev_notebooks/rendering.ipynb
@@ -0,0 +1,236 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "78d17219",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/vincentsarago/Dev/Devseed/titiler/.venv/lib/python3.13/site-packages/rasterio/io.py:140: NotGeoreferencedWarning: Dataset has no geotransform, gcps, or rpcs. The identity matrix will be returned.\n",
+      "  rd = DatasetReader(mempath, driver=driver, sharing=sharing, **kwargs)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy\n",
+    "\n",
+    "from titiler.core.resources.enums import ImageType\n",
+    "from titiler.core.utils import render_image\n",
+    "from matplotlib.pyplot import imshow\n",
+    "\n",
+    "from rasterio.io import MemoryFile\n",
+    "\n",
+    "from rio_tiler.models import ImageData\n",
+    "\n",
+    "# Partial alpha values\n",
+    "cm = {\n",
+    "    1: (0, 0, 0, 0),\n",
+    "    500: (100, 100, 100, 50),\n",
+    "    1000: (255, 255, 255, 255),\n",
+    "}\n",
+    "data = numpy.zeros((1, 256, 256), dtype=\"float32\") + 1\n",
+    "data[0, 0, 0] = 0\n",
+    "d = numpy.ma.masked_equal(data, 0)\n",
+    "d[0, 1:, 1:] = 1\n",
+    "d[0, 2:, 2:] = 500\n",
+    "d[0, 3:, 3:] = 1000\n",
+    "\n",
+    "img = ImageData(d)\n",
+    "content, media = render_image(\n",
+    "    img,\n",
+    "    output_format=ImageType.png,\n",
+    "    colormap=cm,\n",
+    ")\n",
+    "assert media == \"image/png\"\n",
+    "\n",
+    "with MemoryFile(content) as mem:\n",
+    "    with mem.open() as dst:\n",
+    "        data_converted = dst.read()\n",
+    "        assert dst.count == 4\n",
+    "        assert dst.dtypes == (\"uint8\", \"uint8\", \"uint8\", \"uint8\")\n",
+    "        assert data_converted[:, 0, 0].tolist() == [\n",
+    "            0,\n",
+    "            0,\n",
+    "            0,\n",
+    "            0,\n",
+    "        ]  # Masked from Original Mask | set to UINT8 (0)\n",
+    "        assert data_converted[:, 1, 1].tolist() == [0, 0, 0, 0]  # Masked from CMAP\n",
+    "        assert data_converted[:, 2, 2].tolist() == [\n",
+    "            100,\n",
+    "            100,\n",
+    "            100,\n",
+    "            50,\n",
+    "        ]  # Partially masked from CMAP\n",
+    "        assert data_converted[:, 3, 3].tolist() == [255, 255, 255, 255]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f853aedb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "masked_array(\n",
+       "  data=[[--, 1.0, 1.0, 1.0, 1.0],\n",
+       "        [1.0, 1.0, 1.0, 1.0, 1.0],\n",
+       "        [1.0, 1.0, 500.0, 500.0, 500.0],\n",
+       "        [1.0, 1.0, 500.0, 1000.0, 1000.0],\n",
+       "        [1.0, 1.0, 500.0, 1000.0, 1000.0]],\n",
+       "  mask=[[ True, False, False, False, False],\n",
+       "        [False, False, False, False, False],\n",
+       "        [False, False, False, False, False],\n",
+       "        [False, False, False, False, False],\n",
+       "        [False, False, False, False, False]],\n",
+       "  fill_value=0.0,\n",
+       "  dtype=float32)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "d[0, 0:5, 0:5]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "308282ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x116fc1be0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "imshow(d[0, 0:4, 0:4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "441b642e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x11726a990>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "imshow(data_converted[3, 0:4, 0:4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "20906022",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[  0,   0,   0,   0],\n",
+       "       [  0,   0,   0,   0],\n",
+       "       [  0,   0,  50,  50],\n",
+       "       [  0,   0,  50, 255]], dtype=uint8)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data_converted[3, 0:4, 0:4]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4274d194",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b34d1bb2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11c3c53a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "titiler (3.13.9)",
+   "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.13.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docker-compose.yml b/docker-compose.yml
index 9e3207e76..97cdd79e9 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,23 +1,12 @@
-version: '3'
-
 services:
   titiler:
-    # See https://github.com/developmentseed/titiler/discussions/387
-    platform: linux/amd64
     build:
       context: .
-      dockerfile: dockerfiles/Dockerfile.gunicorn
+      dockerfile: dockerfiles/Dockerfile
     ports:
       - "8000:8000"
+    command: ["uvicorn", "titiler.application.main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"]
     environment:
-      # Application
-      - HOST=0.0.0.0
-      - PORT=8000
-      # Gunicorn / Uvicorn
-      # https://github.com/tiangolo/uvicorn-gunicorn-docker#web_concurrency
-      - WEB_CONCURRENCY=1
-      # https://github.com/tiangolo/uvicorn-gunicorn-docker#workers_per_core
-      - WORKERS_PER_CORE=1
       # GDAL config
       - CPL_TMPDIR=/tmp
       - GDAL_CACHEMAX=75%
@@ -39,29 +28,32 @@ services:
       # - TITILER_API_DISABLE_STAC=TRUE/FALSE
       # - TITILER_API_DISABLE_MOSAIC=TRUE/FALSE
       # - TITILER_API_DISABLE_COG=TRUE/FALSE
+      # - TITILER_API_DISABLE_ZARR=TRUE/FALSE
       # - TITILER_API_CORS_ORIGIN=url.io,url.xyz
       # - TITILER_API_CACHECONTROL=public, max-age=3600
       # - TITILER_API_DEBUG=TRUE/FALSE
       # - MOSAIC_CONCURRENCY= # will default to `RIO_TILER_MAX_THREADS`
       # rio-tiler config
       # - RIO_TILER_MAX_THREADS=
+      # telemetry config
+      - TITILER_API_TELEMETRY_ENABLED=True
+      - OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318
+    depends_on:
+      - otel-collector
+    volumes:
+      - ./:/data
 
-  titiler-uvicorn:
-    # See https://github.com/developmentseed/titiler/discussions/387
-    platform: linux/amd64
-    build:
-      context: .
-      dockerfile: dockerfiles/Dockerfile.uvicorn
+  titiler-gunicorn:
+    extends:
+      service: titiler
     ports:
       - "8000:8000"
+    command: ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "titiler.application.main:app", "--bind", "0.0.0.0:8000", "--workers", "1"]
+
+  benchmark:
+    extends:
+      service: titiler
     environment:
-      # Application
-      - HOST=0.0.0.0
-      - PORT=8000
-      # Uvicorn
-      # http://www.uvicorn.org/settings/#production
-      - WEB_CONCURRENCY=1
-      # GDAL config
       - CPL_TMPDIR=/tmp
       - GDAL_CACHEMAX=75%
       - GDAL_INGESTED_BYTES_AT_OPEN=32768
@@ -72,44 +64,41 @@ services:
       - PYTHONWARNINGS=ignore
       - VSI_CACHE=TRUE
       - VSI_CACHE_SIZE=536870912
-      # GDAL VSI Config
-      # https://gdal.org/user/virtual_file_systems.html#vsis3-aws-s3-files
-      # https://gdal.org/user/virtual_file_systems.html#vsigs-google-cloud-storage-files
-      # https://gdal.org/user/virtual_file_systems.html#vsiaz-microsoft-azure-blob-files
-      # - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
-      # - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
-      # TiTiler config
-      # - TITILER_API_DISABLE_STAC=TRUE/FALSE
-      # - TITILER_API_DISABLE_MOSAIC=TRUE/FALSE
-      # - TITILER_API_DISABLE_COG=TRUE/FALSE
-      # - TITILER_API_CORS_ORIGIN=url.io,url.xyz
-      # - TITILER_API_CACHECONTROL=public, max-age=3600
-      # - TITILER_API_DEBUG=TRUE/FALSE
-      # - MOSAIC_CONCURRENCY= # will default to `RIO_TILER_MAX_THREADS`
-      # rio-tiler config
-      # - RIO_TILER_MAX_THREADS=
-
-  benchmark:
-    extends:
-      service: titiler-uvicorn
+      - TITILER_API_TELEMETRY_ENABLED=False
     volumes:
       - ./.github/data:/data
 
   nginx-titiler:
     extends:
       service: titiler
-    ports:
-      - 8081:8081
-    environment:
-      - PORT=8081
-      - TITILER_API_ROOT_PATH=/api/v1/titiler
+    command: ["uvicorn", "titiler.application.main:app", "--host", "0.0.0.0", "--port", "8081", "--workers", "1", "--proxy-headers", "--forwarded-allow-ips='*'", "--root-path=/api/v1/titiler"]
 
   nginx:
     image: nginx
     ports:
-      - 80:80
+      - 8080:80
     volumes:
       - ./dockerfiles/nginx.conf:/etc/nginx/nginx.conf
     depends_on:
       - nginx-titiler
     command: ["nginx-debug", "-g", "daemon off;"]
+
+  otel-collector:
+    image: otel/opentelemetry-collector-contrib:latest
+    command: ["--config=/etc/otel-collector-config.yaml"]
+    volumes:
+      - ./dockerfiles/otel-collector-config.yaml:/etc/otel-collector-config.yaml
+    ports:
+      - "4318:4318"   # OTLP HTTP receiver
+      - "13133:13133" # Health check extension
+    depends_on:
+      - jaeger
+
+  jaeger:
+    image: jaegertracing/all-in-one:latest
+    ports:
+      - "16686:16686" # UI
+      - "14250:14250" # OTLP gRPC (Jaeger receiver)
+    environment:
+      - COLLECTOR_OTLP_ENABLED=true
+
diff --git a/dockerfiles/Dockerfile b/dockerfiles/Dockerfile
new file mode 100644
index 000000000..1ebef5cb6
--- /dev/null
+++ b/dockerfiles/Dockerfile
@@ -0,0 +1,30 @@
+ARG PYTHON_VERSION=3.14
+
+FROM python:${PYTHON_VERSION}
+RUN apt update && apt upgrade -y \
+  && apt install curl -y \
+  && rm -rf /var/lib/apt/lists/*
+
+# Ensure root certificates are always updated at evey container build
+# and curl is using the latest version of them
+# RUN mkdir /usr/local/share/ca-certificates/cacert.org
+# RUN cd /usr/local/share/ca-certificates/cacert.org && curl -k -O https://www.cacert.org/certs/root.crt
+# RUN cd /usr/local/share/ca-certificates/cacert.org && curl -k -O https://www.cacert.org/certs/class3.crt
+# ENV CURL_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
+RUN update-ca-certificates
+
+RUN python -m pip install -U pip
+RUN python -m pip install uvicorn uvicorn-worker gunicorn
+
+COPY src/titiler/ /tmp/titiler/
+RUN python -m pip install /tmp/titiler/core /tmp/titiler/extensions["cogeo,stac"] /tmp/titiler/mosaic["mosaicjson"] /tmp/titiler/xarray /tmp/titiler/application --no-cache-dir --upgrade
+RUN rm -rf /tmp/titiler
+
+###################################################
+# For compatibility (might be removed at one point)
+ENV MODULE_NAME=titiler.application.main
+ENV VARIABLE_NAME=app
+ENV HOST=0.0.0.0
+ENV PORT=80
+ENV WEB_CONCURRENCY=1
+CMD gunicorn -k uvicorn.workers.UvicornWorker ${MODULE_NAME}:${VARIABLE_NAME} --bind ${HOST}:${PORT} --workers ${WEB_CONCURRENCY}
diff --git a/dockerfiles/Dockerfile.gunicorn b/dockerfiles/Dockerfile.gunicorn
deleted file mode 100644
index 6df319f04..000000000
--- a/dockerfiles/Dockerfile.gunicorn
+++ /dev/null
@@ -1,21 +0,0 @@
-# Dockerfile for running titiler application with gunicorn server
-# Size ~1.4GB
-ARG PYTHON_VERSION=3.11
-
-FROM ghcr.io/vincentsarago/uvicorn-gunicorn:${PYTHON_VERSION}
-
-# Ensure root certificates are always updated at evey container build
-# and curl is using the latest version of them
-RUN mkdir /usr/local/share/ca-certificates/cacert.org
-RUN cd /usr/local/share/ca-certificates/cacert.org && curl -k -O https://www.cacert.org/certs/root.crt
-RUN cd /usr/local/share/ca-certificates/cacert.org && curl -k -O https://www.cacert.org/certs/class3.crt
-RUN update-ca-certificates
-ENV CURL_CA_BUNDLE /etc/ssl/certs/ca-certificates.crt
-
-COPY src/titiler/ /tmp/titiler/
-RUN python -m pip install -U pip
-RUN python -m pip install /tmp/titiler/core /tmp/titiler/extensions["cogeo,stac"] /tmp/titiler/mosaic /tmp/titiler/application --no-cache-dir --upgrade
-RUN rm -rf /tmp/titiler
-
-ENV MODULE_NAME titiler.application.main
-ENV VARIABLE_NAME app
diff --git a/dockerfiles/Dockerfile.uvicorn b/dockerfiles/Dockerfile.uvicorn
deleted file mode 100644
index e0a861133..000000000
--- a/dockerfiles/Dockerfile.uvicorn
+++ /dev/null
@@ -1,24 +0,0 @@
-# Dockerfile for running titiler application with uvicorn server
-ARG PYTHON_VERSION=3.11
-
-FROM bitnami/python:${PYTHON_VERSION}
-RUN apt update && apt upgrade -y \
-  && apt install curl -y \
-  && rm -rf /var/lib/apt/lists/*
-
-# Ensure root certificates are always updated at evey container build
-# and curl is using the latest version of them
-RUN mkdir /usr/local/share/ca-certificates/cacert.org
-RUN cd /usr/local/share/ca-certificates/cacert.org && curl -k -O https://www.cacert.org/certs/root.crt
-RUN cd /usr/local/share/ca-certificates/cacert.org && curl -k -O https://www.cacert.org/certs/class3.crt
-RUN update-ca-certificates
-ENV CURL_CA_BUNDLE /etc/ssl/certs/ca-certificates.crt
-
-COPY src/titiler/ /tmp/titiler/
-RUN python -m pip install -U pip
-RUN python -m pip install /tmp/titiler/core /tmp/titiler/extensions["cogeo,stac"] /tmp/titiler/mosaic /tmp/titiler/application["server"] --no-cache-dir --upgrade
-RUN rm -rf /tmp/titiler
-
-ENV HOST 0.0.0.0
-ENV PORT 80
-CMD uvicorn titiler.application.main:app --host ${HOST} --port ${PORT}
diff --git a/dockerfiles/Dockerfile.xarray b/dockerfiles/Dockerfile.xarray
new file mode 100644
index 000000000..9a27e28dc
--- /dev/null
+++ b/dockerfiles/Dockerfile.xarray
@@ -0,0 +1,30 @@
+ARG PYTHON_VERSION=3.14
+
+FROM python:${PYTHON_VERSION}
+RUN apt update && apt upgrade -y \
+  && apt install curl -y \
+  && rm -rf /var/lib/apt/lists/*
+
+# Ensure root certificates are always updated at evey container build
+# and curl is using the latest version of them
+# RUN mkdir /usr/local/share/ca-certificates/cacert.org
+# RUN cd /usr/local/share/ca-certificates/cacert.org && curl -k -O https://www.cacert.org/certs/root.crt
+# RUN cd /usr/local/share/ca-certificates/cacert.org && curl -k -O https://www.cacert.org/certs/class3.crt
+# ENV CURL_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
+RUN update-ca-certificates
+
+RUN python -m pip install -U pip
+RUN python -m pip install uvicorn uvicorn-worker gunicorn
+
+COPY src/titiler/ /tmp/titiler/
+RUN python -m pip install /tmp/titiler/core["telemetry"] /tmp/titiler/xarray starlette-cramjam pydantic-settings --no-cache-dir --upgrade
+RUN rm -rf /tmp/titiler
+
+###################################################
+# For compatibility (might be removed at one point)
+ENV MODULE_NAME=titiler.xarray.main
+ENV VARIABLE_NAME=app
+ENV HOST=0.0.0.0
+ENV PORT=80
+ENV WEB_CONCURRENCY=1
+CMD gunicorn -k uvicorn.workers.UvicornWorker ${MODULE_NAME}:${VARIABLE_NAME} --bind ${HOST}:${PORT} --workers ${WEB_CONCURRENCY}
diff --git a/dockerfiles/nginx.conf b/dockerfiles/nginx.conf
index ccf17b175..12ad20609 100644
--- a/dockerfiles/nginx.conf
+++ b/dockerfiles/nginx.conf
@@ -6,8 +6,8 @@ http {
 
         location /api/v1/titiler {
             rewrite ^/api/v1/titiler(.*)$ $1 break;
-            proxy_pass http://app:8081;
-            proxy_set_header HOST $host;
+            proxy_pass http://nginx-titiler:8081;
+            proxy_set_header HOST $http_host;
             proxy_set_header Referer $http_referer;
             proxy_set_header X-Forwarded-For $remote_addr;
             proxy_set_header X-Forwarded-Proto $scheme;
diff --git a/dockerfiles/otel-collector-config.yaml b/dockerfiles/otel-collector-config.yaml
new file mode 100644
index 000000000..fed63867f
--- /dev/null
+++ b/dockerfiles/otel-collector-config.yaml
@@ -0,0 +1,28 @@
+receivers:
+  otlp:
+    protocols:
+      http:
+        endpoint: 0.0.0.0:4318
+
+processors:
+  batch:
+
+exporters:
+  otlp:
+    endpoint: jaeger:4317
+    tls:
+      insecure: true
+  debug:
+    verbosity: detailed
+
+extensions:
+  health_check:
+    endpoint: 0.0.0.0:13133
+
+service:
+  extensions: [health_check]
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [otlp, debug]
\ No newline at end of file
diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml
index 1d3aa53f7..0691900e1 100644
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -10,6 +10,22 @@ edit_uri: "blob/main/docs/src/"
 site_url: "https://developmentseed.org/titiler/"
 
 extra:
+  analytics:
+    provider: plausible
+    domain: developmentseed.org/titiler
+
+    feedback:
+      title: Was this page helpful?
+      ratings:
+        - icon: material/emoticon-happy-outline
+          name: This page was helpful
+          data: good
+          note: Thanks for your feedback!
+
+        - icon: material/emoticon-sad-outline
+          name: This page could be improved
+          data: bad
+          note: Thanks for your feedback!
   social:
     - icon: "fontawesome/brands/github"
       link: "https://github.com/developmentseed"
@@ -21,21 +37,36 @@ extra:
 nav:
   - TiTiler: "index.md"
   - User Guide:
-    - Intro: "intro.md"
-    - Dynamic Tiling: "dynamic_tiling.md"
-    - Mosaics: "mosaics.md"
-    - TileMatrixSets: "tile_matrix_sets.md"
-    - Output data format: "output_format.md"
+    - Getting Started: "user_guide/getting_started.md"
+    - Titiler with STAC: "user_guide/titiler_with_stac.md"
+    - Dynamic Tiling: "user_guide/dynamic_tiling.md"
+    - TileMatrixSets: "user_guide/tile_matrix_sets.md"
+    - Output data format: "user_guide/output_format.md"
+    - Algorithm: "user_guide/algorithms.md"
+    - Rendering: "user_guide/rendering.md"
 
   - Advanced User Guide:
-      - Tiler Factories: "advanced/tiler_factories.md"
+      - Endpoints Factories: "advanced/endpoints_factories.md"
       - Dependencies: "advanced/dependencies.md"
       - Customization: "advanced/customization.md"
       - Performance Tuning: "advanced/performance_tuning.md"
-      - Custom Algorithm: "advanced/Algorithms.md"
       - Extensions: "advanced/Extensions.md"
-      - Rendering: "advanced/rendering.md"
-      # - APIRoute and environment variables: "advanced/APIRoute_and_environment_variables.md"
+      - Observability with OpenTelemetry: "advanced/telemetry.md"
+
+  - Packages:
+    - titiler.core: "packages/core.md"
+    - titiler.xarray: "packages/xarray.md"
+    - titiler.extensions: "packages/extensions.md"
+    - titiler.mosaic: "packages/mosaic.md"
+    - titiler.application: "packages/application.md"
+
+  - Endpoints documentation:
+    - /cog: "endpoints/cog.md"
+    - /stac: "endpoints/stac.md"
+    - /mosaicjson: "endpoints/mosaic.md"
+    - /tileMatrixSets: "endpoints/tms.md"
+    - /algorithms: "endpoints/algorithms.md"
+    - /colormaps: "endpoints/colormaps.md"
 
   - Examples:
     - Create dynamic tilers with TiTiler:
@@ -47,9 +78,10 @@ nav:
       - Tiler with custom Colormap dependency: "examples/code/tiler_with_custom_colormap.md"
       - Loading data with signed URLs: "examples/code/working_with_signed_urls.md"
       - STAC endpoints with custom `/validate`: "examples/code/tiler_with_custom_stac_validation.md"
-      - Custom Sentinel 2 Tiler: "examples/code/tiler_for_sentinel2.md"
       - Add custom algorithms: "examples/code/tiler_with_custom_algorithm.md"
       - GDAL WMTS Extension: "examples/code/create_gdal_wmts_extension.md"
+      - STAC + Xarray: "examples/code/tiler_with_custom_stac+xarray.md"
+      - Custom Layers: "examples/code/tiler_with_layers.md"
 
     - Use TiTiler endpoints:
       - COG: "examples/notebooks/Working_with_CloudOptimizedGeoTIFF_simple.ipynb"
@@ -61,6 +93,7 @@ nav:
       - NumpyTile: "examples/notebooks/Working_with_NumpyTile.ipynb"
       - Algorithm: "examples/notebooks/Working_with_Algorithm.ipynb"
       - Statistics: "examples/notebooks/Working_with_Statistics.ipynb"
+      - Xarray: "examples/notebooks/Working_with_Zarr.ipynb"
 
   - API:
     - titiler.core:
@@ -68,49 +101,125 @@ nav:
       - factory: api/titiler/core/factory.md
       - routing: api/titiler/core/routing.md
       - errors: api/titiler/core/errors.md
-      - enums: api/titiler/core/resources/enums.md
       - middleware: api/titiler/core/middleware.md
+      - resources:
+        - enums: api/titiler/core/resources/enums.md
+        - responses: api/titiler/core/resources/responses.md
+      - models:
+        - OGC: api/titiler/core/models/OGC.md
+        - Mapbox/MapLibre: api/titiler/core/models/mapbox.md
+        - responses: api/titiler/core/models/responses.md
     - titiler.extensions:
       - cogeo: api/titiler/extensions/cogeo.md
       - stac: api/titiler/extensions/stac.md
       - viewer: api/titiler/extensions/viewer.md
+      - wms: api/titiler/extensions/wms.md
+      - wmts: api/titiler/extensions/wmts.md
     - titiler.mosaic:
       - factory: api/titiler/mosaic/factory.md
-      - enums: api/titiler/mosaic/resources/enums.md
       - errors: api/titiler/mosaic/errors.md
-
-  - titiler.application:
-    - /cog: "endpoints/cog.md"
-    - /stac: "endpoints/stac.md"
-    - /mosaicjson: "endpoints/mosaic.md"
-    - /tileMatrixSets: "endpoints/tms.md"
+      - extensions:
+        - wmts: api/titiler/mosaic/wmts.md
+        - mosaicjson: api/titiler/mosaic/mosaicjson.md
+      - models:
+        - responses: api/titiler/mosaic/models/responses.md
+    - titiler.xarray:
+      - io: api/titiler/xarray/io.md
+      - dependencies: api/titiler/xarray/dependencies.md
+      - extensions: api/titiler/xarray/extensions.md
+      - factory: api/titiler/xarray/factory.md
+      - main: api/titiler/xarray/main.md
 
   - Deployment:
     - Amazon Web Services:
       - Intro: "deployment/aws/intro.md"
-      - ECS: "deployment/aws/ecs.md"
       - Lambda: "deployment/aws/lambda.md"
       - SAM: "deployment/aws/sam.md"
     - k8s / Helm Deployment: "deployment/k8s.md"
     - Azure: "deployment/azure.md"
 
+  - Migrations:
+    - From titiler 0.26.x to 1.x: "migrations/v1_migration.md"
+    - From titiler 1.x to 2.x: "migrations/v2_migration.md"
+
   - External links: "external_links.md"
   - Development - Contributing: "contributing.md"
   - Release Notes: "release-notes.md"
+  - Security: "security.md"
+  - Performance Benchmarks: benchmark.html
 
 plugins:
   - search
+  - social
   - mkdocs-jupyter:
-      include_source: True
+      include_source: true
+      ignore: ["**/.ipynb_checkpoints/*.ipynb"]
+  - mkdocstrings:
+      enable_inventory: true
+      handlers:
+        python:
+          paths: [src]
+          options:
+            filters:
+            - "!^__post_init__"
+            docstring_section_style: list
+            docstring_style: google
+            line_length: 100
+            separate_signature: true
+            show_root_heading: true
+            show_signature_annotations: true
+            show_source: false
+            show_symbol_type_toc: true
+            signature_crossrefs: true
+            extensions:
+              - griffe_inherited_docstrings
+          inventories:
+            - https://docs.python.org/3/objects.inv
+            - https://numpy.org/doc/stable/objects.inv
+            - https://rasterio.readthedocs.io/en/stable/objects.inv
+            - https://docs.pydantic.dev/latest/objects.inv
+            - https://fastapi.tiangolo.com/objects.inv
+            - https://cogeotiff.github.io/rio-tiler/objects.inv
 
 theme:
   name: material
   palette:
-    primary: indigo
-    scheme: default
+    # Palette toggle for automatic mode
+    - media: "(prefers-color-scheme)"
+      toggle:
+        icon: material/brightness-auto
+        name: Switch to light mode
+
+    # Palette toggle for light mode
+    - media: "(prefers-color-scheme: light)"
+      scheme: default
+      primary: indigo
+      accent: indigo
+      toggle:
+          icon: material/brightness-7
+          name: Switch to dark mode
+
+    # Palette toggle for dark mode
+    - media: "(prefers-color-scheme: dark)"
+      scheme: slate
+      primary: indigo
+      accent: indigo
+      toggle:
+          icon: material/brightness-4
+          name: Switch to light mode
+
   custom_dir: 'src/overrides'
   favicon: img/favicon.png
 
+  features:
+    - content.code.annotate
+    - content.code.copy
+    - navigation.indexes
+    - navigation.instant
+    - navigation.tracking
+    - search.suggest
+    - search.share
+
 # https://github.com/kylebarron/cogeo-mosaic/blob/mkdocs/mkdocs.yml#L50-L75
 markdown_extensions:
   - admonition
@@ -124,7 +233,9 @@ markdown_extensions:
   - pymdownx.caret:
       insert: false
   - pymdownx.details
-  - pymdownx.emoji
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
   - pymdownx.escapeall:
       hardbreak: true
       nbsp: true
diff --git a/docs/src/advanced/APIRoute_and_environment_variables.md b/docs/src/advanced/APIRoute_and_environment_variables.md
deleted file mode 100644
index 36e1183a5..000000000
--- a/docs/src/advanced/APIRoute_and_environment_variables.md
+++ /dev/null
@@ -1,40 +0,0 @@
-!!! important
-    This has been deprecated. You can now pass `environment_dependency=lambda: {"GDAL_DISABLE_READDIR_ON_OPEN":"FALSE"}` to the Tiler Factory. This will be passed to a `rasterio.Env()` context manager on top of all gdal related blocks.
-
-    ```python
-    from titiler.core.factory import TilerFactory
-    cog = TilerFactory(
-        reader=COGReader,
-        router_prefix="cog",
-        environment_dependency=lambda: {"GDAL_DISABLE_READDIR_ON_OPEN":"FALSE"},
-    )
-    ```
-
-Sometimes, specifically when using GDAL, it can be useful to have environment variables set for certain endpoints
-(e.g. when using Landsat data on AWS you need `GDAL_DISABLE_READDIR_ON_OPEN=FALSE` but you don't want this environment variable set for other endpoints). To be able to do this
-we created a *custom* APIRoute class which wraps classic fastapi APIRoute with a `rasterio.Env()` block: https://github.com/developmentseed/titiler/blob/8a7127ca56631c2c327713d99e80285048c3aa6c/titiler/custom/routing.py#L13-L41
-
-Example:
-    ```python
-    from fastapi import FastAPI, APIRouter
-    from rasterio._env import get_gdal_config
-    from titiler.core.routing import apiroute_factory
-    from titiler.core.factory import TilerFactory
-
-    app = FastAPI()
-    route_class = apiroute_factory({"GDAL_DISABLE_READDIR_ON_OPEN": "FALSE"})
-    router = APIRouter(route_class=route_class)
-
-    tiler = TilerFactory(router=router)
-
-    @router.get("/simple")
-    def simple():
-        """should return FALSE."""
-        res = get_gdal_config("GDAL_DISABLE_READDIR_ON_OPEN")
-        return {"env": res}
-
-    app.include_router(router)
-    ```
-
-!!! important
-    This has only be tested for python 3.6 and 3.7.
diff --git a/docs/src/advanced/Extensions.md b/docs/src/advanced/Extensions.md
index 9af9a7c2f..16bb665ad 100644
--- a/docs/src/advanced/Extensions.md
+++ b/docs/src/advanced/Extensions.md
@@ -33,28 +33,48 @@ class FactoryExtension(metaclass=abc.ABCMeta):
 
 ## Available extensions
 
-#### cogValidateExtension
+#### titiler.extensions.cogValidateExtension
 
 - Goal: adds a `/validate` endpoint which return the content of rio-cogeo `info` method
 - Additional requirements: `titiler.extensions["cogeo"]` (installs `rio-cogeo`)
 
-#### cogViewerExtension
+#### titiler.extensions.cogViewerExtension
 
 - Goal: adds a `/viewer` endpoint which return an HTML viewer for simple COGs
 
-#### stacViewerExtension
+#### titiler.extensions.stacViewerExtension
 
 - Goal: adds a `/viewer` endpoint which return an HTML viewer for STAC item
 
-#### stacExtension
+#### titiler.extensions.stacExtension
 
 - Goal: adds a `/stac` endpoint which return an HTML viewer for STAC item
 - Additional requirements: `titiler.extensions["stac"]` (installs `rio-stac`)
 
-#### wmsExtension
+#### titiler.extensions.wmsExtension
 
 - Goal: adds a `/wms` endpoint to support OGC WMS specification (`GetCapabilities` and `GetMap`)
 
+#### titiler.extensions.wmtsExtension
+
+- Goal: adds a `/WMTSCapabilities.xml` endpoint to support OGC WMTS RESTFULL specification (`GetCapabilities` and `GetTile`)
+
+#### titiler.extensions.stacRenderExtenstion
+
+- Goal: adds `/render` and `/render/{render_id}` endpoints which return the contents of [STAC render extension](https://github.com/stac-extensions/render) and links to tileset.json and WMTS service
+
+#### titiler.xarray.DatasetMetadataExtension
+
+- Goal: adds `/dataset/`, `/dataset/keys` and `/datasets/dict` endpoints which return metadata about a multidimensional Dataset (not a DataArray)
+
+#### titiler.mosaic.extensions.wmts.wmtsExtension
+
+- Goal: adds `/WMTSCapabilities.xml` to support OGC WMTS RESTFULL specification (`GetCapabilities` and `GetTile`)
+
+#### titiler.mosaic.extensions.mosaicjson.MosaicJSONExtension
+
+- Goal: adds `/` and `/validate` endpoints to return MosaicJSON content and validate external mosaics.
+
 ## How To
 
 ### Use extensions
@@ -81,18 +101,16 @@ tiler = TilerFactory(
 app.include_router(tiler.router, prefix="/cog")
 ```
 
-See [titiler.application](../application) for a full example.
-
 ### Create your own
 
 ```python
 from dataclasses import dataclass, field
 from typing import Tuple, List, Optional
-
+import rasterio
 from starlette.responses import Response
 from fastapi import Depends, FastAPI, Query
-from titiler.core.factory import BaseTilerFactory, FactoryExtension, TilerFactory
-from titiler.core.dependencies import RescalingParams
+from titiler.core.factory import TilerFactory, FactoryExtension
+from titiler.core.dependencies import ImageRenderingParams
 from titiler.core.factory import TilerFactory
 from titiler.core.resources.enums import ImageType
 
@@ -104,8 +122,8 @@ class thumbnailExtension(FactoryExtension):
     # Set some options
     max_size: int = field(default=128)
 
-    # Register method is mandatory and must take a BaseTilerFactory object as input
-    def register(self, factory: BaseTilerFactory):
+    # Register method is mandatory and must take a TilerFactory object as input
+    def register(self, factory: TilerFactory):
         """Register endpoint to the tiler factory."""
 
         # register an endpoint to the factory's router
@@ -125,47 +143,37 @@ class thumbnailExtension(FactoryExtension):
         def thumbnail(
             # we can reuse the factory dependency
             src_path: str = Depends(factory.path_dependency),
+            reader_params=Depends(factory.reader_dependency),
             layer_params=Depends(factory.layer_dependency),
             dataset_params=Depends(factory.dataset_dependency),
             post_process=Depends(factory.process_dependency),
-            rescale: Optional[List[Tuple[float, ...]]] = Depends(RescalingParams),
-            color_formula: Optional[str] = Query(
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
             colormap=Depends(factory.colormap_dependency),
             render_params=Depends(factory.render_dependency),
-            reader_params=Depends(factory.reader_dependency),
             env=Depends(factory.environment_dependency),
         ):
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    im = src.preview(
+                with factory.reader(src_path, **reader_params.as_dict()) as src:
+                    image = src.preview(
                         max_size=self.max_size,
-                        **layer_params,
-                        **dataset_params,
+                        **layer_params.as_dict(),
+                        **dataset_params.as_dict(),
                     )
 
             if post_process:
                 image = post_process(image)
 
-            if rescale:
-                image.rescale(rescale)
-
-            if color_formula:
-                image.apply_color_formula(color_formula)
-
             format = ImageType.jpeg if image.mask.all() else ImageType.png
 
-            content = image.render(
-                img_format=format.driver,
-                colormap=colormap or dst_colormap,
-                **format.profile,
-                **render_params,
+            if post_process:
+                image = post_process(image)
+
+            content, media_type = factory.render_func(
+                image,
+                colormap=colormap,
+                **render_params.as_dict(),
             )
 
-            return Response(content, media_type=format.mediatype)
+            return Response(content, media_type=media_type)
 
 # Use it
 app = FastAPI()
diff --git a/docs/src/advanced/customization.md b/docs/src/advanced/customization.md
index 13bcbfaa6..330d9cb45 100644
--- a/docs/src/advanced/customization.md
+++ b/docs/src/advanced/customization.md
@@ -1,5 +1,32 @@
 
-`TiTiler` is designed to help user customize input/output for each endpoint. This section goes over some simple customization examples.
+`TiTiler` is designed to help users customize input/output for each endpoint. This section goes over some simple customization examples.
+
+### Custom Colormap
+
+Add user defined colormap to the default colormaps provided by rio-tiler
+
+```python
+from fastapi import FastAPI
+
+from rio_tiler.colormap import cmap as default_cmap
+
+from titiler.core.dependencies import create_colormap_dependency
+from titiler.core.factory import TilerFactory
+
+
+app = FastAPI(title="My simple app with custom TMS")
+
+cmap_values = {
+    "cmap1": {6: (4, 5, 6, 255)},
+}
+# add custom colormap `cmap1` to the default colormaps
+cmap = default_cmap.register(cmap_values)
+ColorMapParams = create_colormap_dependency(cmap)
+
+
+cog = TilerFactory(colormap_dependency=ColorMapParams)
+app.include_router(cog.router)
+```
 
 ### Custom DatasetPathParams for `reader_dependency`
 
@@ -13,7 +40,6 @@ import re
 
 from fastapi import FastAPI, HTTPException, Query
 
-from titiler.core.dependencies import DefaultDependency
 from titiler.mosaic.factory import MosaicTilerFactory
 
 
@@ -69,9 +95,11 @@ COGTilerWithCustomTMS = TilerFactory(supported_tms=tms)
 ### Add a MosaicJSON creation endpoint
 ```python
 
-from dataclasses import dataclass
 from typing import List, Optional
 
+from attrs import define
+
+from cogeo_mosaic.backends import MosaicBackend as MosaicJSONBackend
 from titiler.mosaic.factory import MosaicTilerFactory
 from titiler.core.errors import BadRequestError
 from cogeo_mosaic.mosaic import MosaicJSON
@@ -102,9 +130,11 @@ class UpdateMosaicJSON(BaseModel):
     add_first: bool = True
 
 
-@dataclass
+@define(kw_only=True)
 class CustomMosaicFactory(MosaicTilerFactory):
 
+    backend: Type[MosaicJSONBackend] = MosaicJSONBackend
+
     def register_routes(self):
         """Update the class method to add create/update"""
         super().register_routes()
@@ -136,8 +166,10 @@ class CustomMosaicFactory(MosaicTilerFactory):
 
             # Write the MosaicJSON using a cogeo-mosaic backend
             with rasterio.Env(**env):
-                with self.reader(
-                    body.url, mosaic_def=mosaic, reader=self.dataset_reader
+                with self.backend(
+                    body.url, 
+                    mosaic_def=mosaic, 
+                    reader=self.dataset_reader
                 ) as mosaic:
                     try:
                         mosaic.write(overwrite=body.overwrite)
@@ -159,7 +191,7 @@ class CustomMosaicFactory(MosaicTilerFactory):
         ):
             """Update an existing MosaicJSON"""
             with rasterio.Env(**env):
-                with self.reader(body.url, reader=self.dataset_reader) as mosaic:
+                with self.backend(body.url, reader=self.dataset_reader) as mosaic:
                     features = get_footprints(body.files, max_threads=body.max_threads)
                     try:
                         mosaic.update(features, add_first=body.add_first, quiet=True)
diff --git a/docs/src/advanced/dependencies.md b/docs/src/advanced/dependencies.md
index 937395e1f..4298a9ca4 100644
--- a/docs/src/advanced/dependencies.md
+++ b/docs/src/advanced/dependencies.md
@@ -5,31 +5,18 @@ In titiler `Factories`, we use the dependencies to define the inputs for each en
 
 Example:
 ```python
-# Custom Dependency
+from typing import Annotated
 
 from dataclasses import dataclass
-from typing import Optional
-
 from fastapi import Depends, FastAPI, Query
 from titiler.core.dependencies import DefaultDependency
-
-from rio_tiler.io import COGReader
+from rio_tiler.io import Reader
 
 @dataclass
 class ImageParams(DefaultDependency):
-    """Common Preview/Crop parameters."""
-
-    max_size: Optional[int] = Query(
-        1024, description="Maximum image size to read onto."
-    )
-    height: Optional[int] = Query(None, description="Force output image height.")
-    width: Optional[int] = Query(None, description="Force output image width.")
-
-    def __post_init__(self):
-        """Post Init."""
-        if self.width and self.height:
-            self.max_size = None
-
+    max_size: Annotated[
+        int, Query(description="Maximum image size to read onto.")
+    ] = 1024
 
 app = FastAPI()
 
@@ -39,15 +26,10 @@ def preview(
     url: str = Query(..., description="data set URL"),
     params: ImageParams = Depends(),
 ):
-
-    with COGReader(url) as cog:
-        img = cog.preview(**params)  # classes built with `DefaultDependency` can be unpacked
+    with Reader(url) as cog:
+        img = cog.preview(**params.as_dict())  # we use `DefaultDependency().as_dict()` to pass only non-None parameters
         # or
-        img = cog.preview(
-            max_size=params.max_size,
-            height=params.height,
-            width=params.width,
-        )
+        img = cog.preview(max_size=params.max_size)
     ...
 ```
 
@@ -55,61 +37,161 @@ def preview(
 
     In the example above, we create a custom `ImageParams` dependency which will then be injected to the `preview` endpoint to add  **max_size**, **height** and **width** query string parameters.
 
-    Using `titiler.core.dependencies.DefaultDependency`, we can `unpack` the class as if it was a dictionary, which helps with customization.
+    Using `titiler.core.dependencies.DefaultDependency`, we can use `.as_dict(exclude_none=True/False)` method to `unpack` the object parameters. This can be useful if method or reader do not take the same parameters.
 
+## titiler.core
 
-## Factories Dependencies
+#### AssetsParams
 
-The `factories` allow users to set multiple default dependencies. Here is the list of common dependencies and their **default** values.
+Define `assets`.
 
-### BaseTilerFactory
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **assets** | Query (str) | No | None
 
-#### path_dependency
+<details>
 
-Set dataset path (url).
+```python
+@dataclass
+class AssetsParams(DefaultDependency):
+    """Assets parameters."""
+
+    assets: Annotated[
+        list[str],
+        Query(
+            title="Asset names",
+            description="Asset's names.",
+            openapi_examples={
+                "user-provided": {"value": None},
+                "one-asset": {
+                    "description": "Return results for asset `data`.",
+                    "value": ["data"],
+                },
+                "multi-assets": {
+                    "description": "Return results for assets `data` and `cog`.",
+                    "value": ["data", "cog"],
+                },
+            },
+        ),
+    ]
+```
+
+</details>
+
+#### AssetsExprParams
+
+Define `assets`.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **assets** | Query (str) | Yes  |
+| **expression** | Query (str) | No | None
+| **asset_as_band** | Query (bool) | No | False
+
+\* `assets` is required.
+
+<details>
 
 ```python
-def DatasetPathParams(
-    url: str = Query(..., description="Dataset URL")
-) -> str:
-    """Create dataset path from args"""
-    return url
+@dataclass
+class AssetsExprParams(AssetsParams, ExpressionParams):
+    """Assets and Expression parameters."""
+
+    asset_as_band: Annotated[
+        bool | None,
+        Query(
+            title="Consider asset as a 1 band dataset",
+            description="Asset as Band",
+        ),
+    ] = None
+
+    def __post_init__(self):
+        """Post Init."""
+        if not self.assets:
+            raise MissingAssets("assets must be defined")
 ```
 
-#### layer_dependency
+</details>
+
+#### `BidxParams`
+
+Define band indexes.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **bidx**  | Query (int)    | No       | None
 
-Define band indexes or expression
+<details>
 
 ```python
 @dataclass
 class BidxParams(DefaultDependency):
     """Band Indexes parameters."""
 
-    indexes: Optional[List[int]] = Query(
-        None,
-        title="Band indexes",
-        alias="bidx",
-        description="Dataset band indexes",
-        examples={"one-band": {"value": [1]}, "multi-bands": {"value": [1, 2, 3]}},
-    )
+    indexes: Annotated[
+        Optional[List[int]],
+        Query(
+            title="Band indexes",
+            alias="bidx",
+            description="Dataset band indexes",
+            openapi_examples={
+                "user-provided": {"value": None},
+                "one-band": {"value": [1]},
+                "multi-bands": {"value": [1, 2, 3]},
+            },
+        ),
+    ] = None
+```
+
+</details>
 
+#### `ExpressionParams`
+
+Define band expression.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **expression** | Query (str)    | No       | None
+
+
+<details>
+
+```python
 @dataclass
 class ExpressionParams(DefaultDependency):
     """Expression parameters."""
 
-    expression: Optional[str] = Query(
-        None,
-        title="Band Math expression",
-        description="rio-tiler's band math expression",
-        examples={
-            "simple": {"description": "Simple band math.", "value": "b1/b2"},
-            "multi-bands": {
-                "description": "Semicolon (;) delimited expressions (band1: b1/b2, band2: b2+b3).",
-                "value": "b1/b2;b2+b3",
+    expression: Annotated[
+        Optional[str],
+        Query(
+            title="Band Math expression",
+            description="rio-tiler's band math expression",
+            openapi_examples={
+                "user-provided": {"value": None},
+                "simple": {"description": "Simple band math.", "value": "b1/b2"},
+                "multi-bands": {
+                    "description": "Semicolon (;) delimited expressions (band1: b1/b2, band2: b2+b3).",
+                    "value": "b1/b2;b2+b3",
+                },
             },
-        },
-    )
+        ),
+    ] = None
+```
 
+</details>
+
+#### `BidxExprParams`
+
+Define band indexes or expression.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **bidx**  | Query (int)    | No       | None
+| **expression** | Query (str)    | No       | None
+
+<details>
+
+```python
 @dataclass
 class BidxExprParams(ExpressionParams, BidxParams):
     """Band Indexes and Expression parameters."""
@@ -117,176 +199,422 @@ class BidxExprParams(ExpressionParams, BidxParams):
     pass
 ```
 
-#### dataset_dependency
+</details>
+
+#### `ColorMapParams`
+
+Colormap options. See [titiler.core.dependencies](https://github.com/developmentseed/titiler/blob/e46c35c8927b207f08443a274544901eb9ef3914/src/titiler/core/titiler/core/dependencies.py#L18-L54).
 
-Overwrite nodata value, apply rescaling or change default resampling.
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **colormap_name**  | Query (str)     | No       | None
+| **colormap**  | Query (encoded json)    | No       | None
+
+<details>
+
+```python
+cmap = {}
+
+def ColorMapParams(
+    colormap_name: Annotated[  # type: ignore
+        Literal[tuple(cmap.list())],
+        Query(description="Colormap name"),
+    ] = None,
+    colormap: Annotated[
+        Optional[str], Query(description="JSON encoded custom Colormap")
+    ] = None,
+):
+    if colormap_name:
+        return cmap.get(colormap_name)
+
+    if colormap:
+        try:
+            c = json.loads(
+                colormap,
+                object_hook=lambda x: {
+                    int(k): parse_color(v) for k, v in x.items()
+                },
+            )
+
+            # Make sure to match colormap type
+            if isinstance(c, Sequence):
+                c = [(tuple(inter), parse_color(v)) for (inter, v) in c]
+
+            return c
+        except json.JSONDecodeError as e:
+            raise HTTPException(
+                status_code=400, detail="Could not parse the colormap value."
+            ) from e
+
+    return None
+```
+
+</details>
+
+#### CoordCRSParams
+
+Define input Coordinate Reference System.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **crs** | Query (str) | No | None
+
+
+<details>
+
+```python
+def CoordCRSParams(
+    crs: Annotated[
+        Optional[str],
+        Query(
+            alias="coord_crs",
+            description="Coordinate Reference System of the input coords. Default to `epsg:4326`.",
+        ),
+    ] = None,
+) -> Optional[CRS]:
+    """Coordinate Reference System Coordinates Param."""
+    if crs:
+        return CRS.from_user_input(crs)
+
+    return None
+```
+
+</details>
+
+#### `DatasetParams`
+
+Overwrite `nodata` value, apply `rescaling` and change the `I/O` or `Warp` resamplings.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **nodata**  | Query (str, int, float)    | No       | None
+| **unscale** | Query (bool)    | No       | False
+| **resampling** | Query (str) | No        | 'nearest'
+| **reproject** | Query (str) | No        | 'nearest'
+
+<details>
 
 ```python
 @dataclass
 class DatasetParams(DefaultDependency):
     """Low level WarpedVRT Optional parameters."""
 
-    nodata: Optional[Union[str, int, float]] = Query(
-        None, title="Nodata value", description="Overwrite internal Nodata value"
-    )
-    unscale: Optional[bool] = Query(
-        False,
-        title="Apply internal Scale/Offset",
-        description="Apply internal Scale/Offset",
-    )
-    resampling_method: ResamplingName = Query(
-        ResamplingName.nearest,  # type: ignore
-        alias="resampling",
-        description="Resampling method.",
-    )
+    nodata: Annotated[
+        Optional[Union[str, int, float]],
+        Query(
+            title="Nodata value",
+            description="Overwrite internal Nodata value",
+        ),
+    ] = None
+    unscale: Annotated[
+        bool,
+        Query(
+            title="Apply internal Scale/Offset",
+            description="Apply internal Scale/Offset. Defaults to `False` in rio-tiler.",
+        ),
+    ] = False
+    resampling_method: Annotated[
+        Optional[RIOResampling],
+        Query(
+            alias="resampling",
+            description="RasterIO resampling algorithm. Defaults to `nearest` in rio-tiler.",
+        ),
+    ] = None
+    reproject_method: Annotated[
+        Optional[WarpResampling],
+        Query(
+            alias="reproject",
+            description="WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest` in rio-tiler.",
+        ),
+    ] = None
 
     def __post_init__(self):
         """Post Init."""
         if self.nodata is not None:
             self.nodata = numpy.nan if self.nodata == "nan" else float(self.nodata)
-        self.resampling_method = self.resampling_method.value  # type: ignore
+
+        if self.unscale is not None:
+            self.unscale = bool(self.unscale)
 ```
 
-#### render_dependency
+</details>
 
-Image rendering options.
+#### `DatasetPathParams`
 
-```python
-@dataclass
-class ImageRenderingParams(DefaultDependency):
-    """Image Rendering options."""
+Set dataset path.
 
-    add_mask: bool = Query(
-        True, alias="return_mask", description="Add mask to the output data."
-    )
-```
+| Name   | Type      | Required             | Default
+| ------ | ----------|--------------------- |--------------
+| **url**  | Query (str)  | :warning: **Yes**  :warning:  | -
 
-#### colormap_dependency
 
-Colormap options.
+<details>
 
 ```python
-def ColorMapParams(
-    colormap_name: ColorMapName = Query(None, description="Colormap name"),
-    colormap: str = Query(None, description="JSON encoded custom Colormap"),
-) -> Optional[Union[Dict, Sequence]]:
-    """Colormap Dependency."""
-    if colormap_name:
-        return cmap.get(colormap_name.value)
+def DatasetPathParams(
+    url: Annotated[str, Query(description="Dataset URL")]
+) -> str:
+    """Create dataset path from args"""
+    return url
+```
 
-    if colormap:
-        try:
-            return json.loads(
-                colormap,
-                object_hook=lambda x: {int(k): parse_color(v) for k, v in x.items()},
-            )
-        except json.JSONDecodeError:
-            raise HTTPException(
-                status_code=400, detail="Could not parse the colormap value."
-            )
+</details>
+
+
+#### DstCRSParams
+
+Define output Coordinate Reference System.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **crs** | Query (str) | No | None
+
+
+<details>
+
+```python
+def DstCRSParams(
+    crs: Annotated[
+        Optional[str],
+        Query(
+            alias="dst_crs",
+            description="Output Coordinate Reference System.",
+        ),
+    ] = None,
+) -> Optional[CRS]:
+    """Coordinate Reference System Coordinates Param."""
+    if crs:
+        return CRS.from_user_input(crs)
 
     return None
 ```
 
-#### reader_dependency
+</details>
 
-Additional reader options. Defaults to `DefaultDependency` (empty).
+#### HistogramParams
 
+Define *numpy*'s histogram options.
 
-#### Other Attributes
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **histogram_bins** | Query (encoded list of Number) | No | 10
+| **histogram_range** | Query (encoded list of Number) | No | None
 
-##### Supported TMS
-
-The TMS dependency sets the available TMS for a tile endpoint.
+<details>
 
 ```python
-# Allow all morecantile TMS
-from morecantile import tms as default_tms
+@dataclass
+class HistogramParams(DefaultDependency):
+    """Numpy Histogram options."""
+
+    bins: Annotated[
+        Optional[str],
+        Query(
+            alias="histogram_bins",
+            title="Histogram bins.",
+            description="""
+Defines the number of equal-width bins in the given range (10, by default).
+
+If bins is a sequence (comma `,` delimited values), it defines a monotonically increasing array of bin edges, including the rightmost edge, allowing for non-uniform bin widths.
+
+link: https://numpy.org/doc/stable/reference/generated/numpy.histogram.html
+            """,
+            openapi_examples={
+                "user-provided": {"value": None},
+                "simple": {
+                    "description": "Defines the number of equal-width bins",
+                    "value": 8,
+                },
+                "array": {
+                    "description": "Defines custom bin edges (comma `,` delimited values)",
+                    "value": "0,100,200,300",
+                },
+            },
+        ),
+    ] = None
+
+    range: Annotated[
+        Optional[str],
+        Query(
+            alias="histogram_range",
+            title="Histogram range",
+            description="""
+Comma `,` delimited range of the bins.
 
-tiler = TilerFactory(supported_tms=default_tms)
+The lower and upper range of the bins. If not provided, range is simply (a.min(), a.max()).
 
+Values outside the range are ignored. The first element of the range must be less than or equal to the second.
+range affects the automatic bin computation as well.
 
-# Restrict the TMS to `WebMercatorQuad` only
-from morecantile import tms
-from morecantile.defaults import TileMatrixSets
+link: https://numpy.org/doc/stable/reference/generated/numpy.histogram.html
+            """,
+            examples="0,1000",
+        ),
+    ] = None
 
-# Construct a TileMatrixSets object with only the `WebMercatorQuad` tms
-default_tms = TileMatrixSets({"WebMercatorQuad": tms.get("WebMercatorQuad")})
-tiler = TilerFactory(supported_tms=default_tms)
+    def __post_init__(self):
+        """Post Init."""
+        if self.bins:
+            bins = self.bins.split(",")
+            if len(bins) == 1:
+                self.bins = int(bins[0])  # type: ignore
+            else:
+                self.bins = list(map(float, bins))  # type: ignore
+        else:
+            self.bins = 10
+
+        if self.range:
+            self.range = list(map(float, self.range.split(",")))  # type: ignore
 ```
 
-##### Default TMS
+</details>
 
-Set the default's TMS Identifier (default to `WebMercatorQuad`).
+#### `ImageRenderingParams`
+
+Control output image rendering options.
+
+| Name               | Type                               | Required | Default
+| ------             | ----------                         |----------|--------------
+| **rescale**        | Query (str, comma delimited Numer) | No       | None
+| **color_formula**  | Query (str)                        | No       | None
+| **return_mask**    | Query (bool)                       | No       | False
+
+<details>
 
 ```python
-# Create a Tile with it's default TMS being `WGS1984Quad`
-tiler = TilerFactory(default_tms="WGS1984Quad")
+@dataclass
+class ImageRenderingParams(DefaultDependency):
+    """Image Rendering options."""
+
+    rescale: Annotated[
+        Optional[List[str]],
+        Query(
+            title="Min/Max data Rescaling",
+            description="comma (',') delimited Min,Max range. Can set multiple time for multiple bands.",
+            examples=["0,2000", "0,1000", "0,10000"],  # band 1  # band 2  # band 3
+        ),
+    ] = None
+
+    color_formula: Annotated[
+        Optional[str],
+        Query(
+            title="Color Formula",
+            description="rio-color formula (info: https://github.com/mapbox/rio-color)",
+        ),
+    ] = None
+
+    add_mask: Annotated[
+        Optional[bool],
+        Query(
+            alias="return_mask",
+            description="Add mask to the output data. Defaults to `True`",
+        ),
+    ] = None
+
+    def __post_init__(self):
+        """Post Init."""
+        if self.rescale:
+            rescale_array = []
+            for r in self.rescale:
+                parsed = tuple(
+                    map(
+                        float,
+                        r.replace(" ", "").replace("[", "").replace("]", "").split(","),
+                    )
+                )
+                assert (
+                    len(parsed) == 2
+                ), f"Invalid rescale values: {self.rescale}, should be of form ['min,max', 'min,max'] or [[min,max], [min, max]]"
+                rescale_array.append(parsed)
+
+            self.rescale: RescaleType = rescale_array  # Noqa
+
 ```
 
-### TilerFactory
+</details>
 
-The `TilerFactory` inherits dependency from `BaseTilerFactory`.
+#### PartFeatureParams
 
-#### metadata_dependency
+Same as `PreviewParams` but without default `max_size`.
 
-`rio_tiler.io.BaseReader.metadata()` methods options.
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **max_size** | Query (int) | No | None
+| **height** | Query (int) | No | None
+| **width** | Query (int) | No | None
+
+<details>
 
 ```python
 @dataclass
-class MetadataParams(DefaultDependency):
-    """Common Metadada parameters."""
-
-    # Required params
-    pmin: float = Query(2.0, description="Minimum percentile")
-    pmax: float = Query(98.0, description="Maximum percentile")
+class PreviewParams(DefaultDependency):
+    """Common Preview parameters."""
 
-    # Optional params
-    max_size: Optional[int] = Query(
-        None, description="Maximum image size to read onto."
+    # NOTE: sizes dependency can either be a Query or a Path Parameter
+    max_size: Annotated[int, Field(description="Maximum image size to read onto.")] = (
+        1024
     )
-    histogram_bins: Optional[int] = Query(None, description="Histogram bins.")
-    histogram_range: Optional[str] = Query(
-        None, description="comma (',') delimited Min,Max histogram bounds"
-    )
-    bounds: Optional[str] = Query(
-        None,
-        descriptions="comma (',') delimited Bounding box coordinates from which to calculate image statistics.",
+    height: Annotated[
+        Optional[int], Field(description="Force output image height.")
+    ] = None
+    width: Annotated[Optional[int], Field(description="Force output image width.")] = (
+        None
     )
 
     def __post_init__(self):
         """Post Init."""
-        if self.max_size is not None:
-            self.kwargs["max_size"] = self.max_size
-
-        if self.bounds:
-            self.kwargs["bounds"] = tuple(map(float, self.bounds.split(",")))
-
-        hist_options = {}
-        if self.histogram_bins:
-            hist_options.update(dict(bins=self.histogram_bins))
-        if self.histogram_range:
-            hist_options.update(
-                dict(range=list(map(float, self.histogram_range.split(","))))
-            )
-        if hist_options:
-            self.kwargs["hist_options"] = hist_options
+        if self.width or self.height:
+            self.max_size = None
 ```
 
-#### img_dependency
+</details>
+
+#### PixelSelectionParams
 
-Used in Crop/Preview to define size of the output image.
+In `titiler.mosaic`, define pixel-selection method to apply.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **pixel_selection** | Query (str) | No | 'first'
+
+
+<details>
+
+```python
+def PixelSelectionParams(
+    pixel_selection: Annotated[  # type: ignore
+        Literal[tuple([e.name for e in PixelSelectionMethod])],
+        Query(description="Pixel selection method."),
+    ] = "first",
+) -> MosaicMethodBase:
+    """
+    Returns the mosaic method used to combine datasets together.
+    """
+    return PixelSelectionMethod[pixel_selection].value()
+```
+
+</details>
+
+#### PreviewParams
+
+Define image output size.
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **max_size** | Query (int) | No | 1024
+| **height** | Query (int) | No | None
+| **width** | Query (int) | No | None
+
+<details>
 
 ```python
 @dataclass
-class ImageParams(DefaultDependency):
-    """Common Preview/Crop parameters."""
+class PreviewParams(DefaultDependency):
+    """Common Preview parameters."""
 
-    max_size: Optional[int] = Query(
-        1024, description="Maximum image size to read onto."
-    )
-    height: Optional[int] = Query(None, description="Force output image height.")
-    width: Optional[int] = Query(None, description="Force output image width.")
+    max_size: Annotated[int, "Maximum image size to read onto."] = 1024
+    height: Annotated[Optional[int], "Force output image height."] = None
+    width: Annotated[Optional[int], "Force output image width."] = None
 
     def __post_init__(self):
         """Post Init."""
@@ -294,70 +622,327 @@ class ImageParams(DefaultDependency):
             self.max_size = None
 ```
 
-### MultiBaseTilerFactory
+</details>
 
-The `MultiBaseTilerFactory` inherits dependency from `TilerFactory` and `BaseTilerFactory`.
+#### StatisticsParams
 
-#### assets_dependency
+Define options for *rio-tiler*'s statistics method.
 
-Define `assets`.
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **categorical**  | Query (bool)     | No       | False
+| **categories** | Query (list of Number) | No | None
+| **p** | Query (list of Number) | No | [2, 98]
+
+<details>
 
 ```python
 @dataclass
-class AssetsParams(DefaultDependency):
-    """Assets parameters."""
+class StatisticsParams(DefaultDependency):
+    """Statistics options."""
+
+    categorical: Annotated[
+        Optional[bool],
+        Query(description="Return statistics for categorical dataset. Defaults to `False` in rio-tiler"),
+    ] = None
+    categories: Annotated[
+        Optional[List[Union[float, int]]],
+        Query(
+            alias="c",
+            title="Pixels values for categories.",
+            description="List of values for which to report counts.",
+            examples=[1, 2, 3],
+        ),
+    ] = None
+    percentiles: Annotated[
+        Optional[List[int]],
+        Query(
+            alias="p",
+            title="Percentile values",
+            description="List of percentile values (default to [2, 98]).",
+            examples=[2, 5, 95, 98],
+        ),
+    ] = None
 
-    assets: List[str] = Query(
-        None,
-        title="Asset names",
-        description="Asset's names.",
-        examples={
-            "one-asset": {
-                "description": "Return results for asset `data`.",
-                "value": ["data"],
-            },
-            "multi-assets": {
-                "description": "Return results for assets `data` and `cog`.",
-                "value": ["data", "cog"],
-            },
-        },
-    )
+    def __post_init__(self):
+        """Set percentiles default."""
+        if not self.percentiles:
+            self.percentiles = [2, 98]
 ```
 
-### MultiBandTilerFactory
+</details>
 
-The `MultiBaseTilerFactory` inherits dependency from `TilerFactory` and `BaseTilerFactory`.
+#### TileParams
 
-#### bands_dependency
+Define `buffer` and `padding` to apply at tile creation.
 
-Define `bands`.
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **buffer** | Query (float) | No | None
+| **padding** | Query (int) | No | None
+
+<details>
 
 ```python
 @dataclass
-class BandsParams(DefaultDependency):
-    """Band names parameters."""
-
-    bands: List[str] = Query(
-        None,
-        title="Band names",
-        description="Band's names.",
-        examples={
-            "one-band": {
-                "description": "Return results for band `B01`.",
-                "value": ["B01"],
-            },
-            "multi-bands": {
-                "description": "Return results for bands `B01` and `B02`.",
-                "value": ["B01", "B02"],
-            },
-        },
-    )
+class TileParams(DefaultDependency):
+    """Tile options."""
+
+    buffer: Annotated[
+        Optional[float],
+        Query(
+            gt=0,
+            title="Tile buffer.",
+            description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
+        ),
+    ] = None
+
+    padding: Annotated[
+        Optional[int],
+        Query(
+            gt=0,
+            title="Tile padding.",
+            description="Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to `0`.",
+        ),
+    ] = None
+```
+
+</details>
+
+#### `algorithm.dependency`
+
+Control which `algorithm` to apply to the data.
+
+See [titiler.core.algorithm](https://github.com/developmentseed/titiler/blob/e46c35c8927b207f08443a274544901eb9ef3914/src/titiler/core/titiler/core/algorithm/__init__.py#L54-L79).
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **algorithm**  | Query (str)    | No       | None
+| **algorithm_params** | Query (encoded json)     | No       | None
+
+<details>
+
+```python
+algorithms = {}
+
+def post_process(
+    algorithm: Annotated[
+        Literal[tuple(algorithms.keys())],
+        Query(description="Algorithm name"),
+    ] = None,
+    algorithm_params: Annotated[
+        Optional[str],
+        Query(description="Algorithm parameter"),
+    ] = None,
+) -> Optional[BaseAlgorithm]:
+    """Data Post-Processing options."""
+    kwargs = json.loads(algorithm_params) if algorithm_params else {}
+    if algorithm:
+        try:
+            return algorithms.get(algorithm)(**kwargs)
+
+        except ValidationError as e:
+            raise HTTPException(status_code=400, detail=str(e)) from e
+
+    return None
+```
+
+</details>
+
+## titiler.xarray
+
+
+#### XarrayIOParams
+
+Define Xarray's `open_args` to `xarray.open_dataset`.
+
+| Name             | Type        | Required | Default
+| ------           | ----------  |----------|--------------
+| **group**        | Query (str) | No       | None
+| **decode_times** | Query (bool)| No       | None
+
+<details>
+
+```python
+@dataclass
+class XarrayIOParams(DefaultDependency):
+    """Dataset IO Options."""
+
+    group: Annotated[
+        Optional[str],
+        Query(
+            description="Select a specific zarr group from a zarr hierarchy. Could be associated with a zoom level or dataset."
+        ),
+    ] = None
+
+    decode_times: Annotated[
+        Optional[bool],
+        Query(
+            title="decode_times",
+            description="Whether to decode times",
+        ),
+    ] = None
 ```
 
-### MosaicTilerFactory
+</details>
 
-The `MultiBaseTilerFactory` inherits dependency from `BaseTilerFactory`.
+#### XarrayDsParams
 
-#### backend_dependency
+Define options to select a **variable** within a Xarray Dataset.
+
+| Name          | Type        | Required | Default
+| ------        | ----------  |----------|--------------
+| **variable**  | Query (str) | Yes      | None
+| **sel**       | Query (list of str) | No | None
+
+<details>
+
+```python
+@dataclass
+class XarrayDsParams(DefaultDependency):
+    """Xarray Dataset Options."""
+
+    variable: Annotated[str, Query(description="Xarray Variable name.")]
+
+    sel: Annotated[
+        Optional[List[SelDimStr]],
+        Query(
+            description="Xarray Indexing using dimension names `{dimension}={value}` or `{dimension}={method}::{value}`.",
+        ),
+    ] = None
+```
+
+</details>
+
+
+#### XarrayParams
+
+Combination of `XarrayIOParams` and `XarrayDsParams`
+
+| Name             | Type        | Required | Default
+| ------           | ----------  |----------|--------------
+| **group**        | Query (str) | No       | None
+| **decode_times** | Query (bool)| No       | None
+| **variable**     | Query (str) | Yes      | None
+| **sel**          | Query (list of str) | No | None
+
+<details>
+
+```python
+@dataclass
+class XarrayParams(XarrayIOParams, XarrayDsParams):
+    """Xarray Reader dependency."""
+
+    pass
+```
+
+</details>
+
+#### CompatXarrayParams
+
+same as `XarrayParams` but with optional `variable` option.
+
+| Name             | Type        | Required | Default
+| ------           | ----------  |----------|--------------
+| **group**        | Query (str) | No       | None
+| **decode_times** | Query (bool)| No       | None
+| **variable**     | Query (str) | No      | None
+| **sel**          | Query (list of str) | No | None
+
+<details>
+
+```python
+@dataclass
+class XarrayParams(XarrayIOParams, XarrayDsParams):
+    """Xarray Reader dependency."""
+
+    pass
+```
+
+</details>
+
+
+#### DatasetParams
+
+Same as `titiler.core.dependencies.DatasetParams` but with only `nodata` and `reproject`
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **nodata**  | Query (str, int, float)    | No       | None
+| **reproject** | Query (str) | No        | 'nearest'
+
+<details>
+
+```python
+@dataclass
+class DatasetParams(DefaultDependency):
+    """Low level WarpedVRT Optional parameters."""
+
+    nodata: Annotated[
+        Optional[Union[str, int, float]],
+        Query(
+            title="Nodata value",
+            description="Overwrite internal Nodata value",
+        ),
+    ] = None
+    reproject_method: Annotated[
+        Optional[WarpResampling],
+        Query(
+            alias="reproject",
+            description="WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.",
+        ),
+    ] = None
+
+    def __post_init__(self):
+        """Post Init."""
+        if self.nodata is not None:
+            self.nodata = numpy.nan if self.nodata == "nan" else float(self.nodata)
+```
+
+</details>
+
+
+#### PartFeatureParams
+
+Same as `titiler.core.dependencies.PartFeatureParams` but with `resampling` option
+
+| Name      | Type      | Required | Default
+| ------    | ----------|----------|--------------
+| **max_size** | Query (int) | No | None
+| **height** | Query (int) | No | None
+| **width** | Query (int) | No | None
+| **resampling** | Query (str) | No | 'nearest'
+
+
+<details>
+
+```python
+@dataclass
+class PartFeatureParams(DefaultDependency):
+    """Common parameters for bbox and feature."""
+
+    # NOTE: the part sizes dependency can either be a Query or a Path Parameter
+    max_size: Annotated[
+        Optional[int], Field(description="Maximum image size to read onto.")
+    ] = None
+    height: Annotated[
+        Optional[int], Field(description="Force output image height.")
+    ] = None
+    width: Annotated[Optional[int], Field(description="Force output image width.")] = (
+        None
+    )
+    resampling_method: Annotated[
+        Optional[RIOResampling],
+        Query(
+            alias="resampling",
+            description="RasterIO resampling algorithm. Defaults to `nearest`.",
+        ),
+    ] = None
+
+    def __post_init__(self):
+        """Post Init."""
+        if self.width or self.height:
+            self.max_size = None
+```
 
-Additional backend options. Defaults to `DefaultDependency` (empty).
+</details>
diff --git a/docs/src/advanced/endpoints_factories.md b/docs/src/advanced/endpoints_factories.md
new file mode 100644
index 000000000..20e74f27a
--- /dev/null
+++ b/docs/src/advanced/endpoints_factories.md
@@ -0,0 +1,406 @@
+
+TiTiler's endpoints factories are helper functions that let users create a FastAPI *router* (`fastapi.APIRouter`) with a minimal set of endpoints.
+
+!!! Important
+
+    Most of `tiler` **Factories** are built around [`rio_tiler.io.BaseReader`](https://cogeotiff.github.io/rio-tiler/advanced/custom_readers/), which defines basic methods to access datasets (e.g COG or STAC). The default reader is `Reader` for `TilerFactory` and `MosaicBackend` for `MosaicTilerFactory`.
+
+    Factories classes use [dependencies injection](dependencies.md) to define most of the endpoint options.
+
+## titiler.core
+
+### BaseFactory
+
+class: `titiler.core.factory.BaseFactory`
+
+Most **Factories** are built from this [abstract based class](https://docs.python.org/3/library/abc.html) which is used to define commons attributes and utility functions shared between all factories.
+
+#### Attributes
+
+- **router**: FastAPI router. Defaults to `fastapi.APIRouter`.
+- **router_prefix**: Set prefix to all factory's endpoint. Defaults to `""`.
+- **route_dependencies**: Additional routes dependencies to add after routes creations. Defaults to `[]`.
+- **extension**: TiTiler extensions to register after endpoints creations. Defaults to `[]`.
+- **name**: Name of the Endpoints group. Defaults to `None`.
+- **operation_prefix** (*private*): Endpoint's `operationId` prefix. Defined by `self.name` or `self.router_prefix.replace("/", ".")`.
+- **conforms_to**: Set of conformance classes the Factory implement
+
+#### Methods
+
+- **register_routes**: Abstract method which needs to be define by each factories.
+- **url_for**: Method to construct endpoint URL
+- **add_route_dependencies**: Add dependencies to routes.
+
+### TilerFactory
+
+class: `titiler.core.factory.TilerFactory`
+
+Factory meant to create endpoints for single dataset using [*rio-tiler*'s `Reader`](https://cogeotiff.github.io/rio-tiler/readers/#rio_tileriorasterioreader).
+
+#### Attributes
+
+- **reader**: Dataset Reader **required**.
+- **reader_dependency**: Dependency to control options passed to the reader instance init. Defaults to `titiler.core.dependencies.DefaultDependency`
+- **path_dependency**: Dependency to use to define the dataset url. Defaults to `titiler.core.dependencies.DatasetPathParams`.
+- **layer_dependency**: Dependency to define band indexes or expression. Defaults to `titiler.core.dependencies.BidxExprParams`.
+- **dataset_dependency**: Dependency to overwrite `nodata` value, apply `rescaling` and change the `I/O` or `Warp` resamplings. Defaults to `titiler.core.dependencies.DatasetParams`.
+- **tile_dependency**: Dependency to define `buffer` and `padding` to apply at tile creation. Defaults to `titiler.core.dependencies.TileParams`.
+- **stats_dependency**: Dependency to define options for *rio-tiler*'s statistics method used in `/statistics` endpoints. Defaults to `titiler.core.dependencies.StatisticsParams`.
+- **histogram_dependency**: Dependency to define *numpy*'s histogram options used in `/statistics` endpoints. Defaults to `titiler.core.dependencies.HistogramParams`.
+- **img_preview_dependency**: Dependency to define image size for `/preview` and `/statistics` endpoints. Defaults to `titiler.core.dependencies.PreviewParams`.
+- **img_part_dependency**: Dependency to define image size for `/bbox` and `/feature` endpoints. Defaults to `titiler.core.dependencies.PartFeatureParams`.
+- **process_dependency**: Dependency to control which `algorithm` to apply to the data. Defaults to `titiler.core.algorithm.algorithms.dependency`.
+- **colormap_dependency**: Dependency to define the Colormap options. Defaults to `titiler.core.dependencies.ColorMapParams`
+- **render_dependency**: Dependency to control output image rendering options. Defaults to `titiler.core.dependencies.ImageRenderingParams`
+- **environment_dependency**: Dependency to define GDAL environment at runtime. Default to `lambda: {}`.
+- **supported_tms**: List of available TileMatrixSets. Defaults to `morecantile.tms`.
+- **templates**: *Jinja2* templates to use in endpoints. Defaults to `titiler.core.factory.DEFAULT_TEMPLATES`.
+- **render_func**: Image rendering method. Defaults to `titiler.core.utils.render_image`.
+- **add_preview**: Add `/preview` endpoint to the router. Defaults to `True`.
+- **add_part**: Add `/bbox` and `/feature` endpoints to the router. Defaults to `True`.
+- **add_viewer**: Add `/{TileMatrixSetId}/map.html` endpoints to the router. Defaults to `True`.
+- **add_ogc_maps**: Add `/map` endoint (OGC Maps API) to the router. Defaults to `False`.
+
+#### Endpoints
+
+```python
+from fastapi import FastAPI
+
+from titiler.core.factory import TilerFactory
+
+# Create FastAPI application
+app = FastAPI()
+
+# Create router and register set of endpoints
+cog = TilerFactory(
+    add_preview=True,
+    add_part=True,
+    add_viewer=True,
+    add_ogc_maps=True,
+)
+
+# add router endpoint to the main application
+app.include_router(cog.router)
+```
+
+| Method | URL                                                             | Output                                      | Description
+| ------ | --------------------------------------------------------------- |-------------------------------------------- |--------------
+| `GET`  | `/info`                                                         | JSON ([Info][info_model])                   | return dataset's basic info
+| `GET`  | `/info.geojson`                                                 | GeoJSON ([InfoGeoJSON][info_geojson_model]) | return dataset's basic info as a GeoJSON feature
+| `GET`  | `/statistics`                                                   | JSON ([Statistics][stats_model])            | return dataset's statistics
+| `POST` | `/statistics`                                                   | GeoJSON ([Statistics][stats_geojson_model]) | return dataset's statistics for a GeoJSON
+| `GET`  | `/tiles`                                                        | JSON                                        | List of OGC Tilesets available
+| `GET`  | `/tiles/{tileMatrixSetId}`                                      | JSON                                        | OGC Tileset metadata
+| `GET`  | `/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`    | image/bin                                   | create a web map tile image from a dataset
+| `GET`  | `/{tileMatrixSetId}/map.html`                                   | HTML                                        | return a simple map viewer **Optional**
+| `GET`  | `/{tileMatrixSetId}/tilejson.json`                              | JSON ([TileJSON][tilejson_model])           | return a Mapbox TileJSON document
+| `GET`  | `/point/{lon},{lat}`                                            | JSON ([Point][point_model])                 | return pixel values from a dataset
+| `GET`  | `/bbox/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin                                   | create an image from part of a dataset **Optional**
+| `POST` | `/feature[/{width}x{height}][.{format}]`                        | image/bin                                   | create an image from a GeoJSON feature **Optional**
+| `GET`  | `/preview[/{width}x{height}][.{format}]`                        | image/bin                                   | create a preview image from a dataset **Optional**
+| `GET`  | `/maps`                                                         | image/bin                                   | create maps from a dataset **Optional**
+
+
+### MultiBaseTilerFactory
+
+class: `titiler.core.factory.MultiBaseTilerFactory`
+
+Custom `TilerFactory` to be used with [`rio_tiler.io.MultiBaseReader`](https://cogeotiff.github.io/rio-tiler/advanced/custom_readers/#multibasereader) type readers (e.g [`rio_tiler.io.STACReader`](https://cogeotiff.github.io/rio-tiler/readers/#rio_tileriostacstacreader)).
+
+#### Attributes
+
+- **reader**: `rio_tiler.io.base.MultiBaseReader` Dataset Reader **required**.
+- **layer_dependency**: Dependency to define assets or expression. Defaults to `titiler.core.dependencies.AssetsExprParams`.
+- **assets_dependency**: Dependency to define assets to be used. Defaults to `titiler.core.dependencies.AssetsParams`.
+
+#### Endpoints
+
+```python
+from fastapi import FastAPI
+
+from rio_tiler.io import STACReader  # STACReader is a MultiBaseReader
+
+from titiler.core.factory import MultiBaseTilerFactory
+
+app = FastAPI()
+stac = MultiBaseTilerFactory(
+    reader=STACReader,
+    add_preview=True,
+    add_part=True,
+    add_viewer=True,
+    add_ogc_maps=True,
+)
+app.include_router(stac.router)
+```
+
+| Method | URL                                                             | Output                                           | Description
+| ------ | --------------------------------------------------------------- |------------------------------------------------- |--------------
+| `GET`  | `/assets`                                                       | JSON                                             | return the list of available assets
+| `GET`  | `/info`                                                         | JSON ([Info][multiinfo_model])                   | return assets basic info
+| `GET`  | `/info.geojson`                                                 | GeoJSON ([InfoGeoJSON][multiinfo_geojson_model]) | return assets basic info as a GeoJSON feature
+| `GET`  | `/asset_statistics`                                             | JSON ([Statistics][multistats_model])            | return per asset statistics
+| `GET`  | `/statistics`                                                   | JSON ([Statistics][stats_model])                 | return assets statistics (merged)
+| `POST` | `/statistics`                                                   | GeoJSON ([Statistics][multistats_geojson_model]) | return assets statistics for a GeoJSON (merged)
+| `GET`  | `/tiles`                                                        | JSON                                             | List of OGC Tilesets available
+| `GET`  | `/tiles/{tileMatrixSetId}`                                      | JSON                                             | OGC Tileset metadata
+| `GET`  | `/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`    | image/bin                                        | create a web map tile image from assets
+| `GET`  | `/{tileMatrixSetId}/map.html`                                   | HTML                                             | return a simple map viewer **Optional**
+| `GET`  | `/{tileMatrixSetId}/tilejson.json`                              | JSON ([TileJSON][tilejson_model])                | return a Mapbox TileJSON document
+| `GET`  | `/point/{lon},{lat}`                                            | JSON ([Point][multipoint_model])                 | return pixel values from assets
+| `GET`  | `/bbox/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin                                        | create an image from part of assets **Optional**
+| `POST` | `/feature[/{width}x{height}][.{format}]`                        | image/bin                                        | create an image from a geojson feature intersecting assets **Optional**
+| `GET`  | `/preview[/{width}x{height}][.{format}]`                        | image/bin                                        | create a preview image from assets **Optional**
+| `GET`  | `/map`                                                         | image/bin                                        | create maps from a dataset **Optional**
+
+### TMSFactory
+
+class: `titiler.core.factory.TMSFactory`
+
+Endpoints factory for OGC `TileMatrixSets`.
+
+#### Attributes
+
+- **supported_tms**: List of available TileMatrixSets. Defaults to `morecantile.tms`.
+
+```python
+from fastapi import FastAPI
+
+from titiler.core.factory import TMSFactory
+
+app = FastAPI()
+tms = TMSFactory()
+app.include_router(tms.router)
+```
+
+#### Endpoints
+
+| Method | URL                                   | Output                                         | Description
+| ------ | ------------------------------------- |----------------------------------------------- |--------------
+| `GET`  | `/tileMatrixSets`                     | JSON ([TileMatrixSetList][tilematrixset_list]) | retrieve the list of available tiling schemes (tile matrix sets)
+| `GET`  | `/tileMatrixSets/{tileMatrixSetId}`   | JSON ([TileMatrixSet][tilematrixset])          | retrieve the definition of the specified tiling scheme (tile matrix set)
+
+
+### AlgorithmFactory
+
+class: `titiler.core.factory.AlgorithmFactory`
+
+Endpoints factory for custom algorithms.
+
+#### Attributes
+
+- **supported_algorithm**: List of available `Algorithm`. Defaults to `titiler.core.algorithm.algorithms`.
+
+```python
+from fastapi import FastAPI
+
+from titiler.core.factory import AlgorithmFactory
+
+app = FastAPI()
+algo = AlgorithmFactory()
+app.include_router(algo.router)
+```
+
+#### Endpoints
+
+| Method | URL                          | Output                                                   | Description
+| ------ | ---------------------------- |--------------------------------------------------------- |--------------
+| `GET`  | `/algorithms`                | JSON (Dict of [Algorithm Metadata][algorithm_metadata])            | retrieve the list of available Algorithms
+| `GET`  | `/algorithms/{algorithmId}`  | JSON ([Algorithm Metadata][algorithm_metadata])                    | retrieve the metadata of the specified algorithm.
+
+
+### ColorMapFactory
+
+class: `titiler.core.factory.ColorMapFactory`
+
+Endpoints factory for colorMaps metadata.
+
+#### Attributes
+
+- **supported_colormaps**: List of available `ColorMaps`. Defaults to `rio_tiler.colormap.cmap`.
+
+```python
+from fastapi import FastAPI
+
+from titiler.core.factory import ColorMapFactory
+
+app = FastAPI()
+colormap = ColorMapFactory()
+app.include_router(colormap.router)
+```
+
+#### Endpoints
+
+| Method | URL                          | Output                                | Description
+| ------ | ---------------------------- |-------------------------------------- |--------------
+| `GET`  | `/colorMaps`                 | JSON ([colorMapList][colormap_list])  | retrieve the list of available colorMaps
+| `GET`  | `/colorMaps/{colorMapId}`    | JSON ([colorMap][colormap])           | retrieve the metadata or image of the specified colorMap.
+
+
+## titiler.mosaic
+
+### MosaicTilerFactory
+
+class: `titiler.mosaic.factory.MosaicTilerFactory`
+
+Endpoints factory for mosaics.
+
+#### Attributes
+
+- **backend**: `rio_tiler.mosaic.backends.BaseBackend` Mosaic backend.
+- **backend_dependency**: Dependency to control options passed to the backend instance init. Defaults to `titiler.core.dependencies.DefaultDependency`
+- **dataset_reader**: Dataset Reader. Defaults to `rio_tiler.io.Reader`
+- **reader_dependency**: Dependency to control options passed to the reader instance init. Defaults to `titiler.core.dependencies.DefaultDependency`
+- **path_dependency**: Dependency to use to define the dataset. Defaults to `titiler.mosaic.factory.DatasetPathParams`.
+- **assets_accessor_dependency**: Dependency to define options to be forwarded to the backend `get_assets` method. Defaults to `titiler.core.dependencies.DefaultDependency`.
+- **layer_dependency**: Dependency to define band indexes or expression. Defaults to `titiler.core.dependencies.BidxExprParams`.
+- **dataset_dependency**: Dependency to overwrite `nodata` value, apply `rescaling` and change the `I/O` or `Warp` resamplings. Defaults to `titiler.core.dependencies.DatasetParams`.
+- **tile_dependency**: Dependency to define `buffer` and `padding` to apply at tile creation. Defaults to `titiler.core.dependencies.TileParams`.
+- **process_dependency**: Dependency to control which `algorithm` to apply to the data. Defaults to `titiler.core.algorithm.algorithms.dependency`.
+- **stats_dependency**: Dependency to define options for *rio-tiler*'s statistics method used in `/statistics` endpoints. Defaults to `titiler.core.dependencies.StatisticsParams`.
+- **histogram_dependency**: Dependency to define *numpy*'s histogram options used in `/statistics` endpoints. Defaults to `titiler.core.dependencies.HistogramParams`.
+- **colormap_dependency**: Dependency to define the Colormap options. Defaults to `titiler.core.dependencies.ColorMapParams`
+- **render_dependency**: Dependency to control output image rendering options. Defaults to `titiler.core.dependencies.ImageRenderingParams`
+- **pixel_selection_dependency**: Dependency to select the `pixel_selection` method. Defaults to `titiler.mosaic.factory.PixelSelectionParams`.
+- **environment_dependency**: Dependency to define GDAL environment at runtime. Default to `lambda: {}`.
+- **supported_tms**: List of available TileMatrixSets. Defaults to `morecantile.tms`.
+- **render_func**: Image rendering method. Defaults to `titiler.core.utils.render_image`.
+- **optional_headers**: List of OptionalHeader which endpoints could add (if implemented). Defaults to `[]`.
+- **templates**: *Jinja2* templates to use in endpoints. Defaults to `titiler.core.factory.DEFAULT_TEMPLATES`.
+- **add_viewer**: Add `/{TileMatrixSetId}/map.html` endpoints to the router. Defaults to `True`.
+- **add_statistics**: Add `POST - /statistics` endpoints to the router. Defaults to `False`.
+- **add_part**: Add `/bbox` and `/feature` endpoints to the router. Defaults to `False`.
+- **add_ogc_maps**: Add `/map` endpoints to the router. Default to `False`.
+- **conforms_to**: Set of conformance classes the Factory implement
+
+#### Endpoints
+
+| Method | URL                                                             | Output                                             | Description
+| ------ | --------------------------------------------------------------- |--------------------------------------------------- |--------------
+| `GET`  | `/info`                                                         | JSON ([Info][mosaic_info_model])                   | return mosaic's basic info
+| `GET`  | `/info.geojson`                                                 | GeoJSON ([InfoGeoJSON][mosaic_geojson_info_model]) | return mosaic's basic info  as a GeoJSON feature
+| `GET`  | `/tiles`                                                        | JSON                                               | List of OGC Tilesets available
+| `GET`  | `/tiles/{tileMatrixSetId}`                                      | JSON                                               | OGC Tileset metadata
+| `GET`  | `/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`    | image/bin                                          | create a web map tile image from a MosaicJSON
+| `GET`  | `/tiles/{tileMatrixSetId}/{z}/{x}/{y}/assets`                   | JSON                                               | return list of assets intersecting a XYZ tile
+| `GET`  | `/{tileMatrixSetId}/map.html`                                   | HTML                                               | return a simple map viewer **Optional**
+| `GET`  | `/{tileMatrixSetId}/tilejson.json`                              | JSON ([TileJSON][tilejson_model])                  | return a Mapbox TileJSON document
+| `GET`  | `/point/{lon},{lat}`                                            | JSON ([Point][mosaic_point])                       | return pixel value from a MosaicJSON dataset
+| `GET`  | `/point/{lon},{lat}/assets`                                     | JSON                                               | return list of assets intersecting a point
+| `GET`  | `/bbox/{minx},{miny},{maxx},{maxy}/assets`                      | JSON                                               | return list of assets intersecting a bounding box
+| `POST` | `/statistics`                                                   | GeoJSON ([Statistics][stats_geojson_model])        | return info and statistics for a dataset **Optional**
+| `GET`  | `/bbox/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin                                          | create an image from part of a dataset **Optional**
+| `POST` | `/feature[/{width}x{height}][.{format}]`                        | image/bin                                          | create an image from a geojson feature **Optional**
+| `GET`  | `/map`                                                          | image/bin                                          | create maps from a dataset **Optional**
+
+```python
+from fastapi import FastAPI
+
+from titiler.mosaic.factory import MosaicTilerFactory
+from cogeo_mosaic.backends import MosaicBackend as MosaicJSONBackend
+
+# Create FastAPI application
+app = FastAPI()
+
+# Create router and register set of endpoints
+mosaic = TilerFactory(
+    backend=MosaicJSONBackend,
+    add_part=True,     # default to False
+    add_statistics=True,  # default to False
+    add_ogc_maps=True,  # default to False
+)
+
+# add router endpoint to the main application
+app.include_router(mosaic.router)
+```
+
+## titiler.xarray
+
+### TilerFactory
+
+class: `titiler.xarray.factory.TilerFactory`
+
+#### Attributes
+
+- **reader**: Dataset Reader **required**.
+- **path_dependency**: Dependency to use to define the dataset url. Defaults to `titiler.core.dependencies.DatasetPathParams`.
+- **reader_dependency**: Dependency to control options passed to the reader instance init. Defaults to `titiler.xarray.dependencies.XarrayParams`
+- **layer_dependency**: Dependency to define band indexes or expression. Defaults to `titiler.core.dependencies.BidxParams`.
+- **dataset_dependency**: Dependency to overwrite `nodata` value and change the `Warp` resamplings. Defaults to `titiler.xarray.dependencies.DatasetParams`.
+- **tile_dependency**: Dependency for tile creation options. Defaults to `titiler.core.dependencies.DefaultDependency`.
+- **stats_dependency**: Dependency to define options for *rio-tiler*'s statistics method used in `/statistics` endpoints. Defaults to `titiler.core.dependencies.StatisticsParams`.
+- **histogram_dependency**: Dependency to define *numpy*'s histogram options used in `/statistics` endpoints. Defaults to `titiler.core.dependencies.HistogramParams`.
+- **img_part_dependency**: Dependency to define image size for `/bbox` and `/feature` endpoints. Defaults to `titiler.xarray.dependencies.PartFeatureParams`.
+- **process_dependency**: Dependency to control which `algorithm` to apply to the data. Defaults to `titiler.core.algorithm.algorithms.dependency`.
+- **colormap_dependency**: Dependency to define the Colormap options. Defaults to `titiler.core.dependencies.ColorMapParams`
+- **render_dependency**: Dependency to control output image rendering options. Defaults to `titiler.core.dependencies.ImageRenderingParams`
+- **environment_dependency**: Dependency to define GDAL environment at runtime. Default to `lambda: {}`.
+- **supported_tms**: List of available TileMatrixSets. Defaults to `morecantile.tms`.
+- **templates**: *Jinja2* templates to use in endpoints. Defaults to `titiler.core.factory.DEFAULT_TEMPLATES`.
+- **add_part**: Add `/bbox` and `/feature` endpoints to the router. Defaults to `True`.
+- **add_viewer**: Add `/{TileMatrixSetId}/map.html` endpoints to the router. Defaults to `True`.
+- **add_ogc_maps**: Add `/map` endpoints to the router. Default to `False`.
+- **add_preview**: Add `/preview` endpoints to the router. Default to `False`.
+
+```python
+from fastapi import FastAPI
+
+from titiler.xarray.factory import TilerFactory
+
+# Create FastAPI application
+app = FastAPI()
+
+# Create router and register set of endpoints
+md = TilerFactory(
+    add_part=True,     # default to True
+    add_viewer=True,   # default to True
+    add_preview=True,  # default to False
+)
+
+# add router endpoint to the main application
+app.include_router(md.router)
+```
+
+#### Endpoints
+
+| Method | URL                                                             | Output                                      | Description
+| ------ | --------------------------------------------------------------- |-------------------------------------------- |--------------
+| `GET`  | `/info`                                                         | JSON ([Info][info_model])                   | return dataset's basic info
+| `GET`  | `/info.geojson`                                                 | GeoJSON ([InfoGeoJSON][info_geojson_model]) | return dataset's basic info as a GeoJSON feature
+| `POST` | `/statistics`                                                   | GeoJSON ([Statistics][stats_geojson_model]) | return dataset's statistics for a GeoJSON
+| `GET`  | `/tiles`                                                        | JSON                                        | List of OGC Tilesets available
+| `GET`  | `/tiles/{tileMatrixSetId}`                                      | JSON                                        | OGC Tileset metadata
+| `GET`  | `/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`    | image/bin                                   | create a web map tile image from a dataset
+| `GET`  | `/{tileMatrixSetId}/map.html`                                   | HTML                                        | return a simple map viewer **Optional**
+| `GET`  | `/{tileMatrixSetId}/tilejson.json`                              | JSON ([TileJSON][tilejson_model])           | return a Mapbox TileJSON document
+| `GET`  | `/point/{lon},{lat}`                                            | JSON ([Point][point_model])                 | return pixel values from a dataset
+| `GET`  | `/bbox/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin                                   | create an image from part of a dataset **Optional**
+| `POST` | `/feature[/{width}x{height}][.{format}]`                        | image/bin                                   | create an image from a GeoJSON feature **Optional**
+| `GET`  | `/preview[/{width}x{height}][.{format}]`                        | image/bin                                   | create a preview image from a dataset **Optional**
+
+
+[bounds_model]: https://github.com/cogeotiff/rio-tiler/blob/9aaa88000399ee8d36e71d176f67b6ea3ec53f2d/rio_tiler/models.py#L43-L46
+[info_model]: https://github.com/cogeotiff/rio-tiler/blob/9aaa88000399ee8d36e71d176f67b6ea3ec53f2d/rio_tiler/models.py#L56-L72
+[info_geojson_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L30
+[tilejson_model]: https://github.com/developmentseed/titiler/blob/2335048a407f17127099cbbc6c14e1328852d619/src/titiler/core/titiler/core/models/mapbox.py#L16-L38
+[point_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L11-L20
+[stats_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L32
+[stats_geojson_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L46-L49
+
+[multiinfo_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L52
+[multiinfo_geojson_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L53
+[multipoint_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L23-L27
+[multistats_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L55
+[multistats_geojson_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L56-L59
+
+[mosaic_info_model]: https://github.com/developmentseed/cogeo-mosaic/blob/1dc3c873472c8cf7634ad893b9cdc40105ca3874/cogeo_mosaic/models.py#L9-L17
+[mosaic_geojson_info_model]: https://github.com/developmentseed/titiler/blob/2bd1b159a9cf0932ad14e9eabf1e4e66498adbdc/src/titiler/mosaic/titiler/mosaic/factory.py#L130
+[mosaic_model]: https://github.com/developmentseed/cogeo-mosaic/blob/1dc3c873472c8cf7634ad893b9cdc40105ca3874/cogeo_mosaic/mosaic.py#L55-L72
+[mosaic_point]: https://github.com/developmentseed/titiler/blob/2bd1b159a9cf0932ad14e9eabf1e4e66498adbdc/src/titiler/mosaic/titiler/mosaic/models/responses.py#L8-L17
+
+[tilematrixset_list]: https://github.com/developmentseed/titiler/blob/ffd67af34c2807a6e1447817f943446a58441ed8/src/titiler/core/titiler/core/models/OGC.py#L33-L40
+[tilematrixset]: https://github.com/developmentseed/morecantile/blob/eec54326ce2b134cfbc03dd69a3e2938e4109101/morecantile/models.py#L399-L490
+
+[algorithm_metadata]: https://github.com/developmentseed/titiler/blob/ffd67af34c2807a6e1447817f943446a58441ed8/src/titiler/core/titiler/core/algorithm/base.py#L32-L40
+
+[colormap_list]: https://github.com/developmentseed/titiler/blob/535304fd7e1b0bfbb791bdec8cbfb6e78b4a6eb5/src/titiler/core/titiler/core/models/responses.py#L51-L55
+[colormap]: https://github.com/cogeotiff/rio-tiler/blob/6343b571a367ef63a10d6807e3d907c3283ebb20/rio_tiler/types.py#L24-L27
diff --git a/docs/src/advanced/performance_tuning.md b/docs/src/advanced/performance_tuning.md
index 94201cdff..5d9c1044a 100644
--- a/docs/src/advanced/performance_tuning.md
+++ b/docs/src/advanced/performance_tuning.md
@@ -1,6 +1,6 @@
 ## Overview
 
-Titiler makes use of several great underlying libraries, including [GDAL][gdal]
+TiTiler makes use of several great underlying libraries, including [GDAL][gdal]
 and [Python bindings to GDAL][rasterio]. An effective deployment of titiler
 generally requires tweaking GDAL configuration settings. This document provides
 an overview of relevant settings. Full documentation from GDAL is available
@@ -15,7 +15,7 @@ an overview of relevant settings. Full documentation from GDAL is available
 ### Setting a config variable
 
 GDAL configuration is modified using environment variables. Thus in order to
-change a setting you'll need to set environment variables through your
+change a setting, you'll need to set environment variables through your
 deployment mechanism. For example, in order to test locally you'd set an
 environment variable in bash:
 
@@ -66,10 +66,10 @@ files, so if you wished to read this data, you'd want
 
 #### `GDAL_INGESTED_BYTES_AT_OPEN`
 
-Gives the number of initial bytes GDAL should read when opening a file and
+Defines the number of initial bytes GDAL should read when opening a file and
 inspecting its metadata.
 
-Titiler works best with Cloud-Optimized GeoTIFFs (COGs) because they have a
+TiTiler works best with Cloud-Optimized GeoTIFFs (COGs) because they have a
 tiled internal structure that supports efficient random reads. These files have
 an initial metadata section that describes the location (byte range) within the
 file of each internal tile. The more internal tiles the COG has, the more data
diff --git a/docs/src/advanced/rendering.md b/docs/src/advanced/rendering.md
deleted file mode 100644
index ea31bfd3a..000000000
--- a/docs/src/advanced/rendering.md
+++ /dev/null
@@ -1,115 +0,0 @@
-# Rendering Options
-
-When using Titiler to visualize imagery, there are some helper options that change how the data appears on the screen. You can:
-
-1. Adjust band values using basic color-oriented image operations
-2. Apply color maps to create heat maps, colorful terrain based on band value
-3. Rescale images on a per-band basis
-
-## Color Map
-
-Color maps are arrays of colors, used to map pixel values to specific colors. For example, it is possible to map a single band DEM, where pixel values denote height, to a color map which shows higher values as white:
-
-![color map example](../img/colormap.png)
-
-Titiler supports both default colormaps (each with a name) and custom color maps.
-
-### Default Colormaps
-
-Default colormaps pre-made, each with a given name. These maps come from the `rio-tiler` library, which has taken colormaps packaged with Matplotlib and has added others that are commonly used with raster data. 
-
-A list of available color maps can be found in Titiler's Swagger docs, or in the [rio-tiler documentation](https://cogeotiff.github.io/rio-tiler/colormap/#default-rio-tilers-colormaps).
-
-To use a default colormap, simply use the parameter `colormap_name`:
-
-```python3
-import requests
-
-resp = requests.get("titiler.xyz/cog/preview", params={
-    "url": "<YOUR COG HERE>",
-    "colormap_name": "<YOUR COLORMAP NAME HERE>" # e.g. autumn_r
-})
-```
-
-You can take any of the colormaps listed on `rio-tiler`, and add `_r` to reverse it.
-
-### Custom Colormaps
-
-If you'd like to specify your own colormap, you can specify your own using an encoded JSON:
-
-```python3 
-import requests
-
-response = requests.get(
-    f"titiler.xyz/cog/preview",
-    params={
-        "url": "<YOUR COG HERE>",
-        "bidx": "1",
-        "colormap": {
-                "0": "#e5f5f9",
-                "10": "#99d8c9",
-                "255": "#2ca25f",
-            }
-    }
-)
-```
-
-Titiler supports colormaps that are both discrete (where pixels will be one of the colors that you specify) and linear (where pixel colors will blend between the given colors).
-
-For more information, please check out [rio-tiler's docs](https://cogeotiff.github.io/rio-tiler/colormap/).
-
-It is also possible to add a [colormap dependency](../../examples/code/tiler_with_custom_colormap) to automatically apply
-a default colormap.
-
-## Color Formula
-
-Color formulae are simple commands that apply color corrections to images. This is useful for reducing artefacts like atmospheric haze, dark shadows, or muted colors.
-
-Titiler supports color formulae as defined in [Mapbox's `rio-color` plugin](https://github.com/mapbox/rio-color). These include the operations ([taken from the `rio-color` docs](https://github.com/mapbox/rio-color#operations)):
-
-- **Gamma** adjustment adjusts RGB values according to a power law, effectively brightening or darkening the midtones. It can be very effective in satellite imagery for reducing atmospheric haze in the blue and green bands.
-
-- **Sigmoidal** contrast adjustment can alter the contrast and brightness of an image in a way that matches human's non-linear visual perception. It works well to increase contrast without blowing out the very dark shadows or already-bright parts of the image.
-
-- **Saturation** can be thought of as the "colorfulness" of a pixel. Highly saturated colors are intense and almost cartoon-like, low saturation is more muted, closer to black and white. You can adjust saturation independently of brightness and hue but the data must be transformed into a different color space.
-
-In Titiler, color_formulae are applied through the `color_formula` parameter as a string. An example of this option in action:
-
-```python3
-import requests
-
-response = requests.get(
-    f"titiler.xyz/cog/preview",
-    params={
-        "url": "<YOUR COG HERE>",
-        "color_formula": "gamma rg 1.3, sigmoidal rgb 22 0.1, saturation 1.5"
-    }
-)
-```
-
-## Rescaling
-
-Rescaling is the act of adjusting the minimum and maximum values when rendering an image. In an image with a single band, the rescaled minimum value will be set to black, and the rescaled maximum value will be set to white. This is useful if you want to accentuate features that only appear at a certain pixel value (e.g. you have a DEM, but you want to highlight how the terrain changes between sea level and 100m).
-
-Titiler supports rescaling on a per-band basis, using the `rescaling` parameter. The input is a list of comma-delimited min-max ranges (e.g. ["0,100", "100,200", "0,1000]).
-
-```python3
-import requests
-
-response = requests.get(
-    f"titiler.xyz/cog/preview",
-    params={
-        "url": "<YOUR COG HERE>",
-        "rescaling": ["0,100", "0,1000", "0,10000"]
-    }
-)
-```
-
-By default, Titiler will rescale the bands using the min/max values of the input datatype. For example, PNG images 8- or 16-bit unsigned pixels,
-giving a possible range of 0 to 255 or 0 to 65,536, so Titiler will use these ranges to rescale to the output format. 
-
-For certain datasets (e.g. DEMs) this default behaviour can make the image seem washed out (or even entirely one color), 
-so if you see this happen look into rescaling your images to something that makes sense for your data.
-
-It is also possible to add a [rescaling dependency](../../api/titiler/core/dependencies/#rescalingparams) to automatically apply
-a default rescale.
\ No newline at end of file
diff --git a/docs/src/advanced/telemetry.md b/docs/src/advanced/telemetry.md
new file mode 100644
index 000000000..a7de597d0
--- /dev/null
+++ b/docs/src/advanced/telemetry.md
@@ -0,0 +1,87 @@
+
+## Observability with OpenTelemetry
+
+`TiTiler` provides built-in observability through OpenTelemetry, automatically creating traces for all API endpoints. These traces include detailed spans for key internal operations like data access and image processing, enabling fine-grained performance analysis and debugging.
+
+This instrumentation works seamlessly with other OpenTelemetry libraries, such as FastAPIInstrumentor, to provide a complete, end-to-end view of your application's performance, from incoming request to final response.
+
+### Installation
+
+To enable telemetry, you must install titiler.core with the [telemetry] extra. This ensures all necessary OpenTelemetry packages are installed.
+
+```bash
+python -m pip install -U pip
+
+# From Pypi
+python -m pip install titiler.core[telemetry]
+
+# Or from sources
+git clone https://github.com/developmentseed/titiler.git
+cd titiler && python -m pip install -e src/titiler/core[telemetry]
+```
+
+### Configuration
+
+To export traces, you need to configure your application to send them to an observability platform (like Jaeger or Datadog) using an OTLP Exporter.
+
+The following example demonstrates how to set up a tracer provider that exports data via the OTLP protocol over HTTP. This setup is typically done once when your application starts.
+
+```python
+# In your main application file, e.g., main.py
+
+import os
+from fastapi import FastAPI
+from opentelemetry import trace
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.instrumentation.logging import LoggingInstrumentor
+from opentelemetry.sdk.resources import SERVICE_NAME, SERVICE_VERSION, Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from titiler.core.factory import TilerFactory
+
+# --- OpenTelemetry Configuration ---
+
+# Define a "Resource" for your application.
+# This adds metadata to your traces, like the service name and version.
+resource = Resource.create(
+    {
+        SERVICE_NAME: os.getenv("OTEL_SERVICE_NAME", "titiler"),
+        SERVICE_VERSION: "0.1",
+    }
+)
+
+# Create a "TracerProvider" with the defined resource.
+# The provider manages the creation of tracers.
+provider = TracerProvider(resource=resource)
+
+# Configure an "Exporter" to send telemetry data.
+# The OTLPSpanExporter sends data to an OTLP-compatible endpoint.
+# By default, it reads the endpoint from the OTEL_EXPORTER_OTLP_ENDPOINT
+# environment variable. The default for HTTP is http://localhost:4318.
+exporter = OTLPSpanExporter()
+
+# Use a "BatchSpanProcessor" to send spans in the background.
+# This is the recommended processor for production.
+processor = BatchSpanProcessor(exporter)
+provider.add_span_processor(processor)
+
+# Set the configured provider as the global tracer provider.
+trace.set_tracer_provider(provider)
+
+# --- FastAPI Application Setup ---
+app = FastAPI(title="My TiTiler App")
+
+# Instrument the FastAPI application.
+# This adds middleware to trace requests, responses, and exceptions,
+# complementing TiTiler's internal endpoint tracing.
+FastAPIInstrumentor.instrument_app(app)
+
+# Add trace/span info to logging messages for trace correlation
+LoggingInstrumentor().instrument(set_logging_format=True)
+
+# Add your TiTiler endpoints with the enable_telemetry flag set to True
+cog = TilerFactory(enable_telemetry=True)
+app.include_router(cog.router)
+```
diff --git a/docs/src/advanced/tiler_factories.md b/docs/src/advanced/tiler_factories.md
deleted file mode 100644
index c97dadd15..000000000
--- a/docs/src/advanced/tiler_factories.md
+++ /dev/null
@@ -1,147 +0,0 @@
-
-Tiler factories are helper functions that let users create a FastAPI router (`fastapi.APIRouter`) with a minimal set of endpoints.
-
-### `titiler.core.factory.TilerFactory`
-
-```python
-from fastapi import FastAPI
-
-from titiler.core.factory import TilerFactory
-
-app = FastAPI(description="A lightweight Cloud Optimized GeoTIFF tile server")
-cog = TilerFactory()
-app.include_router(cog.router, tags=["Cloud Optimized GeoTIFF"])
-```
-
-| Method | URL                                                             | Output                                      | Description
-| ------ | --------------------------------------------------------------- |-------------------------------------------- |--------------
-| `GET`  | `/bounds`                                                       | JSON ([Bounds][bounds_model])               | return dataset's bounds
-| `GET`  | `/info`                                                         | JSON ([Info][info_model])                   | return dataset's basic info
-| `GET`  | `/info.geojson`                                                 | GeoJSON ([InfoGeoJSON][info_geojson_model]) | return dataset's basic info as a GeoJSON feature
-| `GET`  | `/statistics`                                                   | JSON ([Statistics][stats_model])            | return dataset's statistics
-| `POST` | `/statistics`                                                   | GeoJSON ([Statistics][stats_geojson_model]) | return dataset's statistics for a GeoJSON
-| `GET`  | `/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`  | image/bin                                   | create a web map tile image from a dataset
-| `GET`  | `[/{TileMatrixSetId}]/tilejson.json`                            | JSON ([TileJSON][tilejson_model])           | return a Mapbox TileJSON document
-| `GET`  | `[/{TileMatrixSetId}]/WMTSCapabilities.xml`                     | XML                                         | return OGC WMTS Get Capabilities
-| `GET`  | `/point/{lon},{lat}`                                            | JSON ([Point][point_model])                 | return pixel values from a dataset
-| `GET`  | `/preview[.{format}]`                                           | image/bin                                   | create a preview image from a dataset (**Optional**)
-| `GET`  | `/crop/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin                                   | create an image from part of a dataset (**Optional**)
-| `POST` | `/crop[/{width}x{height}][.{format}]`                           | image/bin                                   | create an image from a GeoJSON feature (**Optional**)
-| `GET`  | `/map`                                                          | HTML                                        | return a simple map viewer
-| `GET`  | `[/{TileMatrixSetId}]/map`                                      | HTML                                        | return a simple map viewer
-
-### `titiler.core.factory.MultiBaseTilerFactory`
-
-Custom `TilerFactory` to be used with `rio_tiler.io.MultiBaseReader` type readers.
-
-```python
-from fastapi import FastAPI
-from rio_tiler.io import STACReader # rio_tiler.io.STACReader is a MultiBaseReader
-
-from titiler.core.factory import MultiBaseTilerFactory
-
-app = FastAPI(description="A lightweight STAC tile server")
-cog = MultiBaseTilerFactory(reader=STACReader)
-app.include_router(cog.router, tags=["STAC"])
-```
-
-| Method | URL                                                             | Output                                           | Description
-| ------ | --------------------------------------------------------------- |------------------------------------------------- |--------------
-| `GET`  | `/bounds`                                                       | JSON ([Bounds][bounds_model])                    | return dataset's bounds
-| `GET`  | `/assets`                                                       | JSON                                             | return the list of available assets
-| `GET`  | `/info`                                                         | JSON ([Info][multiinfo_model])                   | return assets basic info
-| `GET`  | `/info.geojson`                                                 | GeoJSON ([InfoGeoJSON][multiinfo_geojson_model]) | return assets basic info as a GeoJSON feature
-| `GET`  | `/asset_statistics`                                             | JSON ([Statistics][multistats_model])            | return per asset statistics
-| `GET`  | `/statistics`                                                   | JSON ([Statistics][stats_model])                 | return assets statistics (merged)
-| `POST` | `/statistics`                                                   | GeoJSON ([Statistics][multistats_geojson_model]) | return assets statistics for a GeoJSON (merged)
-| `GET`  | `/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`  | image/bin                                        | create a web map tile image from assets
-| `GET`  | `/[{TileMatrixSetId}]/tilejson.json`                            | JSON ([TileJSON][tilejson_model])                | return a Mapbox TileJSON document
-| `GET`  | `/{TileMatrixSetId}/WMTSCapabilities.xml`                       | XML                                              | return OGC WMTS Get Capabilities
-| `GET`  | `/point/{lon},{lat}`                                            | JSON ([Point][multipoint_model])                 | return pixel values from assets
-| `GET`  | `/preview[.{format}]`                                           | image/bin                                        | create a preview image from assets (**Optional**)
-| `GET`  | `/crop/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin                                        | create an image from part of assets (**Optional**)
-| `POST` | `/crop[/{width}x{height}][.{format}]`                           | image/bin                                        | create an image from a geojson feature intersecting assets (**Optional**)
-| `GET`  | `[/{TileMatrixSetId}]/map`                                      | HTML                                             | return a simple map viewer
-
-### `titiler.core.factory.MultiBandTilerFactory`
-
-Custom `TilerFactory` to be used with `rio_tiler.io.MultiBandReader` type readers.
-
-```python
-from fastapi import FastAPI, Query
-from rio_tiler_pds.landsat.aws import LandsatC2Reader # rio_tiler_pds.landsat.aws.LandsatC2Reader is a MultiBandReader
-
-from titiler.core.factory import MultiBandTilerFactory
-
-
-def SceneIDParams(sceneid: str = Query(..., description="Landsat Scene ID")) -> str:
-    """Use `sceneid` in query instead of url."""
-    return sceneid
-
-
-app = FastAPI(description="A lightweight Landsat Collection 2 tile server")
-cog = MultiBandTilerFactory(reader=LandsatC2Reader, path_dependency=SceneIDParams)
-app.include_router(cog.router, tags=["Landsat"])
-```
-
-| Method | URL                                                             | Output                                       | Description
-| ------ | --------------------------------------------------------------- |--------------------------------------------- |--------------
-| `GET`  | `/bounds`                                                       | JSON ([Bounds][bounds_model])                | return dataset's bounds
-| `GET`  | `/bands`                                                        | JSON                                         | return the list of available bands
-| `GET`  | `/info`                                                         | JSON ([Info][info_model])                    | return basic info for a dataset
-| `GET`  | `/info.geojson`                                                 | GeoJSON ([InfoGeoJSON][info_geojson_model])  | return basic info for a dataset as a GeoJSON feature
-| `GET`  | `/statistics`                                                   | JSON ([Statistics][stats_model])             | return info and statistics for a dataset
-| `POST` | `/statistics`                                                   | GeoJSON ([Statistics][stats_geojson_model])  | return info and statistics for a dataset
-| `GET`  | `/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`  | image/bin                                    | create a web map tile image from a dataset
-| `GET`  | `/[{TileMatrixSetId}]/tilejson.json`                            | JSON ([TileJSON][tilejson_model])            | return a Mapbox TileJSON document
-| `GET`  | `/{TileMatrixSetId}/WMTSCapabilities.xml`                       | XML                                          | return OGC WMTS Get Capabilities
-| `GET`  | `/point/{lon},{lat}`                                            | JSON ([Point][point_model])                  | return pixel value from a dataset
-| `GET`  | `/preview[.{format}]`                                           | image/bin                                    | create a preview image from a dataset
-| `GET`  | `/crop/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin                                    | create an image from part of a dataset
-| `POST` | `/crop[/{width}x{height}][.{format}]`                           | image/bin                                    | create an image from a geojson feature
-| `GET`  | `[/{TileMatrixSetId}]/map`                                      | HTML                                         | return a simple map viewer
-
-### `titiler.mosaic.factory.MosaicTilerFactory`
-
-
-| Method | URL                                                             | Output                                             | Description
-| ------ | --------------------------------------------------------------- |--------------------------------------------------- |--------------
-| `GET`  | `/`                                                             | JSON [MosaicJSON][mosaic_model]                    | return a MosaicJSON document
-| `GET`  | `/bounds`                                                       | JSON ([Bounds][bounds_model])                      | return mosaic's bounds
-| `GET`  | `/info`                                                         | JSON ([Info][mosaic_info_model])                   | return mosaic's basic info
-| `GET`  | `/info.geojson`                                                 | GeoJSON ([InfoGeoJSON][mosaic_geojson_info_model]) | return mosaic's basic info  as a GeoJSON feature
-| `GET`  | `/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`  | image/bin                                          | create a web map tile image from a MosaicJSON
-| `GET`  | `[/{TileMatrixSetId}]/tilejson.json`                            | JSON ([TileJSON][tilejson_model])                  | return a Mapbox TileJSON document
-| `GET`  | `[/{TileMatrixSetId}]/WMTSCapabilities.xml`                     | XML                                                | return OGC WMTS Get Capabilities
-| `GET`  | `/point/{lon},{lat}`                                            | JSON ([Point][mosaic_point])                       | return pixel value from a MosaicJSON dataset
-| `GET`  | `/{z}/{x}/{y}/assets`                                           | JSON                                               | return list of assets intersecting a XYZ tile
-| `GET`  | `/{lon},{lat}/assets`                                           | JSON                                               | return list of assets intersecting a point
-| `GET`  | `/{minx},{miny},{maxx},{maxy}/assets`                           | JSON                                               | return list of assets intersecting a bounding box
-| `GET`  | `[/{TileMatrixSetId}]/map`                                      | HTML                                               | return a simple map viewer
-
-
-!!! Important
-
-    **Factories** are built around [`rio_tiler.io.BaseReader`](https://cogeotiff.github.io/rio-tiler/advanced/custom_readers/), which defines basic methods to access datasets (e.g COG or STAC). The default reader is `COGReader` for `TilerFactory` and `MosaicBackend` for `MosaicTilerFactory`.
-
-    Factories classes use [dependencies injection](dependencies.md) to define most of the endpoint options.
-
-
-[bounds_model]: https://github.com/cogeotiff/rio-tiler/blob/9aaa88000399ee8d36e71d176f67b6ea3ec53f2d/rio_tiler/models.py#L43-L46
-[info_model]: https://github.com/cogeotiff/rio-tiler/blob/9aaa88000399ee8d36e71d176f67b6ea3ec53f2d/rio_tiler/models.py#L56-L72
-[info_geojson_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L30
-[tilejson_model]: https://github.com/developmentseed/titiler/blob/2335048a407f17127099cbbc6c14e1328852d619/src/titiler/core/titiler/core/models/mapbox.py#L16-L38
-[point_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L11-L20
-[stats_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L32
-[stats_geojson_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L46-L49
-
-[multiinfo_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L52
-[multiinfo_geojson_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L53
-[multipoint_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L23-L27
-[multistats_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L55
-[multistats_geojson_model]: https://github.com/developmentseed/titiler/blob/c97e251c46b51703d41b1c9e66bc584649aa231c/src/titiler/core/titiler/core/models/responses.py#L56-L59
-
-[mosaic_info_model]: https://github.com/developmentseed/cogeo-mosaic/blob/1dc3c873472c8cf7634ad893b9cdc40105ca3874/cogeo_mosaic/models.py#L9-L17
-[mosaic_geojson_info_model]: https://github.com/developmentseed/titiler/blob/2bd1b159a9cf0932ad14e9eabf1e4e66498adbdc/src/titiler/mosaic/titiler/mosaic/factory.py#L130
-[mosaic_model]: https://github.com/developmentseed/cogeo-mosaic/blob/1dc3c873472c8cf7634ad893b9cdc40105ca3874/cogeo_mosaic/mosaic.py#L55-L72
-[mosaic_point]: https://github.com/developmentseed/titiler/blob/2bd1b159a9cf0932ad14e9eabf1e4e66498adbdc/src/titiler/mosaic/titiler/mosaic/models/responses.py#L8-L17
diff --git a/docs/src/api/titiler/core/dependencies.md b/docs/src/api/titiler/core/dependencies.md
index 51ae7afb2..3e4e260f6 100644
--- a/docs/src/api/titiler/core/dependencies.md
+++ b/docs/src/api/titiler/core/dependencies.md
@@ -1,1471 +1,5 @@
-# Module titiler.core.dependencies
 
-Common dependency.
+::: titiler.core.dependencies
+    options:
+      show_source: true
 
-None
-
-## Functions
-
-    
-### ColorMapParams
-
-```python3
-def ColorMapParams(
-    colormap_name: titiler.core.dependencies.ColorMapName = Query(None),
-    colormap: str = Query(None)
-) -> Union[Dict, Sequence, NoneType]
-```
-
-    
-Colormap Dependency.
-
-    
-### DatasetPathParams
-
-```python3
-def DatasetPathParams(
-    url: str = Query(Ellipsis)
-) -> str
-```
-
-    
-Create dataset path from args
-
-    
-### TMSParams
-
-```python3
-def TMSParams(
-    TileMatrixSetId: titiler.core.dependencies.TileMatrixSetName = Query(TileMatrixSetName.WebMercatorQuad)
-) -> morecantile.models.TileMatrixSet
-```
-
-    
-TileMatrixSet Dependency.
-
-    
-### WebMercatorTMSParams
-
-```python3
-def WebMercatorTMSParams(
-    TileMatrixSetId: titiler.core.dependencies.WebMercatorTileMatrixSetName = Query(WebMercatorTileMatrixSetName.WebMercatorQuad)
-) -> morecantile.models.TileMatrixSet
-```
-
-    
-TileMatrixSet Dependency.
-
-## Classes
-
-### AssetsBidxExprParams
-
-```python3
-class AssetsBidxExprParams(
-    assets: Union[List[str], NoneType] = Query(None),
-    expression: Union[str, NoneType] = Query(None),
-    asset_indexes: Union[Sequence[str], NoneType] = Query(None),
-    asset_expression: Union[Sequence[str], NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-asset_expression
-```
-
-```python3
-asset_indexes
-```
-
-```python3
-assets
-```
-
-```python3
-expression
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### AssetsBidxParams
-
-```python3
-class AssetsBidxParams(
-    assets: List[str] = Query(None),
-    asset_indexes: Union[Sequence[str], NoneType] = Query(None),
-    asset_expression: Union[Sequence[str], NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.AssetsParams
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-asset_expression
-```
-
-```python3
-asset_indexes
-```
-
-```python3
-assets
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### AssetsParams
-
-```python3
-class AssetsParams(
-    assets: List[str] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Descendants
-
-* titiler.core.dependencies.AssetsBidxParams
-
-#### Class variables
-
-```python3
-assets
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### BandsExprParams
-
-```python3
-class BandsExprParams(
-    bands: List[str] = Query(None),
-    expression: Union[str, NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.ExpressionParams
-* titiler.core.dependencies.BandsParams
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-bands
-```
-
-```python3
-expression
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### BandsExprParamsOptional
-
-```python3
-class BandsExprParamsOptional(
-    bands: List[str] = Query(None),
-    expression: Union[str, NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.ExpressionParams
-* titiler.core.dependencies.BandsParams
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-bands
-```
-
-```python3
-expression
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### BandsParams
-
-```python3
-class BandsParams(
-    bands: List[str] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Descendants
-
-* titiler.core.dependencies.BandsExprParamsOptional
-* titiler.core.dependencies.BandsExprParams
-
-#### Class variables
-
-```python3
-bands
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### BidxExprParams
-
-```python3
-class BidxExprParams(
-    indexes: Union[List[int], NoneType] = Query(None),
-    expression: Union[str, NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.ExpressionParams
-* titiler.core.dependencies.BidxParams
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-expression
-```
-
-```python3
-indexes
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### BidxParams
-
-```python3
-class BidxParams(
-    indexes: Union[List[int], NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Descendants
-
-* titiler.core.dependencies.BidxExprParams
-
-#### Class variables
-
-```python3
-indexes
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### ColorMapName
-
-```python3
-class ColorMapName(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* enum.Enum
-
-#### Class variables
-
-```python3
-accent
-```
-
-```python3
-accent_r
-```
-
-```python3
-afmhot
-```
-
-```python3
-afmhot_r
-```
-
-```python3
-autumn
-```
-
-```python3
-autumn_r
-```
-
-```python3
-binary
-```
-
-```python3
-binary_r
-```
-
-```python3
-blues
-```
-
-```python3
-blues_r
-```
-
-```python3
-bone
-```
-
-```python3
-bone_r
-```
-
-```python3
-brbg
-```
-
-```python3
-brbg_r
-```
-
-```python3
-brg
-```
-
-```python3
-brg_r
-```
-
-```python3
-bugn
-```
-
-```python3
-bugn_r
-```
-
-```python3
-bupu
-```
-
-```python3
-bupu_r
-```
-
-```python3
-bwr
-```
-
-```python3
-bwr_r
-```
-
-```python3
-cfastie
-```
-
-```python3
-cividis
-```
-
-```python3
-cividis_r
-```
-
-```python3
-cmrmap
-```
-
-```python3
-cmrmap_r
-```
-
-```python3
-cool
-```
-
-```python3
-cool_r
-```
-
-```python3
-coolwarm
-```
-
-```python3
-coolwarm_r
-```
-
-```python3
-copper
-```
-
-```python3
-copper_r
-```
-
-```python3
-cubehelix
-```
-
-```python3
-cubehelix_r
-```
-
-```python3
-dark2
-```
-
-```python3
-dark2_r
-```
-
-```python3
-flag
-```
-
-```python3
-flag_r
-```
-
-```python3
-gist_earth
-```
-
-```python3
-gist_earth_r
-```
-
-```python3
-gist_gray
-```
-
-```python3
-gist_gray_r
-```
-
-```python3
-gist_heat
-```
-
-```python3
-gist_heat_r
-```
-
-```python3
-gist_ncar
-```
-
-```python3
-gist_ncar_r
-```
-
-```python3
-gist_rainbow
-```
-
-```python3
-gist_rainbow_r
-```
-
-```python3
-gist_stern
-```
-
-```python3
-gist_stern_r
-```
-
-```python3
-gist_yarg
-```
-
-```python3
-gist_yarg_r
-```
-
-```python3
-gnbu
-```
-
-```python3
-gnbu_r
-```
-
-```python3
-gnuplot
-```
-
-```python3
-gnuplot2
-```
-
-```python3
-gnuplot2_r
-```
-
-```python3
-gnuplot_r
-```
-
-```python3
-gray
-```
-
-```python3
-gray_r
-```
-
-```python3
-greens
-```
-
-```python3
-greens_r
-```
-
-```python3
-greys
-```
-
-```python3
-greys_r
-```
-
-```python3
-hot
-```
-
-```python3
-hot_r
-```
-
-```python3
-hsv
-```
-
-```python3
-hsv_r
-```
-
-```python3
-inferno
-```
-
-```python3
-inferno_r
-```
-
-```python3
-jet
-```
-
-```python3
-jet_r
-```
-
-```python3
-magma
-```
-
-```python3
-magma_r
-```
-
-```python3
-name
-```
-
-```python3
-nipy_spectral
-```
-
-```python3
-nipy_spectral_r
-```
-
-```python3
-ocean
-```
-
-```python3
-ocean_r
-```
-
-```python3
-oranges
-```
-
-```python3
-oranges_r
-```
-
-```python3
-orrd
-```
-
-```python3
-orrd_r
-```
-
-```python3
-paired
-```
-
-```python3
-paired_r
-```
-
-```python3
-pastel1
-```
-
-```python3
-pastel1_r
-```
-
-```python3
-pastel2
-```
-
-```python3
-pastel2_r
-```
-
-```python3
-pink
-```
-
-```python3
-pink_r
-```
-
-```python3
-piyg
-```
-
-```python3
-piyg_r
-```
-
-```python3
-plasma
-```
-
-```python3
-plasma_r
-```
-
-```python3
-prgn
-```
-
-```python3
-prgn_r
-```
-
-```python3
-prism
-```
-
-```python3
-prism_r
-```
-
-```python3
-pubu
-```
-
-```python3
-pubu_r
-```
-
-```python3
-pubugn
-```
-
-```python3
-pubugn_r
-```
-
-```python3
-puor
-```
-
-```python3
-puor_r
-```
-
-```python3
-purd
-```
-
-```python3
-purd_r
-```
-
-```python3
-purples
-```
-
-```python3
-purples_r
-```
-
-```python3
-rainbow
-```
-
-```python3
-rainbow_r
-```
-
-```python3
-rdbu
-```
-
-```python3
-rdbu_r
-```
-
-```python3
-rdgy
-```
-
-```python3
-rdgy_r
-```
-
-```python3
-rdpu
-```
-
-```python3
-rdpu_r
-```
-
-```python3
-rdylbu
-```
-
-```python3
-rdylbu_r
-```
-
-```python3
-rdylgn
-```
-
-```python3
-rdylgn_r
-```
-
-```python3
-reds
-```
-
-```python3
-reds_r
-```
-
-```python3
-rplumbo
-```
-
-```python3
-schwarzwald
-```
-
-```python3
-seismic
-```
-
-```python3
-seismic_r
-```
-
-```python3
-set1
-```
-
-```python3
-set1_r
-```
-
-```python3
-set2
-```
-
-```python3
-set2_r
-```
-
-```python3
-set3
-```
-
-```python3
-set3_r
-```
-
-```python3
-spectral
-```
-
-```python3
-spectral_r
-```
-
-```python3
-spring
-```
-
-```python3
-spring_r
-```
-
-```python3
-summer
-```
-
-```python3
-summer_r
-```
-
-```python3
-tab10
-```
-
-```python3
-tab10_r
-```
-
-```python3
-tab20
-```
-
-```python3
-tab20_r
-```
-
-```python3
-tab20b
-```
-
-```python3
-tab20b_r
-```
-
-```python3
-tab20c
-```
-
-```python3
-tab20c_r
-```
-
-```python3
-terrain
-```
-
-```python3
-terrain_r
-```
-
-```python3
-twilight
-```
-
-```python3
-twilight_r
-```
-
-```python3
-twilight_shifted
-```
-
-```python3
-twilight_shifted_r
-```
-
-```python3
-value
-```
-
-```python3
-viridis
-```
-
-```python3
-viridis_r
-```
-
-```python3
-winter
-```
-
-```python3
-winter_r
-```
-
-```python3
-wistia
-```
-
-```python3
-wistia_r
-```
-
-```python3
-ylgn
-```
-
-```python3
-ylgn_r
-```
-
-```python3
-ylgnbu
-```
-
-```python3
-ylgnbu_r
-```
-
-```python3
-ylorbr
-```
-
-```python3
-ylorbr_r
-```
-
-```python3
-ylorrd
-```
-
-```python3
-ylorrd_r
-```
-
-### DatasetParams
-
-```python3
-class DatasetParams(
-    nodata: Union[str, int, float, NoneType] = Query(None),
-    unscale: Union[bool, NoneType] = Query(False),
-    resampling_method: titiler.core.dependencies.ResamplingName = Query(ResamplingName.nearest)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-nodata
-```
-
-```python3
-resampling_method
-```
-
-```python3
-unscale
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### DefaultDependency
-
-```python3
-class DefaultDependency(
-    
-)
-```
-
-#### Descendants
-
-* titiler.core.dependencies.BidxParams
-* titiler.core.dependencies.ExpressionParams
-* titiler.core.dependencies.AssetsParams
-* titiler.core.dependencies.AssetsBidxExprParams
-* titiler.core.dependencies.BandsParams
-* titiler.core.dependencies.ImageParams
-* titiler.core.dependencies.DatasetParams
-* titiler.core.dependencies.ImageRenderingParams
-* titiler.core.dependencies.PostProcessParams
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### ExpressionParams
-
-```python3
-class ExpressionParams(
-    expression: Union[str, NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Descendants
-
-* titiler.core.dependencies.BidxExprParams
-* titiler.core.dependencies.BandsExprParamsOptional
-* titiler.core.dependencies.BandsExprParams
-
-#### Class variables
-
-```python3
-expression
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### ImageParams
-
-```python3
-class ImageParams(
-    max_size: Union[int, NoneType] = Query(1024),
-    height: Union[int, NoneType] = Query(None),
-    width: Union[int, NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-height
-```
-
-```python3
-max_size
-```
-
-```python3
-width
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### ImageRenderingParams
-
-```python3
-class ImageRenderingParams(
-    add_mask: bool = Query(True)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-add_mask
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### PostProcessParams
-
-```python3
-class PostProcessParams(
-    in_range: Union[List[str], NoneType] = Query(None),
-    color_formula: Union[str, NoneType] = Query(None)
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.dependencies.DefaultDependency
-
-#### Class variables
-
-```python3
-color_formula
-```
-
-```python3
-in_range
-```
-
-#### Methods
-
-    
-#### keys
-
-```python3
-def keys(
-    self
-)
-```
-
-    
-Return Keys.
-
-### ResamplingName
-
-```python3
-class ResamplingName(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* enum.Enum
-
-#### Class variables
-
-```python3
-average
-```
-
-```python3
-bilinear
-```
-
-```python3
-cubic
-```
-
-```python3
-cubic_spline
-```
-
-```python3
-gauss
-```
-
-```python3
-lanczos
-```
-
-```python3
-max
-```
-
-```python3
-med
-```
-
-```python3
-min
-```
-
-```python3
-mode
-```
-
-```python3
-name
-```
-
-```python3
-nearest
-```
-
-```python3
-q1
-```
-
-```python3
-q3
-```
-
-```python3
-rms
-```
-
-```python3
-sum
-```
-
-```python3
-value
-```
-
-### TileMatrixSetName
-
-```python3
-class TileMatrixSetName(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* enum.Enum
-
-#### Class variables
-
-```python3
-CanadianNAD83_LCC
-```
-
-```python3
-EuropeanETRS89_LAEAQuad
-```
-
-```python3
-LINZAntarticaMapTilegrid
-```
-
-```python3
-NZTM2000
-```
-
-```python3
-NZTM2000Quad
-```
-
-```python3
-UPSAntarcticWGS84Quad
-```
-
-```python3
-UPSArcticWGS84Quad
-```
-
-```python3
-UTM31WGS84Quad
-```
-
-```python3
-WebMercatorQuad
-```
-
-```python3
-WorldCRS84Quad
-```
-
-```python3
-WorldMercatorWGS84Quad
-```
-
-```python3
-name
-```
-
-```python3
-value
-```
-
-### WebMercatorTileMatrixSetName
-
-```python3
-class WebMercatorTileMatrixSetName(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* enum.Enum
-
-#### Class variables
-
-```python3
-WebMercatorQuad
-```
-
-```python3
-name
-```
-
-```python3
-value
-```
\ No newline at end of file
diff --git a/docs/src/api/titiler/core/errors.md b/docs/src/api/titiler/core/errors.md
index 6b897df9c..16fe3296f 100644
--- a/docs/src/api/titiler/core/errors.md
+++ b/docs/src/api/titiler/core/errors.md
@@ -1,162 +1,2 @@
-# Module titiler.core.errors
 
-Titiler error classes.
-
-None
-
-## Variables
-
-```python3
-DEFAULT_STATUS_CODES
-```
-
-```python3
-logger
-```
-
-## Functions
-
-    
-### add_exception_handlers
-
-```python3
-def add_exception_handlers(
-    app: fastapi.applications.FastAPI,
-    status_codes: Dict[Type[Exception], int]
-) -> None
-```
-
-    
-Add exception handlers to the FastAPI app.
-
-    
-### exception_handler_factory
-
-```python3
-def exception_handler_factory(
-    status_code: int
-) -> Callable
-```
-
-    
-Create a FastAPI exception handler from a status code.
-
-## Classes
-
-### BadRequestError
-
-```python3
-class BadRequestError(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.errors.TilerError
-* builtins.Exception
-* builtins.BaseException
-
-#### Class variables
-
-```python3
-args
-```
-
-#### Methods
-
-    
-#### with_traceback
-
-```python3
-def with_traceback(
-    ...
-)
-```
-
-    
-Exception.with_traceback(tb) --
-
-set self.__traceback__ to tb and return self.
-
-### TileNotFoundError
-
-```python3
-class TileNotFoundError(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.errors.TilerError
-* builtins.Exception
-* builtins.BaseException
-
-#### Class variables
-
-```python3
-args
-```
-
-#### Methods
-
-    
-#### with_traceback
-
-```python3
-def with_traceback(
-    ...
-)
-```
-
-    
-Exception.with_traceback(tb) --
-
-set self.__traceback__ to tb and return self.
-
-### TilerError
-
-```python3
-class TilerError(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* builtins.Exception
-* builtins.BaseException
-
-#### Descendants
-
-* titiler.core.errors.TileNotFoundError
-* titiler.core.errors.BadRequestError
-
-#### Class variables
-
-```python3
-args
-```
-
-#### Methods
-
-    
-#### with_traceback
-
-```python3
-def with_traceback(
-    ...
-)
-```
-
-    
-Exception.with_traceback(tb) --
-
-set self.__traceback__ to tb and return self.
\ No newline at end of file
+::: titiler.core.errors
diff --git a/docs/src/api/titiler/core/factory.md b/docs/src/api/titiler/core/factory.md
index 5f6737af5..80ff1f59d 100644
--- a/docs/src/api/titiler/core/factory.md
+++ b/docs/src/api/titiler/core/factory.md
@@ -1,1000 +1,2 @@
-# Module titiler.core.factory
 
-TiTiler Router factories.
-
-None
-
-## Variables
-
-```python3
-img_endpoint_params
-```
-
-```python3
-templates
-```
-
-## Classes
-
-### BaseTilerFactory
-
-```python3
-class BaseTilerFactory(
-    reader: Type[rio_tiler.io.base.BaseReader],
-    reader_options: Dict = <factory>,
-    router: fastapi.routing.APIRouter = <factory>,
-    path_dependency: Callable[..., str] = <function DatasetPathParams at 0x163cb6ca0>,
-    dataset_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.DatasetParams'>,
-    layer_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.BidxExprParams'>,
-    render_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.ImageRenderingParams'>,
-    colormap_dependency: Callable[..., Union[Dict, NoneType]] = <function ColorMapParams at 0x163cb6c10>,
-    process_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.PostProcessParams'>,
-    tms_dependency: Callable[..., morecantile.models.TileMatrixSet] = <function WebMercatorTMSParams at 0x1632ab0d0>,
-    additional_dependency: Callable[..., Dict] = <function BaseTilerFactory.<lambda> at 0x163f42310>,
-    router_prefix: str = '',
-    gdal_config: Dict = <factory>,
-    optional_headers: List[titiler.core.resources.enums.OptionalHeader] = <factory>
-)
-```
-
-#### Descendants
-
-* titiler.core.factory.TilerFactory
-
-#### Class variables
-
-```python3
-dataset_dependency
-```
-
-```python3
-layer_dependency
-```
-
-```python3
-process_dependency
-```
-
-```python3
-render_dependency
-```
-
-```python3
-router_prefix
-```
-
-#### Methods
-
-    
-#### additional_dependency
-
-```python3
-def additional_dependency(
-    
-)
-```
-
-    
-
-    
-#### colormap_dependency
-
-```python3
-def colormap_dependency(
-    colormap_name: titiler.core.dependencies.ColorMapName = Query(None),
-    colormap: str = Query(None)
-) -> Union[Dict, Sequence, NoneType]
-```
-
-    
-Colormap Dependency.
-
-    
-#### path_dependency
-
-```python3
-def path_dependency(
-    url: str = Query(Ellipsis)
-) -> str
-```
-
-    
-Create dataset path from args
-
-    
-#### register_routes
-
-```python3
-def register_routes(
-    self
-)
-```
-
-    
-Register Tiler Routes.
-
-    
-#### tms_dependency
-
-```python3
-def tms_dependency(
-    TileMatrixSetId: titiler.core.dependencies.WebMercatorTileMatrixSetName = Query(WebMercatorTileMatrixSetName.WebMercatorQuad)
-) -> morecantile.models.TileMatrixSet
-```
-
-    
-TileMatrixSet Dependency.
-
-    
-#### url_for
-
-```python3
-def url_for(
-    self,
-    request: starlette.requests.Request,
-    name: str,
-    **path_params: Any
-) -> str
-```
-
-    
-Return full url (with prefix) for a specific endpoint.
-
-### MultiBandTilerFactory
-
-```python3
-class MultiBandTilerFactory(
-    reader: Type[rio_tiler.io.base.MultiBandReader] = <class 'rio_tiler.io.cogeo.COGReader'>,
-    reader_options: Dict = <factory>,
-    router: fastapi.routing.APIRouter = <factory>,
-    path_dependency: Callable[..., str] = <function DatasetPathParams at 0x163cb6ca0>,
-    dataset_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.DatasetParams'>,
-    layer_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.BandsExprParams'>,
-    render_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.ImageRenderingParams'>,
-    colormap_dependency: Callable[..., Union[Dict, NoneType]] = <function ColorMapParams at 0x163cb6c10>,
-    process_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.PostProcessParams'>,
-    tms_dependency: Callable[..., morecantile.models.TileMatrixSet] = <function TMSParams at 0x1639e3310>,
-    additional_dependency: Callable[..., Dict] = <function BaseTilerFactory.<lambda> at 0x163f42310>,
-    router_prefix: str = '',
-    gdal_config: Dict = <factory>,
-    optional_headers: List[titiler.core.resources.enums.OptionalHeader] = <factory>,
-    img_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.ImageParams'>,
-    add_preview: bool = True,
-    add_part: bool = True,
-    add_statistics: bool = True,
-    bands_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.BandsParams'>
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.factory.TilerFactory
-* titiler.core.factory.BaseTilerFactory
-
-#### Class variables
-
-```python3
-add_part
-```
-
-```python3
-add_preview
-```
-
-```python3
-add_statistics
-```
-
-```python3
-bands_dependency
-```
-
-```python3
-dataset_dependency
-```
-
-```python3
-img_dependency
-```
-
-```python3
-layer_dependency
-```
-
-```python3
-process_dependency
-```
-
-```python3
-reader
-```
-
-```python3
-render_dependency
-```
-
-```python3
-router_prefix
-```
-
-#### Methods
-
-    
-#### additional_dependency
-
-```python3
-def additional_dependency(
-    
-)
-```
-
-    
-
-    
-#### bounds
-
-```python3
-def bounds(
-    self
-)
-```
-
-    
-Register /bounds endpoint.
-
-    
-#### colormap_dependency
-
-```python3
-def colormap_dependency(
-    colormap_name: titiler.core.dependencies.ColorMapName = Query(None),
-    colormap: str = Query(None)
-) -> Union[Dict, Sequence, NoneType]
-```
-
-    
-Colormap Dependency.
-
-    
-#### info
-
-```python3
-def info(
-    self
-)
-```
-
-    
-Register /info endpoint.
-
-    
-#### part
-
-```python3
-def part(
-    self
-)
-```
-
-    
-Register /crop endpoint.
-
-    
-#### path_dependency
-
-```python3
-def path_dependency(
-    url: str = Query(Ellipsis)
-) -> str
-```
-
-    
-Create dataset path from args
-
-    
-#### point
-
-```python3
-def point(
-    self
-)
-```
-
-    
-Register /point endpoints.
-
-    
-#### preview
-
-```python3
-def preview(
-    self
-)
-```
-
-    
-Register /preview endpoint.
-
-    
-#### register_routes
-
-```python3
-def register_routes(
-    self
-)
-```
-
-    
-This Method register routes to the router.
-
-Because we wrap the endpoints in a class we cannot define the routes as
-methods (because of the self argument). The HACK is to define routes inside
-the class method and register them after the class initialisation.
-
-    
-#### statistics
-
-```python3
-def statistics(
-    self
-)
-```
-
-    
-add statistics endpoints.
-
-    
-#### tile
-
-```python3
-def tile(
-    self
-)
-```
-
-    
-Register /tiles endpoint.
-
-    
-#### tilejson
-
-```python3
-def tilejson(
-    self
-)
-```
-
-    
-Register /tilejson.json endpoint.
-
-    
-#### tms_dependency
-
-```python3
-def tms_dependency(
-    TileMatrixSetId: titiler.core.dependencies.TileMatrixSetName = Query(TileMatrixSetName.WebMercatorQuad)
-) -> morecantile.models.TileMatrixSet
-```
-
-    
-TileMatrixSet Dependency.
-
-    
-#### url_for
-
-```python3
-def url_for(
-    self,
-    request: starlette.requests.Request,
-    name: str,
-    **path_params: Any
-) -> str
-```
-
-    
-Return full url (with prefix) for a specific endpoint.
-
-    
-#### wmts
-
-```python3
-def wmts(
-    self
-)
-```
-
-    
-Register /wmts endpoint.
-
-### MultiBaseTilerFactory
-
-```python3
-class MultiBaseTilerFactory(
-    reader: Type[rio_tiler.io.base.MultiBaseReader] = <class 'rio_tiler.io.cogeo.COGReader'>,
-    reader_options: Dict = <factory>,
-    router: fastapi.routing.APIRouter = <factory>,
-    path_dependency: Callable[..., str] = <function DatasetPathParams at 0x163cb6ca0>,
-    dataset_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.DatasetParams'>,
-    layer_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.AssetsBidxExprParams'>,
-    render_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.ImageRenderingParams'>,
-    colormap_dependency: Callable[..., Union[Dict, NoneType]] = <function ColorMapParams at 0x163cb6c10>,
-    process_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.PostProcessParams'>,
-    tms_dependency: Callable[..., morecantile.models.TileMatrixSet] = <function TMSParams at 0x1639e3310>,
-    additional_dependency: Callable[..., Dict] = <function BaseTilerFactory.<lambda> at 0x163f42310>,
-    router_prefix: str = '',
-    gdal_config: Dict = <factory>,
-    optional_headers: List[titiler.core.resources.enums.OptionalHeader] = <factory>,
-    img_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.ImageParams'>,
-    add_preview: bool = True,
-    add_part: bool = True,
-    add_statistics: bool = True,
-    assets_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.AssetsParams'>
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.factory.TilerFactory
-* titiler.core.factory.BaseTilerFactory
-
-#### Class variables
-
-```python3
-add_part
-```
-
-```python3
-add_preview
-```
-
-```python3
-add_statistics
-```
-
-```python3
-assets_dependency
-```
-
-```python3
-dataset_dependency
-```
-
-```python3
-img_dependency
-```
-
-```python3
-layer_dependency
-```
-
-```python3
-process_dependency
-```
-
-```python3
-reader
-```
-
-```python3
-render_dependency
-```
-
-```python3
-router_prefix
-```
-
-#### Methods
-
-    
-#### additional_dependency
-
-```python3
-def additional_dependency(
-    
-)
-```
-
-    
-
-    
-#### bounds
-
-```python3
-def bounds(
-    self
-)
-```
-
-    
-Register /bounds endpoint.
-
-    
-#### colormap_dependency
-
-```python3
-def colormap_dependency(
-    colormap_name: titiler.core.dependencies.ColorMapName = Query(None),
-    colormap: str = Query(None)
-) -> Union[Dict, Sequence, NoneType]
-```
-
-    
-Colormap Dependency.
-
-    
-#### info
-
-```python3
-def info(
-    self
-)
-```
-
-    
-Register /info endpoint.
-
-    
-#### part
-
-```python3
-def part(
-    self
-)
-```
-
-    
-Register /crop endpoint.
-
-    
-#### path_dependency
-
-```python3
-def path_dependency(
-    url: str = Query(Ellipsis)
-) -> str
-```
-
-    
-Create dataset path from args
-
-    
-#### point
-
-```python3
-def point(
-    self
-)
-```
-
-    
-Register /point endpoints.
-
-    
-#### preview
-
-```python3
-def preview(
-    self
-)
-```
-
-    
-Register /preview endpoint.
-
-    
-#### register_routes
-
-```python3
-def register_routes(
-    self
-)
-```
-
-    
-This Method register routes to the router.
-
-Because we wrap the endpoints in a class we cannot define the routes as
-methods (because of the self argument). The HACK is to define routes inside
-the class method and register them after the class initialisation.
-
-    
-#### statistics
-
-```python3
-def statistics(
-    self
-)
-```
-
-    
-Register /statistics endpoint.
-
-    
-#### tile
-
-```python3
-def tile(
-    self
-)
-```
-
-    
-Register /tiles endpoint.
-
-    
-#### tilejson
-
-```python3
-def tilejson(
-    self
-)
-```
-
-    
-Register /tilejson.json endpoint.
-
-    
-#### tms_dependency
-
-```python3
-def tms_dependency(
-    TileMatrixSetId: titiler.core.dependencies.TileMatrixSetName = Query(TileMatrixSetName.WebMercatorQuad)
-) -> morecantile.models.TileMatrixSet
-```
-
-    
-TileMatrixSet Dependency.
-
-    
-#### url_for
-
-```python3
-def url_for(
-    self,
-    request: starlette.requests.Request,
-    name: str,
-    **path_params: Any
-) -> str
-```
-
-    
-Return full url (with prefix) for a specific endpoint.
-
-    
-#### wmts
-
-```python3
-def wmts(
-    self
-)
-```
-
-    
-Register /wmts endpoint.
-
-### TMSFactory
-
-```python3
-class TMSFactory(
-    supported_tms: Type[titiler.core.dependencies.TileMatrixSetName] = <enum 'TileMatrixSetName'>,
-    tms_dependency: Callable[..., morecantile.models.TileMatrixSet] = <function TMSParams at 0x1639e3310>,
-    router: fastapi.routing.APIRouter = <factory>,
-    router_prefix: str = ''
-)
-```
-
-#### Class variables
-
-```python3
-router_prefix
-```
-
-```python3
-supported_tms
-```
-
-#### Methods
-
-    
-#### register_routes
-
-```python3
-def register_routes(
-    self
-)
-```
-
-    
-Register TMS endpoint routes.
-
-    
-#### tms_dependency
-
-```python3
-def tms_dependency(
-    TileMatrixSetId: titiler.core.dependencies.TileMatrixSetName = Query(TileMatrixSetName.WebMercatorQuad)
-) -> morecantile.models.TileMatrixSet
-```
-
-    
-TileMatrixSet Dependency.
-
-    
-#### url_for
-
-```python3
-def url_for(
-    self,
-    request: starlette.requests.Request,
-    name: str,
-    **path_params: Any
-) -> str
-```
-
-    
-Return full url (with prefix) for a specific endpoint.
-
-### TilerFactory
-
-```python3
-class TilerFactory(
-    reader: Type[rio_tiler.io.base.BaseReader] = <class 'rio_tiler.io.cogeo.COGReader'>,
-    reader_options: Dict = <factory>,
-    router: fastapi.routing.APIRouter = <factory>,
-    path_dependency: Callable[..., str] = <function DatasetPathParams at 0x163cb6ca0>,
-    dataset_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.DatasetParams'>,
-    layer_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.BidxExprParams'>,
-    render_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.ImageRenderingParams'>,
-    colormap_dependency: Callable[..., Union[Dict, NoneType]] = <function ColorMapParams at 0x163cb6c10>,
-    process_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.PostProcessParams'>,
-    tms_dependency: Callable[..., morecantile.models.TileMatrixSet] = <function TMSParams at 0x1639e3310>,
-    additional_dependency: Callable[..., Dict] = <function BaseTilerFactory.<lambda> at 0x163f42310>,
-    router_prefix: str = '',
-    gdal_config: Dict = <factory>,
-    optional_headers: List[titiler.core.resources.enums.OptionalHeader] = <factory>,
-    img_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.ImageParams'>,
-    add_preview: bool = True,
-    add_part: bool = True,
-    add_statistics: bool = True
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.factory.BaseTilerFactory
-
-#### Descendants
-
-* titiler.core.factory.MultiBaseTilerFactory
-* titiler.core.factory.MultiBandTilerFactory
-
-#### Class variables
-
-```python3
-add_part
-```
-
-```python3
-add_preview
-```
-
-```python3
-add_statistics
-```
-
-```python3
-dataset_dependency
-```
-
-```python3
-img_dependency
-```
-
-```python3
-layer_dependency
-```
-
-```python3
-process_dependency
-```
-
-```python3
-reader
-```
-
-```python3
-render_dependency
-```
-
-```python3
-router_prefix
-```
-
-#### Methods
-
-    
-#### additional_dependency
-
-```python3
-def additional_dependency(
-    
-)
-```
-
-    
-
-    
-#### bounds
-
-```python3
-def bounds(
-    self
-)
-```
-
-    
-Register /bounds endpoint.
-
-    
-#### colormap_dependency
-
-```python3
-def colormap_dependency(
-    colormap_name: titiler.core.dependencies.ColorMapName = Query(None),
-    colormap: str = Query(None)
-) -> Union[Dict, Sequence, NoneType]
-```
-
-    
-Colormap Dependency.
-
-    
-#### info
-
-```python3
-def info(
-    self
-)
-```
-
-    
-Register /info endpoint.
-
-    
-#### part
-
-```python3
-def part(
-    self
-)
-```
-
-    
-Register /crop endpoint.
-
-    
-#### path_dependency
-
-```python3
-def path_dependency(
-    url: str = Query(Ellipsis)
-) -> str
-```
-
-    
-Create dataset path from args
-
-    
-#### point
-
-```python3
-def point(
-    self
-)
-```
-
-    
-Register /point endpoints.
-
-    
-#### preview
-
-```python3
-def preview(
-    self
-)
-```
-
-    
-Register /preview endpoint.
-
-    
-#### register_routes
-
-```python3
-def register_routes(
-    self
-)
-```
-
-    
-This Method register routes to the router.
-
-Because we wrap the endpoints in a class we cannot define the routes as
-methods (because of the self argument). The HACK is to define routes inside
-the class method and register them after the class initialisation.
-
-    
-#### statistics
-
-```python3
-def statistics(
-    self
-)
-```
-
-    
-add statistics endpoints.
-
-    
-#### tile
-
-```python3
-def tile(
-    self
-)
-```
-
-    
-Register /tiles endpoint.
-
-    
-#### tilejson
-
-```python3
-def tilejson(
-    self
-)
-```
-
-    
-Register /tilejson.json endpoint.
-
-    
-#### tms_dependency
-
-```python3
-def tms_dependency(
-    TileMatrixSetId: titiler.core.dependencies.TileMatrixSetName = Query(TileMatrixSetName.WebMercatorQuad)
-) -> morecantile.models.TileMatrixSet
-```
-
-    
-TileMatrixSet Dependency.
-
-    
-#### url_for
-
-```python3
-def url_for(
-    self,
-    request: starlette.requests.Request,
-    name: str,
-    **path_params: Any
-) -> str
-```
-
-    
-Return full url (with prefix) for a specific endpoint.
-
-    
-#### wmts
-
-```python3
-def wmts(
-    self
-)
-```
-
-    
-Register /wmts endpoint.
\ No newline at end of file
+::: titiler.core.factory
diff --git a/docs/src/api/titiler/core/middleware.md b/docs/src/api/titiler/core/middleware.md
new file mode 100644
index 000000000..9c06108b0
--- /dev/null
+++ b/docs/src/api/titiler/core/middleware.md
@@ -0,0 +1,2 @@
+
+::: titiler.core.middleware
diff --git a/docs/src/api/titiler/core/models/OGC.md b/docs/src/api/titiler/core/models/OGC.md
new file mode 100644
index 000000000..a0fcf3bdb
--- /dev/null
+++ b/docs/src/api/titiler/core/models/OGC.md
@@ -0,0 +1,2 @@
+
+::: titiler.core.models.OGC
diff --git a/docs/src/api/titiler/core/models/mapbox.md b/docs/src/api/titiler/core/models/mapbox.md
new file mode 100644
index 000000000..67b9ac6e3
--- /dev/null
+++ b/docs/src/api/titiler/core/models/mapbox.md
@@ -0,0 +1,2 @@
+
+::: titiler.core.models.mapbox
diff --git a/docs/src/api/titiler/core/models/responses.md b/docs/src/api/titiler/core/models/responses.md
new file mode 100644
index 000000000..fc34ecb70
--- /dev/null
+++ b/docs/src/api/titiler/core/models/responses.md
@@ -0,0 +1,2 @@
+
+::: titiler.core.models.responses
diff --git a/docs/src/api/titiler/core/resources/enums.md b/docs/src/api/titiler/core/resources/enums.md
index eb427e10f..1faab5f5d 100644
--- a/docs/src/api/titiler/core/resources/enums.md
+++ b/docs/src/api/titiler/core/resources/enums.md
@@ -1,239 +1,2 @@
-# Module titiler.core.resources.enums
 
-Titiler.core Enums.
-
-None
-
-## Classes
-
-### ImageDriver
-
-```python3
-class ImageDriver(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* builtins.str
-* enum.Enum
-
-#### Class variables
-
-```python3
-jp2
-```
-
-```python3
-jpeg
-```
-
-```python3
-jpg
-```
-
-```python3
-name
-```
-
-```python3
-npy
-```
-
-```python3
-png
-```
-
-```python3
-pngraw
-```
-
-```python3
-tif
-```
-
-```python3
-value
-```
-
-```python3
-webp
-```
-
-### ImageType
-
-```python3
-class ImageType(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* builtins.str
-* enum.Enum
-
-#### Class variables
-
-```python3
-jp2
-```
-
-```python3
-jpeg
-```
-
-```python3
-jpg
-```
-
-```python3
-name
-```
-
-```python3
-npy
-```
-
-```python3
-png
-```
-
-```python3
-pngraw
-```
-
-```python3
-tif
-```
-
-```python3
-value
-```
-
-```python3
-webp
-```
-
-### MediaType
-
-```python3
-class MediaType(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* builtins.str
-* enum.Enum
-
-#### Class variables
-
-```python3
-geojson
-```
-
-```python3
-html
-```
-
-```python3
-jp2
-```
-
-```python3
-jpeg
-```
-
-```python3
-jpg
-```
-
-```python3
-json
-```
-
-```python3
-mvt
-```
-
-```python3
-name
-```
-
-```python3
-npy
-```
-
-```python3
-pbf
-```
-
-```python3
-png
-```
-
-```python3
-pngraw
-```
-
-```python3
-text
-```
-
-```python3
-tif
-```
-
-```python3
-value
-```
-
-```python3
-webp
-```
-
-```python3
-xml
-```
-
-### OptionalHeader
-
-```python3
-class OptionalHeader(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* builtins.str
-* enum.Enum
-
-#### Class variables
-
-```python3
-name
-```
-
-```python3
-server_timing
-```
-
-```python3
-value
-```
-
-```python3
-x_assets
-```
\ No newline at end of file
+::: titiler.core.resources.enums
diff --git a/docs/src/api/titiler/core/resources/responses.md b/docs/src/api/titiler/core/resources/responses.md
new file mode 100644
index 000000000..e3ddaa410
--- /dev/null
+++ b/docs/src/api/titiler/core/resources/responses.md
@@ -0,0 +1,2 @@
+
+::: titiler.core.resources.responses
diff --git a/docs/src/api/titiler/core/routing.md b/docs/src/api/titiler/core/routing.md
index 839b09283..89e89a435 100644
--- a/docs/src/api/titiler/core/routing.md
+++ b/docs/src/api/titiler/core/routing.md
@@ -1,26 +1,2 @@
-# Module titiler.core.routing
 
-Custom routing classes.
-
-None
-
-## Functions
-
-    
-### apiroute_factory
-
-```python3
-def apiroute_factory(
-    env: Union[Dict, NoneType] = None
-) -> Type[fastapi.routing.APIRoute]
-```
-
-    
-Create Custom API Route class with custom Env.
-
-Because we cannot create middleware for specific router we need to create
-a custom APIRoute which add the `rasterio.Env(` block before the endpoint is
-actually called. This way we set the env outside the threads and we make sure
-that event multithreaded Reader will get the environment set.
-
-Note: This has been tested in python 3.6 and 3.7 only.
\ No newline at end of file
+::: titiler.core.routing
diff --git a/docs/src/api/titiler/extensions/cogeo.md b/docs/src/api/titiler/extensions/cogeo.md
new file mode 100644
index 000000000..7c24ed38a
--- /dev/null
+++ b/docs/src/api/titiler/extensions/cogeo.md
@@ -0,0 +1 @@
+::: titiler.extensions.cogeo
diff --git a/docs/src/api/titiler/extensions/stac.md b/docs/src/api/titiler/extensions/stac.md
new file mode 100644
index 000000000..2f930fc6e
--- /dev/null
+++ b/docs/src/api/titiler/extensions/stac.md
@@ -0,0 +1 @@
+::: titiler.extensions.stac
diff --git a/docs/src/api/titiler/extensions/viewer.md b/docs/src/api/titiler/extensions/viewer.md
new file mode 100644
index 000000000..e303253e3
--- /dev/null
+++ b/docs/src/api/titiler/extensions/viewer.md
@@ -0,0 +1 @@
+::: titiler.extensions.viewer
diff --git a/docs/src/api/titiler/extensions/wms.md b/docs/src/api/titiler/extensions/wms.md
new file mode 100644
index 000000000..301e0fbd8
--- /dev/null
+++ b/docs/src/api/titiler/extensions/wms.md
@@ -0,0 +1 @@
+::: titiler.extensions.wms
diff --git a/docs/src/api/titiler/extensions/wmts.md b/docs/src/api/titiler/extensions/wmts.md
new file mode 100644
index 000000000..f300bc2e4
--- /dev/null
+++ b/docs/src/api/titiler/extensions/wmts.md
@@ -0,0 +1 @@
+::: titiler.extensions.wmts
diff --git a/docs/src/api/titiler/mosaic/errors.md b/docs/src/api/titiler/mosaic/errors.md
index 2f3e10c48..e1ef9b87e 100644
--- a/docs/src/api/titiler/mosaic/errors.md
+++ b/docs/src/api/titiler/mosaic/errors.md
@@ -1,11 +1 @@
-# Module titiler.mosaic.errors
-
-Titiler mosaic errors.
-
-None
-
-## Variables
-
-```python3
-MOSAIC_STATUS_CODES
-```
\ No newline at end of file
+::: titiler.mosaic.errors
diff --git a/docs/src/api/titiler/mosaic/factory.md b/docs/src/api/titiler/mosaic/factory.md
index ad00ccce1..cf1ddcc8b 100644
--- a/docs/src/api/titiler/mosaic/factory.md
+++ b/docs/src/api/titiler/mosaic/factory.md
@@ -1,353 +1 @@
-# Module titiler.mosaic.factory
-
-TiTiler.mosaic Router factories.
-
-None
-
-## Variables
-
-```python3
-MAX_THREADS
-```
-
-```python3
-img_endpoint_params
-```
-
-```python3
-mosaic_tms
-```
-
-## Functions
-
-    
-### PixelSelectionParams
-
-```python3
-def PixelSelectionParams(
-    pixel_selection: titiler.mosaic.resources.enums.PixelSelectionMethod = Query(first)
-) -> rio_tiler.mosaic.methods.base.MosaicMethodBase
-```
-
-    
-Returns the mosaic method used to combine datasets together.
-
-## Classes
-
-### MosaicTilerFactory
-
-```python3
-class MosaicTilerFactory(
-    reader: Type[cogeo_mosaic.backends.base.BaseBackend] = <function MosaicBackend at 0x14133d8b0>,
-    router: fastapi.routing.APIRouter = <factory>,
-    path_dependency: Callable[..., Any] = <function DatasetPathParams at 0x145463550>,
-    dataset_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.DatasetParams'>,
-    layer_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.BidxExprParams'>,
-    render_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.ImageRenderingParams'>,
-    colormap_dependency: Callable[..., Union[Dict[int, Tuple[int, int, int, int]], Sequence[Tuple[Tuple[Union[float, int], Union[float, int]], Tuple[int, int, int, int]]], NoneType]] = <function ColorMapParams at 0x1454633a0>,
-    process_dependency: Callable[..., Optional[titiler.core.algorithm.base.BaseAlgorithm]] = <function Algorithms.dependency.<locals>.post_process at 0x146adc670>,
-    reader_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.DefaultDependency'>,
-    environment_dependency: Callable[..., Dict] = <function BaseTilerFactory.<lambda> at 0x146adc5e0>,
-    supported_tms: morecantile.defaults.TileMatrixSets = TileMatrixSets(tms={'WebMercatorQuad': <TileMatrixSet title='Google Maps Compatible for the World' identifier='WebMercatorQuad'>}),
-    default_tms: str = 'WebMercatorQuad',
-    router_prefix: str = '',
-    optional_headers: List[titiler.core.resources.enums.OptionalHeader] = <factory>,
-    route_dependencies: List[Tuple[List[titiler.core.routing.EndpointScope], List[fastapi.params.Depends]]] = <factory>,
-    extensions: List[titiler.core.factory.FactoryExtension] = <factory>,
-    dataset_reader: Union[Type[rio_tiler.io.base.BaseReader], Type[rio_tiler.io.base.MultiBaseReader], Type[rio_tiler.io.base.MultiBandReader]] = <class 'rio_tiler.io.rasterio.Reader'>,
-    backend_dependency: Type[titiler.core.dependencies.DefaultDependency] = <class 'titiler.core.dependencies.DefaultDependency'>,
-    pixel_selection_dependency: Callable[..., rio_tiler.mosaic.methods.base.MosaicMethodBase] = <function PixelSelectionParams at 0x14133d820>,
-    add_viewer: bool = True
-)
-```
-
-#### Ancestors (in MRO)
-
-* titiler.core.factory.BaseTilerFactory
-
-#### Class variables
-
-```python3
-add_viewer
-```
-
-```python3
-backend_dependency
-```
-
-```python3
-dataset_dependency
-```
-
-```python3
-dataset_reader
-```
-
-```python3
-default_tms
-```
-
-```python3
-layer_dependency
-```
-
-```python3
-reader_dependency
-```
-
-```python3
-render_dependency
-```
-
-```python3
-router_prefix
-```
-
-```python3
-supported_tms
-```
-
-#### Methods
-
-    
-#### add_route_dependencies
-
-```python3
-def add_route_dependencies(
-    self,
-    *,
-    scopes: List[titiler.core.routing.EndpointScope],
-    dependencies=typing.List[fastapi.params.Depends]
-)
-```
-
-    
-Add dependencies to routes.
-
-Allows a developer to add dependencies to a route after the route has been defined.
-
-    
-#### assets
-
-```python3
-def assets(
-    self
-)
-```
-
-    
-Register /assets endpoint.
-
-    
-#### bounds
-
-```python3
-def bounds(
-    self
-)
-```
-
-    
-Register /bounds endpoint.
-
-    
-#### colormap_dependency
-
-```python3
-def colormap_dependency(
-    colormap_name: titiler.core.dependencies.ColorMapName = Query(None),
-    colormap: str = Query(None)
-) -> Union[Dict[int, Tuple[int, int, int, int]], Sequence[Tuple[Tuple[Union[float, int], Union[float, int]], Tuple[int, int, int, int]]], NoneType]
-```
-
-    
-Colormap Dependency.
-
-    
-#### environment_dependency
-
-```python3
-def environment_dependency(
-    
-)
-```
-
-    
-
-    
-#### info
-
-```python3
-def info(
-    self
-)
-```
-
-    
-Register /info endpoint
-
-    
-#### map_viewer
-
-```python3
-def map_viewer(
-    self
-)
-```
-
-    
-Register /map endpoint.
-
-    
-#### path_dependency
-
-```python3
-def path_dependency(
-    url: str = Query(Ellipsis)
-) -> str
-```
-
-    
-Create dataset path from args
-
-    
-#### pixel_selection_dependency
-
-```python3
-def pixel_selection_dependency(
-    pixel_selection: titiler.mosaic.resources.enums.PixelSelectionMethod = Query(first)
-) -> rio_tiler.mosaic.methods.base.MosaicMethodBase
-```
-
-    
-Returns the mosaic method used to combine datasets together.
-
-    
-#### point
-
-```python3
-def point(
-    self
-)
-```
-
-    
-Register /point endpoint.
-
-    
-#### process_dependency
-
-```python3
-def process_dependency(
-    algorithm: Literal['hillshade', 'contours', 'normalizedIndex', 'terrarium', 'terrainrgb'] = Query(None),
-    algorithm_params: str = Query(None)
-) -> Optional[titiler.core.algorithm.base.BaseAlgorithm]
-```
-
-    
-Data Post-Processing options.
-
-    
-#### read
-
-```python3
-def read(
-    self
-)
-```
-
-    
-Register / (Get) Read endpoint.
-
-    
-#### reader
-
-```python3
-def reader(
-    input: str,
-    *args: Any,
-    **kwargs: Any
-) -> cogeo_mosaic.backends.base.BaseBackend
-```
-
-    
-Select mosaic backend for input.
-
-    
-#### register_routes
-
-```python3
-def register_routes(
-    self
-)
-```
-
-    
-This Method register routes to the router.
-
-Because we wrap the endpoints in a class we cannot define the routes as
-methods (because of the self argument). The HACK is to define routes inside
-the class method and register them after the class initialization.
-
-    
-#### tile
-
-```python3
-def tile(
-    self
-)
-```
-
-    
-Register /tiles endpoints.
-
-    
-#### tilejson
-
-```python3
-def tilejson(
-    self
-)
-```
-
-    
-Add tilejson endpoint.
-
-    
-#### url_for
-
-```python3
-def url_for(
-    self,
-    request: starlette.requests.Request,
-    name: str,
-    **path_params: Any
-) -> str
-```
-
-    
-Return full url (with prefix) for a specific endpoint.
-
-    
-#### validate
-
-```python3
-def validate(
-    self
-)
-```
-
-    
-Register /validate endpoint.
-
-    
-#### wmts
-
-```python3
-def wmts(
-    self
-)
-```
-
-    
-Add wmts endpoint.
\ No newline at end of file
+::: titiler.mosaic.factory
diff --git a/docs/src/api/titiler/mosaic/models/responses.md b/docs/src/api/titiler/mosaic/models/responses.md
new file mode 100644
index 000000000..2b32fc0c6
--- /dev/null
+++ b/docs/src/api/titiler/mosaic/models/responses.md
@@ -0,0 +1 @@
+::: titiler.mosaic.models.responses
diff --git a/docs/src/api/titiler/mosaic/mosaicjson.md b/docs/src/api/titiler/mosaic/mosaicjson.md
new file mode 100644
index 000000000..a5b2c611f
--- /dev/null
+++ b/docs/src/api/titiler/mosaic/mosaicjson.md
@@ -0,0 +1 @@
+::: titiler.mosaic.extensions.mosaicjson
diff --git a/docs/src/api/titiler/mosaic/resources/enums.md b/docs/src/api/titiler/mosaic/resources/enums.md
deleted file mode 100644
index d25733aeb..000000000
--- a/docs/src/api/titiler/mosaic/resources/enums.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# Module titiler.mosaic.resources.enums
-
-Titiler.mosaic Enums.
-
-None
-
-## Classes
-
-### PixelSelectionMethod
-
-```python3
-class PixelSelectionMethod(
-    /,
-    *args,
-    **kwargs
-)
-```
-
-#### Ancestors (in MRO)
-
-* builtins.str
-* enum.Enum
-
-#### Class variables
-
-```python3
-first
-```
-
-```python3
-highest
-```
-
-```python3
-lowest
-```
-
-```python3
-mean
-```
-
-```python3
-median
-```
-
-```python3
-name
-```
-
-```python3
-stdev
-```
-
-```python3
-value
-```
\ No newline at end of file
diff --git a/docs/src/api/titiler/mosaic/wmts.md b/docs/src/api/titiler/mosaic/wmts.md
new file mode 100644
index 000000000..c82c97050
--- /dev/null
+++ b/docs/src/api/titiler/mosaic/wmts.md
@@ -0,0 +1 @@
+::: titiler.mosaic.extensions.wmts
diff --git a/docs/src/api/titiler/xarray/dependencies.md b/docs/src/api/titiler/xarray/dependencies.md
new file mode 100644
index 000000000..6bb4bf4a6
--- /dev/null
+++ b/docs/src/api/titiler/xarray/dependencies.md
@@ -0,0 +1 @@
+::: titiler.xarray.dependencies
diff --git a/docs/src/api/titiler/xarray/extensions.md b/docs/src/api/titiler/xarray/extensions.md
new file mode 100644
index 000000000..e6b41dc30
--- /dev/null
+++ b/docs/src/api/titiler/xarray/extensions.md
@@ -0,0 +1 @@
+::: titiler.xarray.extensions
diff --git a/docs/src/api/titiler/xarray/factory.md b/docs/src/api/titiler/xarray/factory.md
new file mode 100644
index 000000000..74f2363b4
--- /dev/null
+++ b/docs/src/api/titiler/xarray/factory.md
@@ -0,0 +1 @@
+::: titiler.xarray.factory
diff --git a/docs/src/api/titiler/xarray/io.md b/docs/src/api/titiler/xarray/io.md
new file mode 100644
index 000000000..37ccfec84
--- /dev/null
+++ b/docs/src/api/titiler/xarray/io.md
@@ -0,0 +1 @@
+::: titiler.xarray.io
diff --git a/docs/src/api/titiler/xarray/main.md b/docs/src/api/titiler/xarray/main.md
new file mode 100644
index 000000000..5cf1ac66b
--- /dev/null
+++ b/docs/src/api/titiler/xarray/main.md
@@ -0,0 +1 @@
+::: titiler.xarray.main
diff --git a/docs/src/benchmark.html b/docs/src/benchmark.html
new file mode 100644
index 000000000..9c1d0cb5c
--- /dev/null
+++ b/docs/src/benchmark.html
@@ -0,0 +1,292 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1, user-scalable=yes" />
+    <style>
+      html {
+        font-family: BlinkMacSystemFont,-apple-system,"Segoe UI",Roboto,Oxygen,Ubuntu,Cantarell,"Fira Sans","Droid Sans","Helvetica Neue",Helvetica,Arial,sans-serif;
+        -webkit-font-smoothing: antialiased;
+        background-color: #fff;
+        font-size: 16px;
+      }
+      body {
+        color: #4a4a4a;
+        margin: 8px;
+        font-size: 1em;
+        font-weight: 400;
+      }
+      header {
+        margin-bottom: 8px;
+        display: flex;
+        flex-direction: column;
+      }
+      main {
+        width: 100%;
+        display: flex;
+        flex-direction: column;
+      }
+      a {
+        color: #3273dc;
+        cursor: pointer;
+        text-decoration: none;
+      }
+      a:hover {
+        color: #000;
+      }
+      button {
+        color: #fff;
+        background-color: #3298dc;
+        border-color: transparent;
+        cursor: pointer;
+        text-align: center;
+      }
+      button:hover {
+        background-color: #2793da;
+        flex: none;
+      }
+      .spacer {
+        flex: auto;
+      }
+      .small {
+        font-size: 0.75rem;
+      }
+      footer {
+        margin-top: 16px;
+        display: flex;
+        align-items: center;
+      }
+      .header-label {
+        margin-right: 4px;
+      }
+      .benchmark-set {
+        margin: 8px 0;
+        width: 100%;
+        display: flex;
+        flex-direction: column;
+      }
+      .benchmark-title {
+        font-size: 3rem;
+        font-weight: 600;
+        word-break: break-word;
+        text-align: center;
+      }
+      .benchmark-graphs {
+        display: flex;
+        flex-direction: row;
+        justify-content: space-around;
+        align-items: center;
+        flex-wrap: wrap;
+        width: 100%;
+      }
+      .benchmark-chart {
+        max-width: 1000px;
+      }
+    </style>
+    <title>Benchmarks</title>
+  </head>
+
+  <body>
+    <header id="header">
+      <div class="header-item">
+        <strong class="header-label">Last Update:</strong>
+        <span id="last-update"></span>
+      </div>
+      <div class="header-item">
+        <strong class="header-label">Repository:</strong>
+        <a id="repository-link" rel="noopener"></a>
+      </div>
+    </header>
+    <main id="main"></main>
+    <footer>
+      <button id="dl-button">Download data as JSON</button>
+      <div class="spacer"></div>
+      <div class="small">Powered by <a rel="noopener" href="https://github.com/marketplace/actions/continuous-benchmark">github-action-benchmark</a></div>
+    </footer>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.9.2/Chart.min.js"
+            integrity="sha512-uWTfEVcTAr+NF8RnQix39Vnfd93celVTAjU2pi4LpdrsPLeLg5RYywi5rw9oF8oCQaJ6b2YPALceNbf3kfDJaA=="
+            crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+    <script id="main-script">
+    'use strict';
+      (function() {
+        // Colors from https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+        const toolColors = {
+          cargo: '#dea584',
+          go: '#00add8',
+          benchmarkjs: '#f1e05a',
+          benchmarkluau: '#000080',
+          pytest: '#3572a5',
+          googlecpp: '#f34b7d',
+          catch2: '#f34b7d',
+          julia: '#a270ba',
+          jmh: '#b07219',
+          benchmarkdotnet: '#178600',
+          customBiggerIsBetter: '#38ff38',
+          customSmallerIsBetter: '#ff3838',
+          _: '#333333'
+        };
+
+        function init(data) {
+          function collectBenchesPerTestCase(entries) {
+            const map = new Map();
+            for (const entry of entries) {
+              const {commit, date, tool, benches} = entry;
+              for (const bench of benches) {
+                const result = { commit, date, tool, bench };
+                const arr = map.get(bench.name);
+                if (arr === undefined) {
+                  map.set(bench.name, [result]);
+                } else {
+                  arr.push(result);
+                }
+              }
+            }
+            return map;
+          }
+
+          // Render header
+          document.getElementById('last-update').textContent = new Date(data.lastUpdate).toString();
+          const repoLink = document.getElementById('repository-link');
+          repoLink.href = data.repoUrl;
+          repoLink.textContent = data.repoUrl;
+
+          // Render footer
+          document.getElementById('dl-button').onclick = () => {
+            const dataUrl = 'data:,' + JSON.stringify(data, null, 2);
+            const a = document.createElement('a');
+            a.href = dataUrl;
+            a.download = 'benchmark_data.json';
+            a.click();
+          };
+
+          // Prepare data points for charts
+          return Object.keys(data.entries).map(name => ({
+            name,
+            dataSet: collectBenchesPerTestCase(data.entries[name]),
+          }));
+        }
+
+        function renderAllChars(dataSets) {
+
+          function renderGraph(parent, name, dataset) {
+            const canvas = document.createElement('canvas');
+            canvas.className = 'benchmark-chart';
+            parent.appendChild(canvas);
+
+            const color = toolColors[dataset.length > 0 ? dataset[0].tool : '_'];
+            const data = {
+              labels: dataset.map(d => d.commit.id.slice(0, 7)),
+              datasets: [
+                {
+                  label: name,
+                  data: dataset.map(d => d.bench.value),
+                  borderColor: color,
+                  backgroundColor: color + '60', // Add alpha for #rrggbbaa
+                }
+              ],
+            };
+            const options = {
+              scales: {
+                xAxes: [
+                  {
+                    scaleLabel: {
+                      display: true,
+                      labelString: 'commit',
+                    },
+                  }
+                ],
+                yAxes: [
+                  {
+                    scaleLabel: {
+                      display: true,
+                      labelString: dataset.length > 0 ? dataset[0].bench.unit : '',
+                    },
+                    ticks: {
+                      beginAtZero: true,
+                    }
+                  }
+                ],
+              },
+              tooltips: {
+                callbacks: {
+                  afterTitle: items => {
+                    const {index} = items[0];
+                    const data = dataset[index];
+                    return '\n' + data.commit.message + '\n\n' + data.commit.timestamp + ' committed by @' + data.commit.committer.username + '\n';
+                  },
+                  label: item => {
+                    let label = item.value;
+                    const { range, unit } = dataset[item.index].bench;
+                    label += ' ' + unit;
+                    if (range) {
+                      label += ' (' + range + ')';
+                    }
+                    return label;
+                  },
+                  afterLabel: item => {
+                    const { extra } = dataset[item.index].bench;
+                    return extra ? '\n' + extra : '';
+                  }
+                }
+              },
+              onClick: (_mouseEvent, activeElems) => {
+                if (activeElems.length === 0) {
+                  return;
+                }
+                // XXX: Undocumented. How can we know the index?
+                const index = activeElems[0]._index;
+                const url = dataset[index].commit.url;
+                window.open(url, '_blank');
+              },
+            };
+
+            new Chart(canvas, {
+              type: 'line',
+              data,
+              options,
+            });
+          }
+
+          function renderBenchSet(name, benchSet, main) {
+            const setElem = document.createElement('div');
+            setElem.className = 'benchmark-set';
+            main.appendChild(setElem);
+
+            const nameElem = document.createElement('h1');
+            nameElem.className = 'benchmark-title';
+            nameElem.textContent = name;
+            setElem.appendChild(nameElem);
+
+            const graphsElem = document.createElement('div');
+            graphsElem.className = 'benchmark-graphs';
+            setElem.appendChild(graphsElem);
+
+            for (const [benchName, benches] of benchSet.entries()) {
+              renderGraph(graphsElem, benchName, benches)
+            }
+          }
+
+          const main = document.getElementById('main');
+          for (const {name, dataSet} of dataSets) {
+            renderBenchSet(name, dataSet, main);
+          }
+        }
+
+        fetch('https://raw.githubusercontent.com/developmentseed/titiler/gh-benchmarks/dev/bench/data.js')
+          .then(res => {
+              if (res.ok) return res.text()
+              throw new Error('Network response was not ok.')
+          })
+          .then(data => {
+            const data_json = JSON.parse(data.replace('window.BENCHMARK_DATA = ', ''));
+            renderAllChars(init(data_json))
+            return
+          })
+          .catch(err => {
+            console.log(err)
+          });
+
+      })();
+    </script>
+  </body>
+</html>
diff --git a/docs/src/deployment/aws/ecs.md b/docs/src/deployment/aws/ecs.md
deleted file mode 100644
index d89b98e1a..000000000
--- a/docs/src/deployment/aws/ecs.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# AWS ECS (Fargate) + ALB (Application Load Balancer)
-
-!!! warning
-        When using Fargate or vanilla ECS, you should set the number of worker carefully. Setting too high a number of workers could lead to extra charges due to a bug in fastapi (https://github.com/developmentseed/titiler/issues/119, https://github.com/tiangolo/fastapi/issues/253).
-
-
-## Deploy
-
-The example handles tasks such as generating a docker image and setting up an application load balancer (ALB) and ECS services.
-
-
-1. Install CDK and connect to your AWS account. This step is only necessary once per AWS account.
-
-    ```bash
-    # Download titiler repo
-    $ git clone https://github.com/developmentseed/titiler.git
-
-    # Create a virtual environment
-    python -m pip install --upgrade virtualenv
-    virtualenv .venv
-    source .venv/bin/activate
-
-    # Install CDK dependencies
-    python -m pip install -r requirements-cdk.txt
-
-    # Install NodeJS dependencies
-    npm install
-
-    $ npm run cdk -- bootstrap # Deploys the CDK toolkit stack into an AWS environment
-
-    # or in specific region
-    $ npm run cdk -- bootstrap aws://${AWS_ACCOUNT_ID}/eu-central-1
-    ```
-
-2. Generate CloudFormation template
-
-    ```bash
-    $ npm run cdk -- synth  # Synthesizes and prints the CloudFormation template for this stack
-    ```
-
-3. Update settings (see [intro.md](intro.md))
-
-    ```bash
-    export TITILER_STACK_NAME="mytiler"
-    export TITILER_STACK_STAGE="dev"
-    export TITILER_STACK_MIN_ECS_INSTANCES=10
-    ```
-
-    Available settings for ECS:
-
-    ```python
-    min_ecs_instances: int = 5
-    max_ecs_instances: int = 50
-
-    # CPU value      |   Memory value
-    # 256 (.25 vCPU) | 0.5 GB, 1 GB, 2 GB
-    # 512 (.5 vCPU)  | 1 GB, 2 GB, 3 GB, 4 GB
-    # 1024 (1 vCPU)  | 2 GB, 3 GB, 4 GB, 5 GB, 6 GB, 7 GB, 8 GB
-    # 2048 (2 vCPU)  | Between 4 GB and 16 GB in 1-GB increments
-    # 4096 (4 vCPU)  | Between 8 GB and 30 GB in 1-GB increments
-    task_cpu: int = 256
-    task_memory: int = 512
-
-    # GUNICORN configuration
-    # Ref: https://github.com/developmentseed/titiler/issues/119
-
-    # WORKERS_PER_CORE
-    # This image will check how many CPU cores are available in the current server running your container.
-    # It will set the number of workers to the number of CPU cores multiplied by this value.
-    workers_per_core: int = 1
-
-    # MAX_WORKERS
-    # You can use it to let the image compute the number of workers automatically but making sure it's limited to a maximum.
-    # should depends on `task_cpu`
-    max_workers: int = 1
-
-    # WEB_CONCURRENCY
-    # Override the automatic definition of number of workers.
-    # Set to the number of CPU cores in the current server multiplied by the environment variable WORKERS_PER_CORE.
-    # So, in a server with 2 cores, by default it will be set to 2.
-    web_concurrency: Optional[int]
-    ```
-
-4. Deploy
-
-    ```bash
-    # Deploys the stack(s) mytiler-ecs-dev in cdk/app.py
-    $ npm run cdk -- deploy mytiler-ecs-dev
-    ```
diff --git a/docs/src/deployment/aws/intro.md b/docs/src/deployment/aws/intro.md
index 5130c9fd0..63a52c11d 100644
--- a/docs/src/deployment/aws/intro.md
+++ b/docs/src/deployment/aws/intro.md
@@ -49,42 +49,6 @@ env: Dict = {
 # add S3 bucket where TiTiler could do HEAD and GET Requests
 buckets: List = []
 
-###########################################################################
-# AWS ECS
-# The following settings only apply to AWS ECS deployment
-min_ecs_instances: int = 5
-max_ecs_instances: int = 50
-
-# CPU value      |   Memory value
-# 256 (.25 vCPU) | 0.5 GB, 1 GB, 2 GB
-# 512 (.5 vCPU)  | 1 GB, 2 GB, 3 GB, 4 GB
-# 1024 (1 vCPU)  | 2 GB, 3 GB, 4 GB, 5 GB, 6 GB, 7 GB, 8 GB
-# 2048 (2 vCPU)  | Between 4 GB and 16 GB in 1-GB increments
-# 4096 (4 vCPU)  | Between 8 GB and 30 GB in 1-GB increments
-task_cpu: int = 256
-task_memory: int = 512
-
-# GUNICORN configuration
-# Ref: https://github.com/developmentseed/titiler/issues/119
-
-# WORKERS_PER_CORE
-# This image will check how many CPU cores are available in the current server running your container.
-# It will set the number of workers to the number of CPU cores multiplied by this value.
-workers_per_core: int = 1
-
-# MAX_WORKERS
-# You can use it to let the image compute the number of workers automatically but making sure it's limited to a maximum.
-# should depends on `task_cpu`
-max_workers: int = 1
-
-# WEB_CONCURRENCY
-# Override the automatic definition of number of workers.
-# Set to the number of CPU cores in the current server multiplied by the environment variable WORKERS_PER_CORE.
-# So, in a server with 2 cores, by default it will be set to 2.
-web_concurrency: Optional[int]
-
-image_version: str = "latest"
-
 ###########################################################################
 # AWS LAMBDA
 # The following settings only apply to AWS Lambda deployment
diff --git a/docs/src/deployment/aws/lambda.md b/docs/src/deployment/aws/lambda.md
index b473784cf..9a3d9b3f6 100644
--- a/docs/src/deployment/aws/lambda.md
+++ b/docs/src/deployment/aws/lambda.md
@@ -20,27 +20,19 @@ The Lambda stack is also deployed by the [AWS CDK](https://aws.amazon.com/cdk/)
     git clone https://github.com/developmentseed/titiler.git
     cd titiler/deployment/aws
 
-    # Create a virtual environment
-    python -m pip install --upgrade virtualenv
-    virtualenv .venv
-    source .venv/bin/activate
-
-    # Install CDK dependencies
-    python -m pip install -r requirements-cdk.txt
-
     # Install NodeJS dependencies
-    npm install
+    npm install -g aws-cdk@2.159.1
 
-    $ npm run cdk -- bootstrap # Deploys the CDK toolkit stack into an AWS environment
+    uv run cdk bootstrap # Deploys the CDK toolkit stack into an AWS environment
 
     # or in specific region
-    $ npm run cdk -- bootstrap aws://${AWS_ACCOUNT_ID}/eu-central-1
+    uv run cdk bootstrap aws://${AWS_ACCOUNT_ID}/eu-central-1
     ```
 
 2. Pre-Generate CFN template
 
     ```bash
-    $ npm run cdk -- synth  # Synthesizes and prints the CloudFormation template for this stack
+    uv run cdk synth  # Synthesizes and prints the CloudFormation template for this stack
     ```
 
 3. Update settings (see [intro.md](intro.md))
@@ -65,8 +57,8 @@ The Lambda stack is also deployed by the [AWS CDK](https://aws.amazon.com/cdk/)
 4. Deploy
 
     ```bash
-    $ npm run cdk -- deploy mytiler-lambda-dev # Deploys the stack(s) titiler-lambda-dev in cdk/app.py
+    uv run cdk deploy mytiler-lambda-dev # Deploys the stack(s) titiler-lambda-dev in cdk/app.py
 
     # Deploy in specific region
-    $ AWS_DEFAULT_REGION=eu-central-1 AWS_REGION=eu-central-1 npm run cdk -- deploy mytiler-lambda-dev
+    AWS_DEFAULT_REGION=eu-central-1 AWS_REGION=eu-central-1 uv run cdk -- deploy mytiler-lambda-dev
     ```
diff --git a/docs/src/endpoints/algorithms.md b/docs/src/endpoints/algorithms.md
new file mode 100644
index 000000000..58e375eee
--- /dev/null
+++ b/docs/src/endpoints/algorithms.md
@@ -0,0 +1,116 @@
+In addition to the `/cog`, `/stac` and `/mosaicjson` endpoints, the `titiler.application` package FastAPI application commes with additional metadata endpoints.
+
+# Algorithms
+
+## API
+
+| Method | URL                          | Output          | Description
+| ------ | ---------------------------- |---------------- |--------------
+| `GET`  | `/algorithms`                | JSON            | retrieve the list of available Algorithms
+| `GET`  | `/algorithms/{algorithmId}`  | JSON            | retrieve the metadata of the specified algorithm.
+
+## Description
+
+
+### List Algorithm
+
+`:endpoint:/algorithm` - Get the list of supported TileMatrixSet
+
+```bash
+$ curl https://myendpoint/algorithms | jq
+
+{
+  "hillshade": {
+    "title": "Hillshade",
+    "description": "Create hillshade from DEM dataset.",
+    "inputs": {
+      "nbands": 1
+    },
+    "outputs": {
+      "nbands": 1,
+      "dtype": "uint8",
+      "min": null,
+      "max": null
+    },
+    "parameters": {
+      "azimuth": {
+        "default": 90,
+        "maximum": 360,
+        "minimum": 0,
+        "title": "Azimuth",
+        "type": "integer"
+      },
+      "angle_altitude": {
+        "default": 90.0,
+        "maximum": 90.0,
+        "minimum": -90.0,
+        "title": "Angle Altitude",
+        "type": "number"
+      },
+      "buffer": {
+        "default": 3,
+        "maximum": 99,
+        "minimum": 0,
+        "title": "Buffer",
+        "type": "integer"
+      }
+    }
+  },
+  ...
+}
+```
+
+### Get Algorithm info
+
+`:endpoint:/algorithms/{algorithmId}` - Get the algorithm metadata
+
+- PathParams:
+    - **algorithmId**: algorithm name
+
+```bash
+$ curl http://127.0.0.1:8000/algorithms/contours | jq
+
+{
+  "title": "Contours",
+  "description": "Create contours from DEM dataset.",
+  "inputs": {
+    "nbands": 1
+  },
+  "outputs": {
+    "nbands": 3,
+    "dtype": "uint8",
+    "min": null,
+    "max": null
+  },
+  "parameters": {
+    "increment": {
+      "default": 35,
+      "maximum": 999,
+      "minimum": 0,
+      "title": "Increment",
+      "type": "integer"
+    },
+    "thickness": {
+      "default": 1,
+      "maximum": 10,
+      "minimum": 0,
+      "title": "Thickness",
+      "type": "integer"
+    },
+    "minz": {
+      "default": -12000,
+      "maximum": 99999,
+      "minimum": -99999,
+      "title": "Minz",
+      "type": "integer"
+    },
+    "maxz": {
+      "default": 8000,
+      "maximum": 99999,
+      "minimum": -99999,
+      "title": "Maxz",
+      "type": "integer"
+    }
+  }
+}
+```
diff --git a/docs/src/endpoints/cog.md b/docs/src/endpoints/cog.md
index a1add20b0..13d1761a6 100644
--- a/docs/src/endpoints/cog.md
+++ b/docs/src/endpoints/cog.md
@@ -9,77 +9,88 @@ The `/cog` routes are based on `titiler.core.factory.TilerFactory` but with `cog
 
 | Method | URL                                                                 | Output    | Description
 | ------ | ------------------------------------------------------------------- |---------- |--------------
-| `GET`  | `/cog/bounds`                                                       | JSON      | return dataset's bounds
 | `GET`  | `/cog/info`                                                         | JSON      | return dataset's basic info
 | `GET`  | `/cog/info.geojson`                                                 | GeoJSON   | return dataset's basic info as a GeoJSON feature
 | `GET`  | `/cog/statistics`                                                   | JSON      | return dataset's statistics
 | `POST` | `/cog/statistics`                                                   | GeoJSON   | return dataset's statistics for a GeoJSON
-| `GET`  | `/cog/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`  | image/bin | create a web map tile image from a dataset
-| `GET`  | `/cog[/{TileMatrixSetId}]/tilejson.json`                            | JSON      | return a Mapbox TileJSON document
-| `GET`  | `/cog[/{TileMatrixSetId}]/WMTSCapabilities.xml`                     | XML       | return OGC WMTS Get Capabilities
+| `GET`  | `/cog/tiles`                                                        | JSON      | List of OGC Tilesets available
+| `GET`  | `/cog/tiles/{tileMatrixSetId}`                                      | JSON      | OGC Tileset metadata
+| `GET`  | `/cog/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`    | image/bin | create a web map tile image from a dataset
+| `GET`  | `/cog/{tileMatrixSetId}/map.html`                                   | HTML      | simple map viewer
+| `GET`  | `/cog/{tileMatrixSetId}/tilejson.json`                              | JSON      | return a Mapbox TileJSON document
 | `GET`  | `/cog/point/{lon},{lat}`                                            | JSON      | return pixel values from a dataset
-| `GET`  | `/cog/preview[.{format}]`                                           | image/bin | create a preview image from a dataset
-| `GET`  | `/cog/crop/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin | create an image from part of a dataset
-| `POST` | `/cog/crop[/{width}x{height}][].{format}]`                          | image/bin | create an image from a GeoJSON feature
-| `GET`  | `/cog[/{TileMatrixSetId}]/map`                                      | HTML      | simple map viewer
+| `GET`  | `/cog/bbox/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin | create an image from part of a dataset
+| `POST` | `/cog/feature[/{width}x{height}][.{format}]`                        | image/bin | create an image from a GeoJSON feature
+| `GET`  | `/cog/preview[/{width}x{height}][.{format}]`                        | image/bin | create a preview image from a dataset
+| `GET`  | `/cog/map`                                                          | image/bin | create map image from a dataset
 | `GET`  | `/cog/validate`                                                     | JSON      | validate a COG and return dataset info (from `titiler.extensions.cogValidateExtension`)
 | `GET`  | `/cog/viewer`                                                       | HTML      | demo webpage (from `titiler.extensions.cogViewerExtension`)
 | `GET`  | `/cog/stac`                                                         | GeoJSON   | create STAC Items from a dataset (from `titiler.extensions.stacExtension`)
+| `GET`  | `/cog/WMTSCapabilities.xml`                                         | XML       | return OGC WMTS Get Capabilities (from `titiler.extensions.wmts.wmtsExtension`)
+
 
 ## Description
 
 ### Tiles
 
-`:endpoint:/cog/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`
+`:endpoint:/cog/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`
 
 - PathParams:
-    - **TileMatrixSetId** (str): TileMatrixSet name, default is `WebMercatorQuad`. **Optional**
+    - **tileMatrixSetId** (str): TileMatrixSet name (e.g `WebMercatorQuad`)
     - **z** (int): TMS tile's zoom level.
     - **x** (int): TMS tile's column.
     - **y** (int): TMS tile's row.
-    - **scale** (int): Tile size scale, default is set to 1 (256x256). **Optional**
-    - **format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
+    - **format** (str): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
 
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
+    - **tilesize** (int): overwrite TMS tileWidth x tileHeight with fixed tilesize.
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
     - **colormap_name** (str): rio-tiler color map name.
     - **return_mask** (bool): Add mask to the output data. Default is True.
-    - **buffer** (float): Add buffer on each side of the tile (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **buffer** (float): Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **padding** (int): Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to `0`.
     - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 Example:
 
-- `https://myendpoint/cog/tiles/1/2/3?url=https://somewhere.com/mycog.tif`
-- `https://myendpoint/cog/tiles/1/2/3.jpg?url=https://somewhere.com/mycog.tif&bidx=3&bidx=1&bidx2`
+- `https://myendpoint/cog/tiles/WebMercatorQuad/1/2/3?url=https://somewhere.com/mycog.tif`
+- `https://myendpoint/cog/tiles/WebMercatorQuad/1/2/3.jpg?url=https://somewhere.com/mycog.tif&bidx=3&bidx=1&bidx2`
 - `https://myendpoint/cog/tiles/WorldCRS84Quad/1/2/3@2x.png?url=https://somewhere.com/mycog.tif`
 - `https://myendpoint/cog/tiles/WorldCRS84Quad/1/2/3?url=https://somewhere.com/mycog.tif&bidx=1&rescale=0,1000&colormap_name=cfastie`
 
 ### Preview
 
-`:endpoint:/cog/preview[.{format}]`
+`:endpoint:/cog/preview`
+
+`:endpoint:/cog/preview.{format}`
+
+`:endpoint:/cog/preview/{width}x{height}.{format}`
 
 - PathParams:
-    - **format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
+    - **format** (str, optional): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value. **Also a QueryParam**
+    - **height** (int, optional): Force output image height. **Also a QueryParam**
+    - **width** (int, optional): Force output image width. **Also a QueryParam**
 
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
     - **max_size** (int): Max image size, default is 1024.
-    - **height** (int): Force output image height.
-    - **width** (int): Force output image width.
+
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
@@ -89,35 +100,38 @@ Example:
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 !!! important
-    if **height** and **width** are provided **max_size** will be ignored.
+    if **height** or **width** is provided **max_size** will be ignored.
 
 Example:
 
 - `https://myendpoint/cog/preview?url=https://somewhere.com/mycog.tif`
 - `https://myendpoint/cog/preview.jpg?url=https://somewhere.com/mycog.tif&bidx=3&bidx=1&bidx2`
+- `https://myendpoint/cog/preview/100x100.jpg?url=https://somewhere.com/mycog.tif&bidx=3&bidx=1&bidx2`
 - `https://myendpoint/cog/preview?url=https://somewhere.com/mycog.tif&bidx=1&rescale=0,1000&colormap_name=cfastie`
 
-### Crop / Part
+### Bbox
 
-`:endpoint:/cog/crop/{minx},{miny},{maxx},{maxy}.{format}`
+`:endpoint:/cog/bbox/{minx},{miny},{maxx},{maxy}.{format}`
 
-`:endpoint:/cog/crop/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}`
+`:endpoint:/cog/bbox/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}`
 
 - PathParams:
     - **minx,miny,maxx,maxy** (str): Comma (',') delimited bounding box in WGS84.
-    - **format** (str): Output image format.
-    - **height** (int): Force output image height.
-    - **width** (int): Force output image width.
+    - **format** (str): Output [image format](../user_guide/output_format.md)
+    - **height** (int, optional): Force output image height. **Also a QueryParam**
+    - **width** (int, optional): Force output image width. **Also a QueryParam**
 
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
-    - **coord-crs** (str): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
-    - **max_size** (int): Max image size, default is 1024.
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
+    - **coord_crs** (str): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
+    - **dst_crs** (str): Output Coordinate Reference System. Default to `coord_crs`.
+    - **max_size** (int): Max image size.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
@@ -127,33 +141,66 @@ Example:
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 !!! important
-    if **height** and **width** are provided **max_size** will be ignored.
+    if **height** or **width** is provided **max_size** will be ignored.
 
 Example:
 
-- `https://myendpoint/cog/crop/0,0,10,10.png?url=https://somewhere.com/mycog.tif`
-- `https://myendpoint/cog/crop/0,0,10,10.png?url=https://somewhere.com/mycog.tif&bidx=1&rescale=0,1000&colormap_name=cfastie`
+- `https://myendpoint/cog/bbox/0,0,10,10.png?url=https://somewhere.com/mycog.tif&bidx=1&rescale=0,1000&colormap_name=cfastie`
+- `https://myendpoint/cog/bbox/0,0,10,10/100x100.png?url=https://somewhere.com/mycog.tif`
+
+### OGC Maps API - GetMap
+
+`:endpoint:/cog/map`
+
+- QueryParams:
+    - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
+    - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
+    - **nodata** (str, int, float): Overwrite internal Nodata value.
+    - **unscale** (bool): Apply dataset internal Scale/Offset.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
+    - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
+    - **color_formula** (str): rio-color formula.
+    - **colormap** (str): JSON encoded custom Colormap.
+    - **colormap_name** (str): rio-tiler color map name.
+    - **return_mask** (bool): Add mask to the output data. Default is True.
+    - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
+    - **algorithm_params** (str): JSON encoded algorithm parameters.
+    - **bbox** (str): Comma (',') delimited bounding box.
+    - **bbox-crs** (str, optional): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
+    - **crs** (str, optional): Output Coordinate Reference System. Default to dataset'crs.
+    - **height** (int, optional): Force output image height. **Also a QueryParam**
+    - **width** (int, optional): Force output image width. **Also a QueryParam**
+    - **f** (str): Output [image format](../user_guide/output_format.md)
+
+### Feature
+
+`:endpoint:/cog/feature - [POST]`
 
+`:endpoint:/cog/feature.{format} - [POST]`
 
-`:endpoint:/cog/crop[/{width}x{height}][].{format}] - [POST]`
+`:endpoint:/cog/feature/{width}x{height}.{format} - [POST]`
 
 - Body:
     - **feature** (JSON): A valid GeoJSON feature (Polygon or MultiPolygon)
 
 - PathParams:
-    - **height** (int): Force output image height. **Optional**
-    - **width** (int): Force output image width. **Optional**
-    - **format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
+    - **height** (int, optional): Force output image height. **Also a QueryParam**
+    - **width** (int, optional): Force output image width. **Also a QueryParam**
+    - **format** (str, optional): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value. **Also a QueryParam**
 
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
-    - **coord-crs** (str): Coordinate Reference System of the input geometry coordinates. Default to `epsg:4326`.
-    - **max_size** (int): Max image size, default is 1024.
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
+    - **coord_crs** (str): Coordinate Reference System of the input geometry coordinates. Default to `epsg:4326`.
+    - **dst_crs** (str): Output Coordinate Reference System. Default to `coord_crs`.
+    - **max_size** (int): Max image size.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
@@ -163,15 +210,13 @@ Example:
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 !!! important
-    if **height** and **width** are provided **max_size** will be ignored.
+    if **height** or **width** is provided **max_size** will be ignored.
 
 Example:
 
-- `https://myendpoint/cog/crop?url=https://somewhere.com/mycog.tif`
-- `https://myendpoint/cog/crop.png?url=https://somewhere.com/mycog.tif`
-- `https://myendpoint/cog/crop/100x100.png?url=https://somewhere.com/mycog.tif&bidx=1&rescale=0,1000&colormap_name=cfastie`
-
-Note: if `height` and `width` are provided `max_size` will be ignored.
+- `https://myendpoint/cog/feature?url=https://somewhere.com/mycog.tif`
+- `https://myendpoint/cog/feature.png?url=https://somewhere.com/mycog.tif`
+- `https://myendpoint/cog/feature/100x100.png?url=https://somewhere.com/mycog.tif&bidx=1&rescale=0,1000&colormap_name=cfastie`
 
 ### Point
 
@@ -183,11 +228,12 @@ Note: if `height` and `width` are provided `max_size` will be ignored.
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
-    - **coord-crs** (str): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
+    - **coord_crs** (str): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
 
 Example:
 
@@ -196,98 +242,97 @@ Example:
 
 ### TilesJSON
 
-`:endpoint:/cog[/{TileMatrixSetId}]/tilejson.json` tileJSON document
+`:endpoint:/cog/{tileMatrixSetId}/tilejson.json` tileJSON document
 
 - PathParams:
-    - **TileMatrixSetId**: TileMatrixSet name, default is `WebMercatorQuad`. **Optional**
+    - **tileMatrixSetId** (str): TileMatrixSet name (e.g `WebMercatorQuad`)
 
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
-    - **tile_format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value.
-    - **tile_scale** (int): Tile size scale, default is set to 1 (256x256).
+    - **tile_format** (str): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value.
+    - **tilesize** (int): overwrite TMS tileWidth x tileHeight with fixed tilesize. Default to 512.
     - **minzoom** (int): Overwrite default minzoom.
     - **maxzoom** (int): Overwrite default maxzoom.
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
     - **colormap_name** (str): rio-tiler color map name.
     - **return_mask** (bool): Add mask to the output data. Default is True.
-    - **buffer** (float): Add buffer on each side of the tile (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **buffer** (float): Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **padding** (int): Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to `0`.
     - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 Example:
 
-- `https://myendpoint/cog/tilejson.json?url=https://somewhere.com/mycog.tif`
-- `https://myendpoint/cog/tilejson.json?url=https://somewhere.com/mycog.tif&tile_format=png`
-- `https://myendpoint/cog/WorldCRS84Quad/tilejson.json?url=https://somewhere.com/mycog.tif&tile_scale=2&bidx=1,2,3`
+- `https://myendpoint/cog/WebMercatorQuad/tilejson.json?url=https://somewhere.com/mycog.tif`
+- `https://myendpoint/cog/WebMercatorQuad/tilejson.json?url=https://somewhere.com/mycog.tif&tile_format=png`
+- `https://myendpoint/cog/WorldCRS84Quad/tilejson.json?url=https://somewhere.com/mycog.tif&tilesize=256&bidx=1,2,3`
 
 
 ### Map
 
-`:endpoint:/cog[/{TileMatrixSetId}]/map` Simple viewer
+`:endpoint:/cog/{tileMatrixSetId}/map.html` Simple viewer
 
 - PathParams:
-    - **TileMatrixSetId**: TileMatrixSet name, default is `WebMercatorQuad`. **Optional**
+    - **tileMatrixSetId** (str): TileMatrixSet name (e.g `WebMercatorQuad`)
 
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
-    - **tile_format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value.
-    - **tile_scale** (int): Tile size scale, default is set to 1 (256x256).
+    - **tile_format** (str): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value.
+    - **tilesize** (int): overwrite TMS tileWidth x tileHeight with fixed tilesize. Defaults to 256.
     - **minzoom** (int): Overwrite default minzoom.
     - **maxzoom** (int): Overwrite default maxzoom.
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
     - **colormap_name** (str): rio-tiler color map name.
     - **return_mask** (bool): Add mask to the output data. Default is True.
-    - **buffer** (float): Add buffer on each side of the tile (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **buffer** (float): Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **padding** (int): Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to `0`.
     - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 Example:
 
-- `https://myendpoint/cog/map?url=https://somewhere.com/mycog.tif`
-- `https://myendpoint/cog/map?url=https://somewhere.com/mycog.tif&tile_format=png`
-- `https://myendpoint/cog/WebMercatorQuad/map?url=https://somewhere.com/mycog.tif&tile_scale=2&bidx=1,2,3`
+- `https://myendpoint/cog/WebMercatorQuad/map.html?url=https://somewhere.com/mycog.tif`
+- `https://myendpoint/cog/WebMercatorQuad/map.html?url=https://somewhere.com/mycog.tif&tile_format=png`
+- `https://myendpoint/cog/WorldCRS84Quad/map.html?url=https://somewhere.com/mycog.tif&tilesize=512&bidx=1,2,3`
 
 
-### Bounds
+### Info
 
-`:endpoint:/cog/bounds` general image bounds
+`:endpoint:/cog/info` general raster info
 
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
 
 Example:
 
-- `https://myendpoint/cog/bounds?url=https://somewhere.com/mycog.tif`
-
-### Info
-
-`:endpoint:/cog/info` general raster info
+- `https://myendpoint/cog/info?url=https://somewhere.com/mycog.tif`
 
 `:endpoint:/cog/info.geojson` general raster info as a GeoJSON feature
 
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
+    - **crs** (str): Geographic Coordinate Reference System. Default to `epsg:4326`.
 
 Example:
 
-- `https://myendpoint/cog/info?url=https://somewhere.com/mycog.tif`
 - `https://myendpoint/cog/info.geojson?url=https://somewhere.com/mycog.tif`
 
-
 ### Statistics
 
 Advanced raster statistics
@@ -297,13 +342,15 @@ Advanced raster statistics
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
     - **max_size** (int): Max image size from which to calculate statistics, default is 1024.
     - **height** (int): Force image height from which to calculate statistics.
     - **width** (int): Force image width from which to calculate statistics.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
+    - **algorithm_params** (str): JSON encoded algorithm parameters.
     - **categorical** (bool): Return statistics for categorical dataset, default is false.
     - **c** (array[float]): Pixels values for categories.
     - **p** (array[int]): Percentile values.
@@ -322,14 +369,18 @@ Example:
 - QueryParams:
     - **url** (str): Cloud Optimized GeoTIFF URL. **Required**
     - **bidx** (array[int]): Dataset band indexes (e.g `bidx=1`, `bidx=1&bidx=2&bidx=3`).
-    - **expression** (str): rio-tiler's band math expression (e.g B1/B2).
-    - **coord-crs** (str): Coordinate Reference System of the input geometry coordinates. Default to `epsg:4326`.
-    - **max_size** (int): Max image size from which to calculate statistics, default is 1024.
+    - **expression** (str): rio-tiler's band math expression (e.g `expression=b1/b2`).
+    - **coord_crs** (str): Coordinate Reference System of the input geometry coordinates. Default to `epsg:4326`.
+    - **dst_crs** (str): Output Coordinate Reference System. Default to `coord_crs`.
+    - **max_size** (int): Max image size from which to calculate statistics.
     - **height** (int): Force image height from which to calculate statistics.
     - **width** (int): Force image width from which to calculate statistics.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
+    - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
+    - **algorithm_params** (str): JSON encoded algorithm parameters.
     - **categorical** (bool): Return statistics for categorical dataset, default is false.
     - **c** (array[float]): Pixels values for categories.
     - **p** (array[int]): Percentile values.
diff --git a/docs/src/endpoints/colormaps.md b/docs/src/endpoints/colormaps.md
new file mode 100644
index 000000000..8ad4f10db
--- /dev/null
+++ b/docs/src/endpoints/colormaps.md
@@ -0,0 +1,96 @@
+In addition to the `/cog`, `/stac` and `/mosaicjson` endpoints, the `titiler.application` package FastAPI application commes with additional metadata endpoints.
+
+# Algorithms
+
+## API
+
+| Method | URL                          | Output | Description
+| ------ | ---------------------------- |--------|--------------
+| `GET`  | `/colorMaps`                 | JSON   | retrieve the list of available colorMaps
+| `GET`  | `/colorMaps/{colorMapId}`    | JSON   | retrieve the metadata or image of the specified colorMap.
+
+## Description
+
+
+### List colormaps
+
+`:endpoint:/colorMaps` - Get the list of supported ColorMaps
+
+```bash
+$ curl https://myendpoint/colorMaps | jq
+
+{
+  "colorMaps": [
+    "dense_r",
+    "delta",
+    ...
+  ],
+  "links": [
+    {
+      "href": "http://myendpoint/colorMaps",
+      "rel": "self",
+      "type": "application/json",
+      "title": "List of available colormaps"
+    },
+    {
+      "href": "http://myendpoint/colorMaps/{colorMapId}",
+      "rel": "data",
+      "type": "application/json",
+      "templated": true,
+      "title": "Retrieve colormap metadata"
+    },
+    {
+      "href": "http://myendpoint/colorMaps/{colorMapId}?format=png",
+      "rel": "data",
+      "type": "image/png",
+      "templated": true,
+      "title": "Retrieve colormap as image"
+    }
+  ]
+}
+```
+
+### Get ColorMap metadata or as image
+
+`:endpoint:/colorMaps/{colorMapId}` - Get the ColorMap metadata or image
+
+- PathParams:
+    - **colorMapId**: colormap name
+
+- QueryParams:
+    - **format** (str): output image format (PNG/JPEG...). Defaults to JSON output.
+    - **orientation** (["vertical", "horizontal"]): image orientation. Defaults to `horizontal`.
+    - **height** (int): output image height. Default to 20px for horizontal or 256px for vertical.
+    - **width** (int): output image width. Defaults to 256px for horizontal or 20px for vertical.
+
+```bash
+$ curl http://myendpoint/colorMaps/viridis | jq
+
+{
+  "0": [
+    68,
+    1,
+    84,
+    255
+  ],
+  ...
+  "255": [
+    253,
+    231,
+    36,
+    255
+  ]
+}
+```
+
+```
+curl http://myendpoint/colorMaps/viridis?format=png
+```
+
+```
+curl http://myendpoint/colorMaps/viridis?format=png&orientation=vertical
+```
+
+```
+curl http://myendpoint/colorMaps/viridis?format=png&orientation=vertical&width=100&height=1000
+```
diff --git a/docs/src/endpoints/mosaic.md b/docs/src/endpoints/mosaic.md
index 47537129c..47334e12f 100644
--- a/docs/src/endpoints/mosaic.md
+++ b/docs/src/endpoints/mosaic.md
@@ -9,18 +9,20 @@ Read Mosaic Info/Metadata and create Web map Tiles from a multiple COG. The `mos
 
 | Method | URL                                                                        | Output    | Description
 | ------ | -------------------------------------------------------------------------- |---------- |--------------
-| `GET`  | `/mosaicjson/`                                                             | JSON      | return a MosaicJSON document
-| `GET`  | `/mosaicjson/bounds`                                                       | JSON      | return mosaic's bounds
 | `GET`  | `/mosaicjson/info`                                                         | JSON      | return mosaic's basic info
 | `GET`  | `/mosaicjson/info.geojson`                                                 | GeoJSON   | return mosaic's basic info as a GeoJSON feature
-| `GET`  | `/mosaicjson/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`  | image/bin | create a web map tile image from mosaic assets
-| `GET`  | `/mosaicjson[/{TileMatrixSetId}]/tilejson.json`                            | JSON      | return a Mapbox TileJSON document
-| `GET`  | `/mosaicjson[/{TileMatrixSetId}]/WMTSCapabilities.xml`                       | XML       | return OGC WMTS Get Capabilities
+| `GET`  | `/mosaicjson/tiles`                                                        | JSON      | List of OGC Tilesets available
+| `GET`  | `/mosaicjson/tiles/{tileMatrixSetId}`                                      | JSON      | OGC Tileset metadata
+| `GET`  | `/mosaicjson/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`    | image/bin | create a web map tile image from mosaic assets
+| `GET`  | `/mosaicjson/{tileMatrixSetId}/map.html`                                   | HTML      | simple map viewer
+| `GET`  | `/mosaicjson/{tileMatrixSetId}/tilejson.json`                              | JSON      | return a Mapbox TileJSON document
 | `GET`  | `/mosaicjson/point/{lon},{lat}`                                            | JSON      | return pixel value from a mosaic assets
-| `GET`  | `/mosaicjson/{z}/{x}/{y}/assets`                                           | JSON      | return list of assets intersecting a XYZ tile
-| `GET`  | `/mosaicjson/{lon},{lat}/assets`                                           | JSON      | return list of assets intersecting a point
-| `GET`  | `/mosaicjson/{minx},{miny},{maxx},{maxy}/assets`                           | JSON      | return list of assets intersecting a bounding box
-| `GET`  | `/mosaicjson[/{TileMatrixSetId}]/map`                                      | HTML      | simple map viewer
+| `GET`  | `/mosaicjson/tiles/{tileMatrixSetId}/{z}/{x}/{y}/assets`                   | JSON      | return list of assets intersecting a XYZ tile
+| `GET`  | `/mosaicjson/point/{lon},{lat}/assets`                                     | JSON      | return list of assets intersecting a point
+| `GET`  | `/mosaicjson/bbox/{minx},{miny},{maxx},{maxy}/assets`                      | JSON      | return list of assets intersecting a bounding box
+| `GET`  | `/mosaicjson/`                                                             | JSON      | return a MosaicJSON document (from titiler.mosaic.extensions.mosaicjson.MosaicJSONExtension)
+| `GET`  | `/mosaicjson/validate`                                                     | JSON      | validate a MosaicJSON document (from titiler.mosaic.extensions.mosaicjson.MosaicJSONExtension)
+| `GET`  | `/mosaicjson/WMTSCapabilities.xml`                                         | XML       | return OGC WMTS Get Capabilities (from titiler.mosaic.extensions.wmts.wmtsExtension)
 
 ## Description
 
diff --git a/docs/src/endpoints/stac.md b/docs/src/endpoints/stac.md
index b70a9700d..656a2ab77 100644
--- a/docs/src/endpoints/stac.md
+++ b/docs/src/endpoints/stac.md
@@ -10,83 +10,86 @@ The `/stac` routes are based on `titiler.core.factory.MultiBaseTilerFactory` but
 | Method | URL                                                                  | Output    | Description
 | ------ | -------------------------------------------------------------------- |---------- |--------------
 | `GET`  | `/stac/assets`                                                       | JSON      | return available assets within the STAC item
-| `GET`  | `/stac/bounds`                                                       | JSON      | return STAC item bounds
 | `GET`  | `/stac/info`                                                         | JSON      | return asset's basic info
 | `GET`  | `/stac/info.geojson`                                                 | GeoJSON   | return asset's basic info as a GeoJSON feature
 | `GET`  | `/stac/asset_statistics`                                             | JSON      | return per asset statistics
 | `GET`  | `/stac/statistics`                                                   | JSON      | return asset's statistics
 | `POST` | `/stac/statistics`                                                   | GeoJSON   | return asset's statistics for a GeoJSON
-| `GET`  | `/stac/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`  | image/bin | create a web map tile image from assets
-| `GET`  | `/stac[/{TileMatrixSetId}]/tilejson.json`                            | JSON      | return a Mapbox TileJSON document
-| `GET`  | `/stac[/{TileMatrixSetId}]/WMTSCapabilities.xml`                       | XML       | return OGC WMTS Get Capabilities
+| `GET`  | `/stac/tiles`                                                        | JSON      | List of OGC Tilesets available
+| `GET`  | `/stac/tiles/{tileMatrixSetId}`                                      | JSON      | OGC Tileset metadata
+| `GET`  | `/stac/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`    | image/bin | create a web map tile image from assets
+| `GET`  | `/stac/{tileMatrixSetId}/map.html`                                   | HTML      | simple map viewer
+| `GET`  | `/stac/{tileMatrixSetId}/tilejson.json`                              | JSON      | return a Mapbox TileJSON document
 | `GET`  | `/stac/point/{lon},{lat}`                                            | JSON      | return pixel value from assets
-| `GET`  | `/stac/preview[.{format}]`                                           | image/bin | create a preview image from assets
-| `GET`  | `/stac/crop/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin | create an image from part of assets
-| `POST` | `/stac/crop[/{width}x{height}][].{format}]`                          | image/bin | create an image from a geojson covering the assets
-| `GET`  | `/stac[/{TileMatrixSetId}]/map`                                      | HTML      | simple map viewer
+| `GET`  | `/stac/bbox/{minx},{miny},{maxx},{maxy}[/{width}x{height}].{format}` | image/bin | create an image from part of assets
+| `POST` | `/stac/feature[/{width}x{height}][.{format}]`                        | image/bin | create an image from a geojson covering the assets
+| `GET`  | `/stac/preview[/{width}x{height}][.{format}]`                        | image/bin | create a preview image from assets
 | `GET`  | `/stac/viewer`                                                       | HTML      | demo webpage (from `titiler.extensions.stacViewerExtension`)
+| `GET`  | `/stac/WMTSCapabilities.xml`                                         | XML       | return OGC WMTS Get Capabilities (from `titiler.extensions.wmts.wmtsExtension`)
 
 ## Description
 
 ### Tiles
 
-`:endpoint:/stac/tiles[/{TileMatrixSetId}]/{z}/{x}/{y}[@{scale}x][.{format}]`
+`:endpoint:/stac/tiles/{tileMatrixSetId}/{z}/{x}/{y}[.{format}]`
 
 - PathParams:
-    - **TileMatrixSetId** (str): TileMatrixSet name, default is `WebMercatorQuad`. **Optional**
+    - **tileMatrixSetId** (str): TileMatrixSet name (e.g `WebMercatorQuad`)
     - **z** (int): TMS tile's zoom level.
     - **x** (int): TMS tile's column.
     - **y** (int): TMS tile's row.
-    - **scale** (int): Tile size scale, default is set to 1 (256x256). **Optional**
-    - **format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
+    - **format** (str): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
+    - **tilesize** (int): overwrite TMS tileWidth x tileHeight with fixed tilesize.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
     - **colormap_name** (str): rio-tiler color map name.
     - **return_mask** (bool): Add mask to the output data. Default is True.
-    - **buffer** (float): Add buffer on each side of the tile (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **buffer** (float): Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **padding** (int): Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to `0`.
     - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
-!!! important
-    **assets** OR **expression** is required
-
 Example:
 
-- `https://myendpoint/stac/tiles/1/2/3?url=https://somewhere.com/item.json&assets=B01&assets=B00`
-- `https://myendpoint/stac/tiles/1/2/3.jpg?url=https://somewhere.com/item.json&assets=B01`
-- `https://myendpoint/stac/tiles/WorldCRS84Quad/1/2/3@2x.png?url=https://somewhere.com/item.json&assets=B01`
-- `https://myendpoint/stac/tiles/WorldCRS84Quad/1/2/3?url=https://somewhere.com/item.json&expression=B01/B02&rescale=0,1000&colormap_name=cfastie`
+- `https://myendpoint/stac/tiles/WebMercatorQuad/1/2/3?url=https://somewhere.com/item.json&assets=B01&assets=B00`
+- `https://myendpoint/stac/tiles/WebMercatorQuad/1/2/3.jpg?url=https://somewhere.com/item.json&assets=B01`
+- `https://myendpoint/stac/tiles/WorldCRS84Quad/1/2/3?url=https://somewhere.com/item.json&assets=B01&assets=B02expression=b1/b2&rescale=0,1000&colormap_name=cfastie`
 
 ### Preview
 
-`:endpoint:/stac/preview[.{format}]`
+`:endpoint:/stac/preview`
+
+`:endpoint:/stac/preview/.{format}`
+
+`:endpoint:/stac/preview/{width}x{height}.{format}`
 
 - PathParams:
-    - **format**: Output image format, default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
+    - **format** (str, optional): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value. **Also a QueryParam**
+    - **height** (int, optional): Force output image height. **Also a QueryParam**
+    - **width** (int, optional): Force output image width. **Also a QueryParam**
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
     - **max_size** (int): Max image size, default is 1024.
-    - **height** (int): Force output image height.
-    - **width** (int): Force output image width.
+    - **dst_crs** (str): Output Coordinate Reference System. Default to dataset's CRS.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
@@ -96,39 +99,39 @@ Example:
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 !!! important
-    - **assets** OR **expression** is required
-
-    - if **height** and **width** are provided **max_size** will be ignored.
+    - if **height** or **width** is provided **max_size** will be ignored.
 
 Example:
 
 - `https://myendpoint/stac/preview?url=https://somewhere.com/item.json&assets=B01`
 - `https://myendpoint/stac/preview.jpg?url=https://somewhere.com/item.json&assets=B01`
-- `https://myendpoint/stac/preview?url=https://somewhere.com/item.json&assets=B01&rescale=0,1000&colormap_name=cfastie`
+- `https://myendpoint/stac/preview/100x100.jpg?url=https://somewhere.com/item.json&assets=B01`
+- `https://myendpoint/stac/preview?url=https://somewhere.com/item.json&assets=B01&assets=B02expression=b1/b2&rescale=0,1000&colormap_name=cfastie`
 
-### Crop / Part
+### Bbox
 
-`:endpoint:/stac/crop/{minx},{miny},{maxx},{maxy}.{format}`
+`:endpoint:/stac/bbox/{minx},{miny},{maxx},{maxy}.{format}`
 
-`:endpoint:/stac/crop/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}`
+`:endpoint:/stac/bbox/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}`
 
 - PathParams:
     - **minx,miny,maxx,maxy** (str): Comma (',') delimited bounding box in WGS84.
-    - **height** (int): Force output image height. **Optional**
-    - **width** (int): Force output image width. **Optional**
-    - **format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
+    - **format** (str): Output [image format](../user_guide/output_format.md).
+    - **height** (int, optional): Force output image height. **Also a QueryParam**
+    - **width** (int, optional): Force output image width. **Also a QueryParam**
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
-    - **coord-crs** (str): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
-    - **max_size** (int): Max image size, default is 1024.
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
+    - **coord_crs** (str): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
+    - **dst_crs** (str): Output Coordinate Reference System. Default to `coord_crs`.
+    - **max_size** (int): Max image size.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
@@ -138,36 +141,69 @@ Example:
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 !!! important
-    - **assets** OR **expression** is required
-
-    - if **height** and **width** are provided **max_size** will be ignored.
+    - if **height** or **width** is provided **max_size** will be ignored.
 
 Example:
 
-- `https://myendpoint/stac/crop/0,0,10,10.png?url=https://somewhere.com/item.json&assets=B01`
-- `https://myendpoint/stac/crop/0,0,10,10.png?url=https://somewhere.com/item.json&assets=B01&rescale=0,1000&colormap_name=cfastie`
+- `https://myendpoint/stac/bbox/0,0,10,10.png?url=https://somewhere.com/item.json&assets=B01`
+- `https://myendpoint/stac/bbox/0,0,10,10/100x100.png?url=https://somewhere.com/item.json&assets=B01`
+- `https://myendpoint/stac/bbox/0,0,10,10.png?url=https://somewhere.com/item.json&assets=B01&assets=B02expression=b1/b2&rescale=0,1000&colormap_name=cfastie`
+
+### OGC Maps API - GetMap
+
+`:endpoint:/stac/map`
+
+- QueryParams:
+    - **url** (str): STAC Item URL. **Required**
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
+    - **nodata** (str, int, float): Overwrite internal Nodata value.
+    - **unscale** (bool): Apply dataset internal Scale/Offset.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
+    - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
+    - **color_formula** (str): rio-color formula.
+    - **colormap** (str): JSON encoded custom Colormap.
+    - **colormap_name** (str): rio-tiler color map name.
+    - **return_mask** (bool): Add mask to the output data. Default is True.
+    - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
+    - **algorithm_params** (str): JSON encoded algorithm parameters.
+    - **bbox** (str): Comma (',') delimited bounding box.
+    - **bbox-crs** (str, optional): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
+    - **crs** (str, optional): Output Coordinate Reference System. Default to dataset'crs.
+    - **height** (int, optional): Force output image height. **Also a QueryParam**
+    - **width** (int, optional): Force output image width. **Also a QueryParam**
+    - **f** (str): Output [image format](../user_guide/output_format.md)
+
+### Feature
+
+`:endpoint:/stac/feature - [POST]`
+
+`:endpoint:/stac/feature.{format} - [POST]`
 
-`:endpoint:/stac/crop[/{width}x{height}][].{format}] - [POST]`
+`:endpoint:/stac/feature/{width}x{height}.{format} - [POST]`
 
 - Body:
     - **feature** (JSON): A valid GeoJSON feature (Polygon or MultiPolygon)
 
 - PathParams:
-    - **height** (int): Force output image height. **Optional**
-    - **width** (int): Force output image width. **Optional**
-    - **format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value. **Optional**
+    - **format** (str, optional): Output [image format](../user_guide/output_format.md). **Also a QueryParam**
+    - **height** (int, optional): Force output image height. **Also a QueryParam**
+    - **width** (int, optional): Force output image width. **Also a QueryParam**
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
-    - **coord-crs** (str): Coordinate Reference System of the input geometry coordinates. Default to `epsg:4326`.
-    - **max_size** (int): Max image size, default is 1024.
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
+    - **coord_crs** (str): Coordinate Reference System of the input geometry coordinates. Default to `epsg:4326`.
+    - **dst_crs** (str): Output Coordinate Reference System. Default to `coord_crs`.
+    - **max_size** (int): Max image size.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
@@ -177,15 +213,13 @@ Example:
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
 !!! important
-    - **assets** OR **expression** is required
-
-    - if **height** and **width** are provided **max_size** will be ignored.
+    - if **height** or **width** is provided **max_size** will be ignored.
 
 Example:
 
-- `https://myendpoint/stac/crop?url=https://somewhere.com/item.json&assets=B01`
-- `https://myendpoint/stac/crop.png?url=https://somewhere.com/item.json&assets=B01`
-- `https://myendpoint/stac/crop/100x100.png?url=https://somewhere.com/item.json&assets=B01&rescale=0,1000&colormap_name=cfastie`
+- `https://myendpoint/stac/feature?url=https://somewhere.com/item.json&assets=B01`
+- `https://myendpoint/stac/feature.png?url=https://somewhere.com/item.json&assets=B01`
+- `https://myendpoint/stac/feature/100x100.png?url=https://somewhere.com/item.json&assets=B01&rescale=0,1000&colormap_name=cfastie`
 
 ### Point
 
@@ -196,17 +230,14 @@ Example:
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
     - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
-    - **coord-crs** (str): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
+    - **coord_crs** (str): Coordinate Reference System of the input coordinates. Default to `epsg:4326`.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
-
-!!! important
-    **assets** OR **expression** is required
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
 
 Example:
 
@@ -214,91 +245,75 @@ Example:
 
 ### TilesJSON
 
-`:endpoint:/stac[/{TileMatrixSetId}]/tilejson.json` tileJSON document
+`:endpoint:/stac/{tileMatrixSetId}/tilejson.json` tileJSON document
 
 - PathParams:
-    - **TileMatrixSetId**: TileMatrixSet name, default is `WebMercatorQuad`.
+    - **tileMatrixSetId** (str): TileMatrixSet name (e.g `WebMercatorQuad`)
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
-    - **tile_format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value.
-    - **tile_scale** (int): Tile size scale, default is set to 1 (256x256).
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
+    - **tile_format** (str): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value.
+    - **tilesize** (int): overwrite TMS tileWidth x tileHeight with fixed tilesize. Defaults to 512.
     - **minzoom** (int): Overwrite default minzoom.
     - **maxzoom** (int): Overwrite default maxzoom.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
     - **colormap_name** (str): rio-tiler color map name.
     - **return_mask** (bool): Add mask to the output data. Default is True.
-    - **buffer** (float): Add buffer on each side of the tile (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **buffer** (float): Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **padding** (int): Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to `0`.
     - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
-!!! important
-    **assets** OR **expression** is required
-
 Example:
 
-- `https://myendpoint/stac/tilejson.json?url=https://somewhere.com/item.json&assets=B01`
-- `https://myendpoint/stac/tilejson.json?url=https://somewhere.com/item.json&assets=B01&tile_format=png`
-- `https://myendpoint/stac/WorldCRS84Quad/tilejson.json?url=https://somewhere.com/item.json&tile_scale=2&expression=B01/B02`
+- `https://myendpoint/stac/WebMercatorQuad/tilejson.json?url=https://somewhere.com/item.json&assets=B01`
+- `https://myendpoint/stac/WebMercatorQuad/tilejson.json?url=https://somewhere.com/item.json&assets=B01&tile_format=png`
+- `https://myendpoint/stac/WorldCRS84Quad/tilejson.json?url=https://somewhere.com/item.json&tilesize=256&assets=B01&assets=B02&expression=b1/b2`
 
 ### Map
 
-`:endpoint:/stac[/{TileMatrixSetId}]/map`  Simple viewer
+`:endpoint:/stac/{tileMatrixSetId}/map.html`  Simple viewer
 
 - PathParams:
-    - **TileMatrixSetId**: TileMatrixSet name, default is `WebMercatorQuad`. **Optional**
+    - **tileMatrixSetId** (str): TileMatrixSet name (e.g `WebMercatorQuad`)
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
-    - **tile_format** (str): Output image format, default is set to None and will be either JPEG or PNG depending on masked value.
-    - **tile_scale** (int): Tile size scale, default is set to 1 (256x256).
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
+    - **tile_format** (str): Output [image format](../user_guide/output_format.md), default is set to None and will be either JPEG or PNG depending on masked value.
+    - **tilesize** (int): overwrite TMS tileWidth x tileHeight with fixed tilesize. Defaults to 256.
     - **minzoom** (int): Overwrite default minzoom.
     - **maxzoom** (int): Overwrite default maxzoom.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
     - **rescale** (array[str]): Comma (',') delimited Min,Max range (e.g `rescale=0,1000`, `rescale=0,1000&rescale=0,3000&rescale=0,2000`).
     - **color_formula** (str): rio-color formula.
     - **colormap** (str): JSON encoded custom Colormap.
     - **colormap_name** (str): rio-tiler color map name.
     - **return_mask** (bool): Add mask to the output data. Default is True.
-    - **buffer** (float): Add buffer on each side of the tile (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **buffer** (float): Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).
+    - **padding** (int): Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to `0`.
     - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
     - **algorithm_params** (str): JSON encoded algorithm parameters.
 
-!!! important
-    **assets** OR **expression** is required
-
-Example:
-
-- `https://myendpoint/stac/tilejson.json?url=https://somewhere.com/item.json&assets=B01`
-- `https://myendpoint/stac/tilejson.json?url=https://somewhere.com/item.json&assets=B01&tile_format=png`
-- `https://myendpoint/stac/WorldCRS84Quad/tilejson.json?url=https://somewhere.com/item.json&tile_scale=2&expression=B01/B02`
-
-
-### Bounds
-
-`:endpoint:/stac/bounds` - Return the bounds of the STAC item.
-
-- QueryParams:
-    - **url** (str): STAC Item URL. **Required**
-
 Example:
 
-- `https://myendpoint/stac/bounds?url=https://somewhere.com/item.json`
+- `https://myendpoint/stac/WebMercatorQuad/tilejson.json?url=https://somewhere.com/item.json&assets=B01`
+- `https://myendpoint/stac/WebMercatorQuad/tilejson.json?url=https://somewhere.com/item.json&assets=B01&tile_format=png`
+- `https://myendpoint/stac/WorldCRS84Quad/tilejson.json?url=https://somewhere.com/item.json&tilesize=512&expression=B01/B02`
 
 
 ### Info
@@ -307,22 +322,26 @@ Example:
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names. Default to all available assets.
+    - **assets** (array[str]): asset names. **Required**
 
 Example:
 
 - `https://myendpoint/stac/info?url=https://somewhere.com/item.json&assets=B01`
 
+!!! note
+    
+    Use `assets=:all:` to use all available assets
+
 `:endpoint:/stac/info.geojson` - Return basic info on STAC item's COG as a GeoJSON feature
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names. Default to all available assets.
-
-Example:
-
-- `https://myendpoint/stac/info.geojson?url=https://somewhere.com/item.json&assets=B01`
+    - **assets** (array[str]): asset names. **Required**
+    - **crs** (str): Geographic Coordinate Reference System. Default to `epsg:4326`.
 
+!!! note
+    
+    Use `assets=:all:` to use all available assets
 
 `:endpoint:/stac/assets` - Return the list of available assets
 
@@ -336,15 +355,13 @@ Example:
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names. Default to all available assets.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
-    - **asset_expression** (array[str]): Per asset band math expression (e.g `Asset1|b1\*b2`).
+    - **assets** (array[str]): asset names. **Required**
     - **max_size** (int): Max image size from which to calculate statistics, default is 1024.
     - **height** (int): Force image height from which to calculate statistics.
     - **width** (int): Force image width from which to calculate statistics.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
     - **categorical** (bool): Return statistics for categorical dataset, default is false.
     - **c** (array[float]): Pixels values for categories.
     - **p** (array[int]): Percentile values.
@@ -355,21 +372,25 @@ Example:
 
 - `https://myendpoint/stac/statistics?url=https://somewhere.com/item.json&assets=B01&categorical=true&c=1&c=2&c=3&p=2&p98`
 
+!!! note
+    
+    Use `assets=:all:` to use all available assets
 
 `:endpoint:/stac/statistics - [GET]`
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names. Default to all available assets.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
     - **max_size** (int): Max image size from which to calculate statistics, default is 1024.
     - **height** (int): Force image height from which to calculate statistics.
     - **width** (int): Force image width from which to calculate statistics.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
+    - **algorithm_params** (str): JSON encoded algorithm parameters.
     - **categorical** (bool): Return statistics for categorical dataset, default is false.
     - **c** (array[float]): Pixels values for categories.
     - **p** (array[int]): Percentile values.
@@ -380,6 +401,9 @@ Example:
 
 - `https://myendpoint/stac/statistics?url=https://somewhere.com/item.json&assets=B01&categorical=true&c=1&c=2&c=3&p=2&p98`
 
+!!! note
+    
+    Use `assets=:all:` to use all available assets
 
 `:endpoint:/stac/statistics - [POST]`
 
@@ -388,17 +412,20 @@ Example:
 
 - QueryParams:
     - **url** (str): STAC Item URL. **Required**
-    - **assets** (array[str]): asset names. Default to all available assets.
-    - **expression** (str): rio-tiler's math expression with asset names (e.g `Asset1_b1/Asset2_b1`).
-    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset, so expression `Asset1/Asset2` can be passed.
-    - **asset_bidx** (array[str]): Per asset band math expression (e.g `Asset1|1,2,3`).
-    - **coord-crs** (str): Coordinate Reference System of the input geometry coordinates. Default to `epsg:4326`.
-    - **max_size** (int): Max image size from which to calculate statistics, default is 1024.
+    - **assets** (array[str]): asset names. **Required**
+    - **expression** (str): rio-tiler's math expression (e.g `b1/b2`).
+    - **asset_as_band** (bool): tell rio-tiler that each asset is a 1 band dataset.
+    - **coord_crs** (str): Coordinate Reference System of the input geometry coordinates. Default to `epsg:4326`.
+    - **dst_crs** (str): Output Coordinate Reference System. Default to `coord_crs`.
+    - **max_size** (int): Max image size from which to calculate statistics.
     - **height** (int): Force image height from which to calculate statistics.
     - **width** (int): Force image width from which to calculate statistics.
     - **nodata** (str, int, float): Overwrite internal Nodata value.
     - **unscale** (bool): Apply dataset internal Scale/Offset.
-    - **resampling** (str): rasterio resampling method. Default is `nearest`.
+    - **resampling** (str): RasterIO resampling algorithm. Defaults to `nearest`.
+    - **reproject** (str): WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.
+    - **algorithm** (str): Custom algorithm name (e.g `hillshade`).
+    - **algorithm_params** (str): JSON encoded algorithm parameters.
     - **categorical** (bool): Return statistics for categorical dataset, default is false.
     - **c** (array[float]): Pixels values for categories.
     - **p** (array[int]): Percentile values.
@@ -409,6 +436,10 @@ Example:
 
 - `https://myendpoint/stac/statistics?url=https://somewhere.com/item.json&assets=B01&categorical=true&c=1&c=2&c=3&p=2&p98`
 
+!!! note
+    
+    Use `assets=:all:` to use all available assets
+
 
 ### Viewer
 
diff --git a/docs/src/endpoints/tms.md b/docs/src/endpoints/tms.md
index 41cd57516..3a634b682 100644
--- a/docs/src/endpoints/tms.md
+++ b/docs/src/endpoints/tms.md
@@ -1,24 +1,14 @@
-The `titiler.application` package comes with a full FastAPI application with COG, STAC and MosaicJSON supports.
 
-# TileMatrixSets
-
-The `tms` router extend the default `titiler.core.factory.TMSFactory`, adding some custom TileMatrixSets.
-
-```python
-from fastapi import FastAPI
-from titiler.application.routers.tms import tms
-
-app = FastAPI()
-app.include_router(tms.router, tags=["TileMatrixSets"])
-```
+In addition to the `/cog`, `/stac` and `/mosaicjson` endpoints, the `titiler.application` package FastAPI application comes with additional metadata endpoints.
 
+# TileMatrixSets
 
 ## API
 
 | Method | URL                                 | Output    | Description
 | ------ | ----------------------------------- |---------- |--------------
 | `GET`  | `/tileMatrixSets`                   | JSON      | return the list of supported TileMatrixSet
-| `GET`  | `/tileMatrixSets/{TileMatrixSetId}` | JSON      | return the TileMatrixSet JSON document
+| `GET`  | `/tileMatrixSets/{tileMatrixSetId}` | JSON      | return the TileMatrixSet JSON document
 
 ## Description
 
@@ -50,10 +40,10 @@ $ curl https://myendpoint/tileMatrixSets | jq
 
 ### Get TMS info
 
-`:endpoint:/tileMatrixSets/{TileMatrixSetId}` - Get the TileMatrixSet JSON document
+`:endpoint:/tileMatrixSets/{tileMatrixSetId}` - Get the TileMatrixSet JSON document
 
 - PathParams:
-    - **TileMatrixSetId**: TileMatrixSet name
+    - **tileMatrixSetId**: TileMatrixSet name
 
 ```bash
 $ curl http://127.0.0.1:8000/tileMatrixSets/WebMercatorQuad | jq
diff --git a/docs/src/examples/code/create_gdal_wmts_extension.md b/docs/src/examples/code/create_gdal_wmts_extension.md
index 4a687c84d..396127538 100644
--- a/docs/src/examples/code/create_gdal_wmts_extension.md
+++ b/docs/src/examples/code/create_gdal_wmts_extension.md
@@ -29,19 +29,7 @@ class gdalwmtsExtension(FactoryExtension):
         """Register endpoint to the tiler factory."""
 
         @factory.router.get(
-            "/wmts.xml",
-            response_class=XMLResponse,
-            responses={
-                200: {
-                    "description": "GDAL WMTS service description XML file",
-                    "content": {
-                        "application/xml": {},
-                    },
-                },
-            },
-        )
-        @factory.router.get(
-            "/{TileMatrixSetId}/wmts.xml",
+            "/{tileMatrixSetId}/wmts.xml",
             response_class=XMLResponse,
             responses={
                 200: {
@@ -54,9 +42,8 @@ class gdalwmtsExtension(FactoryExtension):
         )
         def gdal_wmts(
             request: Request,
-            TileMatrixSetId: Literal[tuple(factory.supported_tms.list())] = Query(  # type: ignore
-                factory.default_tms,
-                description=f"TileMatrixSet Name (default: '{factory.default_tms}')",
+            tileMatrixSetId: Literal[tuple(factory.supported_tms.list())] = Path(  # type: ignore
+                description="TileMatrixSet Name",
             ),
             url: str = Depends(factory.path_dependency),  # noqa
             bandscount: int = Query(
@@ -74,7 +61,7 @@ class gdalwmtsExtension(FactoryExtension):
         ):
             """Return a GDAL WMTS Service description."""
             route_params = {
-                "TileMatrixSetId": TileMatrixSetId,
+                "tileMatrixSetId": tileMatrixSetId,
             }
             wmts_url = factory.url_for(request, "wmts", **route_params)
 
@@ -151,7 +138,7 @@ add_exception_handlers(app, DEFAULT_STATUS_CODES)
 ```python
 from rio_tiler.io import Reader
 
-with Reader("http://0.0.0.0/wmts.xml?url=file.tif&bidx=1&bandscount=1&datatype=float32&tile_format=tif") as src:
+with Reader("http://0.0.0.0/WebMercatorQuad/wmts.xml?url=file.tif&bidx=1&bandscount=1&datatype=float32&tile_format=tif") as src:
     im = src.preview()
 ```
 
diff --git a/docs/src/examples/code/img/example_custom_layers_docs.png b/docs/src/examples/code/img/example_custom_layers_docs.png
new file mode 100644
index 000000000..b7176a650
Binary files /dev/null and b/docs/src/examples/code/img/example_custom_layers_docs.png differ
diff --git a/docs/src/examples/code/img/example_custom_layers_preview.png b/docs/src/examples/code/img/example_custom_layers_preview.png
new file mode 100644
index 000000000..f646d61c8
Binary files /dev/null and b/docs/src/examples/code/img/example_custom_layers_preview.png differ
diff --git a/docs/src/examples/code/img/stac_xarray_docs.png b/docs/src/examples/code/img/stac_xarray_docs.png
new file mode 100644
index 000000000..662f4ce82
Binary files /dev/null and b/docs/src/examples/code/img/stac_xarray_docs.png differ
diff --git a/docs/src/examples/code/img/stac_xarray_map.png b/docs/src/examples/code/img/stac_xarray_map.png
new file mode 100644
index 000000000..136d67a02
Binary files /dev/null and b/docs/src/examples/code/img/stac_xarray_map.png differ
diff --git a/docs/src/examples/code/img/stac_xarray_tile.png b/docs/src/examples/code/img/stac_xarray_tile.png
new file mode 100644
index 000000000..81cc36782
Binary files /dev/null and b/docs/src/examples/code/img/stac_xarray_tile.png differ
diff --git a/docs/src/examples/code/mosaic_from_urls.md b/docs/src/examples/code/mosaic_from_urls.md
index 28f9e5913..31d8a1948 100644
--- a/docs/src/examples/code/mosaic_from_urls.md
+++ b/docs/src/examples/code/mosaic_from_urls.md
@@ -20,30 +20,24 @@ app/backends.py
 from typing import Type, List, Tuple, Dict, Union
 
 import attr
-from rio_tiler.io import BaseReader, COGReader, MultiBandReader, MultiBaseReader
+from rio_tiler.io import BaseReader, Reader, MultiBaseReader
 from rio_tiler.constants import WEB_MERCATOR_TMS, WGS84_CRS
+from rio_tiler.mosaic.backend import BaseBackend
 from rasterio.crs import CRS
 from morecantile import TileMatrixSet
 
-from cogeo_mosaic.backends.base import BaseBackend
-from cogeo_mosaic.mosaic import MosaicJSON
-
 
 @attr.s
 class MultiFilesBackend(BaseBackend):
 
-    input: List[str] = attr.ib()
-
-    reader: Union[
-        Type[BaseReader],
-        Type[MultiBaseReader],
-        Type[MultiBandReader],
-    ] = attr.ib(default=COGReader)
-    reader_options: Dict = attr.ib(factory=dict)
+    input: list[str] = attr.ib()
+    tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
 
-    geographic_crs: CRS = attr.ib(default=WGS84_CRS)
+    reader: type[BaseReader] | type[MultiBaseReader] = (
+        attr.ib(default=Reader)
+    )
+    reader_options: dict = attr.ib(factory=dict)
 
-    tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
     minzoom: int = attr.ib(default=0)
     maxzoom: int = attr.ib(default=30)
 
@@ -53,51 +47,33 @@ class MultiFilesBackend(BaseBackend):
     )
     crs: CRS = attr.ib(init=False, default=WGS84_CRS)
 
-    # mosaic_def is outside the __init__ method
-    mosaic_def: MosaicJSON = attr.ib(init=False)
-
-    _backend_name = "MultiFiles"
-
-    def __attrs_post_init__(self):
-        """Post Init."""
-        # Construct a FAKE/Empty mosaicJSON
-        # mosaic_def has to be defined.
-        self.mosaic_def = MosaicJSON(
-            mosaicjson="0.0.2",
-            name="it's fake but it's ok",
-            minzoom=self.minzoom,
-            maxzoom=self.maxzoom,
-            tiles=[]  # we set `tiles` to an empty list.
-        )
-
-    def write(self, overwrite: bool = True):
-        """This method is not used but is required by the abstract class."""
-        pass
-
-    def update(self):
-        """We overwrite the default method."""
-        pass
-
-    def _read(self) -> MosaicJSON:
-        """This method is not used but is required by the abstract class."""
-        pass
-
-    def assets_for_tile(self, x: int, y: int, z: int) -> List[str]:
+    def assets_for_tile(self, x: int, y: int, z: int) -> list[str]:
         """Retrieve assets for tile."""
         return self.get_assets()
 
-    def assets_for_point(self, lng: float, lat: float) -> List[str]:
+    def assets_for_point(self, lng: float, lat: float) -> list[str]:
         """Retrieve assets for point."""
         return self.get_assets()
 
-    def get_assets(self) -> List[str]:
+    def assets_for_bbox(
+        self,
+        left: float,
+        bottom: float,
+        right: float,
+        top: float,
+        coord_crs: CRS | None = None,
+        **kwargs,
+    ) -> list[str]:
+        """Retrieve assets for bbox."""
+        return self.get_assets()
+
+    def get_assets(self) -> list[str]:
         """assets are just files we give in path"""
         return self.input
 
     @property
     def _quadkeys(self) -> List[str]:
         return []
-
 ```
 
 2 - Create endpoints
@@ -105,7 +81,7 @@ class MultiFilesBackend(BaseBackend):
 ```python
 """routes.
 
-app/router.py
+app/routers.py
 
 """
 
@@ -136,7 +112,7 @@ def DatasetPathParams(url: str = Query(..., description="Dataset URL")) -> List[
     return url.split(",")
 
 
-mosaic = MosaicTiler(reader=MultiFilesBackend, path_dependency=DatasetPathParams)
+mosaic = MosaicTiler(backend=MultiFilesBackend, path_dependency=DatasetPathParams)
 
 ```
 
diff --git a/docs/src/examples/code/tiler_for_sentinel2.md b/docs/src/examples/code/tiler_for_sentinel2.md
deleted file mode 100644
index d0e0256c3..000000000
--- a/docs/src/examples/code/tiler_for_sentinel2.md
+++ /dev/null
@@ -1,244 +0,0 @@
-**Goal**: Create a dynamic tiler for Sentinel-2 (using AWS Public Dataset)
-
-**requirements**: titiler.core, titiler.mosaic, rio-tiler-pds
-
-Note: See https://github.com/developmentseed/titiler-pds for a end-to-end implementation
-
-### Sentinel 2
-
-Thanks to Digital Earth Africa and in collaboration with Sinergise, Element 84, Amazon Web Services (AWS) and the Committee on Earth Observation Satellites (CEOS), Sentinel 2 (Level 2) data over Africa, usually stored as JPEG2000, has been translated to COG. More importantly, a STAC database and API has been set up.
-
-https://www.digitalearthafrica.org/news/operational-and-ready-use-satellite-data-now-available-across-africa
-
-The API is provided by [@element84](https://www.element84.com) and follows the latest specification: https://earth-search.aws.element84.com/v0
-
-
-```python
-"""Sentinel 2 (COG) Tiler."""
-
-from titiler.core.factory import MultiBandTilerFactory
-from titiler.core.dependencies import BandsExprParams
-from titiler.mosaic.factory import MosaicTilerFactory
-
-from rio_tiler_pds.sentinel.aws import S2COGReader
-from rio_tiler_pds.sentinel.utils import s2_sceneid_parser
-
-from fastapi import FastAPI, Query
-
-
-def CustomPathParams(
-    sceneid: str = Query(..., description="Sentinel 2 Sceneid.")
-):
-    """Create dataset path from args"""
-    assert s2_sceneid_parser(sceneid)  # Makes sure the sceneid is valid
-    return sceneid
-
-
-app = FastAPI()
-
-scene_tiler = MultiBandTilerFactory(reader=S2COGReader, path_dependency=CustomPathParams, router_prefix="scenes")
-app.include_router(scene_tiler.router, prefix="/scenes", tags=["scenes"])
-
-mosaic_tiler = MosaicTilerFactory(
-    router_prefix="mosaic",
-    dataset_reader=S2COGReader,
-    layer_dependency=BandsExprParams,
-)
-app.include_router(mosaic_tiler.router, prefix="/mosaic", tags=["mosaic"])
-```
-
-
-### How to
-
-1. Search for Data
-```python
-import os
-import json
-import base64
-import httpx
-import datetime
-import itertools
-import urllib.parse
-import pathlib
-
-from io import BytesIO
-from functools import partial
-from concurrent import futures
-
-from rasterio.plot import reshape_as_image
-from rasterio.features import bounds as featureBounds
-
-# Endpoint variables
-titiler_endpoint = "http://127.0.0.1:8000"
-stac_endpoint = "https://earth-search.aws.element84.com/v0/search"
-
-# Make sure both are up
-assert httpx.get(f"{titiler_endpoint}/docs").status_code == 200
-assert httpx.get(stac_endpoint).status_code == 200
-
-geojson = {
-  "type": "FeatureCollection",
-  "features": [
-    {
-      "type": "Feature",
-      "properties": {},
-      "geometry": {
-        "type": "Polygon",
-        "coordinates": [
-          [
-            [
-              -2.83447265625,
-              4.12728532324537
-            ],
-            [
-              2.120361328125,
-              4.12728532324537
-            ],
-            [
-              2.120361328125,
-              8.254982704877875
-            ],
-            [
-              -2.83447265625,
-              8.254982704877875
-            ],
-            [
-              -2.83447265625,
-              4.12728532324537
-            ]
-          ]
-        ]
-      }
-    }
-  ]
-}
-
-bounds = featureBounds(geojson)
-
-start = datetime.datetime.strptime("2019-01-01", "%Y-%m-%d").strftime("%Y-%m-%dT00:00:00Z")
-end = datetime.datetime.strptime("2019-12-11", "%Y-%m-%d").strftime("%Y-%m-%dT23:59:59Z")
-
-# POST body
-query = {
-    "collections": ["sentinel-s2-l2a-cogs"],
-    "datetime": f"{start}/{end}",
-    "query": {
-        "eo:cloud_cover": {
-            "lt": 3
-        },
-        "sentinel:data_coverage": {
-            "gt": 10
-        }
-    },
-    "intersects": geojson["features"][0]["geometry"],
-    "limit": 1000,
-    "fields": {
-      'include': ['id', 'properties.datetime', 'properties.eo:cloud_cover'],  # This will limit the size of returned body
-      'exclude': ['assets', 'links']  # This will limit the size of returned body
-    },
-    "sortby": [
-        {
-            "field": "properties.eo:cloud_cover",
-            "direction": "desc"
-        },
-    ]
-}
-
-# POST Headers
-headers = {
-    "Content-Type": "application/json",
-    "Accept-Encoding": "gzip",
-    "Accept": "application/geo+json",
-}
-
-data = httpx.post(stac_endpoint, headers=headers, json=query).json()
-print("Results context:")
-print(data["context"])
-
-sceneid = [f["id"] for f in data["features"]]
-cloudcover = [f["properties"]["eo:cloud_cover"] for f in data["features"]]
-dates = [f["properties"]["datetime"][0:10] for f in data["features"]]
-```
-
-2. Get TileJSON
-```python
-# Fetch TileJSON
-# For this example we use the first `sceneid` returned from the STAC API
-# and we sent the Bands to B04,B03,B02 which are red,green,blue
-data = httpx.get(f"{titiler_endpoint}/scenes/tilejson.json?sceneid={sceneid[4]}&bands=B04&bands=B03&bands=B02&rescale=0,2000").json()
-print(data)
-```
-
-3. Mosaic
-
-```python
-from cogeo_mosaic.backends import MosaicBackend
-from typing import Dict, List, Sequence, Optional
-from pygeos import polygons
-import mercantile
-
-# Simple Mosaic
-def custom_accessor(feature):
-    """Return feature identifier."""
-    return feature["id"]
-
-with MosaicBackend(
-    "stac+https://earth-search.aws.element84.com/v0/search",
-    query,
-    minzoom=8,
-    maxzoom=15,
-    mosaic_options={"accessor": custom_accessor},
-) as mosaic:
-    print(mosaic.metadata)
-    mosaic_doc = mosaic.mosaic_def.dict(exclude_none=True)
-
-# Optimized Mosaic
-def optimized_filter(
-    tile: mercantile.Tile,  # noqa
-    dataset: Sequence[Dict],
-    geoms: Sequence[polygons],
-    minimum_tile_cover=None,  # noqa
-    tile_cover_sort=False,  # noqa
-    maximum_items_per_tile: Optional[int] = None,
-) -> List:
-    """Optimized filter that keeps only one item per grid ID."""
-    gridid: List[str] = []
-    selected_dataset: List[Dict] = []
-
-    for item in dataset:
-        grid = item["id"].split("_")[1]
-        if grid not in gridid:
-            gridid.append(grid)
-            selected_dataset.append(item)
-
-    dataset = selected_dataset
-
-    indices = list(range(len(dataset)))
-    if maximum_items_per_tile:
-        indices = indices[:maximum_items_per_tile]
-
-    return [dataset[ind] for ind in indices]
-
-
-with MosaicBackend(
-    "stac+https://earth-search.aws.element84.com/v0/search",
-    query,
-    minzoom=8,
-    maxzoom=14,
-    mosaic_options={"accessor": custom_accessor, "asset_filter": optimized_filter},
-) as mosaic:
-    print(mosaic.metadata)
-    mosaic_doc = mosa
-
-# Write the mosaic
-mosaic_file = "mymosaic.json.gz"
-with MosaicBackend(mosaic_file, mosaic_def=mosaic_doc) as mosaic:
-    mosaic.write(overwrite=True)
-```
-
-Use the mosaic in titiler
-```python
-mosaic = str(pathlib.Path(mosaic_file).absolute())
-data = httpx.get(f"{titiler_endpoint}/mosaic/tilejson.json?url=file:///{mosaic}&bands=B01&rescale=0,1000").json()
-print(data)
-```
diff --git a/docs/src/examples/code/tiler_with_auth.md b/docs/src/examples/code/tiler_with_auth.md
index b45acf690..801499d42 100644
--- a/docs/src/examples/code/tiler_with_auth.md
+++ b/docs/src/examples/code/tiler_with_auth.md
@@ -43,7 +43,7 @@ app/models.py
 
 """
 
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import List, Optional
 
 from jose import jwt
@@ -67,7 +67,7 @@ class AccessToken(BaseModel):
     @validator("iat", pre=True, always=True)
     def set_creation_time(cls, v) -> datetime:
         """Set token creation time (iat)."""
-        return datetime.utcnow()
+        return datetime.now(timezone.UTC)
 
     @validator("exp", always=True)
     def set_expiration_time(cls, v, values) -> datetime:
@@ -140,12 +140,12 @@ def DatasetPathParams(
     """Create dataset path from args"""
 
     if not api_key_query:
-        raise HTTPException(status_code=403, detail="Missing `access_token`")
+        raise HTTPException(status_code=401, detail="Missing `access_token`")
 
     try:
         AccessToken.from_string(api_key_query)
     except JWTError:
-        raise HTTPException(status_code=403, detail="Invalid `access_token`")
+        raise HTTPException(status_code=401, detail="Invalid `access_token`")
 
     return url
 ```
diff --git a/docs/src/examples/code/tiler_with_cache.md b/docs/src/examples/code/tiler_with_cache.md
index 880ed6875..a29d7bd82 100644
--- a/docs/src/examples/code/tiler_with_cache.md
+++ b/docs/src/examples/code/tiler_with_cache.md
@@ -167,7 +167,7 @@ from rio_tiler.io import BaseReader, Reader
 
 from titiler.core.factory import img_endpoint_params
 from titiler.core.factory import TilerFactory as TiTilerFactory
-from titiler.core.dependencies import ImageParams, RescalingParams
+from titiler.core.dependencies import RescalingParams
 from titiler.core.models.mapbox import TileJSON
 from titiler.core.resources.enums import ImageType
 
@@ -186,15 +186,15 @@ class TilerFactory(TiTilerFactory):
         @self.router.get(r"/tiles/{z}/{x}/{y}.{format}", **img_endpoint_params)
         @self.router.get(r"/tiles/{z}/{x}/{y}@{scale}x", **img_endpoint_params)
         @self.router.get(r"/tiles/{z}/{x}/{y}@{scale}x.{format}", **img_endpoint_params)
-        @self.router.get(r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}", **img_endpoint_params)
+        @self.router.get(r"/tiles/{tileMatrixSetId}/{z}/{x}/{y}", **img_endpoint_params)
         @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}.{format}", **img_endpoint_params
+            r"/tiles/{tileMatrixSetId}/{z}/{x}/{y}.{format}", **img_endpoint_params
         )
         @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}@{scale}x", **img_endpoint_params
+            r"/tiles/{tileMatrixSetId}/{z}/{x}/{y}@{scale}x", **img_endpoint_params
         )
         @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}@{scale}x.{format}",
+            r"/tiles/{tileMatrixSetId}/{z}/{x}/{y}@{scale}x.{format}",
             **img_endpoint_params,
         )
         # Add default cache config dictionary into cached alias.
@@ -204,7 +204,7 @@ class TilerFactory(TiTilerFactory):
             z: int = Path(..., ge=0, le=30, description="TMS tiles's zoom level"),
             x: int = Path(..., description="TMS tiles's column"),
             y: int = Path(..., description="TMS tiles's row"),
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
+            tileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
                 self.default_tms,
                 description=f"TileMatrixSet Name (default: '{self.default_tms}')",
             ),
@@ -235,7 +235,7 @@ class TilerFactory(TiTilerFactory):
             reader_params=Depends(self.reader_dependency),
         ):
             """Create map tile from a dataset."""
-            tms = self.supported_tms.get(TileMatrixSetId)
+            tms = self.supported_tms.get(tileMatrixSetId)
 
             with self.reader(src_path, tms=tms, **reader_params) as src_dst:
                 image = src_dst.tile(
@@ -280,7 +280,7 @@ class TilerFactory(TiTilerFactory):
             response_model_exclude_none=True,
         )
         @self.router.get(
-            "/{TileMatrixSetId}/tilejson.json",
+            "/{tileMatrixSetId}/tilejson.json",
             response_model=TileJSON,
             responses={200: {"description": "Return a tilejson"}},
             response_model_exclude_none=True,
@@ -288,7 +288,7 @@ class TilerFactory(TiTilerFactory):
         @cached(alias="default")
         def tilejson(
             request: Request,
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
+            tileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
                 self.default_tms,
                 description=f"TileMatrixSet Name (default: '{self.default_tms}')",
             ),
@@ -332,7 +332,7 @@ class TilerFactory(TiTilerFactory):
                 "x": "{x}",
                 "y": "{y}",
                 "scale": tile_scale,
-                "TileMatrixSetId": TileMatrixSetId,
+                "tileMatrixSetId": tileMatrixSetId,
             }
             if tile_format:
                 route_params["format"] = tile_format.value
@@ -354,7 +354,7 @@ class TilerFactory(TiTilerFactory):
             if qs:
                 tiles_url += f"?{urlencode(qs)}"
 
-            tms = self.supported_tms.get(TileMatrixSetId)
+            tms = self.supported_tms.get(tileMatrixSetId)
             with self.reader(src_path, tms=tms, **reader_params) as src_dst:
                 return {
                     "bounds": src_dst.geographic_bounds,
diff --git a/docs/src/examples/code/tiler_with_custom_algorithm.md b/docs/src/examples/code/tiler_with_custom_algorithm.md
index e606982e6..547d5ffe5 100644
--- a/docs/src/examples/code/tiler_with_custom_algorithm.md
+++ b/docs/src/examples/code/tiler_with_custom_algorithm.md
@@ -32,7 +32,6 @@ class Multiply(BaseAlgorithm):
         # Create output ImageData
         return ImageData(
             data,
-            img.mask,
             assets=img.assets,
             crs=img.crs,
             bounds=img.bounds,
diff --git a/docs/src/examples/code/tiler_with_custom_colormap.md b/docs/src/examples/code/tiler_with_custom_colormap.md
index 8a9e5f86e..77ab08ef8 100644
--- a/docs/src/examples/code/tiler_with_custom_colormap.md
+++ b/docs/src/examples/code/tiler_with_custom_colormap.md
@@ -15,7 +15,7 @@ cmap = urlencode(
     }
 )
 response = requests.get(
-    f"http://127.0.0.1:8000/cog/tiles/8/53/50.png?url=https://myurl.com/cog.tif&bidx=1&rescale=0,10000&{cmap}"
+    f"http://127.0.0.1:8000/cog/tiles/WebMercatorQuad/8/53/50.png?url=https://myurl.com/cog.tif&bidx=1&rescale=0,10000&{cmap}"
 )
 ```
 
@@ -33,34 +33,33 @@ app/dependencies.py
 """
 
 import json
-from enum import Enum
-from typing import Dict, Optional
+
+from typing import Annotated, Dict, Optional, Literal
 
 import numpy
 import matplotlib
-from rio_tiler.colormap import cmap, parse_color
+from rio_tiler.colormap import parse_color
+from rio_tiler.colormap import cmap as default_cmap
 from fastapi import HTTPException, Query
 
 
-ColorMapName = Enum(  # type: ignore
-    "ColorMapName", [(a, a) for a in sorted(cmap.list())]
-)
-
-class ColorMapType(str, Enum):
-    """Colormap types."""
-
-    explicit = "explicit"
-    linear = "linear"
-
-
 def ColorMapParams(
-    colormap_name: ColorMapName = Query(None, description="Colormap name"),
-    colormap: str = Query(None, description="JSON encoded custom Colormap"),
-    colormap_type: ColorMapType = Query(ColorMapType.explicit, description="User input colormap type."),
+    colormap_name: Annotated[  # type: ignore
+        Literal[tuple(default_cmap.list())],
+        Query(description="Colormap name"),
+    ] = None,
+    colormap: Annotated[
+        str,
+        Query(description="JSON encoded custom Colormap"),
+    ] = None,
+    colormap_type: Annotated[
+        Literal["explicit", "linear"],
+        Query(description="User input colormap type."),
+    ] = "explicit",
 ) -> Optional[Dict]:
     """Colormap Dependency."""
     if colormap_name:
-        return cmap.get(colormap_name.value)
+        return default_cmap.get(colormap_name)
 
     if colormap:
         try:
@@ -73,7 +72,7 @@ def ColorMapParams(
                 status_code=400, detail="Could not parse the colormap value."
             )
 
-        if colormap_type == ColorMapType.linear:
+        if colormap_type == "linear":
             # input colormap has to start from 0 to 255 ?
             cm = matplotlib.colors.LinearSegmentedColormap.from_list(
                 'custom',
diff --git a/docs/src/examples/code/tiler_with_custom_stac+xarray.md b/docs/src/examples/code/tiler_with_custom_stac+xarray.md
new file mode 100644
index 000000000..99eb2eb45
--- /dev/null
+++ b/docs/src/examples/code/tiler_with_custom_stac+xarray.md
@@ -0,0 +1,260 @@
+
+**Goal**: Create a custom STAC Reader supporting both COG and NetCDF/Zarr dataset
+
+**requirements**:
+
+- `titiler.core`
+- `titiler.xarray`
+- `fsspec`
+- `zarr`
+- `h5netcdf`
+- `aiohttp` (optional)
+- `s3fs` (optional)
+
+**links**:
+
+- https://cogeotiff.github.io/rio-tiler/examples/STAC_datacube_support/
+
+
+#### 1. Custom STACReader
+
+First, we need to create a custom `STACReader` which will support both COG and NetCDF/Zarr dataset. The custom parts will be:
+
+- add `netcdf` and `zarr` as valid asset media types
+- introduce a new `md://` prefixed asset form, so users can pass `assets=md://{netcdf asset name}?variable={variable name}` as we do for the `GDAL vrt string connection` support.
+
+```python title="stac.py"
+import attr
+from urllib.parse import urlparse, parse_qsl
+from rio_tiler.types import AssetInfo
+from rio_tiler.io import BaseReader, Reader
+from rio_tiler.io.stac import DEFAULT_VALID_TYPE, STAC_ALTERNATE_KEY
+from rio_tiler.io.stac import STACReader as BaseSTACReader
+
+from titiler.xarray.io import FsReader as XarrayReader
+
+valid_types = {
+    *DEFAULT_VALID_TYPE,
+    "application/x-netcdf",
+    "application/vnd+zarr",
+}
+
+
+@attr.s
+class STACReader(BaseSTACReader):
+    """Custom STACReader which adds support for XarrayReader.
+
+    Example:
+    >>> with STACReader("https://raw.githubusercontent.com/cogeotiff/rio-tiler/refs/heads/main/tests/fixtures/stac_netcdf.json") as src:
+            print(src.assets)
+            print(src._get_asset_info("netcdf|variable=dataset"))
+
+        ['geotiff', 'netcdf']
+        {'url': 'https://raw.githubusercontent.com/cogeotiff/rio-tiler/refs/heads/main/tests/fixtures/dataset_2d.nc', 'name': 'netcdf', 'metadata': {}, 'reader_options': {'variable': 'dataset'}, 'method_options': {}, 'media_type': 'application/x-netcdf'}
+
+    """
+    include_asset_types: set[str] = attr.ib(default=valid_types)
+
+    def _get_reader(self, asset_info: AssetInfo) -> type[BaseReader]:
+        """Get Asset Reader."""
+        asset_type = asset_info.get("media_type", None)
+        if asset_type and asset_type in [
+            "application/x-netcdf",
+            "application/vnd+zarr",
+            "application/x-hdf5",
+            "application/x-hdf",
+        ]:
+            return XarrayReader
+
+        return Reader
+
+    def _get_asset_info(self, asset: str) -> AssetInfo:
+        """Validate asset names and return asset's info.
+
+        Args:
+            asset (str): STAC asset name.
+
+        Returns:
+            AssetInfo: STAC asset info.
+
+        """
+        asset, vrt_options = self._parse_vrt_asset(asset)
+        
+        reader_options: dict[str, Any] = {}
+        method_options: dict[str, Any] = {}
+        # NOTE: asset can be in form of
+        # "{asset_name}|some_option=some_value&another_option=another_value"
+        if "|" in asset:
+            asset, params = asset.split("|", 1)
+            # NOTE: Construct method options from params
+            if params:
+                for param in params.split("&"):
+                    key, value = param.split("=", 1)
+                    if key == "indexes":
+                        method_options["indexes"] = list(map(int, value.split(",")))
+                    elif key == "expression":
+                        method_options["expression"] = value
+                    # XarrayReader Reader-Options
+                    elif key == "variable":
+                        reader_options["variable"] = value
+                    elif key == "group":
+                        reader_options["group"] = value
+                    elif key == "decode_times":
+                        reader_options["decode_times"] = value.lower() in ["true", "yes", "1"]
+                    elif key == "datetime":
+                        reader_options["datetime"] = value
+                    elif key == "drop_dim":
+                        reader_options["drop_dim"] = value
+                                                                                                                  
+        if asset not in self.assets:
+            raise InvalidAssetName(
+                f"'{asset}' is not valid, should be one of {self.assets}"
+            )
+
+        asset_info = self.item.assets[asset]
+        extras = asset_info.extra_fields
+
+        info = AssetInfo(
+            url=asset_info.get_absolute_href() or asset_info.href,
+            name=asset,
+            metadata=extras if not vrt_options else None,
+            reader_options=reader_options,
+            method_options=method_options,
+        )
+
+        if STAC_ALTERNATE_KEY and extras.get("alternate"):
+            if alternate := extras["alternate"].get(STAC_ALTERNATE_KEY):
+                info["url"] = alternate["href"]
+
+        if asset_info.media_type:
+            info["media_type"] = asset_info.media_type
+
+        # https://github.com/stac-extensions/file
+        if head := extras.get("file:header_size"):
+            info["env"] = {"GDAL_INGESTED_BYTES_AT_OPEN": head}
+
+        # https://github.com/stac-extensions/raster
+        if extras.get("raster:bands") and not vrt_options:
+            bands = extras.get("raster:bands")
+            stats = [
+                (b["statistics"]["minimum"], b["statistics"]["maximum"])
+                for b in bands
+                if {"minimum", "maximum"}.issubset(b.get("statistics", {}))
+            ]
+            # check that stats data are all double and make warning if not
+            if (
+                stats
+                and all(isinstance(v, (int, float)) for stat in stats for v in stat)
+                and len(stats) == len(bands)
+            ):
+                info["dataset_statistics"] = stats
+            else:
+                warnings.warn(
+                    "Some statistics data in STAC are invalid, they will be ignored."
+                )
+
+        if vrt_options:
+            info["url"] = f"vrt://{info['url']}?{vrt_options}"
+
+        return info
+```
+
+#### 2. Application
+
+```python title="main.py"
+"""FastAPI application."""
+from fastapi import FastAPI
+from titiler.core.factory import MultiBaseTilerFactory
+from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
+
+from .stac import STACReader
+
+# STAC uses MultiBaseReader so we use MultiBaseTilerFactory to built the default endpoints
+stac = MultiBaseTilerFactory(
+    reader=STACReader, 
+    add_preview=False, 
+    add_ogc_maps=False,
+)
+
+# Create FastAPI application
+app = FastAPI()
+app.include_router(stac.router)
+add_exception_handlers(app, DEFAULT_STATUS_CODES)
+```
+
+```
+uvicorn app:app --port 8080 --reload
+```
+
+<img width="800" src="img/stac_xarray_docs.png">
+
+##### Available Assets
+
+```bash
+curl http://127.0.0.1:8080/assets\?url\=https%3A%2F%2Fraw.githubusercontent.com%2Fcogeotiff%2Frio-tiler%2Frefs%2Fheads%2Fmain%2Ftests%2Ffixtures%2Fstac_netcdf.json | jq
+
+[
+  "geotiff",
+  "netcdf"
+]
+```
+
+##### Info
+
+```bash
+curl http://127.0.0.1:8080/info?url=https://raw.githubusercontent.com/cogeotiff/rio-tiler/refs/heads/main/tests/fixtures/stac_netcdf.json&assets=netcdf|variable=dataset  | jq
+{
+  "netcdf|variable=dataset": {
+    "bounds": [
+      -170.085,
+      -80.08,
+      169.914999999975,
+      79.91999999999659
+    ],
+    "crs": "http://www.opengis.net/def/crs/EPSG/0/4326",
+    "band_metadata": [
+      [
+        "b1",
+        {}
+      ]
+    ],
+    "band_descriptions": [
+      [
+        "b1",
+        "dataset"
+      ]
+    ],
+    "dtype": "float64",
+    "nodata_type": "Nodata",
+    "name": "dataset",
+    "count": 1,
+    "width": 2000,
+    "height": 1000,
+    "dimensions": [
+      "y",
+      "x"
+    ],
+    "attrs": {
+      "valid_min": 1.0,
+      "valid_max": 1000.0,
+      "fill_value": 0
+    }
+  }
+}
+```
+
+#####  Map.html 
+
+```
+http://127.0.0.1:8080/WebMercatorQuad/map.html?url=https://raw.githubusercontent.com/cogeotiff/rio-tiler/refs/heads/main/tests/fixtures/stac_netcdf.json&assets=netcdf|variable=dataset&rescale=0,1000&colormap_name=viridis
+```
+
+<img width="800" src="img/stac_xarray_map.png">
+
+##### Tile Request
+
+```
+http://127.0.0.1:8080/tiles/WebMercatorQuad/1/0/0?url=https://raw.githubusercontent.com/cogeotiff/rio-tiler/refs/heads/main/tests/fixtures/stac_netcdf.json&assets=netcdf|variable=dataset&rescale=0,1000
+```
+
+<img width="256" src="img/stac_xarray_tile.png">
diff --git a/docs/src/examples/code/tiler_with_custom_tms.md b/docs/src/examples/code/tiler_with_custom_tms.md
index eb4edacc1..0813dee9c 100644
--- a/docs/src/examples/code/tiler_with_custom_tms.md
+++ b/docs/src/examples/code/tiler_with_custom_tms.md
@@ -20,15 +20,14 @@ from pyproj import CRS
 EPSG6933 = TileMatrixSet.custom(
     (-17357881.81713629, -7324184.56362408, 17357881.81713629, 7324184.56362408),
     CRS.from_epsg(6933),
-    identifier="EPSG6933",
+    id="EPSG6933",
     matrix_scale=[1, 1],
 )
-
 # 2. Register TMS
-tms = tms.register([EPSG6933])
+tms = tms.register({EPSG6933.id:EPSG6933})
 
-tms = TMSFactory(supported_tms=tms)
-cog = TilerFactory(supported_tms=tms)
+tms_factory = TMSFactory(supported_tms=tms)
+cog_factory = TilerFactory(supported_tms=tms)
 ```
 
 2 - Create app and register our custom endpoints
@@ -44,11 +43,11 @@ from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
 
 from fastapi import FastAPI
 
-from .routes import cog, tms
+from .routes import cog_factory, tms_factory
 
 app = FastAPI(title="My simple app with custom TMS")
 
-app.include_router(cog.router, tags=["Cloud Optimized GeoTIFF"])
-app.include_router(tms.router, tags=["Tiling Schemes"])
+app.include_router(cog_factory.router, tags=["Cloud Optimized GeoTIFF"])
+app.include_router(tms_factory.router, tags=["Tiling Schemes"])
 add_exception_handlers(app, DEFAULT_STATUS_CODES)
 ```
diff --git a/docs/src/examples/code/tiler_with_layers.md b/docs/src/examples/code/tiler_with_layers.md
new file mode 100644
index 000000000..1465ba05d
--- /dev/null
+++ b/docs/src/examples/code/tiler_with_layers.md
@@ -0,0 +1,243 @@
+
+**Goal**: Create a Custom TiTiler with a limited set of supported `layers`
+
+**requirements**: titiler.core
+
+**How**:
+
+The idea is to create a set of endpoints with a `/layers/{layer_id}` prefix and a set of configuration, e.g
+
+```
+config = {
+    "layer_1": {
+        "url": "dataset_1 url",
+        "indexes": [1],
+        "render": {
+            "rescale": [(0, 1000)],
+            "colormap_name": "viridis"
+        }
+    },
+    ...
+}
+```
+
+We then use custom set of endpoint dependencies to get the `layer` configuration and `inject` the parameters.
+
+
+```python
+import json
+from dataclasses import dataclass, field
+from typing import Dict, Literal, Annotated, Optional, Sequence
+
+from fastapi import FastAPI, Path, HTTPException, Query
+from rio_tiler.colormap import ColorMaps
+from rio_tiler.colormap import cmap as default_cmap
+from rio_tiler.colormap import parse_color
+from starlette.requests import Request
+
+from titiler.core import dependencies
+from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
+from titiler.core.factory import TilerFactory
+
+
+# Layers Configuration
+available_layers = {
+    "red": {
+        "url": "https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/21/J/XN/2021/2/S2B_21JXN_20210214_1_L2A/B04.tif",
+        "render": {
+            "rescale": [
+                (0, 1000),
+            ],
+        },
+    },
+    "green": {
+        "url": "https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/21/J/XN/2021/2/S2B_21JXN_20210214_1_L2A/B03.tif",
+        "render": {
+            "rescale": [
+                (0, 1000),
+            ],
+        },
+    },
+    "bleue": {
+        "url": "https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/21/J/XN/2021/2/S2B_21JXN_20210214_1_L2A/B02.tif",
+        "render": {
+            "rescale": [
+                (0, 1000),
+            ],
+        },
+    },
+}
+
+# VRT of bands B04, B03, B02, and B05 files
+# gdalbuildvrt vrt.vrt /vsicurl/https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/21/J/XN/2021/2/S2B_21JXN_20210214_1_L2A/B{04,03,02,08}.tif -separate
+# cat vrt.vrt | tr -d '\n' | tr -d ' '
+vrt_rdbnir = '<VRTDataset rasterXSize="10980" rasterYSize="10980">  <SRS dataAxisToSRSAxisMapping="1,2">PROJCS["WGS 84 / UTM zone 21S",GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]],PROJECTION["Transverse_Mercator"],PARAMETER["latitude_of_origin",0],PARAMETER["central_meridian",-57],PARAMETER["scale_factor",0.9996],PARAMETER["false_easting",500000],PARAMETER["false_northing",10000000],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["Easting",EAST],AXIS["Northing",NORTH],AUTHORITY["EPSG","32721"]]</SRS>  <GeoTransform>  6.0000000000000000e+05,  1.0000000000000000e+01,  0.0000000000000000e+00,  7.3000000000000000e+06,  0.0000000000000000e+00, -1.0000000000000000e+01</GeoTransform>  <VRTRasterBand dataType="UInt16" band="1">    <NoDataValue>0</NoDataValue>    <ComplexSource>      <SourceFilename relativeToVRT="0">/vsicurl/https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/21/J/XN/2021/2/S2B_21JXN_20210214_1_L2A/B04.tif</SourceFilename>      <SourceBand>1</SourceBand>      <SourceProperties RasterXSize="10980" RasterYSize="10980" DataType="UInt16" BlockXSize="1024" BlockYSize="1024" />      <SrcRect xOff="0" yOff="0" xSize="10980" ySize="10980" />      <DstRect xOff="0" yOff="0" xSize="10980" ySize="10980" />      <NODATA>0</NODATA>    </ComplexSource>  </VRTRasterBand>  <VRTRasterBand dataType="UInt16" band="2">    <NoDataValue>0</NoDataValue>    <ComplexSource>      <SourceFilename relativeToVRT="0">/vsicurl/https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/21/J/XN/2021/2/S2B_21JXN_20210214_1_L2A/B03.tif</SourceFilename>      <SourceBand>1</SourceBand>      <SourceProperties RasterXSize="10980" RasterYSize="10980" DataType="UInt16" BlockXSize="1024" BlockYSize="1024" />      <SrcRect xOff="0" yOff="0" xSize="10980" ySize="10980" />      <DstRect xOff="0" yOff="0" xSize="10980" ySize="10980" />      <NODATA>0</NODATA>    </ComplexSource>  </VRTRasterBand>  <VRTRasterBand dataType="UInt16" band="3">    <NoDataValue>0</NoDataValue>    <ComplexSource>      <SourceFilename relativeToVRT="0">/vsicurl/https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/21/J/XN/2021/2/S2B_21JXN_20210214_1_L2A/B02.tif</SourceFilename>      <SourceBand>1</SourceBand>      <SourceProperties RasterXSize="10980" RasterYSize="10980" DataType="UInt16" BlockXSize="1024" BlockYSize="1024" />      <SrcRect xOff="0" yOff="0" xSize="10980" ySize="10980" />      <DstRect xOff="0" yOff="0" xSize="10980" ySize="10980" />      <NODATA>0</NODATA>    </ComplexSource>  </VRTRasterBand>  <VRTRasterBand dataType="UInt16" band="4">    <NoDataValue>0</NoDataValue>    <ComplexSource>      <SourceFilename relativeToVRT="0">/vsicurl/https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/21/J/XN/2021/2/S2B_21JXN_20210214_1_L2A/B08.tif</SourceFilename>      <SourceBand>1</SourceBand>      <SourceProperties RasterXSize="10980" RasterYSize="10980" DataType="UInt16" BlockXSize="1024" BlockYSize="1024" />      <SrcRect xOff="0" yOff="0" xSize="10980" ySize="10980" />      <DstRect xOff="0" yOff="0" xSize="10980" ySize="10980" />      <NODATA>0</NODATA>    </ComplexSource>  </VRTRasterBand></VRTDataset>'
+
+# Mpre configs (using VRT)
+available_layers.update(
+    {
+        "true_color": {
+            "url": vrt_rdbnir,
+            "indexes": [1, 2, 3],
+            "render": {
+                "rescale": [
+                    (0, 3000),
+                    (0, 3000),
+                    (0, 3000),
+                ],
+            },
+        },
+        "false_color": {
+            "url": vrt_rdbnir,
+            "indexes": [4, 1, 2],
+            "render": {
+                "rescale": [
+                    (0, 4000),
+                    (0, 3000),
+                    (0, 3000),
+                ],
+            },
+        },
+        "ndvi": {
+            "url": vrt_rdbnir,
+            "expression": "(b4-b1)/(b4+b1)",
+            "render": {
+                "rescale": [
+                    (-1, 1),
+                ],
+                "colormap_name": "viridis",
+            },
+        },
+    }
+)
+
+# List of all Layers
+layers_list = Literal["red", "green", "blue", "true_color", "false_color", "ndvi"]
+
+
+# Custom `DatasetPathParams` which return the dataset URL for a `layer_id`
+def DatasetPathParams(layer_id: layers_list = Path()) -> str:
+    return available_layers[layer_id]["url"]
+
+
+@dataclass
+class CustomAsDict:
+    """Custom `DefaultDependency` to ignore `requests`"""
+    def as_dict(self, exclude_none: bool = True) -> Dict:
+        """Transform dataclass to dict."""
+        exclude_keys = {"request"}
+        if exclude_none:
+            return {
+                k: v
+                for k, v in self.__dict__.items()
+                if v is not None and k not in exclude_keys
+            }
+
+        return {k: v for k, v in self.__dict__.items() if k not in exclude_keys}
+
+
+# Custom Layer Param
+@dataclass
+class LayerParams(CustomAsDict, dependencies.BidxExprParams):
+
+    request: Request = field(default=None)
+
+    def __post_init__(self):
+        if (layer := self.request.path_params.get("layer_id")) and not any(
+            [self.indexes, self.expression]
+        ):
+            layer_params = available_layers[layer]
+            if indexes := layer_params.get("indexes"):
+                self.indexes = indexes
+            elif expr := layer_params.get("expression"):
+                self.expression = expr
+
+# Custom Rendering Params
+@dataclass
+class RenderingParams(CustomAsDict, dependencies.ImageRenderingParams):
+
+    request: Request = field(default=None)
+
+    def __post_init__(self):
+        super().__post_init__()
+
+        if layer := self.request.path_params.get("layer_id"):
+            layer_params = available_layers[layer].get("render", {})
+
+            if not self.rescale and (rescale := layer_params.get("rescale")):
+                self.rescale = rescale
+
+            if not self.color_formula and (color_formula := layer_params.get("color_formula")):
+                self.color_formula = color_formula
+
+            if self.add_mask is not None and (add_mask := layer_params.get("add_mask")):
+                self.add_mask = add_mask
+
+
+# Custom ColorMap Params
+def ColorMapParams(
+    request: Request,
+    colormap_name: Annotated[  # type: ignore
+        Literal[tuple(default_cmap.list())],
+        Query(description="Colormap name"),
+    ] = None,
+    colormap: Annotated[
+        Optional[str], Query(description="JSON encoded custom Colormap")
+    ] = None,
+):
+    if layer := request.path_params.get("layer_id"):
+        layer_params = available_layers[layer].get("render", {})
+        colormap_name = layer_params.get("colormap_name", colormap_name)
+        colormap = layer_params.get("colormap", colormap)
+
+    if colormap_name:
+        return default_cmap.get(colormap_name)
+
+    if colormap:
+        try:
+            c = json.loads(
+                colormap,
+                object_hook=lambda x: {
+                    int(k): parse_color(v) for k, v in x.items()
+                },
+            )
+
+            # Make sure to match colormap type
+            if isinstance(c, Sequence):
+                c = [(tuple(inter), parse_color(v)) for (inter, v) in c]
+
+            return c
+        except json.JSONDecodeError as e:
+            raise HTTPException(
+                status_code=400, detail="Could not parse the colormap value."
+            ) from e
+
+    return None
+
+
+app = FastAPI()
+
+cog = TilerFactory(
+    path_dependency=DatasetPathParams,
+    layer_dependency=LayerParams,
+    render_dependency=RenderingParams,
+    colormap_dependency=ColorMapParams,
+    router_prefix="/layers/{layer_id}",
+)
+app.include_router(cog.router, prefix="/layers/{layer_id}")
+add_exception_handlers(app, DEFAULT_STATUS_CODES)
+
+# Run the application
+import uvicorn
+uvicorn.run(app=app, host="127.0.0.1", port=8080, log_level="info")
+```
+
+
+`http://127.0.0.1:8080/docs`
+
+![](img/example_custom_layers_docs.png)
+
+
+`http://127.0.0.1:8080/layers/true_color/preview`
+
+![](img/example_custom_layers_preview.png)
diff --git a/docs/src/examples/notebooks/Working_with_Algorithm.ipynb b/docs/src/examples/notebooks/Working_with_Algorithm.ipynb
index cb0fe237c..b25ca3d2f 100644
--- a/docs/src/examples/notebooks/Working_with_Algorithm.ipynb
+++ b/docs/src/examples/notebooks/Working_with_Algorithm.ipynb
@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": null,
    "id": "55915667",
    "metadata": {},
    "outputs": [],
@@ -34,17 +34,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "3ac532e8",
    "metadata": {},
    "outputs": [],
    "source": [
-    "titiler_endpoint = \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind."
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "5c65b3d5",
    "metadata": {},
    "outputs": [],
@@ -62,25 +64,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "id": "7abeb9c0",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'bounds': [7.090624928537461, 45.916058441028206, 7.1035698381384185, 45.925093000254144], 'minzoom': 15, 'maxzoom': 18, 'band_metadata': [['b1', {'STATISTICS_COVARIANCES': '10685.98787505646', 'STATISTICS_EXCLUDEDVALUES': '-9999', 'STATISTICS_MAXIMUM': '2015.0944824219', 'STATISTICS_MEAN': '1754.471184271', 'STATISTICS_MINIMUM': '1615.8128662109', 'STATISTICS_SKIPFACTORX': '1', 'STATISTICS_SKIPFACTORY': '1', 'STATISTICS_STDDEV': '103.37305197708'}]], 'band_descriptions': [['b1', '']], 'dtype': 'float32', 'nodata_type': 'Nodata', 'colorinterp': ['gray'], 'width': 2000, 'nodata_value': -9999.0, 'overviews': [2, 4, 8], 'count': 1, 'height': 2000, 'driver': 'GTiff'}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Fetch dataset Metadata\n",
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/cog/info\",\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "print(r)"
@@ -98,226 +92,57 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "id": "80803e00",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_493d25e8d4a7d0ccbb6c5ba53002d2ef {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_493d25e8d4a7d0ccbb6c5ba53002d2ef&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_493d25e8d4a7d0ccbb6c5ba53002d2ef = L.map(\n",
-       "                &quot;map_493d25e8d4a7d0ccbb6c5ba53002d2ef&quot;,\n",
-       "                {\n",
-       "                    center: [45.920575720641175, 7.09709738333794],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 15,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_654956450a257609df94d6305d93393e = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_493d25e8d4a7d0ccbb6c5ba53002d2ef);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_b0efd2f1567d48e5497fd4bdde6675d3 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/cog/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fdata.geo.admin.ch%2Fch.swisstopo.swissalti3d%2Fswissalti3d_2019_2573-1085%2Fswissalti3d_2019_2573-1085_0.5_2056_5728.tif&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Office f\\u00e9d\\u00e9ral de topographie swisstopo&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_493d25e8d4a7d0ccbb6c5ba53002d2ef);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x11a0d72a0>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"]\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=r[\"minzoom\"],\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Office fédéral de topographie swisstopo\"\n",
-    ")\n",
-    "aod_layer.add_to(m)\n",
+    "TileLayer(\n",
+    "    tiles=r[\"tiles\"][0], opacity=1, attr=\"Office fédéral de topographie swisstopo\"\n",
+    ").add_to(m)\n",
     "m"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "id": "64c2faab",
    "metadata": {
     "scrolled": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_71b52f5430275cfd0a398451ea87751e {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_71b52f5430275cfd0a398451ea87751e&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_71b52f5430275cfd0a398451ea87751e = L.map(\n",
-       "                &quot;map_71b52f5430275cfd0a398451ea87751e&quot;,\n",
-       "                {\n",
-       "                    center: [45.920575720641175, 7.09709738333794],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 15,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_9ba1a335399e08e559b5b1bc247093e6 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_71b52f5430275cfd0a398451ea87751e);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_1e5a4bdb2fddd91709a7e24361237823 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/cog/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fdata.geo.admin.ch%2Fch.swisstopo.swissalti3d%2Fswissalti3d_2019_2573-1085%2Fswissalti3d_2019_2573-1085_0.5_2056_5728.tif\\u0026rescale=1615.812%2C2015.09448\\u0026colormap_name=terrain&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Office f\\u00e9d\\u00e9ral de topographie swisstopo&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_71b52f5430275cfd0a398451ea87751e);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x11a4324f0>"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": url,\n",
     "        # rio-tiler cannot rescale automatically the data when using a colormap\n",
     "        \"rescale\": \"1615.812,2015.09448\",\n",
     "        \"colormap_name\": \"terrain\",\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"]\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=r[\"minzoom\"],\n",
     ")\n",
     "\n",
     "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Office fédéral de topographie swisstopo\"\n",
+    "    tiles=r[\"tiles\"][0], opacity=1, attr=\"Office fédéral de topographie swisstopo\"\n",
     ")\n",
     "aod_layer.add_to(m)\n",
     "m"
@@ -333,29 +158,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "id": "26ef9eef",
    "metadata": {
     "scrolled": true
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Available algorithm\n",
-      "['hillshade', 'contours', 'normalizedIndex', 'terrarium', 'terrainrgb']\n",
-      "\n",
-      "Metadata from `Hillshade` algorithm\n",
-      "Inputs\n",
-      "{'nbands': 1}\n",
-      "Outputs\n",
-      "{'nbands': 1, 'dtype': 'uint8'}\n",
-      "Parameters\n",
-      "{'azimuth': {'title': 'Azimuth', 'default': 90, 'type': 'integer'}, 'angle_altitude': {'title': 'Angle Altitude', 'default': 90, 'type': 'number'}, 'buffer': {'title': 'Buffer', 'default': 3, 'type': 'integer'}}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Fetch algorithms\n",
     "print(\"Available algorithm\")\n",
@@ -381,117 +189,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "id": "4cc8c900",
    "metadata": {
     "scrolled": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_8e6eaadb22e4e86175d001c273d8bfc7 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_8e6eaadb22e4e86175d001c273d8bfc7&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_8e6eaadb22e4e86175d001c273d8bfc7 = L.map(\n",
-       "                &quot;map_8e6eaadb22e4e86175d001c273d8bfc7&quot;,\n",
-       "                {\n",
-       "                    center: [45.920575720641175, 7.09709738333794],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 15,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_da9ba086ee9b4a41074a1c75c4d2c301 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_8e6eaadb22e4e86175d001c273d8bfc7);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_2e319f4a6fb6125a1429aa0580709419 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/cog/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fdata.geo.admin.ch%2Fch.swisstopo.swissalti3d%2Fswissalti3d_2019_2573-1085%2Fswissalti3d_2019_2573-1085_0.5_2056_5728.tif\\u0026algo=hillshade\\u0026buffer=3&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Yo!!&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_8e6eaadb22e4e86175d001c273d8bfc7);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x11ad1dc00>"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": url,\n",
     "        \"algorithm\": \"hillshade\",\n",
-    "        # Hillshade algorithm use a 3pixel buffer so we need \n",
+    "        # Hillshade algorithm use a 3pixel buffer so we need\n",
     "        # to tell the tiler to apply a 3 pixel buffer around each tile\n",
     "        \"buffer\": 3,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"]\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=r[\"minzoom\"],\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Yo!!\"\n",
-    ")\n",
+    "aod_layer = TileLayer(tiles=r[\"tiles\"][0], opacity=1, attr=\"Yo!!\")\n",
     "aod_layer.add_to(m)\n",
     "m"
    ]
@@ -506,241 +228,67 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": null,
    "id": "54d674e9",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_93b8aa41082e604285244c0c9f502747 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_93b8aa41082e604285244c0c9f502747&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_93b8aa41082e604285244c0c9f502747 = L.map(\n",
-       "                &quot;map_93b8aa41082e604285244c0c9f502747&quot;,\n",
-       "                {\n",
-       "                    center: [45.920575720641175, 7.09709738333794],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 15,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_a2565c928566aada1b4dcef281a2601b = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_93b8aa41082e604285244c0c9f502747);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_6f98876f8ff75297ab7d042fd7d9a08f = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/cog/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fdata.geo.admin.ch%2Fch.swisstopo.swissalti3d%2Fswissalti3d_2019_2573-1085%2Fswissalti3d_2019_2573-1085_0.5_2056_5728.tif\\u0026algo=contours\\u0026algo_params=%7B%22increment%22%3A+20%2C+%22thickness%22%3A+2%2C+%22minz%22%3A+1600%2C+%22maxz%22%3A+2000%7D&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Yo!!&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_93b8aa41082e604285244c0c9f502747);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x11fa5e870>"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": url,\n",
     "        \"algorithm\": \"contours\",\n",
     "        \"algorithm_params\": json.dumps(\n",
     "            {\n",
-    "                \"increment\": 20, # contour line every 20 meters\n",
-    "                \"thickness\": 2, # 2m thickness\n",
+    "                \"increment\": 20,  # contour line every 20 meters\n",
+    "                \"thickness\": 2,  # 2m thickness\n",
     "                \"minz\": 1600,\n",
-    "                \"maxz\": 2000\n",
+    "                \"maxz\": 2000,\n",
     "            }\n",
     "        ),\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"]\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=r[\"minzoom\"],\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Yo!!\"\n",
-    ")\n",
-    "aod_layer.add_to(m)\n",
+    "TileLayer(tiles=r[\"tiles\"][0], opacity=1, attr=\"Yo!!\").add_to(m)\n",
     "m"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": null,
    "id": "1c80efe0",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_92209ed3c44d128976c5adc3a4448674 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_92209ed3c44d128976c5adc3a4448674&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_92209ed3c44d128976c5adc3a4448674 = L.map(\n",
-       "                &quot;map_92209ed3c44d128976c5adc3a4448674&quot;,\n",
-       "                {\n",
-       "                    center: [45.920575720641175, 7.09709738333794],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 15,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_dd18cd598f2ab3b1938d3e12075392bc = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_92209ed3c44d128976c5adc3a4448674);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_7cfa4db06b73e20305790d4ee9355531 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/cog/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fdata.geo.admin.ch%2Fch.swisstopo.swissalti3d%2Fswissalti3d_2019_2573-1085%2Fswissalti3d_2019_2573-1085_0.5_2056_5728.tif\\u0026algo=contours\\u0026algo_params=%7B%22increment%22%3A+5%2C+%22thickness%22%3A+1%2C+%22minz%22%3A+1600%2C+%22maxz%22%3A+2000%7D&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Yo!!&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_92209ed3c44d128976c5adc3a4448674);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x11fa813d0>"
-      ]
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": url,\n",
     "        \"algorithm\": \"contours\",\n",
     "        \"algorithm_params\": json.dumps(\n",
     "            {\n",
-    "                \"increment\": 5, # contour line every 5 meters\n",
-    "                \"thickness\": 1, # 1m thickness\n",
+    "                \"increment\": 5,  # contour line every 5 meters\n",
+    "                \"thickness\": 1,  # 1m thickness\n",
     "                \"minz\": 1600,\n",
-    "                \"maxz\": 2000\n",
+    "                \"maxz\": 2000,\n",
     "            }\n",
     "        ),\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"]\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=r[\"minzoom\"],\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Yo!!\"\n",
-    ")\n",
-    "aod_layer.add_to(m)\n",
+    "TileLayer(tiles=r[\"tiles\"][0], opacity=1, attr=\"Yo!!\").add_to(m)\n",
     "m"
    ]
   },
@@ -755,9 +303,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 with Fil",
+   "display_name": "titiler (3.13.9)",
    "language": "python",
-   "name": "filprofile"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -769,12 +317,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.13 (main, May 24 2022, 21:13:51) \n[Clang 13.1.6 (clang-1316.0.21.2)]"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "8a5edab282632443219e051e4ade2d1d5bbc671c781051bf1437897cbdfea0f1"
-   }
+   "version": "3.13.9"
   }
  },
  "nbformat": 4,
diff --git a/docs/src/examples/notebooks/Working_with_CloudOptimizedGeoTIFF.ipynb b/docs/src/examples/notebooks/Working_with_CloudOptimizedGeoTIFF.ipynb
index 94b3be3bc..dcc679ad8 100644
--- a/docs/src/examples/notebooks/Working_with_CloudOptimizedGeoTIFF.ipynb
+++ b/docs/src/examples/notebooks/Working_with_CloudOptimizedGeoTIFF.ipynb
@@ -42,6 +42,7 @@
    "outputs": [],
    "source": [
     "import os\n",
+    "import datetime\n",
     "import json\n",
     "import urllib.parse\n",
     "from io import BytesIO\n",
@@ -49,7 +50,7 @@
     "from concurrent import futures\n",
     "\n",
     "import httpx\n",
-    "\n",
+    "import numpy\n",
     "from boto3.session import Session as boto3_session\n",
     "\n",
     "from rasterio.plot import reshape_as_image\n",
@@ -57,9 +58,10 @@
     "\n",
     "from tqdm.notebook import tqdm\n",
     "\n",
-    "from folium import Map, TileLayer\n",
+    "from folium import Map, TileLayer, GeoJson\n",
     "\n",
-    "%pylab inline"
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.dates as mdates"
    ]
   },
   {
@@ -68,7 +70,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "titiler_endpoint = \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind."
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")"
    ]
   },
   {
@@ -86,40 +90,25 @@
    "source": [
     "# use geojson.io\n",
     "geojson = {\n",
-    "  \"type\": \"FeatureCollection\",\n",
-    "  \"features\": [\n",
-    "    {\n",
-    "      \"type\": \"Feature\",\n",
-    "      \"properties\": {},\n",
-    "      \"geometry\": {\n",
-    "        \"type\": \"Polygon\",\n",
-    "        \"coordinates\": [\n",
-    "          [\n",
-    "            [\n",
-    "              -74.1796875,\n",
-    "              45.18978009667531\n",
-    "            ],\n",
-    "            [\n",
-    "              -73.092041015625,\n",
-    "              45.18978009667531\n",
-    "            ],\n",
-    "            [\n",
-    "              -73.092041015625,\n",
-    "              46.00459325574482\n",
-    "            ],\n",
-    "            [\n",
-    "              -74.1796875,\n",
-    "              46.00459325574482\n",
-    "            ],\n",
-    "            [\n",
-    "              -74.1796875,\n",
-    "              45.18978009667531\n",
-    "            ]\n",
-    "          ]\n",
-    "        ]\n",
-    "      }\n",
-    "    }\n",
-    "  ]\n",
+    "    \"type\": \"FeatureCollection\",\n",
+    "    \"features\": [\n",
+    "        {\n",
+    "            \"type\": \"Feature\",\n",
+    "            \"properties\": {},\n",
+    "            \"geometry\": {\n",
+    "                \"type\": \"Polygon\",\n",
+    "                \"coordinates\": [\n",
+    "                    [\n",
+    "                        [-74.1796875, 45.18978009667531],\n",
+    "                        [-73.092041015625, 45.18978009667531],\n",
+    "                        [-73.092041015625, 46.00459325574482],\n",
+    "                        [-74.1796875, 46.00459325574482],\n",
+    "                        [-74.1796875, 45.18978009667531],\n",
+    "                    ]\n",
+    "                ],\n",
+    "            },\n",
+    "        }\n",
+    "    ],\n",
     "}\n",
     "\n",
     "bounds = featureBounds(geojson)"
@@ -131,11 +120,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "Map(\n",
+    "m = Map(\n",
     "    tiles=\"OpenStreetMap\",\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=6\n",
-    ")"
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=6,\n",
+    ")\n",
+    "\n",
+    "GeoJson(geojson).add_to(m)\n",
+    "m"
    ]
   },
   {
@@ -169,22 +161,29 @@
     "session = boto3_session(region_name=\"us-west-2\")\n",
     "client = session.client(\"s3\")\n",
     "\n",
-    "bucket = \"omi-no2-nasa\"  #https://registry.opendata.aws/omi-no2-nasa/\n",
+    "bucket = \"omi-no2-nasa\"  # https://registry.opendata.aws/omi-no2-nasa/\n",
     "\n",
     "\n",
     "def list_objects(bucket, prefix):\n",
     "    \"\"\"AWS s3 list objects.\"\"\"\n",
     "\n",
-    "    paginator = client.get_paginator('list_objects_v2')\n",
+    "    paginator = client.get_paginator(\"list_objects_v2\")\n",
     "\n",
     "    files = []\n",
     "    for subset in paginator.paginate(Bucket=bucket, Prefix=prefix):\n",
     "        files.extend(subset.get(\"Contents\", []))\n",
     "\n",
-    "    return [r[\"Key\"] for r in files]\n",
+    "    return files\n",
+    "\n",
+    "\n",
+    "list_files = list_objects(bucket, \"OMI-Aura_L3\")\n",
+    "\n",
+    "print(\"Archive Size\")\n",
+    "files = [r[\"Key\"] for r in list_files]\n",
+    "print(f\"Found {len(files)} OMI-NO2 files\")\n",
     "\n",
-    "files = list_objects(bucket, \"OMI-Aura_L3\")\n",
-    "print(f\"Found : {len(files)}\")"
+    "size = sum([r[\"Size\"] / 1000000.0 for r in list_files])\n",
+    "print(f\"Size of the archive: {size} Mo ({size / 1000} Go)\")"
    ]
   },
   {
@@ -227,7 +226,11 @@
    },
    "outputs": [],
    "source": [
-    "files_Oct5 = list(filter(lambda x: (x.split(\"_\")[2][5:7] == \"10\") & (x.split(\"_\")[2][7:9] == \"05\"), files))\n",
+    "files_Oct5 = list(\n",
+    "    filter(\n",
+    "        lambda x: (x.split(\"_\")[2][5:7] == \"10\") & (x.split(\"_\")[2][7:9] == \"05\"), files\n",
+    "    )\n",
+    ")\n",
     "print(len(files_Oct5))\n",
     "print(files_Oct5)"
    ]
@@ -238,10 +241,10 @@
    "source": [
     "### DATA Endpoint\n",
     "\n",
-    "`{endpoint}/cog/tiles/{z}/{x}/{y}.{format}?url={cog}&{otherquery params}`\n",
+    "`{endpoint}/cog/tiles/{tileMatrixSetId}/{z}/{x}/{y}.{format}?url={cog}&{otherquery params}`\n",
     "\n",
     "\n",
-    "`{endpoint}/cog/crop/{minx},{miny},{maxx},{maxy}.{format}?url={cog}&{otherquery params}`\n",
+    "`{endpoint}/cog/bbox/{minx},{miny},{maxx},{maxy}.{format}?url={cog}&{otherquery params}`\n",
     "\n",
     "\n",
     "`{endpoint}/cog/point/{minx},{miny}?url={cog}&{otherquery params}`\n"
@@ -275,10 +278,7 @@
     "# Fetch File Metadata to get min/max rescaling values (because the file is stored as float32)\n",
     "\n",
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/statistics\",\n",
-    "    params = {\n",
-    "        \"url\": _url(files[0])\n",
-    "    }\n",
+    "    f\"{titiler_endpoint}/cog/statistics\", params={\"url\": _url(files[0])}\n",
     ").json()\n",
     "\n",
     "print(json.dumps(r, indent=4))"
@@ -291,25 +291,24 @@
    "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": _url(files[2]),\n",
     "        \"rescale\": \"0,3000000000000000\",\n",
     "        \"colormap_name\": \"viridis\",\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=6\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=6\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"NASA\"\n",
+    "TileLayer(tiles=r[\"tiles\"][0], opacity=1, attr=\"NASA\").add_to(m)\n",
+    "\n",
+    "GeoJson(geojson, style_function=lambda feature: {\"fill\": False, \"color\": \"red\"}).add_to(\n",
+    "    m\n",
     ")\n",
-    "aod_layer.add_to(m)\n",
+    "\n",
     "m"
    ]
   },
@@ -334,8 +333,9 @@
     "\n",
     "xmin, ymin, xmax, ymax = bounds\n",
     "\n",
+    "\n",
     "def fetch_bbox(file):\n",
-    "    url = f\"{titiler_endpoint}/cog/crop/{xmin},{ymin},{xmax},{ymax}.npy\"\n",
+    "    url = f\"{titiler_endpoint}/cog/bbox/{xmin},{ymin},{xmax},{ymax}.npy\"\n",
     "    params = {\n",
     "        \"url\": _url(file),\n",
     "        \"bidx\": \"1\",\n",
@@ -344,7 +344,10 @@
     "    r = httpx.get(url, params=params)\n",
     "    data = numpy.load(BytesIO(r.content))\n",
     "    s = _stats(data[0:-1], data[-1])\n",
-    "    return s[1], file.split(\"_\")[2]\n",
+    "    return (\n",
+    "        _stats(data[0:-1], data[-1]),\n",
+    "        datetime.datetime.strptime(file.split(\"_\")[2].replace(\"m\", \"\"), \"%Y%m%d\"),\n",
+    "    )\n",
     "\n",
     "\n",
     "# small tool to filter invalid response from the API\n",
@@ -382,19 +385,20 @@
    "outputs": [],
    "source": [
     "with futures.ThreadPoolExecutor(max_workers=10) as executor:\n",
-    "    future_work = [\n",
-    "        executor.submit(fetch_bbox, file) for file in files_15\n",
-    "    ]\n",
+    "    future_work = [executor.submit(fetch_bbox, file) for file in files_15]\n",
     "\n",
-    "    for f in tqdm(futures.as_completed(future_work), total=len(future_work)):               \n",
+    "    for f in tqdm(futures.as_completed(future_work), total=len(future_work)):\n",
     "        pass\n",
     "\n",
-    "values, dates  = zip(*list(_filter_futures(future_work)))\n",
+    "values, dates = zip(*list(_filter_futures(future_work)))\n",
     "\n",
-    "fig, ax1 = plt.subplots(dpi=150)\n",
+    "max_values = [v[1] for v in values]\n",
+    "\n",
+    "fig, ax1 = plt.subplots(dpi=300)\n",
     "fig.autofmt_xdate()\n",
     "\n",
-    "ax1.plot(dates, values, label=\"No2\")\n",
+    "ax1.plot(dates, max_values, label=\"No2\")\n",
+    "ax1.xaxis.set_major_locator(mdates.YearLocator(1, 7))\n",
     "\n",
     "ax1.set_xlabel(\"Dates\")\n",
     "ax1.set_ylabel(\"No2\")\n",
@@ -416,19 +420,20 @@
    "outputs": [],
    "source": [
     "with futures.ThreadPoolExecutor(max_workers=50) as executor:\n",
-    "    future_work = [\n",
-    "        executor.submit(fetch_bbox, file) for file in files\n",
-    "    ]\n",
+    "    future_work = [executor.submit(fetch_bbox, file) for file in files]\n",
     "\n",
-    "    for f in tqdm(futures.as_completed(future_work), total=len(future_work)):               \n",
+    "    for f in tqdm(futures.as_completed(future_work), total=len(future_work)):\n",
     "        pass\n",
     "\n",
-    "values, dates  = zip(*list(_filter_futures(future_work)))\n",
+    "values, dates = zip(*list(_filter_futures(future_work)))\n",
+    "\n",
+    "max_values = [v[1] for v in values]\n",
     "\n",
     "fig, ax1 = plt.subplots(dpi=150)\n",
     "fig.autofmt_xdate()\n",
     "\n",
-    "ax1.plot(dates, values, label=\"No2\")\n",
+    "ax1.plot(dates, max_values, label=\"No2\")\n",
+    "ax1.xaxis.set_major_locator(mdates.YearLocator())\n",
     "\n",
     "ax1.set_xlabel(\"Dates\")\n",
     "ax1.set_ylabel(\"No2\")\n",
@@ -460,7 +465,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.2"
+   "version": "3.9.18"
   }
  },
  "nbformat": 4,
diff --git a/docs/src/examples/notebooks/Working_with_CloudOptimizedGeoTIFF_simple.ipynb b/docs/src/examples/notebooks/Working_with_CloudOptimizedGeoTIFF_simple.ipynb
index 78c4509ea..751091bdd 100644
--- a/docs/src/examples/notebooks/Working_with_CloudOptimizedGeoTIFF_simple.ipynb
+++ b/docs/src/examples/notebooks/Working_with_CloudOptimizedGeoTIFF_simple.ipynb
@@ -50,7 +50,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "titiler_endpoint = \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")\n",
     "url = \"https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif\""
    ]
   },
@@ -70,9 +72,9 @@
     "# Fetch File Metadata to get min/max rescaling values (because the file is stored as float32)\n",
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/cog/info\",\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
@@ -95,9 +97,9 @@
     "# Fetch File Metadata to get min/max rescaling values (because the file is stored as float32)\n",
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/cog/statistics\",\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "print(json.dumps(r, indent=4))"
@@ -117,23 +119,18 @@
    "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=13\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=13\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"DigitalGlobe OpenData\"\n",
-    ")\n",
-    "aod_layer.add_to(m)\n",
+    "TileLayer(tiles=r[\"tiles\"][0], opacity=1, attr=\"DigitalGlobe OpenData\").add_to(m)\n",
+    "\n",
     "m"
    ]
   },
@@ -150,24 +147,25 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "url = \"https://data.geo.admin.ch/ch.swisstopo.swissalti3d/swissalti3d_2019_2573-1085/swissalti3d_2019_2573-1085_0.5_2056_5728.tif\"\n",
     "\n",
     "# Fetch File Metadata to get min/max rescaling values (because the file is stored as float32)\n",
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/cog/info\",\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "print(r)\n",
     "print(\"Data is of type:\", r[\"dtype\"])\n",
     "\n",
     "# This dataset has statistics metadata\n",
-    "minv, maxv = r[\"band_metadata\"][0][1][\"STATISTICS_MINIMUM\"], r[\"band_metadata\"][0][1][\"STATISTICS_MAXIMUM\"]\n",
-    "print(\"With values from \", minv, \"to \", maxv)\n",
-    "\n"
+    "minv, maxv = (\n",
+    "    r[\"band_metadata\"][0][1][\"STATISTICS_MINIMUM\"],\n",
+    "    r[\"band_metadata\"][0][1][\"STATISTICS_MAXIMUM\"],\n",
+    ")\n",
+    "print(\"With values from \", minv, \"to \", maxv)"
    ]
   },
   {
@@ -179,12 +177,12 @@
     "# We could get the min/max values using the statistics endpoint\n",
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/cog/statistics\",\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
-    "print(json.dumps(r[\"1\"], indent=4))"
+    "print(json.dumps(r[\"b1\"], indent=4))"
    ]
   },
   {
@@ -194,7 +192,7 @@
     "### Display Tiles\n",
     "\n",
     "\n",
-    "1. Without `rescaling` values, TiTiler will return black/grey tiles because it will rescale the data base on min/max value of the datatype."
+    "Note: By default if the metadata has `min/max` statistics, titiler will use those to rescale the data"
    ]
   },
   {
@@ -204,24 +202,19 @@
    "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"] + 1\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=r[\"minzoom\"] + 1,\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Swisstopo\"\n",
-    ")\n",
-    "aod_layer.add_to(m)\n",
+    "TileLayer(tiles=r[\"tiles\"][0], opacity=1, attr=\"Swisstopo\").add_to(m)\n",
     "m"
    ]
   },
@@ -229,45 +222,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "2. Apply linear rescaling using Min/Max value \n",
-    "\n",
-    "This is needed to rescale the value to byte (0 -> 255) which can then be encoded in JPEG or PNG"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
-    "        \"url\": url,\n",
-    "        \"rescale\": f\"{minv},{maxv}\"\n",
-    "    }\n",
-    ").json()\n",
-    "\n",
-    "bounds = r[\"bounds\"]\n",
-    "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"] + 1\n",
-    ")\n",
-    "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Swisstopo\"\n",
-    ")\n",
-    "aod_layer.add_to(m)\n",
-    "m"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "3. Apply ColorMap\n",
+    "Apply ColorMap\n",
     "\n",
     "Now that the data is rescaled to byte values (0 -> 255) we can apply a colormap"
    ]
@@ -279,26 +234,17 @@
    "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
-    "        \"url\": url,\n",
-    "        \"rescale\": f\"{minv},{maxv}\",\n",
-    "        \"colormap_name\": \"terrain\"\n",
-    "    }\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\"url\": url, \"rescale\": f\"{minv},{maxv}\", \"colormap_name\": \"terrain\"},\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"] + 1\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=r[\"minzoom\"] + 1,\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Swisstopo\"\n",
-    ")\n",
-    "aod_layer.add_to(m)\n",
+    "TileLayer(tiles=r[\"tiles\"][0], opacity=1, attr=\"Swisstopo\").add_to(m)\n",
     "m"
    ]
   },
@@ -306,7 +252,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "4. Apply non-linear colormap (intervals)\n",
+    "Apply non-linear colormap (intervals)\n",
     "\n",
     "see https://cogeotiff.github.io/rio-tiler/colormap/#intervals-colormaps"
    ]
@@ -322,49 +268,35 @@
     "cmap = json.dumps(\n",
     "    [\n",
     "        # ([min, max], [r, g, b, a])\n",
-    "        ([0, 1500], [255,255,204, 255]),\n",
-    "        ([1500, 1700], [161,218,180, 255]),\n",
-    "        ([1700, 1900], [65,182,196, 255]),\n",
-    "        ([1900, 2000], [44,127,184, 255]),\n",
-    "        ([2000, 3000], [37,52,148, 255]),\n",
+    "        ([0, 1500], [255, 255, 204, 255]),\n",
+    "        ([1500, 1700], [161, 218, 180, 255]),\n",
+    "        ([1700, 1900], [65, 182, 196, 255]),\n",
+    "        ([1900, 2000], [44, 127, 184, 255]),\n",
+    "        ([2000, 3000], [37, 52, 148, 255]),\n",
     "    ]\n",
     ")\n",
     "# https://colorbrewer2.org/#type=sequential&scheme=YlGnBu&n=5\n",
     "\n",
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\",\n",
-    "    params = {\n",
-    "        \"url\": url,\n",
-    "        \"colormap\": cmap\n",
-    "    }\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\"url\": url, \"colormap\": cmap},\n",
     ").json()\n",
     "\n",
     "bounds = r[\"bounds\"]\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=r[\"minzoom\"] + 1\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=r[\"minzoom\"] + 1,\n",
     ")\n",
     "\n",
-    "aod_layer = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    opacity=1,\n",
-    "    attr=\"Swisstopo\"\n",
-    ")\n",
+    "aod_layer = TileLayer(tiles=r[\"tiles\"][0], opacity=1, attr=\"Swisstopo\")\n",
     "aod_layer.add_to(m)\n",
     "m"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "titiler (3.13.9)",
    "language": "python",
    "name": "python3"
   },
@@ -378,7 +310,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.2"
+   "version": "3.13.9"
   }
  },
  "nbformat": 4,
diff --git a/docs/src/examples/notebooks/Working_with_MosaicJSON.ipynb b/docs/src/examples/notebooks/Working_with_MosaicJSON.ipynb
index b62c9220e..40a54b4f7 100644
--- a/docs/src/examples/notebooks/Working_with_MosaicJSON.ipynb
+++ b/docs/src/examples/notebooks/Working_with_MosaicJSON.ipynb
@@ -1,7 +1,6 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -30,7 +29,7 @@
     "\n",
     "By default, TiTiler has `mosaicjson` endpoints.\n",
     "\n",
-    "Docs: https://api.cogeo.xyz/docs#/MosaicJSON"
+    "Docs: https://titiler.xyz/api.html#/MosaicJSON"
    ]
   },
   {
@@ -118,13 +117,13 @@
     "session = boto3_session(region_name=\"us-west-2\")\n",
     "client = session.client(\"s3\")\n",
     "\n",
-    "bucket = \"noaa-eri-pds\"  #https://registry.opendata.aws/omi-no2-nasa/\n",
+    "bucket = \"noaa-eri-pds\"  # https://registry.opendata.aws/omi-no2-nasa/\n",
     "\n",
     "\n",
     "def list_objects(bucket, prefix):\n",
     "    \"\"\"AWS s3 list objects.\"\"\"\n",
     "\n",
-    "    paginator = client.get_paginator('list_objects_v2')\n",
+    "    paginator = client.get_paginator(\"list_objects_v2\")\n",
     "\n",
     "    files = []\n",
     "    for subset in paginator.paginate(Bucket=bucket, Prefix=prefix):\n",
@@ -132,6 +131,7 @@
     "\n",
     "    return [r[\"Key\"] for r in files]\n",
     "\n",
+    "\n",
     "files = list_objects(bucket, \"2020_Nashville_Tornado/20200307a_RGB\")\n",
     "files = [f\"s3://{bucket}/{f}\" for f in files if f.endswith(\".tif\")]\n",
     "\n",
@@ -163,8 +163,8 @@
    "outputs": [],
    "source": [
     "# We can derive the `bbox` from the filename\n",
-    "# s3://noaa-eri-pds/2020_Nashville_Tornado/20200307a_RGB/20200307aC0870130w361200n.tif \n",
-    "# -> 20200307aC0870130w361200n.tif \n",
+    "# s3://noaa-eri-pds/2020_Nashville_Tornado/20200307a_RGB/20200307aC0870130w361200n.tif\n",
+    "# -> 20200307aC0870130w361200n.tif\n",
     "# -> 20200307aC \"0870130w\" \"361200n\" .tif\n",
     "# -> 0870130w -> 87.025 (West)\n",
     "# -> 361200n -> 36.2 (Top)\n",
@@ -174,16 +174,20 @@
     "from geojson_pydantic.features import Feature\n",
     "from geojson_pydantic.geometries import Polygon\n",
     "\n",
+    "\n",
     "def dms_to_degree(v: str) -> float:\n",
     "    \"\"\"convert degree minute second to decimal degrees.\n",
-    "    \n",
+    "\n",
     "    '0870130w' -> 87.025\n",
     "    \"\"\"\n",
     "    deg = int(v[0:3])\n",
     "    minutes = int(v[3:5])\n",
     "    seconds = int(v[5:7])\n",
     "    direction = v[-1].upper()\n",
-    "    return (float(deg) + float(minutes)/60 + float(seconds)/(60*60)) * (-1 if direction in ['W', 'S'] else 1)\n",
+    "    return (float(deg) + float(minutes) / 60 + float(seconds) / (60 * 60)) * (\n",
+    "        -1 if direction in [\"W\", \"S\"] else 1\n",
+    "    )\n",
+    "\n",
     "\n",
     "def fname_to_feature(src_path: str) -> Feature:\n",
     "    bname = os.path.basename(src_path)\n",
@@ -194,16 +198,14 @@
     "    lat = dms_to_degree(\"0\" + lat_dms)\n",
     "\n",
     "    return Feature(\n",
-    "        geometry=Polygon.from_bounds(\n",
-    "            lon, lat - 0.025, lon + 0.025, lat \n",
-    "        ),\n",
+    "        geometry=Polygon.from_bounds(lon, lat - 0.025, lon + 0.025, lat),\n",
     "        properties={\n",
     "            \"path\": src_path,\n",
-    "        }\n",
+    "        },\n",
     "    )\n",
-    "features = [\n",
-    "   fname_to_feature(f).dict(exclude_none=True) for f in files\n",
-    "]\n",
+    "\n",
+    "\n",
+    "features = [fname_to_feature(f).dict(exclude_none=True) for f in files]\n",
     "\n",
     "# OR We could use Rasterio/rio-tiler\n",
     "\n",
@@ -231,20 +233,23 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "geojson = {'type': 'FeatureCollection', 'features': features}\n",
+    "geojson = {\"type\": \"FeatureCollection\", \"features\": features}\n",
     "\n",
     "bounds = featureBounds(geojson)\n",
     "\n",
     "m = Map(\n",
     "    tiles=\"OpenStreetMap\",\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=6\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=6,\n",
     ")\n",
     "\n",
     "geo_json = GeoJson(\n",
     "    data=geojson,\n",
     "    style_function=lambda x: {\n",
-    "        'opacity': 1, 'dashArray': '1', 'fillOpacity': 0, 'weight': 1\n",
+    "        \"opacity\": 1,\n",
+    "        \"dashArray\": \"1\",\n",
+    "        \"fillOpacity\": 0,\n",
+    "        \"weight\": 1,\n",
     "    },\n",
     ")\n",
     "geo_json.add_to(m)\n",
@@ -280,10 +285,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# We are creating the mosaicJSON using the features we created earlier\n",
     "# by default MosaicJSON.from_feature will look in feature.properties.path to get the path of the dataset\n",
-    "mosaicdata = MosaicJSON.from_features(features, minzoom=info.minzoom, maxzoom=info.maxzoom)\n",
+    "mosaicdata = MosaicJSON.from_features(\n",
+    "    features, minzoom=info.minzoom, maxzoom=info.maxzoom\n",
+    ")\n",
     "with MosaicBackend(\"NOAA_Nashville_Tornado.json.gz\", mosaic_def=mosaicdata) as mosaic:\n",
     "    mosaic.write(overwrite=True)\n",
     "    print(mosaic.info())"
@@ -297,20 +303,21 @@
    },
    "outputs": [],
    "source": [
-    "titiler_endpoint = \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")\n",
     "\n",
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/mosaicjson/tilejson.json\",\n",
+    "    f\"{titiler_endpoint}/mosaicjson/WebMercatorQuad/tilejson.json\",\n",
     "    params={\n",
     "        # For this demo we are use the same mosaic but stored on the web\n",
-    "        \"url\": \"https://gist.githubusercontent.com/vincentsarago/c6ace3ccd29a82a4a5531693bbcd61fc/raw/e0d0174a64a9acd2fb820f2c65b1830aab80f52b/NOAA_Nashville_Tornado.json\" \n",
-    "    }\n",
+    "        \"url\": \"https://gist.githubusercontent.com/vincentsarago/c6ace3ccd29a82a4a5531693bbcd61fc/raw/e0d0174a64a9acd2fb820f2c65b1830aab80f52b/NOAA_Nashville_Tornado.json\"\n",
+    "    },\n",
     ").json()\n",
     "print(r)\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=13\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=13\n",
     ")\n",
     "\n",
     "tiles = TileLayer(\n",
@@ -318,13 +325,16 @@
     "    min_zoom=r[\"minzoom\"],\n",
     "    max_zoom=r[\"maxzoom\"],\n",
     "    opacity=1,\n",
-    "    attr=\"NOAA\"\n",
+    "    attr=\"NOAA\",\n",
     ")\n",
     "\n",
     "geo_json = GeoJson(\n",
     "    data=geojson,\n",
     "    style_function=lambda x: {\n",
-    "        'opacity': 1, 'dashArray': '1', 'fillOpacity': 0, 'weight': 1\n",
+    "        \"opacity\": 1,\n",
+    "        \"dashArray\": \"1\",\n",
+    "        \"fillOpacity\": 0,\n",
+    "        \"weight\": 1,\n",
     "    },\n",
     ")\n",
     "tiles.add_to(m)\n",
@@ -342,7 +352,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -356,7 +366,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.2"
+   "version": "3.9.17"
   }
  },
  "nbformat": 4,
diff --git a/docs/src/examples/notebooks/Working_with_NumpyTile.ipynb b/docs/src/examples/notebooks/Working_with_NumpyTile.ipynb
index b6b580506..d3e46e00e 100755
--- a/docs/src/examples/notebooks/Working_with_NumpyTile.ipynb
+++ b/docs/src/examples/notebooks/Working_with_NumpyTile.ipynb
@@ -54,7 +54,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "titiler_endpoint = \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")\n",
     "url = \"https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif\""
    ]
   },
@@ -64,7 +66,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "r = httpx.get(f\"{titiler_endpoint}/cog/tilejson.json?url={url}\").json()\n",
+    "r = httpx.get(f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json?url={url}\").json()\n",
     "print(r)"
    ]
   },
@@ -88,7 +90,9 @@
     "# Call TiTiler endpoint using the first tile\n",
     "\n",
     "tile = tiles[0]\n",
-    "r = httpx.get(f\"{titiler_endpoint}/cog/tiles/{tile.z}/{tile.x}/{tile.y}.npy?url={url}\")"
+    "r = httpx.get(\n",
+    "    f\"{titiler_endpoint}/cog/tiles/WebMercatorQuad/{tile.z}/{tile.x}/{tile.y}.npy?url={url}\"\n",
+    ")"
    ]
   },
   {
diff --git a/docs/src/examples/notebooks/Working_with_STAC.ipynb b/docs/src/examples/notebooks/Working_with_STAC.ipynb
index 4d4660d52..74e7e32b6 100644
--- a/docs/src/examples/notebooks/Working_with_STAC.ipynb
+++ b/docs/src/examples/notebooks/Working_with_STAC.ipynb
@@ -1,7 +1,6 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -13,7 +12,7 @@
     "\n",
     "> The SpatioTemporal Asset Catalog (STAC) specification aims to standardize the way geospatial assets are exposed online and queried. A 'spatiotemporal asset' is any file that represents information about the earth captured in a certain space and time. The initial focus is primarily remotely-sensed imagery (from satellites, but also planes, drones, balloons, etc), but the core is designed to be extensible to SAR, full motion video, point clouds, hyperspectral, LiDAR and derived data like NDVI, Digital Elevation Models, mosaics, etc.\n",
     "\n",
-    "Ref: https://github.com/radiantearth/stac-spechttps://github.com/radiantearth/stac-spec\n",
+    "Ref: https://github.com/radiantearth/stac-spec\n",
     "\n",
     "Using STAC makes data indexation and discovery really easy. In addition to the Collection/Item/Asset (data) specifications, data providers are also encouraged to follow a STAC API specification:  https://github.com/radiantearth/stac-api-spec\n",
     "\n",
@@ -30,7 +29,7 @@
     "\n",
     "# TiTiler: STAC + COG\n",
     "\n",
-    "Docs: https://github.com/developmentseed/titiler/blob/main/docs/endpoints/stac.md\n",
+    "Docs: https://github.com/developmentseed/titiler/blob/main/docs/src/endpoints/stac.md\n",
     "\n",
     "\n",
     "TiTiler was first designed to work with single COG by passing the file URL to the tiler.\n",
@@ -106,30 +105,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Uncomment this line if you need to install the dependencies\n",
-    "# !pip rasterio folium httpx tqdm"
+    "# !pip install rasterio folium httpx tqdm"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "%pylab is deprecated, use %matplotlib inline and import the required libraries.\n",
-      "Populating the interactive namespace from numpy and matplotlib\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "import json\n",
@@ -143,7 +133,7 @@
     "from functools import partial\n",
     "from concurrent import futures\n",
     "\n",
-    "from tqdm.notebook import tqdm\n",
+    "# from tqdm.notebook import tqdm\n",
     "\n",
     "from rasterio.plot import reshape_as_image\n",
     "from rasterio.features import bounds as featureBounds\n",
@@ -155,12 +145,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Endpoint variables\n",
-    "titiler_endpoint = \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")\n",
     "stac_endpoint = \"https://earth-search.aws.element84.com/v0/search\""
    ]
   },
@@ -179,148 +171,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_04a8d0c0976b6fe1ce7862c023c14c1b {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_04a8d0c0976b6fe1ce7862c023c14c1b&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_04a8d0c0976b6fe1ce7862c023c14c1b = L.map(\n",
-       "                &quot;map_04a8d0c0976b6fe1ce7862c023c14c1b&quot;,\n",
-       "                {\n",
-       "                    center: [29.486523152893376, 30.848407745361328],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 11,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_eeab3ac34a120cd62f720d68d432fdd8 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_04a8d0c0976b6fe1ce7862c023c14c1b);\n",
-       "        \n",
-       "    \n",
-       "\n",
-       "        function geo_json_d096d9ddd2be64d0d8b3ef420fb5cb4b_onEachFeature(feature, layer) {\n",
-       "            layer.on({\n",
-       "            });\n",
-       "        };\n",
-       "        var geo_json_d096d9ddd2be64d0d8b3ef420fb5cb4b = L.geoJson(null, {\n",
-       "                onEachFeature: geo_json_d096d9ddd2be64d0d8b3ef420fb5cb4b_onEachFeature,\n",
-       "            \n",
-       "        });\n",
-       "\n",
-       "        function geo_json_d096d9ddd2be64d0d8b3ef420fb5cb4b_add (data) {\n",
-       "            geo_json_d096d9ddd2be64d0d8b3ef420fb5cb4b\n",
-       "                .addData(data)\n",
-       "                .addTo(map_04a8d0c0976b6fe1ce7862c023c14c1b);\n",
-       "        }\n",
-       "            geo_json_d096d9ddd2be64d0d8b3ef420fb5cb4b_add({&quot;features&quot;: [{&quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.810813903808594, 29.454247067148533], [30.88600158691406, 29.454247067148533], [30.88600158691406, 29.51879923863822], [30.810813903808594, 29.51879923863822], [30.810813903808594, 29.454247067148533]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;properties&quot;: {}, &quot;type&quot;: &quot;Feature&quot;}], &quot;type&quot;: &quot;FeatureCollection&quot;});\n",
-       "\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x11f7006d0>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "geojson = {\n",
-    "  \"type\": \"FeatureCollection\",\n",
-    "  \"features\": [\n",
-    "    {\n",
-    "      \"type\": \"Feature\",\n",
-    "      \"properties\": {},\n",
-    "      \"geometry\": {\n",
-    "        \"type\": \"Polygon\",\n",
-    "        \"coordinates\": [\n",
-    "          [\n",
-    "            [\n",
-    "              30.810813903808594,\n",
-    "              29.454247067148533\n",
-    "            ],\n",
-    "            [\n",
-    "              30.88600158691406,\n",
-    "              29.454247067148533\n",
-    "            ],\n",
-    "            [\n",
-    "              30.88600158691406,\n",
-    "              29.51879923863822\n",
-    "            ],\n",
-    "            [\n",
-    "              30.810813903808594,\n",
-    "              29.51879923863822\n",
-    "            ],\n",
-    "            [\n",
-    "              30.810813903808594,\n",
-    "              29.454247067148533\n",
-    "            ]\n",
-    "          ]\n",
-    "        ]\n",
-    "      }\n",
-    "    }\n",
-    "  ]\n",
+    "    \"type\": \"FeatureCollection\",\n",
+    "    \"features\": [\n",
+    "        {\n",
+    "            \"type\": \"Feature\",\n",
+    "            \"properties\": {},\n",
+    "            \"geometry\": {\n",
+    "                \"type\": \"Polygon\",\n",
+    "                \"coordinates\": [\n",
+    "                    [\n",
+    "                        [30.810813903808594, 29.454247067148533],\n",
+    "                        [30.88600158691406, 29.454247067148533],\n",
+    "                        [30.88600158691406, 29.51879923863822],\n",
+    "                        [30.810813903808594, 29.51879923863822],\n",
+    "                        [30.810813903808594, 29.454247067148533],\n",
+    "                    ]\n",
+    "                ],\n",
+    "            },\n",
+    "        }\n",
+    "    ],\n",
     "}\n",
     "\n",
     "bounds = featureBounds(geojson)\n",
     "\n",
     "m = Map(\n",
     "    tiles=\"OpenStreetMap\",\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=11\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=11,\n",
     ")\n",
     "\n",
     "geo_json = GeoJson(data=geojson)\n",
@@ -337,83 +219,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Results context:\n",
-      "{'page': 1, 'limit': 100, 'matched': 85, 'returned': 85}\n",
-      "\n",
-      "Example of item:\n",
-      "{\n",
-      "    \"bbox\": [\n",
-      "        30.155974613579858,\n",
-      "        28.80949327971016,\n",
-      "        31.050481437029678,\n",
-      "        29.815791988006527\n",
-      "    ],\n",
-      "    \"geometry\": {\n",
-      "        \"coordinates\": [\n",
-      "            [\n",
-      "                [\n",
-      "                    30.155974613579858,\n",
-      "                    28.80949327971016\n",
-      "                ],\n",
-      "                [\n",
-      "                    30.407037927198104,\n",
-      "                    29.805008695373978\n",
-      "                ],\n",
-      "                [\n",
-      "                    31.031551610920825,\n",
-      "                    29.815791988006527\n",
-      "                ],\n",
-      "                [\n",
-      "                    31.050481437029678,\n",
-      "                    28.825387639743422\n",
-      "                ],\n",
-      "                [\n",
-      "                    30.155974613579858,\n",
-      "                    28.80949327971016\n",
-      "                ]\n",
-      "            ]\n",
-      "        ],\n",
-      "        \"type\": \"Polygon\"\n",
-      "    },\n",
-      "    \"id\": \"S2B_36RTT_20191205_0_L2A\",\n",
-      "    \"collection\": \"sentinel-s2-l2a-cogs\",\n",
-      "    \"type\": \"Feature\",\n",
-      "    \"properties\": {\n",
-      "        \"datetime\": \"2019-12-05T08:42:04Z\",\n",
-      "        \"eo:cloud_cover\": 2.75\n",
-      "    }\n",
-      "}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "start = datetime.datetime.strptime(\"2019-01-01\", \"%Y-%m-%d\").strftime(\"%Y-%m-%dT00:00:00Z\")\n",
-    "end = datetime.datetime.strptime(\"2019-12-11\", \"%Y-%m-%d\").strftime(\"%Y-%m-%dT23:59:59Z\")\n",
+    "start = datetime.datetime.strptime(\"2019-01-01\", \"%Y-%m-%d\").strftime(\n",
+    "    \"%Y-%m-%dT00:00:00Z\"\n",
+    ")\n",
+    "end = datetime.datetime.strptime(\"2019-12-11\", \"%Y-%m-%d\").strftime(\n",
+    "    \"%Y-%m-%dT23:59:59Z\"\n",
+    ")\n",
     "\n",
     "# POST body\n",
     "query = {\n",
     "    \"collections\": [\"sentinel-s2-l2a-cogs\"],\n",
     "    \"datetime\": f\"{start}/{end}\",\n",
     "    \"query\": {\n",
-    "        \"eo:cloud_cover\": {\n",
-    "            \"lt\": 5\n",
-    "        },\n",
+    "        \"eo:cloud_cover\": {\"lt\": 5},\n",
     "    },\n",
     "    \"intersects\": geojson[\"features\"][0][\"geometry\"],\n",
     "    \"limit\": 100,\n",
     "    \"fields\": {\n",
-    "      'include': ['id', 'properties.datetime', 'properties.eo:cloud_cover'],  # This will limit the size of returned body\n",
-    "      'exclude': ['assets', 'links']  # This will limit the size of returned body\n",
-    "    }\n",
+    "        \"include\": [\n",
+    "            \"id\",\n",
+    "            \"properties.datetime\",\n",
+    "            \"properties.eo:cloud_cover\",\n",
+    "        ],  # This will limit the size of returned body\n",
+    "        \"exclude\": [\"assets\", \"links\"],  # This will limit the size of returned body\n",
+    "    },\n",
     "}\n",
     "\n",
     "# POST Headers\n",
@@ -437,122 +272,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_9ef3417d1da93aaea3b18f812aec0a70 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_9ef3417d1da93aaea3b18f812aec0a70&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_9ef3417d1da93aaea3b18f812aec0a70 = L.map(\n",
-       "                &quot;map_9ef3417d1da93aaea3b18f812aec0a70&quot;,\n",
-       "                {\n",
-       "                    center: [29.486523152893376, 30.848407745361328],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 8,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_787def1031f04803f9ea93e1f8743620 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_9ef3417d1da93aaea3b18f812aec0a70);\n",
-       "        \n",
-       "    \n",
-       "        function geo_json_3dd6121e037ae323b480ff60bc56adc7_styler(feature) {\n",
-       "            switch(feature.id) {\n",
-       "                default:\n",
-       "                    return {&quot;dashArray&quot;: &quot;1&quot;, &quot;fillOpacity&quot;: 0, &quot;opacity&quot;: 1, &quot;weight&quot;: 1};\n",
-       "            }\n",
-       "        }\n",
-       "\n",
-       "        function geo_json_3dd6121e037ae323b480ff60bc56adc7_onEachFeature(feature, layer) {\n",
-       "            layer.on({\n",
-       "            });\n",
-       "        };\n",
-       "        var geo_json_3dd6121e037ae323b480ff60bc56adc7 = L.geoJson(null, {\n",
-       "                onEachFeature: geo_json_3dd6121e037ae323b480ff60bc56adc7_onEachFeature,\n",
-       "            \n",
-       "                style: geo_json_3dd6121e037ae323b480ff60bc56adc7_styler,\n",
-       "        });\n",
-       "\n",
-       "        function geo_json_3dd6121e037ae323b480ff60bc56adc7_add (data) {\n",
-       "            geo_json_3dd6121e037ae323b480ff60bc56adc7\n",
-       "                .addData(data)\n",
-       "                .addTo(map_9ef3417d1da93aaea3b18f812aec0a70);\n",
-       "        }\n",
-       "            geo_json_3dd6121e037ae323b480ff60bc56adc7_add({&quot;context&quot;: {&quot;limit&quot;: 100, &quot;matched&quot;: 85, &quot;page&quot;: 1, &quot;returned&quot;: 85}, &quot;features&quot;: [{&quot;bbox&quot;: [30.155974613579858, 28.80949327971016, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.155974613579858, 28.80949327971016], [30.407037927198104, 29.805008695373978], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.155974613579858, 28.80949327971016]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20191205_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-12-05T08:42:04Z&quot;, &quot;eo:cloud_cover&quot;: 2.75}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.003275612870066, 29.815367588317667], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.003275612870066, 29.815367588317667], [30.721356053407547, 28.82022938973768], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191203_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-12-03T08:52:04Z&quot;, &quot;eo:cloud_cover&quot;: 1.96}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.01310125436907, 29.815515749544545], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.01310125436907, 29.815515749544545], [30.73047055179516, 28.820383051335178], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20191128_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-11-28T08:52:01Z&quot;, &quot;eo:cloud_cover&quot;: 2.22}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.00203585566591, 29.815348842032666], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00203585566591, 29.815348842032666], [30.848197511878276, 29.26346954470151], [30.721047680861904, 28.820224180102507], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191123_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-11-23T08:52:06Z&quot;, &quot;eo:cloud_cover&quot;: 1.78}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14144002646059, 28.809186025893656, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14144002646059, 28.809186025893656], [30.391324818745886, 29.80469928932157], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14144002646059, 28.809186025893656]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191120_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-11-20T08:42:11Z&quot;, &quot;eo:cloud_cover&quot;: 3.2}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.007722941018542, 29.815434740308746], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.007722941018542, 29.815434740308746], [30.725247571107957, 28.820295072307324], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20191118_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-11-18T08:52:04Z&quot;, &quot;eo:cloud_cover&quot;: 1.35}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.000173532313315, 29.81532066009473], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.000173532313315, 29.81532066009473], [30.84759150158622, 29.27275302958581], [30.718487769863287, 28.82018090583095], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191113_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-11-13T08:52:08Z&quot;, &quot;eo:cloud_cover&quot;: 1.61}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14717199710363, 28.809307383958586, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14717199710363, 28.809307383958586], [30.397734124988197, 29.804825720471396], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14717199710363, 28.809307383958586]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20191105_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-11-05T08:42:10Z&quot;, &quot;eo:cloud_cover&quot;: 2.77}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.99562155385856, 29.815251665930738], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.99562155385856, 29.815251665930738], [30.71244600129903, 28.820078579468696], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191103_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-11-03T08:52:08Z&quot;, &quot;eo:cloud_cover&quot;: 1.88}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.006481737802574, 29.815416013950014], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.006481737802574, 29.815416013950014], [30.723813762389014, 28.820270884983724], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20191029_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-10-29T08:52:06Z&quot;, &quot;eo:cloud_cover&quot;: 3.96}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.137960424419255, 28.809112236423964, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.137960424419255, 28.809112236423964], [30.389671235472697, 29.804666619945944], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.137960424419255, 28.809112236423964]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191021_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-10-21T08:42:13Z&quot;, &quot;eo:cloud_cover&quot;: 4.88}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.005861341269522, 29.815406649492058], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.005861341269522, 29.815406649492058], [30.72391633810453, 28.820272615868674], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20191019_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-10-19T08:52:07Z&quot;, &quot;eo:cloud_cover&quot;: 1.34}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14737687712114, 28.809311717195744, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14737687712114, 28.809311717195744], [30.267845515326158, 29.288578085287412], [30.401663724924685, 29.804903082628872], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14737687712114, 28.809311717195744]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20191016_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-10-16T08:42:11Z&quot;, &quot;eo:cloud_cover&quot;: 3.01}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.00017377791805, 29.815320663813125], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00017377791805, 29.815320663813125], [30.838157293795494, 29.236963156105517], [30.718487318920808, 28.820180898203656], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191014_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-10-14T08:52:08Z&quot;, &quot;eo:cloud_cover&quot;: 2.02}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.140826418437545, 28.809173020061884, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.140826418437545, 28.809173020061884], [30.392979274084425, 29.804731955200836], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.140826418437545, 28.809173020061884]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191011_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-10-11T08:42:13Z&quot;, &quot;eo:cloud_cover&quot;: 4.33}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14962864703342, 28.809359321888333, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14962864703342, 28.809359321888333], [30.400835484257655, 29.804886786755986], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14962864703342, 28.809359321888333]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20191006_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-10-06T08:42:11Z&quot;, &quot;eo:cloud_cover&quot;: 2.89}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.99986222891442, 29.815315946679068], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.99986222891442, 29.815315946679068], [30.717054576582488, 28.820156657053623], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20191004_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-10-04T08:52:08Z&quot;, &quot;eo:cloud_cover&quot;: 1.86}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.01217033523485, 29.815501743528362], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.01217033523485, 29.815501743528362], [30.729343972536213, 28.820364091666796], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190929_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-09-29T08:52:06Z&quot;, &quot;eo:cloud_cover&quot;: 1.73}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.15290414388948, 28.809428502066876, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.15290414388948, 28.809428502066876], [30.404763851873966, 29.804964032398765], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.15290414388948, 28.809428502066876]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190926_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-09-26T08:42:10Z&quot;, &quot;eo:cloud_cover&quot;: 3.09}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.01434251494815, 29.815534414552335], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.01434251494815, 29.815534414552335], [30.73210924000249, 28.820410612696342], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190919_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-09-19T08:52:05Z&quot;, &quot;eo:cloud_cover&quot;: 1.56}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.00586230651507, 29.81540666406405], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00586230651507, 29.81540666406405], [30.72780886647385, 28.820338241582785], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190909_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-09-09T08:52:07Z&quot;, &quot;eo:cloud_cover&quot;: 2.05}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.145534514651914, 28.80927273981933, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.145534514651914, 28.80927273981933], [30.39690730608458, 29.804809427969126], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.145534514651914, 28.80927273981933]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190906_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-09-06T08:42:12Z&quot;, &quot;eo:cloud_cover&quot;: 3.63}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.999758723258527, 29.815314379347058], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.999758723258527, 29.815314379347058], [30.716644862525918, 28.820149722136154], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190904_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-09-04T08:52:05Z&quot;, &quot;eo:cloud_cover&quot;: 2.44}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.003792553495717, 29.81537540150385], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.003792553495717, 29.81537540150385], [30.721048631911938, 28.8202241961706], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190830_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-08-30T08:52:09Z&quot;, &quot;eo:cloud_cover&quot;: 1.96}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14348733822098, 28.809229399831715, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14348733822098, 28.809229399831715], [30.39442624486167, 29.80476050747152], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14348733822098, 28.809229399831715]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190827_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-08-27T08:42:14Z&quot;, &quot;eo:cloud_cover&quot;: 4.91}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.99944972080771, 29.815309699801954], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.99944972080771, 29.815309699801954], [30.837810686162104, 29.23876133503118], [30.718487796453882, 28.820180906280694], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190825_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-08-25T08:52:07Z&quot;, &quot;eo:cloud_cover&quot;: 2.5}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.00006929117041, 29.81531908187105], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00006929117041, 29.81531908187105], [30.718078873772527, 28.82017398910531], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190820_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-08-20T08:52:11Z&quot;, &quot;eo:cloud_cover&quot;: 2.23}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.997379915274937, 29.815278335945486], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.997379915274937, 29.815278335945486], [30.714494283478025, 28.820113300509846], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190815_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-08-15T08:52:09Z&quot;, &quot;eo:cloud_cover&quot;: 2.19}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.998621109934795, 29.815297147717892], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.998621109934795, 29.815297147717892], [30.71592808076258, 28.820137586724048], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190810_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-08-10T08:52:12Z&quot;, &quot;eo:cloud_cover&quot;: 1.89}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.99644905848158, 29.81526422005544], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.99644905848158, 29.81526422005544], [30.71357258780428, 28.820097680421874], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190805_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-08-05T08:52:10Z&quot;, &quot;eo:cloud_cover&quot;: 2.84}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.997379940898654, 29.815278336333957], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.997379940898654, 29.815278336333957], [30.714596717659756, 28.82011503608535], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190731_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-07-31T08:52:13Z&quot;, &quot;eo:cloud_cover&quot;: 1.84}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.998415559648848, 29.81529403316627], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.998415559648848, 29.81529403316627], [30.845508746617096, 29.269019954730673], [30.717361191307376, 28.820161846072978], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190726_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-07-26T08:52:10Z&quot;, &quot;eo:cloud_cover&quot;: 3.13}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.99551843268224, 29.81525010110955], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.99551843268224, 29.81525010110955], [30.71357279908112, 28.820097684003134], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190721_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-07-21T08:52:14Z&quot;, &quot;eo:cloud_cover&quot;: 2.38}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.136322895702868, 28.80907747943239, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.136322895702868, 28.80907747943239], [30.287715215223635, 29.40859040178462], [30.390913090936124, 29.804691156868273], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.136322895702868, 28.80907747943239]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190718_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-07-18T08:42:19Z&quot;, &quot;eo:cloud_cover&quot;: 4.73}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.999656598219673, 29.81531283284149], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.999656598219673, 29.81531283284149], [30.834576430347884, 29.226258357373265], [30.71869254018666, 28.82018436917939], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190716_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-07-16T08:52:11Z&quot;, &quot;eo:cloud_cover&quot;: 1.7}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.995828743539313, 29.81525480970501], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.995828743539313, 29.81525480970501], [30.713982464949066, 28.820104627437168], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190711_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-07-11T08:52:14Z&quot;, &quot;eo:cloud_cover&quot;: 2.67}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.999758748897907, 29.81531437973531], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.999758748897907, 29.81531437973531], [30.71674729691273, 28.820151456081632], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190706_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-07-06T08:52:11Z&quot;, &quot;eo:cloud_cover&quot;: 3.54}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.998310798353582, 29.815292445672675], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.998310798353582, 29.815292445672675], [30.715518414146423, 28.820130649187636], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190701_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-07-01T08:52:14Z&quot;, &quot;eo:cloud_cover&quot;: 2.68}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.00451790144647, 29.815386361205444], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00451790144647, 29.815386361205444], [30.850626444638195, 29.265403131028854], [30.723608321633574, 28.82026741809708], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190626_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-06-26T08:52:10Z&quot;, &quot;eo:cloud_cover&quot;: 3.93}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.00006921446304, 29.81531908070966], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00006921446304, 29.81531908070966], [30.717771570495902, 28.820168790067797], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190621_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-06-21T08:52:13Z&quot;, &quot;eo:cloud_cover&quot;: 2.06}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14164507435743, 28.80919037139826, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14164507435743, 28.80919037139826], [30.23958912548818, 29.199025116312836], [30.39649503088676, 29.80480130213401], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14164507435743, 28.80919037139826]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190618_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-06-18T08:42:18Z&quot;, &quot;eo:cloud_cover&quot;: 4.51}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 29.19543518929729, 31.00803320265495, 29.815439419485056], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.831386620620734, 29.19543518929729], [29.90784465598233, 29.42239652131928], [29.896473859714554, 29.793998377705638], [31.00803320265495, 29.815439419485056], [30.831386620620734, 29.19543518929729]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190616_1_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-06-16T08:52:05Z&quot;, &quot;eo:cloud_cover&quot;: 1.73}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.00286171775937, 29.815361331131783], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00286171775937, 29.815361331131783], [30.720229365704412, 28.820210352096016], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190611_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-06-11T08:52:13Z&quot;, &quot;eo:cloud_cover&quot;: 2.86}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.012997773358155, 29.81551419295936], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.012997773358155, 29.81551419295936], [30.73016326863559, 28.82037788087317], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190606_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-06-06T08:52:08Z&quot;, &quot;eo:cloud_cover&quot;: 2.58}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.155155817504838, 28.80947601242103, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.155155817504838, 28.80947601242103], [30.40641772032487, 29.80499651835825], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.155155817504838, 28.80947601242103]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190603_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-06-03T08:42:12Z&quot;, &quot;eo:cloud_cover&quot;: 4.52}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.998724538606208, 29.815298714775142], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.998724538606208, 29.815298714775142], [30.716030491564577, 28.820139320814608], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190601_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-06-01T08:52:14Z&quot;, &quot;eo:cloud_cover&quot;: 1.72}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.138574451419974, 28.80912526418697, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.138574451419974, 28.80912526418697], [30.389877894992473, 29.8046707039918], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.138574451419974, 28.80912526418697]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190529_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-29T08:42:18Z&quot;, &quot;eo:cloud_cover&quot;: 4.06}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.136322677435437, 28.809077474798283, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.136322677435437, 28.809077474798283], [30.387603684279387, 29.804625742788854], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.136322677435437, 28.809077474798283]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190519_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-19T08:42:19Z&quot;, &quot;eo:cloud_cover&quot;: 4.27}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.007207029314362, 29.815426958030123], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.007207029314362, 29.815426958030123], [30.83942305493462, 29.21587096726433], [30.726270836772336, 28.82031232474263], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190517_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-17T08:52:09Z&quot;, &quot;eo:cloud_cover&quot;: 2.73}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14778635782354, 28.80932037682926, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14778635782354, 28.80932037682926], [30.39938832996731, 29.804858301110386], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14778635782354, 28.80932037682926]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190514_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-14T08:42:14Z&quot;, &quot;eo:cloud_cover&quot;: 4.58}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.994380694970506, 29.815232831065412], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.994380694970506, 29.815232831065412], [30.712343849210246, 28.82007684704377], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190512_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-12T08:52:14Z&quot;, &quot;eo:cloud_cover&quot;: 1.65}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.135094486230354, 28.80905139305262, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.135094486230354, 28.80905139305262], [30.386569997384672, 29.804605293824444], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.135094486230354, 28.80905139305262]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190509_2_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-09T08:42:18Z&quot;, &quot;eo:cloud_cover&quot;: 0}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.135094486230354, 28.80905139305262, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.135094486230354, 28.80905139305262], [30.386569997384672, 29.804605293824444], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.135094486230354, 28.80905139305262]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190509_1_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-09T08:42:18Z&quot;, &quot;eo:cloud_cover&quot;: 0}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.135094486230354, 28.80905139305262, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.135094486230354, 28.80905139305262], [30.386569997384672, 29.804605293824444], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.135094486230354, 28.80905139305262]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190509_3_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-09T08:42:18Z&quot;, &quot;eo:cloud_cover&quot;: 0}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.002861692151146, 29.815361330744608], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.002861692151146, 29.815361330744608], [30.720126931041865, 28.820208620790762], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190507_1_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-07T08:52:09Z&quot;, &quot;eo:cloud_cover&quot;: 0}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.99665588985808, 29.81526735709731], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.99665588985808, 29.81526735709731], [30.713674974884718, 28.82009941589912], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190502_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-05-02T08:52:13Z&quot;, &quot;eo:cloud_cover&quot;: 3.29}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.137141597425234, 28.80909485908466, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.137141597425234, 28.80909485908466], [30.38884424933316, 29.804650273647056], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.137141597425234, 28.80909485908466]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190429_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-04-29T08:42:17Z&quot;, &quot;eo:cloud_cover&quot;: 3.18}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.004517880471205, 29.815386360888585], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.004517880471205, 29.815386360888585], [30.84361395137725, 29.240388930288002], [30.723505770653947, 28.82026568739532], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190427_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-04-27T08:52:09Z&quot;, &quot;eo:cloud_cover&quot;: 1.77}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 30.998247168653652, 29.81529148142353], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [30.998247168653652, 29.81529148142353], [30.99738248053307, 29.81195825716795], [30.71816395714578, 28.827212860056584], [30.71664143697684, 28.821863909908], [30.716450393329765, 28.821229111566097], [30.716064374265304, 28.82013989452283], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190422_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-04-22T09:00:59Z&quot;, &quot;eo:cloud_cover&quot;: 1.39}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.137922579080115, 28.80911152755668, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.137927017732245, 28.80911152755668], [30.137922579080115, 28.80927379613276], [30.146039132896878, 28.842098800989802], [30.14769996826997, 28.848808875387697], [30.14936098017612, 28.855518938383437], [30.168399834525474, 28.93169003072582], [30.2234385717036, 29.150947487821867], [30.2375702459448, 29.206443353415715], [30.258791794423292, 29.28968547689254], [30.28098050758118, 29.376372361681753], [30.281167182420837, 29.37709778300067], [30.28135385950093, 29.377823204158993], [30.28154053882158, 29.378548625156725], [30.281727220382933, 29.37927404599382], [30.28191390418512, 29.379999466670263], [30.28210059022829, 29.380724887186027], [30.282287278512577, 29.38145030754109], [30.28247396903811, 29.38217572773543], [30.282660661805036, 29.382901147769008], [30.282847356813495, 29.38362656764181], [30.283220753555547, 29.385077406904998], [30.298168767088054, 29.442930141752072], [30.392546403813135, 29.80436260579971], [30.392743791368623, 29.804727307050893], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.137927017732245, 28.80911152755668]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190419_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-04-19T08:50:18Z&quot;, &quot;eo:cloud_cover&quot;: 3.34}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14263085543237, 28.80921135221724, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14263528680692, 28.80921135221724], [30.14263085543237, 28.80937362145967], [30.14410610622383, 28.815358182478032], [30.147057026231007, 28.827327277662892], [30.14927304153865, 28.836213925763627], [30.187178819557484, 28.988009294999436], [30.22535808908873, 29.140704284260057], [30.282273398336788, 29.366476556903365], [30.30091829596746, 29.44027989216585], [30.393025399442802, 29.8018464267698], [30.393213428137575, 29.802571747506885], [30.393401459155132, 29.803297068068673], [30.393777528159166, 29.80474770866612], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14263528680692, 28.80921135221724]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190409_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-04-09T08:51:24Z&quot;, &quot;eo:cloud_cover&quot;: 2.53}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.007142061651646, 29.81542597788147], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.007142061651646, 29.81542597788147], [31.005695908131194, 29.810099166994526], [31.00521281307222, 29.808377676822758], [30.997674146117856, 29.7817387110831], [30.996514255503104, 29.77766119192187], [30.724052444832086, 28.820274912442773], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190407_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-04-07T08:56:11Z&quot;, &quot;eo:cloud_cover&quot;: 1.42}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 29.115004948201697, 31.009520938582753, 29.81546184648132], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.809155769218616, 29.115004948201697], [29.916257536555776, 29.334809216508813], [29.91148550829385, 29.336051566326134], [29.91044608707564, 29.336388231581974], [29.896473859714554, 29.793998377705638], [31.009520938582753, 29.81546184648132], [31.008750357876323, 29.81258120771687], [30.924240330283602, 29.515177303662462], [30.81199155441333, 29.120825557105327], [30.810365813794295, 29.115114945091367], [30.809155769218616, 29.115004948201697]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190328_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-03-28T08:58:13Z&quot;, &quot;eo:cloud_cover&quot;: 0.02}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.011589530709404, 29.815493001789328], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.011589530709404, 29.815493001789328], [31.01110774154407, 29.81369937338383], [30.735404903273356, 28.844826452306023], [30.73388129469274, 28.83947764626295], [30.729214753115382, 28.823158856550283], [30.728353736277803, 28.820347418799535], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190323_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-03-23T08:54:09Z&quot;, &quot;eo:cloud_cover&quot;: 0.87}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.013554696234372, 29.815522569365356], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.013554696234372, 29.815522569365356], [31.013272592142304, 29.814092834582375], [31.012209836959165, 29.810287563513533], [31.009793941412635, 29.801680191845236], [30.733223392491666, 28.82728636348899], [30.73265189304671, 28.825291830178866], [30.73122127270839, 28.820395680302777], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190318_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-03-18T08:55:08Z&quot;, &quot;eo:cloud_cover&quot;: 1.75}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.154094584556155, 28.809453718197346, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.154098998210717, 28.809453718197346], [30.154094584556155, 28.809615989057615], [30.154644973748788, 28.8119728587854], [30.15593583054776, 28.817231815302364], [30.19179627823161, 28.96140605927571], [30.24111049108768, 29.158709387739528], [30.243153151882236, 29.166869673853398], [30.29769885744087, 29.38284619982904], [30.313561431461537, 29.445406639839586], [30.401607458550732, 29.789928511775713], [30.401795534707045, 29.790653823849205], [30.401983613186786, 29.79137913574679], [30.402171693990088, 29.792104447468468], [30.402359777117088, 29.792829759014186], [30.402547862567936, 29.793555070383952], [30.402735950342773, 29.794280381577728], [30.40292404044173, 29.79500569259549], [30.403112132864955, 29.795731003437194], [30.403300227612593, 29.796456314102837], [30.40348832468478, 29.797181624592394], [30.40367642408165, 29.797906934905832], [30.403864525803357, 29.79863224504312], [30.404052629850035, 29.799357555004246], [30.40424073622183, 29.800082864789175], [30.404428844918876, 29.800808174397897], [30.404616955941318, 29.801533483830372], [30.404805069289303, 29.802258793086573], [30.404993184962958, 29.802984102166494], [30.40518130296244, 29.803709411070084], [30.405369423287873, 29.804434719797346], [30.405562202527157, 29.804979716514726], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.154098998210717, 28.809453718197346]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190315_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-03-15T08:43:23Z&quot;, &quot;eo:cloud_cover&quot;: 3.48}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.007969496618546, 29.815438458769037], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.007969496618546, 29.815438458769037], [31.007881808092744, 29.814643192721963], [30.997740572993695, 29.778401540276942], [30.916375613173784, 29.491235645275033], [30.731704803129507, 28.840613957237046], [30.72618348549215, 28.82121309014577], [30.725895853510558, 28.820306003361562], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190313_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-03-13T08:52:21Z&quot;, &quot;eo:cloud_cover&quot;: 1.15}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.27917303438719, 29.202037622770256, 31.04339332852454, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[31.039712735626495, 29.202037622770256], [31.029195116208335, 29.203507228433164], [30.28561802606418, 29.325791437178523], [30.280651170790193, 29.32677270079703], [30.279182134522557, 29.327825168256126], [30.27917303438719, 29.328167750127587], [30.294812488479977, 29.390725399253675], [30.308435204895122, 29.444401025839156], [30.39923699440455, 29.80160806945133], [30.399425068371883, 29.80233338403879], [30.399613144663544, 29.803058698450403], [30.39980122327967, 29.803784012686144], [30.399989304220405, 29.804509326746004], [30.40018671994701, 29.804874018503273], [31.031551610920825, 29.815791988006527], [31.04339332852454, 29.202091498390654], [31.039712735626495, 29.202037622770256]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190310_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-03-10T08:52:50Z&quot;, &quot;eo:cloud_cover&quot;: 1.81}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.017071315524028, 29.815575406889856], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.017071315524028, 29.815575406889856], [31.016787380123564, 29.814235871714303], [30.73894139123242, 28.83766789199018], [30.738369738334967, 28.83567337653516], [30.737321107532985, 28.83204682406729], [30.73446135478601, 28.822164395591482], [30.7338839914029, 28.820440440065767], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190308_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-03-08T08:57:39Z&quot;, &quot;eo:cloud_cover&quot;: 1.59}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.011692960400918, 29.815494558705474], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.011692960400918, 29.815494558705474], [31.011113098716756, 29.813428791124508], [30.730221287067, 28.823987813390584], [30.729649859332138, 28.821993270651316], [30.72917303168299, 28.820361214010127], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190303_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-03-03T08:52:04Z&quot;, &quot;eo:cloud_cover&quot;: 1.18}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.149595380460493, 28.809358618873024, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.149595380460493, 28.809358618873024], [30.14976128823292, 28.810787316901102], [30.150126511264908, 28.81241867089858], [30.150676818561664, 28.81477555074919], [30.151782403898366, 28.819309006427293], [30.18727132060179, 28.961852673688586], [30.22451953876774, 29.110739876789435], [30.2390010813794, 29.168407723706668], [30.292049086365555, 29.378401797348804], [30.30958553983763, 29.447671558320614], [30.388421567154662, 29.756113620944923], [30.400440124810526, 29.80307497658376], [30.400628209516622, 29.8038002900007], [30.40081629654754, 29.804525603241668], [30.40101371540405, 29.804890293943664], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.149595380460493, 28.809358618873024]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190228_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-02-28T08:55:57Z&quot;, &quot;eo:cloud_cover&quot;: 4.25}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.147948368880286, 28.80932400011884, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.147957706678966, 28.80932400011884], [30.147948368880286, 28.809666570101665], [30.16235454988688, 28.867519469875294], [30.230516693145834, 29.139909046681225], [30.246866421972058, 29.204831020486978], [30.30030755017178, 29.416634647803125], [30.39854673832217, 29.804300519600535], [30.398739479528704, 29.804845524050798], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.147957706678966, 28.80932400011884]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190223_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-02-23T08:45:41Z&quot;, &quot;eo:cloud_cover&quot;: 3.77}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.007866067219243, 29.815436898941172], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.007866067219243, 29.815436898941172], [31.007093745467, 29.812646446584573], [30.726538252352917, 28.82374533590517], [30.725966897008288, 28.821750781483857], [30.72548620688583, 28.820299096441854], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190221_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-02-21T08:52:35Z&quot;, &quot;eo:cloud_cover&quot;: 1.03}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.147743659192237, 28.809319671380266, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.147752997658937, 28.809319671380266], [30.147743659192237, 28.809662241302096], [30.149954581844863, 28.818729176398257], [30.15124525130287, 28.82398816257152], [30.153276468527782, 28.832149241121833], [30.187481366964384, 28.9692536345779], [30.22342997875722, 29.113062557305657], [30.237357614581434, 29.168373809983354], [30.292652830363867, 29.386712642901625], [30.307961306118617, 29.446736687262508], [30.398616768873826, 29.801595856233227], [30.39880483827397, 29.802321171434595], [30.39899290999829, 29.803046486460143], [30.399180984046914, 29.8037718013099], [30.399369060419996, 29.804497115983803], [30.399566473799133, 29.804861808532475], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.147752997658937, 28.809319671380266]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190218_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-02-18T08:42:09Z&quot;, &quot;eo:cloud_cover&quot;: 2.05}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.00755577907009, 29.815432218972298], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00755577907009, 29.815432218972298], [31.006881524152753, 29.812913907336174], [31.004852852004003, 29.805665614820626], [31.001952900171858, 29.795426831177704], [30.732990175225016, 28.847492580774126], [30.73203820870797, 28.844138291706024], [30.727084147201495, 28.826912367981855], [30.725178972011673, 28.820293915437066], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190216_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-02-16T08:52:02Z&quot;, &quot;eo:cloud_cover&quot;: 1.54}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14712461429584, 28.809306683305483, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.147138870869153, 28.809306683305483], [30.14712461429584, 28.809829552898687], [30.18187779955264, 28.948931047550715], [30.230987698412537, 29.14533090551817], [30.30038947711374, 29.421326804772026], [30.38570238281162, 29.75732270158238], [30.3975363560289, 29.803378601985337], [30.397912485936633, 29.80482923440267], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.147138870869153, 28.809306683305483]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190213_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-02-13T08:42:07Z&quot;, &quot;eo:cloud_cover&quot;: 2.31}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.144468310312206, 28.809250369424447, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.144477659467093, 28.809250369424447], [30.144468310312206, 28.80959293836966], [30.147604231345053, 28.822287555409346], [30.14945005235391, 28.829723140672627], [30.184767146750602, 28.971000850287798], [30.223139210440234, 29.123880762186158], [30.22685385242674, 29.138570422385225], [30.242652186055363, 29.200955720710333], [30.29760166851304, 29.41766217389518], [30.30189492390509, 29.434526787977724], [30.393639984975405, 29.79410124379271], [30.39382800811338, 29.79482656380896], [30.3940160335733, 29.79555188364994], [30.394204061355296, 29.796277203315604], [30.39439209145952, 29.797002522805947], [30.394580123886108, 29.797727842120914], [30.3947681586352, 29.79845316126053], [30.394956195706943, 29.799178480224718], [30.39514423510147, 29.799903799013485], [30.39533227681893, 29.800629117626794], [30.395520320859458, 29.801354436064628], [30.395708367223193, 29.802079754326943], [30.395896415910283, 29.80280507241375], [30.396084466920865, 29.80353039032499], [30.39627252025508, 29.80425570806065], [30.396465248783446, 29.804800715086778], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.144477659467093, 28.809250369424447]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190208_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-02-08T08:42:10Z&quot;, &quot;eo:cloud_cover&quot;: 1.53}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.006314627204915, 29.815413491817537], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.006314627204915, 29.815413491817537], [31.004002208743177, 29.80682563747254], [30.72517351194149, 28.825256128453994], [30.72374521033561, 28.82026972817795], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190201_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-02-01T08:52:06Z&quot;, &quot;eo:cloud_cover&quot;: 1.17}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.14364947489565, 28.809233031541858, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.143658826722557, 28.809233031541858], [30.14364947489565, 28.80957560024275], [30.1536142241064, 28.849835940777606], [30.155460791029032, 28.857271480981655], [30.187071408314853, 28.98439897422757], [30.22282720539459, 29.12784317504289], [30.24159087730775, 29.202196661398844], [30.2935398281382, 29.407657484331644], [30.38789735811055, 29.77630838505523], [30.388085316041703, 29.77703371047923], [30.38827327629106, 29.777759035728632], [30.38846123885875, 29.77848436080346], [30.388649203744922, 29.779209685703652], [30.388837170949706, 29.7799350104292], [30.38902514047326, 29.780660334980073], [30.389213112315716, 29.78138565935624], [30.389401086477218, 29.782110983557697], [30.3895890629579, 29.7828363075844], [30.389777041757906, 29.78356163143633], [30.38996502287738, 29.78428695511346], [30.39015300631646, 29.78501227861579], [30.39034099207529, 29.785737601943243], [30.390528980154006, 29.786462925095826], [30.390716970552756, 29.78718824807352], [30.390904963271677, 29.787913570876288], [30.3910929583109, 29.788638893504107], [30.39128095567058, 29.789364215956954], [30.39146895535086, 29.79008953823481], [30.39165695735187, 29.790814860337647], [30.391844961673755, 29.79154018226542], [30.39203296831666, 29.79226550401813], [30.392220977280722, 29.79299082559574], [30.39240898856608, 29.793716146998225], [30.392597002172874, 29.794441468225568], [30.39278501810125, 29.795166789277733], [30.392973036351353, 29.795892110154696], [30.393161056923315, 29.79661743085644], [30.393349079817277, 29.797342751382942], [30.39353710503339, 29.79806807173418], [30.39372513257178, 29.798793391910106], [30.3939131624326, 29.79951871191071], [30.394101194615992, 29.80024403173597], [30.394289229122087, 29.800969351385866], [30.394477265951036, 29.801694670860346], [30.394665305102976, 29.802419990159432], [30.394853346578042, 29.803145309283035], [30.395229436498134, 29.804595947003843], [30.39543150923271, 29.80478033445987], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.143658826722557, 28.809233031541858]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190129_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-01-29T08:42:10Z&quot;, &quot;eo:cloud_cover&quot;: 2.24}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.005383764074377, 29.81539943880828], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.005383764074377, 29.81539943880828], [31.004130218521066, 29.81079728814972], [30.99881905602052, 29.791770575137374], [30.997274166188603, 29.786243698519968], [30.996791307103603, 29.784522183704986], [30.996018044664357, 29.78180383452771], [30.92011379948442, 29.515203012456766], [30.72941854046595, 28.846800905650497], [30.728084403831456, 28.842177025715134], [30.727321806769673, 28.83954768868914], [30.7231271477175, 28.825131374582554], [30.721696982428725, 28.820235148560116], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190127_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-01-27T08:52:02Z&quot;, &quot;eo:cloud_cover&quot;: 1.86}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.144677939555645, 28.80925470312051, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.144682367765977, 28.80925470312051], [30.144677939555645, 28.80941697265232], [30.14485804814033, 28.810322803544658], [30.1476288199197, 28.82138605736678], [30.182595062496453, 28.960311521496156], [30.229888165664164, 29.148014220708443], [30.29561338050525, 29.407158400754152], [30.299719136056197, 29.423297648752747], [30.396309903632318, 29.8028132236906], [30.39649795768794, 29.8035385411928], [30.3966860140673, 29.804263858519406], [30.396878744900803, 29.804808865077245], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.144682367765977, 28.80925470312051]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190124_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-01-24T08:42:07Z&quot;, &quot;eo:cloud_cover&quot;: 3.74}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.144263601390413, 28.80924603541856, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.144272951213303, 28.80924603541856], [30.144263601390413, 28.8095886043027], [30.14444370649508, 28.81049443549752], [30.148860390430507, 28.8288086539328], [30.22108901794462, 29.1160808930803], [30.288980485631736, 29.385375138846495], [30.304090165271983, 29.445034678200045], [30.39355113532679, 29.797527140810555], [30.393739162265067, 29.79825246096471], [30.393927191525705, 29.798977780943552], [30.394115223108848, 29.799703100747053], [30.394303257014627, 29.800428420375187], [30.394491293243195, 29.801153739827917], [30.394679331794684, 29.801879059105243], [30.394867372669243, 29.802604378207125], [30.395055415867002, 29.80332969713355], [30.39543150923271, 29.80478033445987], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.144272951213303, 28.80924603541856]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190119_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-01-19T08:42:10Z&quot;, &quot;eo:cloud_cover&quot;: 2.37}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.006228742043312, 29.815411930695582], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.00621119793566, 29.815411930695582], [31.006228742043312, 29.814528031469724], [31.00603620797152, 29.813803358701822], [30.72484623814737, 28.821461212257542], [30.724462090953306, 28.820281823709184], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190107_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-01-07T08:52:00Z&quot;, &quot;eo:cloud_cover&quot;: 2.18}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [30.148357788391497, 28.80933265666646, 31.050481437029678, 29.815791988006527], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[30.14836712485415, 28.80933265666646], [30.148357788391497, 28.809675226771272], [30.151859466426515, 28.824001137978417], [30.185162575029953, 28.95639641621358], [30.23412406079832, 29.150988253245053], [30.301332490124523, 29.41683583047224], [30.398452044197093, 29.799968986156994], [30.398640110271234, 29.800694301498055], [30.399016249391398, 29.8021449316529], [30.399392397808352, 29.803595561104494], [30.399580475503477, 29.804320875566532], [30.39977322247271, 29.804865878845646], [31.031551610920825, 29.815791988006527], [31.050481437029678, 28.825387639743422], [30.14836712485415, 28.80933265666646]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_36RTT_20190104_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-01-04T08:42:04Z&quot;, &quot;eo:cloud_cover&quot;: 3.77}, &quot;type&quot;: &quot;Feature&quot;}, {&quot;bbox&quot;: [29.896473859714554, 28.804454491507947, 31.006314627204915, 29.815413491817537], &quot;collection&quot;: &quot;sentinel-s2-l2a-cogs&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[29.92628490999458, 28.804454491507947], [29.896473859714554, 29.793998377705638], [31.006314627204915, 29.815413491817537], [31.00612889421045, 29.814346082720974], [30.91402666895001, 29.490116153244493], [30.735250063742406, 28.861425016690696], [30.72354038738294, 28.820266271613317], [29.92628490999458, 28.804454491507947]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2B_36RTT_20190102_0_L2A&quot;, &quot;properties&quot;: {&quot;datetime&quot;: &quot;2019-01-02T08:52:03Z&quot;, &quot;eo:cloud_cover&quot;: 2.96}, &quot;type&quot;: &quot;Feature&quot;}], &quot;links&quot;: [], &quot;numberMatched&quot;: 85, &quot;numberReturned&quot;: 85, &quot;stac_extensions&quot;: [], &quot;stac_version&quot;: &quot;1.0.0-beta.2&quot;, &quot;type&quot;: &quot;FeatureCollection&quot;});\n",
-       "\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x11fe24f70>"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "m = Map(\n",
     "    tiles=\"OpenStreetMap\",\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=8\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=8,\n",
     ")\n",
     "\n",
     "geo_json = GeoJson(\n",
     "    data=data,\n",
     "    style_function=lambda x: {\n",
-    "        'opacity': 1, 'dashArray': '1', 'fillOpacity': 0, 'weight': 1\n",
+    "        \"opacity\": 1,\n",
+    "        \"dashArray\": \"1\",\n",
+    "        \"fillOpacity\": 0,\n",
+    "        \"weight\": 1,\n",
     "    },\n",
     ")\n",
     "geo_json.add_to(m)\n",
@@ -568,35 +304,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x158635dc0>"
-      ]
-     },
-     "execution_count": 28,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "fig = plt.figure(dpi=100)\n",
     "fig.autofmt_xdate()\n",
     "ax = fig.add_subplot(1, 1, 1)\n",
-    "ax.plot(dates, cloudcover, label=\"Cloud Cover\", color=\"tab:red\", linewidth=0.4, linestyle=\"-.\")\n",
+    "ax.plot(\n",
+    "    dates,\n",
+    "    cloudcover,\n",
+    "    label=\"Cloud Cover\",\n",
+    "    color=\"tab:red\",\n",
+    "    linewidth=0.4,\n",
+    "    linestyle=\"-.\",\n",
+    ")\n",
     "\n",
     "ax.legend()"
    ]
@@ -607,12 +329,12 @@
    "source": [
     "## Use Titiler endpoint\n",
     "\n",
-    "https://api.cogeo.xyz/docs#/SpatioTemporal%20Asset%20Catalog\n",
+    "https://titiler.xyz/api.html#/SpatioTemporal%20Asset%20Catalog\n",
     "\n",
-    "`{endpoint}/stac/tiles/{z}/{x}/{y}.{format}?url={stac_item}&{otherquery params}`\n",
+    "`{endpoint}/stac/tiles/{tileMatrixSetId}/{z}/{x}/{y}.{format}?url={stac_item}&{otherquery params}`\n",
     "\n",
     "\n",
-    "`{endpoint}/stac/crop/{minx},{miny},{maxx},{maxy}.{format}?url={stac_item}&{otherquery params}`\n",
+    "`{endpoint}/stac/bbox/{minx},{miny},{maxx},{maxy}.{format}?url={stac_item}&{otherquery params}`\n",
     "\n",
     "\n",
     "`{endpoint}/stac/point/{minx},{miny}?url={stac_item}&{otherquery params}`\n"
@@ -620,7 +342,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -636,123 +358,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "https://earth-search.aws.element84.com/v0/collections/sentinel-s2-l2a-cogs/items/S2B_36RTT_20190102_0_L2A\n",
-      "{'tilejson': '2.2.0', 'version': '1.0.0', 'scheme': 'xyz', 'tiles': ['http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv0%2Fcollections%2Fsentinel-s2-l2a-cogs%2Fitems%2FS2B_36RTT_20190102_0_L2A&assets=B04&assets=B03&assets=B02&color_formula=Gamma+RGB+3.5+Saturation+1.7+Sigmoidal+RGB+15+0.35'], 'minzoom': 8, 'maxzoom': 14, 'bounds': [29.896473859714554, 28.804454491507947, 31.006314627204915, 29.815413491817537], 'center': [30.451394243459735, 29.309933991662742, 8]}\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_8a4aea0aa494734cb54f7aec35321c3c {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_8a4aea0aa494734cb54f7aec35321c3c&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_8a4aea0aa494734cb54f7aec35321c3c = L.map(\n",
-       "                &quot;map_8a4aea0aa494734cb54f7aec35321c3c&quot;,\n",
-       "                {\n",
-       "                    center: [29.486523152893376, 30.848407745361328],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 10,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_c118643ea749d6febfdd44909d46e0b6 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_8a4aea0aa494734cb54f7aec35321c3c);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_a69192cb4b782a44a6945fc89950ac06 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv0%2Fcollections%2Fsentinel-s2-l2a-cogs%2Fitems%2FS2B_36RTT_20190102_0_L2A\\u0026assets=B04\\u0026assets=B03\\u0026assets=B02\\u0026color_formula=Gamma+RGB+3.5+Saturation+1.7+Sigmoidal+RGB+15+0.35&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Digital Earth Africa&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 14, &quot;maxZoom&quot;: 14, &quot;minZoom&quot;: 8, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_8a4aea0aa494734cb54f7aec35321c3c);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x15830db50>"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Get Tile URL\n",
-    "item =  url_template.format(id=sceneid[-1])\n",
+    "item = url_template.format(id=sceneid[-1])\n",
     "print(item)\n",
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/stac/tilejson.json\",\n",
-    "    params = (\n",
+    "    f\"{titiler_endpoint}/stac/WebMercatorQuad/tilejson.json\",\n",
+    "    params=(\n",
     "        (\"url\", item),\n",
     "        # Simple RGB combination (True Color)\n",
-    "        (\"assets\", \"B04\"),  # red, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
-    "        (\"assets\", \"B03\"),  # green, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
-    "        (\"assets\", \"B02\"),  # blue, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
-    "        (\"color_formula\", \"Gamma RGB 3.5 Saturation 1.7 Sigmoidal RGB 15 0.35\"),  # We use a rio-color formula to make the tiles look nice\n",
+    "        (\n",
+    "            \"assets\",\n",
+    "            \"B04\",\n",
+    "        ),  # red, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
+    "        (\n",
+    "            \"assets\",\n",
+    "            \"B03\",\n",
+    "        ),  # green, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
+    "        (\n",
+    "            \"assets\",\n",
+    "            \"B02\",\n",
+    "        ),  # blue, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
+    "        (\n",
+    "            \"color_formula\",\n",
+    "            \"Gamma RGB 3.5 Saturation 1.7 Sigmoidal RGB 15 0.35\",\n",
+    "        ),  # We use a rio-color formula to make the tiles look nice\n",
     "        (\"minzoom\", 8),  # By default titiler will use 0\n",
-    "        (\"maxzoom\", 14), # By default titiler will use 24\n",
-    "    )\n",
+    "        (\"maxzoom\", 14),  # By default titiler will use 24\n",
+    "    ),\n",
     ").json()\n",
     "print(r)\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=10\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=10\n",
     ")\n",
     "\n",
     "tiles = TileLayer(\n",
@@ -760,7 +403,7 @@
     "    min_zoom=r[\"minzoom\"],\n",
     "    max_zoom=r[\"maxzoom\"],\n",
     "    opacity=1,\n",
-    "    attr=\"Digital Earth Africa\"\n",
+    "    attr=\"Digital Earth Africa\",\n",
     ")\n",
     "tiles.add_to(m)\n",
     "m"
@@ -768,119 +411,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'tilejson': '2.2.0', 'version': '1.0.0', 'scheme': 'xyz', 'tiles': ['http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv0%2Fcollections%2Fsentinel-s2-l2a-cogs%2Fitems%2FS2B_36RTT_20191205_0_L2A&assets=B08&assets=B04&assets=B03&color_formula=Gamma+RGB+3.5+Saturation+1.7+Sigmoidal+RGB+15+0.35'], 'minzoom': 8, 'maxzoom': 14, 'bounds': [30.155974613579858, 28.80949327971016, 31.050481437029678, 29.815791988006527], 'center': [30.603228025304766, 29.312642633858346, 8]}\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_876522dae9ad1d9f41bb3f4f9628f041 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_876522dae9ad1d9f41bb3f4f9628f041&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_876522dae9ad1d9f41bb3f4f9628f041 = L.map(\n",
-       "                &quot;map_876522dae9ad1d9f41bb3f4f9628f041&quot;,\n",
-       "                {\n",
-       "                    center: [29.486523152893376, 30.848407745361328],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 10,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_4ddd6c4aaac30dac49553f64a8c5cf7e = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_876522dae9ad1d9f41bb3f4f9628f041);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_f4e19ffbf3a73035f272707367472bce = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv0%2Fcollections%2Fsentinel-s2-l2a-cogs%2Fitems%2FS2B_36RTT_20191205_0_L2A\\u0026assets=B08\\u0026assets=B04\\u0026assets=B03\\u0026color_formula=Gamma+RGB+3.5+Saturation+1.7+Sigmoidal+RGB+15+0.35&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Digital Earth Africa&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 14, &quot;maxZoom&quot;: 14, &quot;minZoom&quot;: 8, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_876522dae9ad1d9f41bb3f4f9628f041);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x15874fe80>"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/stac/tilejson.json\",\n",
-    "    params = (\n",
+    "    f\"{titiler_endpoint}/stac/WebMercatorQuad/tilejson.json\",\n",
+    "    params=(\n",
     "        (\"url\", url_template.format(id=sceneid[0])),\n",
     "        # False Color Infrared\n",
-    "        (\"assets\", \"B08\"),  # nir, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
-    "        (\"assets\", \"B04\"),  # red, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
-    "        (\"assets\", \"B03\"),  # green, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
-    "        (\"color_formula\", \"Gamma RGB 3.5 Saturation 1.7 Sigmoidal RGB 15 0.35\"),  # We use a rio-color formula to make the tiles look nice\n",
+    "        (\n",
+    "            \"assets\",\n",
+    "            \"B08\",\n",
+    "        ),  # nir, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
+    "        (\n",
+    "            \"assets\",\n",
+    "            \"B04\",\n",
+    "        ),  # red, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
+    "        (\n",
+    "            \"assets\",\n",
+    "            \"B03\",\n",
+    "        ),  # green, in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
+    "        (\n",
+    "            \"color_formula\",\n",
+    "            \"Gamma RGB 3.5 Saturation 1.7 Sigmoidal RGB 15 0.35\",\n",
+    "        ),  # We use a rio-color formula to make the tiles look nice\n",
     "        (\"minzoom\", 8),  # By default titiler will use 0\n",
-    "        (\"maxzoom\", 14), # By default titiler will use 24\n",
-    "    )\n",
+    "        (\"maxzoom\", 14),  # By default titiler will use 24\n",
+    "    ),\n",
     ").json()\n",
     "print(r)\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=10\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=10\n",
     ")\n",
     "\n",
     "tiles = TileLayer(\n",
@@ -888,7 +453,7 @@
     "    min_zoom=r[\"minzoom\"],\n",
     "    max_zoom=r[\"maxzoom\"],\n",
     "    opacity=1,\n",
-    "    attr=\"Digital Earth Africa\"\n",
+    "    attr=\"Digital Earth Africa\",\n",
     ")\n",
     "tiles.add_to(m)\n",
     "m"
@@ -896,120 +461,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'tilejson': '2.2.0', 'version': '1.0.0', 'scheme': 'xyz', 'tiles': ['http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv0%2Fcollections%2Fsentinel-s2-l2a-cogs%2Fitems%2FS2B_36RTT_20191205_0_L2A&expression=%28B08-B04%29%2F%28B08%2BB04%29&asset_as_band=true&rescale=-1%2C1&colormap_name=viridis'], 'minzoom': 8, 'maxzoom': 14, 'bounds': [30.155974613579858, 28.80949327971016, 31.050481437029678, 29.815791988006527], 'center': [30.603228025304766, 29.312642633858346, 8]}\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_05a2d255a06c6ec6147b7fbe14429aea {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_05a2d255a06c6ec6147b7fbe14429aea&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_05a2d255a06c6ec6147b7fbe14429aea = L.map(\n",
-       "                &quot;map_05a2d255a06c6ec6147b7fbe14429aea&quot;,\n",
-       "                {\n",
-       "                    center: [29.486523152893376, 30.848407745361328],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 10,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_4a1fc4767be0474fe5defbba770a15b5 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_05a2d255a06c6ec6147b7fbe14429aea);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_a197485a4f26b0b403fa257a78283cee = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv0%2Fcollections%2Fsentinel-s2-l2a-cogs%2Fitems%2FS2B_36RTT_20191205_0_L2A\\u0026expression=%28B08-B04%29%2F%28B08%2BB04%29\\u0026asset_as_band=true\\u0026rescale=-1%2C1\\u0026colormap_name=viridis&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Digital Earth Africa&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 14, &quot;maxZoom&quot;: 14, &quot;minZoom&quot;: 8, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_05a2d255a06c6ec6147b7fbe14429aea);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x15874ff40>"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/stac/tilejson.json\",\n",
-    "    params = {\n",
-    "        \"url\": url_template.format(id=sceneid[0]),\n",
-    "        \"expression\": \"(B08-B04)/(B08+B04)\",  # NDVI (nir-red)/(nir+red), in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
-    "        # We need to tell rio-tiler that each asset is a Band \n",
-    "        # (so it will select the first band within each asset automatically)\n",
-    "        \"asset_as_band\": True,\n",
-    "        \"rescale\": \"-1,1\",\n",
-    "        \"minzoom\": 8,  # By default titiler will use 0\n",
-    "        \"maxzoom\": 14, # By default titiler will use 24\n",
-    "        \"colormap_name\": \"viridis\",\n",
-    "    }\n",
+    "    f\"{titiler_endpoint}/stac/WebMercatorQuad/tilejson.json\",\n",
+    "    params=(\n",
+    "        (\"url\", url_template.format(id=sceneid[0])),\n",
+    "        (\"assets\", \"B08\"),\n",
+    "        (\"assets\", \"B04\"),\n",
+    "        (\n",
+    "            \"expression\",\n",
+    "            \"(b1-b2)/(b1+b2)\",\n",
+    "        ),  # NDVI (nir-red)/(nir+red), in next STAC item version (see\n",
+    "        (\"rescale\", \"-1,1\"),\n",
+    "        (\"colormap_name\", \"viridis\"),\n",
+    "        (\"minzoom\", 8),  # By default titiler will use 0\n",
+    "        (\"maxzoom\", 14),  # By default titiler will use 24\n",
+    "    ),\n",
     ").json()\n",
     "print(r)\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=10\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=10\n",
     ")\n",
     "\n",
     "tiles = TileLayer(\n",
@@ -1017,7 +494,7 @@
     "    min_zoom=r[\"minzoom\"],\n",
     "    max_zoom=r[\"maxzoom\"],\n",
     "    opacity=1,\n",
-    "    attr=\"Digital Earth Africa\"\n",
+    "    attr=\"Digital Earth Africa\",\n",
     ")\n",
     "tiles.add_to(m)\n",
     "m"
@@ -1034,36 +511,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def fetch_bbox_array(sceneid, bbox, assets = None, expression = None, **kwargs):\n",
+    "def fetch_bbox_array(sceneid, bbox, assets, expression=None, **kwargs):\n",
     "    \"\"\"Helper function to fetch and decode Numpy array using Titiler endpoint.\"\"\"\n",
     "    # STAC ITEM URL\n",
     "    stac_item = f\"https://earth-search.aws.element84.com/v0/collections/sentinel-s2-l2a-cogs/items/{sceneid}\"\n",
     "\n",
     "    xmin, ymin, xmax, ymax = bbox\n",
-    "    \n",
+    "\n",
     "    # TiTiler required URL + asset or expression parameters\n",
-    "    params = ((\"url\", stac_item), )\n",
-    "    if assets:\n",
-    "        for asset in assets:\n",
-    "            params += ((\"assets\", asset), )\n",
-    "    elif expression:\n",
-    "        params += ((\"expression\", expression), (\"asset_as_band\", True),)\n",
-    "    else:\n",
-    "        raise Exception(\"Missing band or expression input\")\n",
+    "    params = ((\"url\", stac_item), (\"max_size\", 1024))\n",
+    "\n",
+    "    for asset in assets:\n",
+    "        params += ((\"assets\", asset),)\n",
+    "\n",
+    "    if expression:\n",
+    "        params += (\n",
+    "            (\"expression\", expression),\n",
+    "            (\"asset_as_band\", True),\n",
+    "        )\n",
     "\n",
     "    params += tuple(kwargs.items())\n",
     "\n",
     "    # TITILER ENDPOINT\n",
-    "    url = f\"{titiler_endpoint}/stac/crop/{xmin},{ymin},{xmax},{ymax}.npy\"\n",
+    "    url = f\"{titiler_endpoint}/stac/bbox/{xmin},{ymin},{xmax},{ymax}.npy\"\n",
     "    r = httpx.get(url, params=params)\n",
     "    data = numpy.load(BytesIO(r.content))\n",
-    "    \n",
+    "\n",
     "    return sceneid, data[0:-1], data[-1]\n",
     "\n",
+    "\n",
     "def _filter_futures(tasks):\n",
     "    for future in tasks:\n",
     "        try:\n",
@@ -1071,6 +551,7 @@
     "        except Exception:\n",
     "            pass\n",
     "\n",
+    "\n",
     "def _stats(data, mask):\n",
     "    arr = numpy.ma.array(data)\n",
     "    arr.mask = mask == 0\n",
@@ -1079,43 +560,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(1, 128, 128)\n",
-      "(128, 128)\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.image.AxesImage at 0x15879f490>"
-      ]
-     },
-     "execution_count": 33,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Fetch one data\n",
-    "_, data, mask = fetch_bbox_array(sceneid[0], bounds, assets=[\"B02\"], width=128, height=128)\n",
+    "_, data, mask = fetch_bbox_array(\n",
+    "    sceneid[0], bounds, assets=[\"B02\"], width=128, height=128\n",
+    ")\n",
     "\n",
     "print(data.shape)\n",
     "print(mask.shape)\n",
@@ -1125,43 +579,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "900812f792d44a349a3b2e1579b17338",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "  0%|          | 0/85 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "diplay all results\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvwAAAY0CAYAAACVrNlFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9R5Ota3qeiV3P6z6zTNptz97HVQEgCgSBbhoI3Wy1pEAHpdAP4JBiaKKOACcYERNSHCio6BEH5I/gSBHShAoFFKGQgQIQ0XAFFFAGx26XbrnPvVaDL08BIBrNA/BsVqG4rtHZeXJn5s71rPd9vsfct5RSCkeOHDly5MiRI0eOHPmRRP2gf4AjR44cOXLkyJEjR468PY4J/5EjR44cOXLkyJEjP8IcE/4jR44cOXLkyJEjR36EOSb8R44cOXLkyJEjR478CHNM+I8cOXLkyJEjR44c+RHmmPAfOXLkyJEjR44cOfIjzDHhP3LkyJEjR44cOXLkR5hjwn/kyJEjR44cOXLkyI8wx4T/yJEjR44cOXLkyJEfYY4J/5EjR44cOXLkyJEjP8K8tYT/X/2rf8X7779PXdf83M/9HL/2a7/2tr7VkSN/hmP8HflBcoy/Iz9ojjF45AfJMf5++HgrCf+//tf/ml/6pV/in/7Tf8pv/MZv8DM/8zP8vb/393jz5s3b+HZHjvwpjvF35AfJMf6O/KA5xuCRHyTH+PvhREop5av+oj/3cz/H3/7bf5t/+S//JQA5Z54/f84/+kf/iH/8j//x/+jfzTnz4sULVqsVIvJV/2g/cpRS2O/3PH36FKWOE1rwHxZ/X3z+MQa/PMcY/NMc4+8/Lsf4+7Mc7+D/eBzj789yPAP/4/JlY9B81d/Ye8+//bf/ll/+5V/+/seUUvzCL/wCv/qrv/pnPn+aJqZp+v6fP//8c77xjW981T/Wjzyffvopz549+0H/GD9w/qLxB8cY/Ko4xuAx/n6QHONv5ngH/2A4xt/M8Qz8wfHvi8GvPOG/vr4mpcSjR4/+1McfPXrEt771rT/z+f/8n/9z/tk/+2d/5uOXP7YmxkSYAjFEyv1DnihBO4UyQhFB6fnPSUBl4aKu+frlGd2Q+d71FV970LK0lrO64v2TNVNT+N3tFSYa6iLoIgQUU/JsxwmK4ESxsoYnq4oHTYO2mleHjk83HfvJ86itedo2rA30KfHmEHjTe8acsU6zLZGLymJFiLGQY+RNjny9XbIUTV0E0cK2Fi6LYZoC75yvWLcV1hlWC816UbO+OKMUuN0euLrreHR+hmsVaYqMUZOTZuw8/9v/w/+Z1Wr1Vb+UfyX5i8Yf/Pkx+PRnF0w+4PuI7zMFMFoQJahKIVpRcoECWEG1GlUKZ67m66endH3k2zdveP90wdoJp9bxznpJsYrf6zeQCnUGVYQeoeTItveoonBKsbKax03FxarC1YarfuCq9wwxs7aaS+VYKkWUxFU/8aoPDBmqSrMNkbNKY5WQS6Hkwi2ZD5uWNgu6QJJC7+B81Awp8eSsYd1W1E5zsjCs1xWrizNEKe5uO95c7Xj48BzjDDlmQjKkouiHif/d//H/doxBvtr4e/63L4glE3MmpUxJGW0EUYqc5rBTRhAgl4IkwWrN0/UJP/3wEdfDxP/v449496Rh7TTn1vJ8uWB0mu/s77BoWhQpZV57z8IIMSQERaU0C6c5aTVnzqGM5m6I7GIkSKbRhcc0LI3iMPW8PHhej5EkgraKQGRhFUYpQEi5cOMj71YVS9FUohAFW5VYZEEpy8WiYVlbnDWcLSyrtWZ1uqYUw+1dz9XNnsuHKypXkVNkiELOmrGP/Lf/3f/lGH/3fFV38E/9Tx6xnyaGMVByIYtAAjQgAmWuLJpWU9eaFKB2jndWK75x9oDbXc+vfvYJ7500rLRmbS2PThYkK7wcOhLQao0A1z5yaS0Y8H2Y7+DKcFJrjAYjilvv6WMmF6g1PKobqlzYHDpedp5rn8gaaqNJklhYgzZCKoUwRm6C51m7pspg7ucaUsnYAMuF5eSkpa4rauc4Xxia1rC+aCkYbm4OvLnacnmxwDpNSpmYHbkY+j7w3/53/9dj/N3zVZ6BP/NzD9iPkS5Ess2IKoSQUSgaZ1GimGIgS6I2immAtnZ87ekD/tb77/PJ6xv+77/5TX7q6QkrZzitK947OWFsEt9+fYOIsDAagJsQOUWxXjl2B8/CWM6ahrY2aMk4EV6PA4eQoQgLKzywLTlMHPqR285z6xPeCLVRUMPKGozW5AxdP/ImJr6xWEIp871cIPpMqxXL1nF6smDRVDjnWK0NjTMsTs/JAtu7A5ubPZePT1Fak2MkREvJmkMf+N/87/9P/94Y/MoT/r8ov/zLv8wv/dIvff/Pu92O58+f8/R8iRKFFcEpRRcitbN8stky4EEXjGgKUGtNVgUxglaKzc5TSkErRddlxCZaKWQyJSe+vlxxvfestEUjfHoYWGnNSb2gyxlnhPNlzdNHa061o2ShbhpcVXN96KkVdCFzmyNrZymVIiUhi0YqjQuFPYnLuuJp7egmz6U2NEUzjJEhJ7RWNNZxN0ReDj1vrgIPFg2PVg2+VIwh8+l+QmfBCawsaD9xcl7jFYy3B8IYkTT/3o5tr788f14Mnjc10jTYE6FRmiEUqqrm892WjomsMhoNArYoii4oIygyd7c9OWdUEQ4HTzGaaqlRZFLOfH215NV+ZGk1CmHb9Zxqxbpu6EvBWc3FoubZ2ZJF7RDA1TWVG9n0E7YUpkm4kYnThSU6TQ4JI0LVWKqxsFOZy8bxpK0ZQ+IdrdDFMIyBPiZEC02l2MTI5/3A6zvPo6ni6aIl6YouFz65fUWlNUYVKlPwfc/5+Ql5yry6umMYI/n+93aMwb8cf178XbQLrFM4ramMoR8S2ihedgeG5EEVrNUggolCivP/D0Q+fn2HL5lKDMFnxiIEBSIFmxMfrpa86SdabRDgNkZOrSWQED1/z1XteHq5ZGEMpRSWbWYbEzufyFPgEApv0sTCKGKtSCgaZ1hWFVs/ElVi4Qwr6+hi5DFLVJgfYHpAibDUln2JbMeBOyLn0XFuLVOw7KIjXo8YZbBKWFRCngLLU0ueEkPf46cMeY67Y/z95fjz4q+tLOu2otKGxlr2U8Am4ePtli4HUGCtQozGKSGT0aYwFM+n+y3eBxptmSJoBa1ROCtoo3hvteTVOLE0FiXCXeqpjaIIuKbBirCoNBcnLUUSBk2dM2NMjD4RfGA7ZYbkWViNagyihaUxnDeGgcxAxFnNqTF0teeZWTIFIftEyhkRYW0MY0psJOHDQJ0Cda8YOkW9cKSrHUYUhkKrMnEceXi+xk+Zm82Byd8XfDjG338If14MLpcV5ydLGmtZNBWHacJn+Oj6hiF6smScU0QptFWF0wljIKbAtusJyVNpzb4P5FyojUbjWRThx9YrPh9HFs6iRbibApXTKBSLylEzn4Nnp0vICaMUetEwhMzkMylMTBEOueAqQymZZAqnleNkUVNM5hA9ldOcVBbdCI9VBSGRx0jOBW3hwekCPyUmCzehZyiBVXCUSXFDQb3Zo7XG3N/XaRg4f7jEh8zd7ZYwJXSeg/DfF4NfecJ/eXmJ1prXr1//qY+/fv2ax48f/5nPr6qKqqr+zMcbNx8268qxqBzbfsKIpo+Jq2lPIFEZC1KoxdCnQEkQcuEQEk4XBGF7CHSSIAuP1xVdCvzE6QrjhSkUNmPg1a7n0dmS2jhCDBgN1mnq2nHdz1WBRV1jlGZlDT54rrYDXimSGIwR2gqMKigKUykMKXGioGksI4WHtmLTBw4p06eEJvNOMbwOnm1K7A8RnzJKoKTCRga2IWGzsKwsJ0vHZDOPnlZkVcjjQOgm8nFk8E/xF40/+PNj0CnFsnac1BXrxtH1GSWWPnn8GPGlYM1c6XdJ0QdPzpkhAcOEq+bq67YPdCUhRfH0JNBL4seWJ0goTKFwOwauuomn6wWNNaQU0Vphrca1lisfeLdZ0NgKg6YRTRwjd6MnG0UUhdaW1kFWGWc0E5lDipyoiqZyJAIPjeP1GOjiHINKhKZorlJgX+J8KMZMlRVFA3h225FKCcvWslg4uj7y/P1TcixMY8dhP6C1/spfx7+qfJXxZ9CcuoqTtmbhKvbiyUrYTYGQErlkjGhEKSqtOYSRGDP7caLvA7VTKIH9GBmmjMrCg9YSpfDe2YqUCiEWDj6y85H365qsNd6UuYulFdZabn3g6aJlUQkuJCoJHJJiDJ4BcMyV1EWtqbWi0ZbXZWAqmaVWtJVlzIWHpuaV7+lzZioZ0cJTU7OdJroS8T6TU6KowGGwaB/o9xNGFOvWcb6qsEPk6Ts1KWbiODD2nnKcm/5TfFV3cMlwuqg4axsWVc22GzFRcTdMeJ9JKmOMRolCFyHGhM+RbRiYSqIyCiWKPhQmMsYmplQQSTxetGSEKRa2PrKbAs+cQxVF0EKmkASKFV53nq+tT2kRfEgM4jlkYTd6PFArg3VCqxK1KJxobnJiS8IpQ+MsQ8pc1g0fTQOJQqSggAtjuCMyxcw4ZFyaqDIctILRMHUFWwrrxnC2rlFT5L13TylJCNPAMARE/cDrpj9UfJVnYMmZs5XlwWrFSduy2Q14Cq9uNvSxUKTgnAGlUaLJOTGNkbvS8Um5IpeIEuG282x9BOD5SQWj8HSxIAJTLmwGz9V+5MlFjUVTFMRUmHIkKXh5GPiJBxc0IgRf6IfAvhR8KmRjoShcJSy1YaGFhat4nXtuc0Jry2U9Fz2e2IbvjlskF1IpaCUs2opd6kk54wuUXFAhM4bMpkRUyGhRrJYN52cLpiHw9OmanCH7njCMc/ftS/CVn5TOOf7m3/yb/Mqv/Mr3P5Zz5ld+5Vf4+Z//+S/9dWKaxyfqylBVlpUzxMPEWjnq7NBeoZPCGoOymn6MHLaBOMDipKFpHUUKvmR2PrAbAyEXhiKsnePHzlaknPnD6y0vNj0rbchALIUuJvY+MI6B33lzg1GKxhgetg3PlgtOnKOpLR+enXJqK05NzeNmweOq4bQ4xlAQLYjWpKIJeT6o9j7Sx0QfEgef6EJgVwJLZ6mNAYQQMzFEdqOn+ET0gavdwO+/3PPRpiMD1gqV1tj7dvmRP+arij8AnxNWC5XVKKNprMbvepqiqIJBjQqVFK4YUIreJw67yNhnxBl0ZcBAVNDlzCFkfBZGW1hVlh87X5JK5ju3O17tB1bWIVaTlTDmxCF6uuT5rdsrtMwVssum4smiYekMVSV8eLLiTFecGsfDuubMOU5EGCloozHKkLPgY2YIsBsDXYgcYmIXAz5mDilxWjuW1qIQppQJPjGESIiZfoy82Qx8dHXg9banpILWGiuCZj6Uj8x8lfE3hYDKgimKUgpVyUQ/4bKgJ0XphTIBHnIR+iFy2AWGPhFLARGSzUwUdiGy8ZE+F3ojLCvD105X5ALf3XS87gcaramdJSvFRKEvid0Y+J2rWxSKShvWWnNuNEtnWTcV762XrEzFmW14XC1ZlAqXNIeUCIAohUaRo2IMibsY2afEPkW6HEmuMJI4aywLo5ECPkHKhUMK+JgYJ8/tfuDTmwPX2wGFYJxGa4MqihK/2tfwrzpfVQyGlCBniJnJB1TORB9orMVhIQjZFyQAKPopM3SJYZ8Y+kgImWghKmHM0EcYEnQals7xwemSSOF72wNvugmnFJUyZDJDThxyZJtGfud6AxQqo1g6w7qqaGvLWWN5d9XSWMfS1ly6BkuheHgzeIZYAIVCU5Ji20cOITKmObEKCCjDwSd0FnIo+JDxIYPAPidSmu/uTe95uR25O3hCymir0VqjUchXLnvyV5uv8gyMU0JyJudA70cIgTQOEBIqCiopyIKJmhgz231gt/XcbXpe3tzR9QPFFLwUdj5wNwUOCHeiaBeWr1+cEhN862rHx7uORimWxiIijCQOJbD1I//26jVaaxaVY11XnDaOtnasljVP1guaqua0XvK4WWGKRkfhk/3AJiayKCwagtCNE4cpEIuQlSIqIRa4jR58xmlDZS2C0KXMXhVygckndoeJm9uB3cGTSqEyhtponFLoLxmDb+XR9Jd+6Zf4B//gH/C3/tbf4u/8nb/Dv/gX/4Ku6/iH//Af/gW+ioBXDCrSl8QZiu3+gLcO5RRKaVIpGGURAaMUYmHRVpyuVijADDuKLZgiNKuKdrHgP39+xgWZpqn4jZcHXtyNzEJFhVfjxJtpQimotCIdPLooPr+94cI1xJLovGeKGRfh3LZs/YG7OPBymhCEJYb3FgvOl47T2mEQ6iL0PqGV8MpP3I6BWgRb4Gxl5qdEYOcDPmeMBdGKBkXKhUCiJ/A7m4F3f9/w+OEJuSS0BuLxtPl3+WriD0w2SND4sRBLZKE0d/2BSfS8S6IVpYC2GqSgjWDQONGIUWhRmEaTydgamrWmXTf8l8/fZQHUDn7jxZ5Xd9P83FYKb6JnI4mSC25KlK5wVhyfb/ZcVhU5ZQ5j4JATWhWWjWZzCFx7P8euCA+05d12wYO2Zl1ZEDBacesD2qg5BntPJcIiG86ainEMKCX0JfFiGtAKcq3mh5yQCGRC9rw4TDz63U95drFAQqYqiikdE/4/yVcVfxYDU2bII70VVtawve3n0Ryn0alABmcsWDBOIVrQSchhrqBroxAlGClUjWFR1/zks1MuzdxF/eabLS/v+vvST+F1GPFqDkcbEuPgIcFnNxsum4qM0PtMSnMXdVE73sSBzTixC3PX6Bx4WrdcthVn1mGzcKYzt2liYTWvO8/WexotXLaOs9qRfEIlSKXQq0SrLCVFNJBzIedEyIVPp8jv/eEVDy9bUp6rtCqlr/w1/KvOVxGDOmvilNnlgaw9a+u4G3q83I/PFoVOwlndkq2irwJSMqYochayBrSgRLCiaCvNqnF84/EZC8A6+O2rDVf7kVwKKWau80BRoCiUDDlkGuCj7R2P3YLGOBKAVhSVqSpLVyZ23rMdEyEmHljDO9WCy9awdgZT5vfOGx84rSxvfCLmzFILBzKNVvNugkDSCm+EaAxNhJwKPgsaQeXI3RT43d9/xeOHK3IGrRX+eAf/Gb6qM7A1NTEIN5uBIj1ntubueocvgnKGIpmUCy0GZTS2VpgiGITDGDBGoSuNAiyaZeM40Q0/9e5jViZTNRX/9vWWF3c9FEFTeNHtmTQUMjopZEjoAN/97IrnpwtqV5NQaO2IZaRxjl2cuJlGNkNgmiJf1w3v2JaLRcWla2iz4VInXvYHTlvHZspkhKXS7LIHMolMGjWdQJcLKQQaNM5oBiJZMql47mLkW9/6lIcP54KhVoqUv9wZ+FYS/r//9/8+V1dX/JN/8k949eoVP/uzP8u/+Tf/5s8scfyPcWCiOwTaQfNg4ajdgst3T3izGaijoRSFAlahcNI6Pnz/gligm0Ze373i0lZ8fbHm08OB4DMrBV9fC2m3Zesa+iLsJ09MCacUIsLXTpe8l2q2MWKd5dK1fM1P/N7ra7YqYZOwTIbW1JgE33r5iv9+uyXnwql1aFv4ozTwv3r2lEoprgbPp4cRcmG1rHgx7PmfvveQD07WGKf51osrSPDd7kAvmSgFXwo3m5FHbUVYWsaUGadALpmvtQ3f/OiO/8f3XvPe2Qlfu1xzvj6OU/y7fBXxB7DXicPUsfCWh7GhWSiePD7j5WHPmDQgKIRlEFat4Sc+/ICYC9u+Z7M/sK4qLvIpn4U9U4qcaM2Pry39bos3FWqs2I3zgWW0RkR4r1nyPEe2PqDFcKIaHo893z7c8GskTBEWaCprgMz1p7d8c7cni3BaO6wRvjkM/C/feYdKKW6mwKt+pOTISV3xWRj5+XfO+WC9xDrN77y4pQrCH6XIJhdCAZsz9X7kfHJMa0cMhX4KTFPiSeP45uc3/D+/+5L3T5Z8cLHitLFv5XX8q8pXFX+Dy3w0DTRec95WLDA8erRG7w+kSehEIwhugJWG9548I6REN4wMo+e8anhEyyt/wOfIuTP8tbMa+omNsffdngQa9P1i7fN6CUS23qNi4ZE2hKz53nbH720TKimaYlhVGpMUn28Gfvewwyq4rB1eC98MA393fY5jbqVf+wmtYOksr9PEf/HuI95bL0HgNz97xTmKl0wMOZHynMDHcKBKGmrIet7HqhCaVPiDjzf8xidXPDtpeX7WcmL/7CjAf+p8FTHoG+FlSqxQvNNWtHUFJIZtT2gMtpk7MtFHltbwnz15jC+FfvJMQ2DRGhrjuO5HQsksK817a0ff93htUFHTdYk8JpQBnQuP1Hyf7WNAlcRFtHxAzZubPR+pPTopFsWyWtbUKbPZdvzmfoOIcFFVuFr4aDzwn+sVdoDdYeQmBQKZuqn5yI/87MUF763XiILfe/GS913LDYk7H/ExEzKk24FKQyTPxcSkIGgc8PJVz+9fHXh8uuLJacOqPXbZ/12+qjPwKo28vu05qSref3DKom45vcw8qxRXfqTPEYXQBlg5zYcfPEf0PG546AaWCA/0Qz7d3jHmwElr+IknFclv2KeKPgpdn8gRtBYSmkttgcQ+JbSyXFYr/qb1fHLY8gf9BpsVaxwPmiXGR678jv++vyPnzIm1SGP59eGa/7JZY/vC1XbDmzAyEbloGr7Z7/mvHj7lw/NzxGg++vwNf80t6XJmXzIjCVEFl4V0iNwo5t2WAjIF6qnwsot8++U1j89OeHi2plp+uTzwrQ2f/eIv/iK/+Iu/+Jf++zlqThrH42XLu6dryOBl4OX1nlIKSglSYMqB26GwDkLOmUim0oY+ZcIUuagapIKiFL/6YgMCT89G+jHx0e2OMSR0JbR1w4tywCCMZBCDsYqL9QKVhI98h4hQW8uYM7UVrveePs3V2JrICY4PlzU5JILK94tHhuspkMbAy77nXGuUElqrUVl4vmyYYqSdIkoJS6OxYyZZTQoZnwqHWOhiICiFUXAXAmmzZ4yJR1X91b1oP0L8h8YfwLhLnJ+0PFkteO9kDRSG6Al3iSiAnpcZp+yZBqHELSUWSsksreVgC347ctrWoCAp4f/12R0AD1cth8HzvasN/RRZ1IamqngjI1UqTCXjKFQmc7lqMEkTpwGyYFGMJVOhuJ1G+pJRQIgJlw0frNtZRUcKVsGyNrzpI2UKXHUjL8SilKIxCiOa52vLJAk3eNS9OlDaB7QSXFZMJdPlxD7GuWIHbHwkbwemOCd6R/40X0X8laA4rS0P2oan6xUShIOM+AAFhbEKKYUcA/tcYLMj+kLIGWuh1x4VhFNbU4CQFL/6YgvAs2VL7yOf3faMY6J2hqZuuJEBmwpeMs4YqsrwcL2gSoFPfY8wC7TcpcyZMvRlTqZSnoUMXFI8ayq0FASoBBpRHFKkS4m77LmaRvROkAwmax4talIu7CWhtKZSinEzUNUG6zR9iCQgIiQFKUc2g2fMhcOUubDH+Psf4j80Bg0Vi8bwqK14Z70gRWFqAtN2TyiZpOb48zmyjQm1n0exUhGcMWQMm5BYtpYCTEX4tdc7AB6tK/Zj4uN9z5ASTgRnNTcyUqOIhXmHxBgeLRYsqHgdRyKFnArXw8ADZZgMBAFV5u/NlHlgK7Sb96ccQhsVVyXigEBh4wfcDkxRtKI5XTb4fiSJRjeKWsObfotShnWlGcgELSinKKqwnSJjKFz3IzkXmnwsuv0P8VWcgevzJQs0D+sF719eQgmMJeDv7ogxU1DkAiEkNsOIKvcjhBlMFrYxY7XnctGSS6ZE4f/z0Q0Ajy6X7LtrPrq5YwyRVhuWi5o34cAiC0mDtoq6Fh5dNFRieTFNRJ8pqXA7djSxMJnCUDJaBK0MOhTerx2LRmFESKIYo+amFMAgWnPXj7xiR2UNlREeNCvkMJJCRDmNc4q7qx1JzZ3bkUJ2BlNXpBLZ7Cb6lNH7gRQyih9wwv8fSr6vdqecMSkyxIRtLZlCnAKhFKSARZhSZCJglMYoTRFQVjiMBXICNY/UXL2eCGRuO8/dYeLzm47gM1kVfMrcpMAiaqzWnDiD1pq2cTRO4w8yXzJTZIyFwYM2ioU19CEylMSSzMNVg1SaglDrwglwNU7EIBQvxAyHad4PkJT5eLen94ml0ZwvK9a15eM3B1SBofdshsCQI9ooUHCbA0VgM3pCzNzZ6d/7uzzyl2PoPJ1oJlsh60IcA24xj5LFKRCEOQZTIaaELxFr5hhUCooT9jIxb1ooBp+5OniSyjw+eO72I6/uRtJUKBpChGvtWUahUobTymG0om4cj7QjDZqbbmI3BKaUuIsJI4qF1gw50cVIazUPFzXWgBJoRZO18Kob8CkjYR6b2IdI5wsmwyc7zxgSS6U4XVSsWsdHw46RwuQ9V73nECJKz5MfNyFQirD1gVwKt8MxBt8GIWdiEiQrnCjGmKicmeMvJuL9g17OheATlUr3SZKmGKHUMPpMpQBR7EPmbpiwlWHbebaj5+W2J/i5yxkKXJeJE69wWE5tjTGaReNotSN0sB0jY8hMKfG6TDgHazsrnQwlYWTuRjhrUAiVhlolbg6FlbK0RaFjYcieKSVSibzuO0JJNPfKQIvK8ukQEJlFGLpYyLrQitAWxcscyFLoQuRFP3A3D5Ef+YqJJc8ji2gabelSwjqDqHnUJoWMINgs+JjwZKzSc7dSaZTVHLoRZB597FLmrg+4SrMdA3eD581+IMaCEWFMmRs8q2So0aycxWhF01hq40hBuD1MHGIgxsLLnFgvLafW0qfInshSNE8WjsrN8YdRTFJII7RoWqXRWRh9IMaEioktE5TMqtK09TwX3S3mUV+ReadJidAWjc6FQ040xjDmxPU4oY87JG8NqQRJCmctJ3XNOEWcM5RcSD4Rc0EV7ufcM97M8pwClPtdyi54khVKLhwOmavDhHGaN4c5/j697Qkxk2IhRriKnpA0lbEsa4tRhkXb0DqhHDpu08AhBPYxcBcyC225rOt570QSK6V5eLKkdg1KoFGBJkMcAmvreKBaKmXwPhCCRyu4HQcChdoplsuKtnH0+xE/BZQISKZoKAbUBJuSWGnDGDNX/UAJX26s9oc24S+SGXNkM0286hQ+JR40a7RSSCqUmCgiBKOIKtNLorGzpu+UAnXUs371fbfNx0zXeULJNEm47UZCyDRKY1B8vO3ZKuh9YGULJy6jJCOmcLUfeX09MORI0YXBJ3SC5cJx7ipgPvAysLKW1jlizsSU0FpYaM1509AFP6sZhDlID36eZXUYHjhDq+cd6r1k2qyIg59lDw0srUGLzHNfVjP5zJDScX7wLTL1E9tUeC1Cq4WcEo8XpxitsUAMad6xECGYecmxMQa0MAWPC4pU5mVZMQUfC91hIkrCebg9eELIVKLQeV7y2blMP2TWqrB2DqUKogs3XeD6bmLvPVOJDCEyhczFsuLcWjYRfCqIwFJb2soQcyYUkAytES5cwxQiOkOKCUG4GwPj5Km1YWUNlZq9BQ4qcYZhGALdGEkCrdOoMi8ZLdQ8Gx7IbL7kYXPkL8Y4TOyzcCuKxiqmKfG4WmCMxkSIuZBzwTMrPvQl4ZQgqpCkoJIixgQCRQpTynTjhKOQQmE7enzMVEqjET47DOxNIQyRE61YV3ObWzvhzW7k5m5iJJMVjD6hstBax1nl2AbPlApGCyttqIyZvQEQtBZao3nY1EwhkHxmVJFSMjvv2WVYOsPifhE8lYS3UBehiwmfMkUg3ctvTnlW/1FqlnHcx2PC/zaIujCS2cbI637Ex8z6xNE4R+/nYlzJs5pOlMKoMkVphHlMsUqFEAIZTS4FHzNTylRZExNsxokYElbmkbIX/UinCoP3nChzvzxZwGQ2feT1vqcL4f5uBasUSiyXVcVtELoSAaFWGqcNOWdQIHbeVXpYV0z9HH+TKkgp9H5W6GmsprYGqxQpZ6j0XMiJmZwLKCgFCsIUMwsnGBFEClM57pC8LTKRaOBQJl53B6ZpYNk21Naiy4SEOe8KWhGY1ecSQskwpojVhpgTQ4QUC+OUGHycH1ynzOvDNJ+BWqNF8dGmY6sSY8ict4ozCiIFbRSv9wMvXncM0RMl0YVZP18jPGwa7qKnCwGNsNIO5xwpJ4oOoIVFbXiwaJn6Oa5GKTgFA4kYE42taJxFa0VIiWgUTdYMeT5HC+BLwsbCmDNneS7qFWCMP8AZ/q+CIplQIte+sE8Fq6H2kcY4WhNmMw0pDCoRKygqUWwm58ymP7DuLaUACCUrYszEFJFUUEWolEbVFcXNC7O/cbXhvF7yyo/YApLgZ5+cEtTEr//BK37zj+54+LDmvWcLQkpUWWPRnNq5/bgnUmlDFTWnumYbB/qU8VJ43Nb81OUZF1rzrf2ORKE2lj/stwQKD53FoOj6yC5O7GPiuREkFmql0E6xrAw5FxZYLpyjU4kpZaZjsvXWCFMi+oHJT1z3B1xraM8WLBpHLgU9enY+0JtEqgVSIChDorD1B5aDooyCUpCyIuZEzBES6AqcUSxrQ0kFRPHbdxvOTMPGT5gyt4v/+tM1lMhvfXTF73y04/zE8ORBRZzCPMtfBGvnlnkniVYbXNS0el4k6mKgz4mHVcVPPzrnUlt+b7shkTmpHN867Gi0pnUarGI3BoZNz10JPFaWQ5/QGZzTtMYSUqEVw4k1KDvvvozheOG9Dbq7Ht96xjByN/XzxXK6YFnNBQUVAn2M9HjQ86iLDXlWJzOR1WQRP6uRRJ3xJRElkaeJS9tQGQM1sya5Er55s+GyWfF5OHDNrLP+U3oBJH7z4zf83os9D84r3nnYEmLiggoT57FFT4ESWSpFFQVnhS5EfEyUrHinaXhvVSNj4rv9gUYLZ9bwsp9YO8eZcfMoZgjcdSM7yZxJRRgzqmQoipQVHYJO0DhN7QxKC910LLG+DaQSRsl8Fjpe3/W4LPzdi6ectC1TAHLAl8RoA1TQS2FInlgyXjInvSL5QsqKLOBzxoe5SHXiakwuNGoe5REl/MG+40I3XE8dV0yIwE/KkiyBb352xW9/uuVkbXlyWTNNcL6q0RSW1hILSIAmgwzzwvoYIocciVJ4Utc8WbX4MfBJf2BhNJe24oWPVM6gi8WiOAyR/TRxkMxjY7gd5wqriDBQcGpe0k2xsHaKymi2x6LbWyNGT2zhddzz8kVPTor/9U9+yMV6wX70xJjxeS74qgp20cPkCaUQdWYVLboIMmlimeVYExl8QDc1TWVRWshlzqN+/fUNDxcL3oSRfUgsKos8jpAiv/Gdl/z6t6+5OHW8+7hl8plnq9lMNbpZ6aBKQlvADhFdZbqxZzeNRJ153i55fLZgnDzf6bZMRvO4brgaeowSnFOgDPsusB0GNhJ431puxkBRipShnxJVVqSQGImcVYa6MoT4V7zCj5qdGItkgvYELHfDxMJZgrOklNiVOH8OUFUW5zQhAkaYJJOGxLIYlFFoMYiqiCnyxveI0fNTVEnoSnPa1MQpUbRiEz1XyVNVlgrL/+InLympMEqGVDipDH6XKAVejR2HOBtw/dj5EtGF3TDxepgQqzirG0xOpAiXi5Z+f8f1ONBZS6cLJzhEK4aSSAFUzCyt4U0aGCtBimCdzHrHUfis71hoy80Q2IVAOiqkvDWKzGol0Wf22xHtFZ/fbDitLVYKlISiADJPjlVmHr3KCRSEVEhh7vIYFEoMWlXEBFejh3v5w5gTrppn7f0wVyx2OXETM8ZULLXjv/6JjA6wTZFYYF1busP82r+aRrqYWGnLe4slRisOfuJVN2KU4mFVkaUwTbBYVBy2met+lgcbdeZUGUTA+4TEQkqFhTFsSfS1YILGaYWRWQnrs71noRRdCIw5E48X3lsh50QYMilEunFEguLz01Maa/BxHjUQlZEsRF9oVgYlMrvyRhhVJk+Rtji0VriikTR7l9yGiaghpEwmI1pxag05AkWxSYHrFKi/OAN/7AE6Cb2a4/1iWeHvIk4p3oyBKWWWyvDINogRhhS5mibEwGlrkBGmKXFWG1SX2I+ZGDOdLtTM/z2k2dHVZYXVGe8yuy6iRagLuFgwRtElxboYrqbIVDJhOj5wvg1UPXf7QgmMKVGS8GLb0RrHSRXIMRFyBmbnZ2MFMUJJoErGK4WPE5XXZIFCoRIBXbjyIykXYsn3anuKEzF4Pzv6bnPiOiecMTit+btfO0NSppNCXTkuWsfNXYcxiqswy7cuiua5azCm0IWRV/2IqQ2nTYO5j7/1oiZ2B278RCLR3fv3bEfFIXosgkKhbEEXYZ/n7pFTBkkFW4QOOMuFF91EZJbyPPJ2GKaAaS3KCNEWgs5cb0Yulkv6fiT7wG4s9KUQE7Rufv2kFFKETMH7wNIaDIqa2X2+5MznXUekEEOipIwYYWUcfipEDZ/ue5wx/L1vtDQV/MJPP6WEwqFETG15uNZcbya0MeyTR1vFo7blgTiSieyGno/uDrjG8fh8jYyJlBIP1y1/uN9yO3hMEYZSqHzhlgP9MKELJBK4QlTC3TQiRtNiMNliteY6J5ZB87IfSV4Yv+QZ+MOb8N+3Kv44lUhsfGYKiUOMDDkQSsYGjZoyYxwZy0ROGZ1BtOBQ5FSYQoQCJ0bx7skJ3z50HHJEjNC4WWHk9qrHRUXzwHDpLBemIqd5xObpo1P+5zHz23c7Pg+RC2P53E5s84FDiuRSMKI4Mw3n6yWX6yWyvWU3TpAiq8qRcuTzOCAyHxAvpwmxcKLndYsCYBXaaYr3bEMiqXnpKAPdFAgh87RpkAKXjeV0aRi+ZCvnyF+CAuX+gVLy7Bb5Yncg5xVjSkySiCrjshAPmeg9++TJKc8NOKuwShFDYvIRVYSlVjw/q/lOl+lSQmmolYJcuH3ZY4OwunRcLmqeL2f1ERHh0cWav/v1xG/dbPmjccQ4y1UVGMNEl/K9szQsKsODdcPpusGYPfthQjKcOUdOnptpxCghUHgVPQpome3Ji1Y4pzBWsGPhOs97Cq0Rsgi7OHfQ3m1ryLBUisbAZI4V1rdBnluUlJxQoVCmxMc3dzxeN4wxEIhkXXBaU0KmDPPDYMwZyBSnMFoTfSbejx0srOJ5W/FR8PgcUVbQRkOEzdYzRc/ywvKgXfDeaglpnod99OCCn4/C72y3vM6RZ23NHxwOPMywiwFVwFjDycLycNXQLhxcb9lPAaLmzGlyylwz4FWiV/O4SIPlIY4+REYNlQhOaRqEax8w9dxqBwgJxkPiSWPQAq7MxmJWHxOut0EMGdHMizsJii18dLPlsnb0MTNSwBWcEUK8T3xLId+bWikLLYaUEyEnciosCjxdV7wsiX25VyMBiIXd3cSUE+2J5lFjed7UswSnCGfrE/7Wu4k/3PW8yYWlET7CM4bCIWQkQW0UJ6uK9bph1VY02x2DT9ioaJwip8h+6Eg5ElKmKxEBHmvDnlmhTIBaoFXCx36iOnOYwPxQXeBm9Ly/rEihoMv875Rj+L01VMzYUtCmoOqMc4bv7O84s8KgM6Obi7YWxRRhSBGhUAoYJUilqKNBAb1PxFhYi+LD04Y/nDy76FFaMMpilKLfBVJONA80Z6uGp8uGfF9UvThb8F//5AN+727PyxBYa8tvhQ07H1FaU0eNrYSTy3NW65blosHV1wx+xAVhXVWkNHHTd+QSyVroZR43f+5qNrkwqEgt8wTKyglXfuLismWZDa588WaE53WNngrJF0rK5PHL3cE/tAm/fGEoJYKoOSUetMckqJxhiSP4QN+P9CrhRGOZ56m0KFpjiDlQYoGccSKslGCINK1wSUPW0Oc0V5GywgmslebBouL5omIcB1arBhHLyXpFOwZyOJCB2mnWOJQSQp7dSUXAATfdnn5IFD/7llynkZNFzWHfsSyKYt1sCpLmCzvnREkKNCgFNYJSmkOI6PtLfxKhUnN1JKEwaFKOxHhMtt4WJc+KJHD/8Bmhu0+UalGgHSEFutEzSMQrNSchZY7ehZl3T1JIs1mVCAsByRFbwTtYisCQMrs+oLNgFTQiPGkrniwqxqFn3TTkXGjXNU03YoZ5Qb3RZpYBQ2Z52S9uZiJXXU83BEqEJIWrceR84RjGkRMUogx9TEgWehIlgy4ya2BrRY2hqEjIc1VV388QnteWZBQ2CYXCkCPHEHxLpEIRKAmKny+dviSGnDHa0GbwU6DDMxHJae7CaAU6q3nXJ9+71+aCE2GpBSFRqcKZcWSl6HNm243oOM8lN8byzmrB8/WCKWYqY8kps1pYVqPl7pAwuXDhKs7qipIKMZV59EFDMrOogJ8SxAwFtmXuXG67gEODKuRScFp9P/4cglYaUXMyP2Qhp0Jj5uXQqGDRGqQW8pSRNL/PwrHB9FaIIc4LkcwLgyS4mwZaa3BWs8JRJsUmdkwh4cwsYamKIFmoQyGquYskuVCVwgrBlIR18I62zMpnia3PkAWlC04JD5qKJ01FiglnNCllVouWagqkfU9JkXfqigtbo9NETAWDIhAJRN50gW4IpFhIKuNFcNbgfWRlNIMIpcBKG3Z5VoFSWZONJrp5DMkkjdOgdKFQoMyu98UpSk6zKWFOjEcfiLeGaTXaza+BtrPh3rb3NNnSWMuqavDTxNaPjClirOC0xqjZE2dlNXHI8/npMy4X1lYwqtCuFA9SS87Qx1mWVUZwutCK4llT8+6iYfSBlTOEpFktl7huJPQDSRRP64qHdUUsc95pleDDALnmerdlGidSDAQFXTDUTtMPmTPjSGr+Oy5YtjmSKZioQBRRBD/Me1fOarSe96OwBh0yF65GcqLoQl8iw5ec9PihTfiVUSg1VzeVFkQBKjM5YaEMDYndMKGswRlFSYmcEwoFStC6cFJbgiokoFbCeWVQThN7z10OPF443muXmOz47HakhMBBRzYpcJdn7fuUMq0z1M3sghrLnLj97OUZ45RoBA4hksh8tN3xZhxYWEcfAj5lFIqLuuHyZImxis/3d9yNI4cps+sU5YtHG4FWG1rrIBuyJJaDYvR5XlrLmRpDL4k+zxXkTCam4233tikFSJCmzNQHXqUdj5bNvDQWC6ay1EpR0rzERgZVBD3BeW0I9by0VinFqTNoJzB4tiXwqKl4t2mwaN5sA2GYTbVe9yPOCu+sKoyaWNnZUVKMmo1vlOKnH5wwhYyTke5efefjXcdN8CzqhjDNlSylNBdVzelJyweVpt1u2YyZXYS7fSLdq1EoJSyMpTEG1UZqLCs/K1j5XKAUTFAcBIY8y4/GAumrN+w+wheTYV9U+QEpHO56Xhw8Ty6W1EYjYSSqucOTSkbpgsqCRIVMhYe1ZSqKBDRacVFZtCvIEDmUxIPW8H7bYPJ6jr/R0+fEVd/TOuHpuiJRcBpqZ9EyO1rmUPjrl6f0UwCr6cq8XPvi0HHjJyos+34kxVkm+bSpOTlpeL8SrvYHDvdLvpsuEhWAoJWitY7WWroYeGAWBB+IaV6Od0UgJnal0Pm5OpulHPeY3hLaCsoJFKHETAmZ/uB5Me14fNKwbizaKG53PTkVsioUMiUL4oEsrJVirDWpKGqBM6XJVaGkyKEULlrHs6ahxnDXC/000ktmFwN3KfAB3BfYZgnkooQxZ0qGn7w8oZsi2SrGkkg58umhx3lPI4bRRyIFYwwXdcXZsqGpDO6wp4sTU0ps95nhfhl8ZS0rZ3FWcwiJ1s5a6D7luWuhIAyZbQhM93tLsRTG41jtW0NpZnMpa1gsKhBFGDIHidRiuZQWEO5e9+RcKPHewqroe+mewkVlmUykroVaFA8rBxUE77kl8mRZ88FiSaVrbreJbtyz15F9idwmT0yZmBS6KjhnSQidjzywFT/9+AFD8MSc8LlwiJGP9jteB49J81J4zBFrFI9WKx6ftqi6ot1vGOJ8Bl71EfFzDFqjqJ3FVYaUAhaNSUJk7vTqWOg6z81hoJsC2gqRTBf+ilf4lRG0EYR5YUYbQQSimTWolVLoUjDOUNWa2AcKCVXmStHaKk7QDG7WblYCnS5kEkGgl8izqub5Wcvj5oSTamAYB36v286W3jmStUJEIVIQJTTWcFo7lpXl0lZ81vesjcYpYR8Tn/Qd9PDANmRmRQKjLQ+WK5ZNResMzk089POi2fcieBEmCsuq4rxuqI1ln8CXzLPFglsT2EwTaYo0IuxDIhdFltn+m3xMtt4WAn88V5Yh+9nqezMNrIxh4QySC65x1LYijoESE5SMQzjRhkZgskJWc7dgUIWuzKojXcloJ7xzUvPOYsmnbmDXTXxzt+du8jSjIqVMLBnK/DBRW81p61g5y2Vt+dxPcwwiHFLmRT9CP/KwzYjAWDJGax6sFiyairaal96HJOx85A/CwBjm8YpV5bioa5wydGWkpMTjRcUmRDbeE75wQ03ze7HIbBZmjjLUb4dSKPmL2cY58R93IyPC2aJitXRImZN9VWZfki8EQxyKlWhOrWYyikxBtMJbIRBBFEOJOCs8Wzc8aVd8upjYbjv+8LDjbpxoh9nBUWR2MxeZlxQXzuK05tRY9nvPSim0gUOEl4cBgJWpmVIgxkxtCuvVgqaxPHGGVkemrOhT5o9iwUfFRJqN6toGZzV9F9FacVo3bL1nCgkVCzklkmR8nGduc5nVio68BTRgFBLzfP7Fgu8insjaGRo3Vx5LKhgESbNErC7QiGalDG3Js2LOvS/DpAq9yuQ4d6seVYonpy3vLpZc7wtvDge+23d0KXEbPKkUrChEzcUxpw0r52i0ZWE0N/uRFnBa6ErmZTdCByfaze7gApXLnLUNq9qyqB21DsRSGHLiO94zBWEomUXlOG9qlFH0cSACS+UYyfgSoaR556XAmPL3XaxVPBpvvTVkXqQzVlM1FSlF3AI8s8u79QZn526NQeYF3cTcTbeWtbGcimI084OjKGG0szJOyoVdCTyrGt69WPDu+oLrXeLVVvOt3ZYuB+7idK/2aNBMIJnKKta1Y1FVnNQV+97TGIVVhV1IfLwfYH9gVSxTyUTJtLXl/HRN01ZUtcaZQEhCnxOHKZFGGFKgrS1nixZtNV2fiAFOTc2YZ+nv5D1TN/9MQ86oeYWGIl8uBn9oE35RBWXmf4SiIKLmJ/xSGJOaF4OUgIK2cpAdKQYkJ1Za8/55S3fnmdDkArsUeDF0FDJnqsIZjRGNUYZ1W/O1c8sQLJ+lAYJQG0NSCmVqOr+jGyLnzvKTFydoUby46/jkZuBr65rHztGoxKtwACANPQqFz4XKFqIkQoqQMu+ul1hj6byHUXjdZ96kwOPFgsfLliFnpqFj1wd+8tEFizxRbYXdNG9yq6w414ZshCQF/yUtlY/8JSizzj7MC7w5zupNCPRjQACjFb7AwlWUZIniERVZInx4tuRm0xGZFwH2OfL51JFz4YGuqIu6N+vQnFQV+kTYOMtHYSRFaPQsM6uMYjceOHSRtdV842KNSoqX+44XtxPvrR0PnaGJie/c73TcDPNs4igZUzK9xO/PIj67WFLZim4aSUPh1c2sqf6obXjYLBgz5HFgP3n+2qMLlilQHYSbNKLQ1KJo7Sw/mslM41EW8W1wf9fxJ9PZnOcn0MEnTMwoo1Ep3p+PGe7lCs8ax3vrBYfdiBWhKGGfI5/2I4nMIxoqrTFoNJq2sjw/MZxpxas0Uu5nW32JLIpimAKHYW5tf3i+xInh882BF/uJD5aGS2MxZD4bZ0+GsXhynqWVXck80WUWGIjwzllD7SxjjNikeHVbeFN6Hi4XPGwbxhxnpat+5PH6AqUNBxkJKZCs4tJZFlkR9LyL0h1Hyt4KMcy9uxwycYzEPpOn+Q7eHwJFCknme83KLFxQyqw+9nBZ86Sq2O8PUBQZYV8Cn4WeROFcOyqlcEphtaatah5Lom7WXL+J3IUJCoypUBdNPwX2fWRtLD9+uqIuhk82Wz65nvhwoTl1BqPhdd8D0Kt5KTgrYUFhSOn7AheP1pbaCT4nUjBcbyMvU+R0WXPeNviSKGOhHwrvrytaCt000Q8RnPDENbRhRGsFUug4BuDbQmTuLFbWztOqKWPvvUaHXcL3nkM3ziOLSiMCpszLt8/PVzxf1exvOgiGXGCTAt/1HUngoXI0ZfY4cVqxagwGzcKe8nociD4CmVgiKGGcPIdh4rzWfOPhKa1UfLbd8+K658fPKs4ag0X45G4PwFalWa5dF9am8AGFEOZxgYerBlcZfA6UUHF1N/FZ77lYNzxYLvExw37PNme+vjwhpci+6+jCiFXwbLXi5DBR7NxZ26u/6hV+PT89U+ZWxjR5Qp6NQASLZd6i3/Ude98hAdZieVTVPF8sObc1r6qRPmV2JbIvAa8SPmdOmA27XALlC9MUSCnQWIUT4XHreHdRM4yeb22uMH7gzWagWdWcnS4IEaa05Xv7jiet5dGypdaKizAnPocwUUVAFYqKbIYB0khOms1oud17braexXrNoxJhOqByIfqMUYWnzvKua6hrTV1apjHzUg9s8Fy4Fn1f1VdlHpE98nYQgS9WSfiTD9BllphzOWO0Yhc7hkNPGgsLhIe24sPFgmVd81nV0zHLwx1yJJAZyVwIVFpRZ41M0A+RyQcaDcbAA+V4rCs23cSnu55WhFebntW65fxsOcuOFXh9CDxe1ly2FbWD6/tW8yBClfR9wljYHgI8hJQyV3vF9TZysx25vDghxoE8CirN4xpGFx65ikeuorKaxgljDLw6jHTAha6hgC0aQyGWY4Xr7SDzDhNfFPj/OPXvfcT6eVY1dLMAgUhhIY4Hrubd5YLTuuZ13+FFM5LZE5lITJIZdaLNiipBmRJ9PzL4ueJvtHBpKx5XNYcu8ebuDk3kZtPTNo6TVc2UEocS+Xh/4HF9yvmyonWwn9cs2QwBV4S6CEpgGD3EmpSE3ej49DZxt4ssFi1tE1lOiRQDY9CghEtdcblc4KzGaU0qmdtuIOvCpWpIlNkLAqE7jpS9FfpX4+wumwrZZ9JYZidxCt3BIyVh60IYI1nNRZGl0jxwNe+tWhzw2ghjiQy5cEiJQKFXiVMzn0/LoKgG6K0ni7C0hmLmB4IndU0/el7dHaiV41V3oHaak7qax1xL4bUfebpY8sDaeUfl/oFzGxKN0kQRYhI6P9/NKRXuOsft68xtN3J+WtM2npNJISnjw6z8d6kdl8sGZwWrNSEHXhwSPsNjQHtFZQ1CIU7HDtPboq0MbWOxRkHMpCmxqOeMfyMjoxSU0rPKjppfh4VzvLta8DcuHqJ14kp19CYy5MwmRXwu9DrxSFUsiqFNCjVlhmGEKeMs9BJYV5bndsHURf5w+xmtZD6/OqArx2JZM/iJOEW+vd/z5NTyqK6xRTipOgCuYqBWirFk9mPkzaEnXbRzHhgUm6vE3X5gsVhQVZmTVEHWhJgQMpfS8Oh8Qa0UxjVMU+DjyTMS+Ql9RpJAda+w54r/Ur/PH9qEn5LwQ5rHJNI8Gyh6fkFfb3cwFBZO487mUQtKYZw8fRGkmbjbFrqUEaVpi8YwK1SkAF9bL/np01NO3TyHPY7hXoIT/meXl8Q0z82/uh5YtIr15YqPU+AP+j1jt+XCWBYZ/qv3zvl4HPnuzTUgbFKi1sIHdYUkIUrCGE0b56+dHfzBzR2gef7wgnV3QLfC105XfL6PfHezYZcT23HkjQ/89G5NLfPB8jeePkBp4XfvrgE4hIIrlouq+sG8Pv8pIMxL8bPoyZx4DYCDISSUmWfezRJIBSmZaYBxikTrudvNMprKKGpjUEVwWSDAe6uGb6xOOK8arNaMOVE5S0qZn1+dklLGl8zr3UjbGFaXS26l8L1h4LdfdCyNpUbz08/PeDlOfHJ7oFDY54BWhR9bnDDFhKawsorHlaY1mSSJb15vSSjee3TGWT/wrNXslwte7Eb+6PbAtmR2PtKT+CBMNMxJ1088PMVqy7f3WwCufcRkxYkcZ3reOoo/JVu23XdkAqerCtXcf06ez8AxK6SquIs94b7l64ClKJQ4VITnyyUfLhrOrKMWzdBnnKuAwM8uT0ipEGPhejvRNpqz0wXbnPi4HxiuO9ZOoTP8F89OuBojr/d7ioLdfbenTZo+ZuoKzhvDGosxmqrOfOvlhoLi0dmCkxx41iim0yUfb0a+fd3TkRlTZp8y7+qG2gi1M3x4cYql8Lv7HaWGPnkcmtPW/kd/Of5TwL/xGDVn8vn7wTcH4KGbiEGxPDHokwJJEJ+YpsQhw6EIIcwqUClnjMBCC6INj0LFO/WCD9ctZ7am1pZQCk3tICn+zvKUlGYn6bvDCI3mdLVkqoQXXcfHux21CH6I/MzDFW/GiZc7j1Jqdm/OiYaKzmdOWs2zdcvTdsHCQC+J33+zISXh0bLhaYpMWnjvtOXT/ci3D3s6EmMqHFLmkbMslaV1Fe9fXFBS4TuHW0oNd/cz1qtj/L01Fsuakgr9biCmzOG25+bNiI+RFAUnmtZo7InMHYACw+DZS4df7tgM42ym5jMaYW0NpSooL3x4suAn1+dcuIpKa/o+z54MwH9z+ZiSZtnZm/2Ac5b20SmtKD6623H7ZsfaWnTI/Pz7Z7zygc+vbhAKA3Eu6mnHxnvOW8OHZ0veq2pao0mi+a0Xr4kl86RteJICOOhXKz7e9Hxzs6HLs5v09o3n3bpmUTuWteOnnz8hJ8W39q8pLbzyHls0J82XywN/aBN+H+O8sHY/wqqUYhbrmQ+cJBnPrCqCnj8vFzhMgU/vOi6aRKhm2cOoClnPWroPjeFrixVLY6gko2WulKaUSYBYg9YFnTOuFP7o+sBVzNyFRJ8SG+/ZF89D4zhRluLnmcXKKs4qRyqRnsJBAo/qih9fLThvasak2W3GOSEkMoUDj4pnnYUham6nwNUU2MfI6zgQirAvkbEINmfqVPBT4rt9TwHWumKlBXt0+XtriOL7lX2BP1XlL0AuQirqfqF8Nn7JubD3gU9Dz1mVSO08r1oUKBEWorlYON5vliy0wQlYmedCv/jKziqyFlQW6lT4o5uB21LoU6BPiUPKdCFzaiqWVtACWmusVpzrihACWx3YhsBjZ3l/veDBqmUcCje7gW5I9DkyDJFOMicp0yPc+MiVD+xT4ioFtFGMKZOZdwE0GULis2m2nV+IZa313M068tXzRYtJQO7PPeTe8VNBEvClUNSciEmGSGHjAx/f7lm5is5ETCno+xHGWgqXC8vzumGpZsM/kbnNnPOsdFZbIem5e+gn4aObPS/8xCF4tnmOwbt9wSTFw4WZRxtmG1LOrWUaA57EXkfWbl5Kv1wYfIL9dqQfI13JdDnyvtE0OXPoFbdT5GYMdCmzKRGjFKOLRIQpFiYyU0p8HkagsMBxoi3uuMf0VlDlvsPO/bX7xRlV5gJcLIUp3D+JSp6X+DPcDZ4/CrBSmrEREgnRCm2EBsPFouJpU9Hi0KIQPcsoziNfcR5dRSFZcEHz7aue6y4w5MyQIlOIHEImkNDGzo63eZbOXFiDD1BUYVSRB5XjcVNz0hgOCbY7j59glyJ96pBKsygwhMguRe685xAToysICozGZ8g5MuZMFxOvwwjAStUstcOmY/y9LTa7kcoKWiu01pQis3mWz0w+E9VsGlgsZFVQE4QMb7qR3/7smlZr4koTy3z/GhEW2nC5cnywXLJ2Fm0AiagkxKRxZJwWsmjIgkmRP3xzx0f9gX0KbP3sqLvt5+XwS6uYwuwnYTUsjYEYiRo6nXlkNc/altNFw5g027uRsUts4sR+CkhTs0yFvmjuJs9tP9KHwGDuHdIrAZWIBLpSuO08H/t5dG1Fw1JXqPLlim4/tAm/aJmrpgJKz21h+GIpbV7kRQk6C7HMNtlSIOXCEBKdSUgNQ0lzdSIDQfAmcuZq9P3f0SKI0VSVQe4rEblAjgk1ZV53I6MRJhImC4sy29BfKMchJbwUFPPPIcymRbGeNdZTKZiiSDFxM9wvIGnhehr5qBvZOOGBWHTMbMc5iELONCLENGueU4QkQq8CvQ+c6oouRFbG4ETY+y/Xyjnyl+BPDlDLn/4wzEkXZp6ZDikjqUCeLee7nLA2goKxJLhfqiTPBm6n1qHvPRaKaIwTaiP0PswxmAs5JmQM3E6eeBCSymilWGtDAR6aikMOBDVL0mlmPf+C4Esm3AtES56rHq9jJnqwaLow8Mk0cucMF1lRIbMRV5rfLw2KvpRZ+SAXkip8sZt2WTk2Y2CBwuTC7hiDbwURmS+z+2T6+w+f9zGZKSQFWiCmOeEvRQgps89xNheUQmCW0fzifJxU4tQY7H1MisyXadUaVExo0UjOlJRhTFwNnup++Qwl1KLn8SGtSUWIcq9HXsCnTMwJWztUTiilkKKZfGY3eIIXStFsvOeTsWeoHJdaYZLB50yWQpH5HI4538uSFlJOjMzLeo/bmpves1IGC+zD9IN5gX7E+eOa/r1S1BcqBvfZf86QU8ICIc9nX8kQ0/wwZyth1DAbic8xnHJm0JG1Nvd1OkFEo9XcxYkqkosmJ4GcEQ/bKdKlRBEwWqhEM5bMqbHzsroSrMyeDPsUoMCi1hzinAymmOnGQMxzMmhFM8WJV97jk+WBNehoCLlQ7t9zlRJ8nt+DFMgpE+67vO+1K66HiUY05MztdDz/3hYhJhDBMe9slpJB5vHn6DNFC9FltAixzH4MpczKSpshQCvEBKMUiprliUNIdAgnpsLkjBRB1CypaWoHMUC2SC5IikguXB0GdJhm8Q0FrWh8yZwvKmqjqO28p6cLHGIgUjipNDbOo+kpZQ7DhL+XWbai6ULik7Fj8oH3XIVKiXAvxZxFcEoYyagslJQJRNK9YuV7izWvDj0LDLoIm2n4Ur/PH9qEX+l585p7bWe5P31SntVHvlDxOcGwJQAFJfPllwskVUgCB8LsVlsUEucZU6HMLn9SZt1+rWgaSzd65vNidgDcBc9N9OhJ42WW6FoqhzbCQms+DyOTKegMh5hQMVFKpogiSyHkTB8SOQZiTiyMRtS88X/rR3LRdJJZRkMXIvH+geNSWVLx5JJplCMXYTsF9iGwFI1CsEWYUqQPx4XJt82/W90XNT9wzupRihNt2aZAZj6MFPOdmDX3ajyzepS5VxDYSwTmB4OYCsaAMYZmYehKInqhSCFQ2CXPLgXUqMgaFk6xMoaihVZp3viJYObkr6RESmU2Hsnzz5EKdD6RwkiyiqUYUEIombvgKSQOxXCK0N/LzzktNMUQS7zXSp9lRfchzYoDWhjL/HAx5MDhmPC/FeReeWEuJZTvP3wWmA85AW0VJ8qyHfx9Hlbuz695mStrmEpC59mQMCfYC6hSyCWRBTIaqw1ta+n6TAqFDHgK+xS4S5HVKBRdqI1mqTVKwAhs4mwgo4CSC12IqFKorKKOGkExpEwcA0OO1MzmMSEXNt6jpdBrzVnOhJJBFawSzrJhU+YN+UZrcp6l5wKFttJ0WaMoTMWzC8f4exvM4mRfdJbuW+33pkZfdHRUgZXW7FIm3nfkBSGXQtKFaObFW7l3P81pnuUX5njJGUpRaKWpK8OuJGKZHzFCKexSYJ8T1SQUDYuiqUWwWahQdCkxloKR+dzbpUhdNGst1HlOwroY8T2YKVHd76ggcEiRNwG8wCJDoCBaMKJZKs1WIgVweq7gD37eQVgpS8esXNQlz346PnC+LXKaixpJZXKeVetKzgSfST6jrEIVODWGbcoU7ou/zDLVxQheCnuJ3xd9mb8Gcz6ZMqIUSs2F37Y2bPqIn+1D5hgMnk2KuKDQWrGyhlopBp2o9H0XXIFiLrZsvEcZRZHZ+6Tkwn4MDGNBTYET12CtRpSwHwOfi2CV0MRZ6KUowdj5+xxyQaGoRcgZhjESYmFdOarkKVLoysRmGL/U7/OHN+GXua3MF+NxWShhHqbWetYhb2vL+wvHtw8Heh1m90URtBZUpRnwHHKck30F2hiCgpuh48RViIKSEjYIRYRDTAzDSEyZfYx8Mg7sJNEET58zD7Xj3DqSLVxFz3UI1I1jksQujqiiOMGgUqFiVhXahcBQhL2fOLUabTUqw4lYUoy8ThOdymRV0Eph1Fz1p6g5mWwbuhC52XZ0OWOAphhu/QQU7Bet/iNfOXPCNT9xf7/aL3NsKuZLqnGWp03NJ+nAzswGNU4LriisVexJDDmis1AzqwEUme2yT6zDZiFHIRhFNI6hRPY+kGLmEAKf+okDBRsSIYFDY8ps/f0mRm5SoraGSGHHfJEuUag0V/JnharEmDN7n1hpNXtcFOHUWCiJuxTwokgCohTOCKfoOQY1rNqK3iduNwO9ztgEBstNHCk5o8txc/xtUsqfSLr+xK9ai7CsLY9qx3fDjkMMIAUrc9fJGU3WkSFFbJ6LHnOTSbP1E0utZkm3NM8HKaUY8lwNnXJmnxKfe0+vIhUKKYIOhSqAV3AtkZs80tSzAsYUMikl1hhyKbRZowt0OaJSIU2ZlVOEJFSiOLUWoXATIlnA50IUQSvhEoupErXWnNQ1Bx+43e7oY0E60EVzoyZE0tyJOPIWKLMG//1/F9JcQSizL4TW85Lt+23Nxxw4+Axqdjg1IojTZCmMRFTJmDJrE2c0h5BpVUaljI7zPlRShS5GtqMn5UyfAx/7gQMRnTVJKbRPsydKydyUwk32WDNPAKR7TXzDbCpo5+dHujxLuvoYWNXzz+a05sQ6nIJDziTul3rV/N55YByN0hStWbqayUde7Q/sc+QNYLJlKoGQZ2fWI2+HmAqiZvPI8EUhI0IKc2GiMoq1q3l2Jnz7Zs/BTygF1b1amXWanY50MaDuzSVDLlSpsPMTWVsqyRRJZCWsSuIQRrreU8j0yfNx37M3mYVVGCOciKJB4zW86ka2RCozmwn6FDnEyEIMd92EirPU32EMiMB06BlWEWtnZbTzXGGAjUSGovHMo0m1VjyxNVlpJgPndU03eT6/27CJAa0NKgoHGeZ9l7/qxluuNYSQSAaU0lBgug6zG6jTLJzjaxfn/Ddff8bp737C729viDGysobzk5pXrnCg0CjLAoMTTTGFR6rl013P2eMarYRuCmwOHZ/tNzy+OGebM9/ZbLnxE6cLxwfrEz7Z7+a2ic3s1cRNN/FO2/K10yXcF5eirdlPEWMVzb6gnaLB4BGk0nx8O/DrDHxdLTkrhrYIN8CoCg9PFLFAnxIJ4cHpmp9oW9at5XbT8fLQcxsiF7oh68zdOKEpWCNEfUz43xaimed2Srl3tL6/+u4vvdZa3j8/4xe+/phf/9bn/O7tGyYfWBrN2brmlQrscqJKikZpKqNRVvG8WvJmnLhcViij2KfIfjfwne6O98/O8HXkO3cdt8PERdvytbrlahxp0MRG87lLbKbEM+142ixggntxlHlEyM6u0Vpm2/qQBaUMn1/vecXIe9ScKkurNLclcTCRy6YlV9CXTBDh8cUJP+4WrFvY7AfejAM30fOAmpThJg2YnLEC4biz+1Yo5U8qRcn395cAUMK6qfjG5Tl/88k5v65f8c1Prgk5clo5Hp0ueEWgK55GKRZYDJoihXebll0fuDhfYLRmTIm7ruflpweenS3Zo/jDw56bceShdTxrVqALazt3Ir87DhxC4GvNkg+bJWHKsxswkLTgVUF6WFSaqmhSUEij+PTqwGs18DA4lqIxRtjkSNsIlTOIKsQcyblwslzygas4XVluDgOf9geuhzD7RGjYjh4pCqU12f1gXp8fdUqeZxQK9+M6cB+U83l4vmr42x884q9/cMavf/6a7+3u8DGytIazk4bX2jOUSI2hxWC1pjh4qGu6DKuFIavMJg70u8hHfeL9s3M8he9sd7zpB1Za8zg7lo1lVVs23vNyGDikwHvUPLftvMCZZzdmJZpkFXqEk8ZRZUU6CNI6Pt3dcb0beGwaWgw5w+scef/BgrNK4WNhjAkRWLctD1zFaWUZhpE/7DpejiMneo4/bxO63C8rH5833xqjD2hj8SHdm/wJOQsxFEqCi9WCn//GB/zsk1N+7bvf5re+dcVE5GxZ8+xyzcdp5NqPrMWyZB4VOejE+6ph202cXliMFoac+Gzo+M6nG94/O6V3me/d7Hi97bF5LkBcNAvO6prNMPKtw4G77Pkbds0J8zhYLiDF8kRZpgSVcawaQ10U0WtcY/jebsOndze82yxYKIVPmW0pXJwsOasbIDGmSA6FtdSs1msuWs2+H3m9PfD6MHDuWjICZu6yRgX5SxZ+f2gT/pDmMZiUCvN41GzwgVKAprGOy7bm5cstLo48WNTklaZoYZsjtRHeY8EbPxCZqwttNGzLxOf9yKm1PFk1nLc1756vmGRuL7bMTYVSIGVYKsVD7UhxdhxNDp4vF1zoihAShxiJeTa+WaqKKUd0rXAItbGs2wVnbcPOd/yMPWGh51ZOnxKh77ne7fn4bsBUGiisteFZa9hP0OsBHz2hzO3StmSuh4l1a3lWN7TKcDMc24lvnX9HkpPC3NpbOB6uHS+vbijTyBNXEZuGpKFLkdoanmN4FQZSng+oqijepJ4pJVau4nGTOW8r3j8/Z0iKlDxtytgyHyAhC2vrMGhyKoz3I2nvNg2n2hB8oovz4rkCaq0YEbSe7eytMqxtw1lTsdkf+KnFilrNRkpDCfR95qYPfC+ONJXBACtRXDaOYRjotWFMBc/srKtDYRtGLhrLAzdraW+OM6xvj8IXw9PcO+0BoLSmrWtOVmteXh1Qw8hl7ch1jWjFbQloCs9My12MZASNokJxO0Ze5og7KC6bitPG8f7qDM/c4q6YPZcShZFCA1hdYeK9m6+Bx/cLi2RIIdyPks2V0wk/e6REMEazqipWlWVjO77eXGDvVZ3GHGEsvDoEsAPOzQZhTgkPnMLfu4xzP8JZzPweuvOey1XFqXLYDHf9l2tnH/kLIvctzTIn/MD3u5zaCCfrmsePT/js7oD2gYt1RVrUpFK4KwFBeCQVgyloFFY0pih2PpEANWhOK81ZZfhgtQA0PgUaZK7aO8FhQM9dyzxEYko4ER6Kw2ZFlaH3BZ9BScFaiCHjrGKICWU0i9Zx3jg2teInm0saMRRRdCXxeX/g6uCZvCLI/HBzog1rZej7zEEHokAWhQAuwZAip7WhYZaD3Hy58ekjf0kykGJm6ueq1tR5UihYa7g4WfHu5QWf7V6h/cTTtmWo5k77dZiQnHlXagYNUjQuCzWWbU7EYaI+GB4s4LSteG9xwUQhJ8WIoRaF1kKlhTZZ1skih4QvEbHwZKpQyByDMeHv90hNhpEEeFwpLKqa00XLctlyPRz4z04uWEqFEqFPgY+6DdebntJEgkAsmaUyXJ46fD/QuXo2/tIOrSymCAc/cVpXLMWhUubuS8bgD23C73sPupBiId3PCGvmhRqVYWkrni1X3F3fsAmBh60FMexL5mXM7FJE7i8WoxRZwTYE9n4il8j/++6G9/OCb+gTTlY1ZYwEH+m7iVYUT6uKJimKhUcnp1xNE0HNoxS7HHlZBlajRjO31iOFjZ7NPrY+sTKG86bl2WmNFjjVhnNnccZSimBK5L1KcbIQbnNgMvPewlobgofBj+xj4kXX42PmA7dCmfnBZeUcRQsTmXyUQH+L3C9Ncl/tur/ztFXoSrFsHY+WC7ZvbtjniQetJithWzJbyWxjZBbwKVg9j5Xtc2AbPBT4/15Fnq9qflzWLJuGyScm7+m6xKIY3qk0TbEgmsfLmk1OTCR8SexD4E2eqMPc/ZofFwt7EtnAGBKNVly0jqerlkqE07rmxGmsGFIuSCp86Bous2NTIkULoguNUoxjZPCZfZ541Q9MPvHMzBPYLikWSs9jGCVznCp7W8wL2PfD1H+MFCqnOVnWPFzVfLq9ZeMnLmqDEkVP4SoXDjmS07y0rQVQmTEXNtFTFPzmIfFO9nyoFyzTrG3ed4H+MNIWeOoqVsVQdOHcajY+sVIWg3AIkatpxKHvzcBm5bReBXzO7HPhxFrOm5aLdYUxhTNnOXPzRZdzxkVwrmVdIn2J90uZ0CpNTgofIzdd4G6aKLHwrllQG4XymUrm8ZAigtE/tNfYX23kvtB2P+8M87iBAMtFzcPzNY9OT/j9z7fsfeaBMSQp/P/Z+5NezbIsPRN71m5O83W3s9bNm+gyMiODmVlJiWJJRalEqQBBgDTUQNCofoJ+mArSQINClapUhLIkkiiQTGYXmRkRHu5ubs21e+/XnmZ3S4P9eTCliRxCGsIraAvwgQ/czM3Ovvuss9b7Pu9BC6MYhlIoJBrxWCzmnJg7lUTMMI4jV+qJlsogz4lxCkxzZG0svutZIcQIl43noUSWzqDJcp8ig8508SxzU4gGjlQvy1gcF87wbOH5bN1jRHjUtVxYixFLVKVF+bjrSLNymCOzrSZQNUKIiWPITCfDMSViVJ7bBb0z9KXKhlFBGsEtPqw431eVAqUUcqoZCSiEoZpvr5dLPrm55vn1Ff/qZ59zd5h4uukpSdmVzGsS25iJWlimmpmA1Iyn+5wZNTLujjyOM99jwaLzhAgpJUKIrKzl40VPV2oPcLmqqd8X2mAz3M+RL8vIMhso9TxECjuN1TeVBHHCR13Ds4sl4gzPfMNN0+OMJaeMZsMPug2nODMOmZ0GMFWSXopyCjPT3nAMgRQiH7cdy9ZxrQ1oBcbghKb5dnfgd/amDGPC9wZrKrEkjQVrq+Fw3bQ8v1jz5HLNF69eE1RZeUMqyi5nppQpqiSN9NYhRcixkOZMmXNNJouR1zrisjCFwse+IeXCPkX2saLhBhEswovVgt4awnl9ciqJX0wHNk3HsrUMJbEPEZMdc8k8WvdkqWahXz7s2EhF4mkpNTXYSiVjSENvlHQ68joGpgQI/Iu0JRXFe8O7FPBiedp1ZFPYxcCcEzsKTizpg376vZWeGea/rrOOX4xwuep4frXi0XrJq6/fECl0jSdmpeSKDyy5kEqhk6qZ11R1zJqqVuNUEm/TjMsncjBciyN9g90swlg4G8uVp65momYq/utkPF+ME+vWsXSesRQOOeG1/rxcrRdQhFAKXx6OrKlnOeRC5wreCtYYvDT0ppDHwm2KpFx/zz/d7ilJcc5wn2a8WJ60HQXYpsgpJ2Zqwmb+0PC/l9Kz+ezXuJRz1yUC18ueF1drrpcdfzUHZi089tWzMeRCzBmjQsqZBRYrQkmFnMCowTYQA+wk81ICRY9cGiGGqp0ec2Ys9fkisLQGccKiGKK1jOJ4OU1c+Zaut4w5cYyJpVochWfrZaVFlcLr04mVETyGVDK9dThrsKJ48TTG8noqPIRYqTwG/jztSKWwKY5tquCFm7ZHbP1gOcVIlEqnCh/uwPdSv6ZDoZVIBr/edj6+WPDi0YbVsiXlghGh95aAYrPUFGdrGDXS0eBra0IpWv0kxkAURjLvJOAxbHImpsw+zOxTYCqFIgZV4doKa7G0CCtrWYvn62ng0aKlt46hJA4psVJLdsqT9QLFMObErw4HOq2m4VAyvXO01mC1miExEENhFxMxZnZG+TfzjgHlcWrYpYgU4dI1GAMzkX3MtFicQvow8XhvFYf0a7N3TnWCnkL9eX/+aMNnz69Z9A3DOFESLHtHtsqc6nlZLiwhZppkq/SqVPrhUh1t9mgSjhS+lhlXDlzY2mjvQ2AfAmNKGN+QgXXb4o1hpZ6gHU9M4hfzjme2p3OOY4rspplu9szW8OLyEqNwDJG/vbtj7aqsMqdE01pMYzEOfHKsrOHlODENIzEXdCz8t9MtUQpPQuQhTFDgqm1wznDQyHYKNFKpkbN8uzP4nW3451NCnMNaOSf9KbR1u/14veSTm0suVj1RoXWO682KmJXtcWAchvrFnzKP1x0GYU4ZSZlUTNWYZpinxBsdGUJC1wsAXqXIbQiccsbbSsAYNLF2HmMrA0+k5XYeuFp4lq1DY/0IaLPQG/jBasWxKK+Gga/3R27Eseg7Uko8sYbeuGoscYbWN7SDMIXEoRQOmnmrAW8My9ayJ3Hl22pEVkNGOcZIiYITg8sfRvzvrfTv/PP/geisL5RPby64PK+wm8ZxuV6SUmF3HBjHgUJFgN20DUaEEDMaoS1CPuOkwlR4pzMxKS+aKkZ+MMLDueFqvWODMFBYGos3DiugvuVuCly11fxDSgxzxiVwGD5ZLJmT8mYY+Ho6sTkjNIeUaRaGZeNwpr4ExRuasaa3nlAasbybA1aFzggHk7n0Dc6cTZ+iHFOmnPFiHzjo76n+TpP/d69zEeHpxYrPbi7YdA2qinOW61VPVmEYRuZpQjCUnOlcbbeyVnRnB3hLnUoVw2EupDwQ2zqpvCuRuxSZUia4zNp6AnXz0xsDxiHn4KHr3uMaQ0kwS6ENQhb43mrBKSt3Y+CLcWRjHKbAVCJPFj2ds+cpqcE1ljZMTHNiVmUW5Z3OYOBGG/YlsXKe66ZuO2JRRs2guU6NP3gm30/VWPtfQwu+wXMi8PRyxcc3a9rGYkw17160LVNUpjmhMdEaR1SlE1cNuyhRC14MTqpiSLIyTomv81glXsBtnLiNteE/GcvCe0bN9CL0YhHroDFMOfC87zFWkCTkIKyTAw+f9guOSXk7jbyaj6zU0lnDYAzPF57eVhRoAWgdPlUk9pQqJehNnkkOUs7sS2RlHNe+OZPJEvuQsJLxCPIh7v69VRjq4EzOlBp7bv4FeHaz4eMnlzhXASmrtuVysyYXJUwTD2Ng4RuSZFp1IJDIhBiqrxOHSpVjj3PhawZoKiXmTZx4M01MOTOfTd5RK2lxaTxiBLeE0/3Ex/2y+v1mJWhioR5c4XcvLtmGyMv9ni93W66alqXxjCSeO8ei9efhr+Jdixln5lQ4hboh+NVhgNYwpcxdClw4z5OmBVWmknhIAScWp3Vj+m3qO9vwxykhVjFGKAlMANq63vn4cs33H13R+JqAt7aGz773ERaYX9/y/9o9gFQT7MZ3rBtP8IltGVAPySs2nWkCTvBW+GKuOtCfTyMzijWCLYW1tvzFcOBH3YqnvmPTeqw1fDosWfSGYymcStUQjjHwbNFitKK73mB4mwO3eaLVmXW0NI3DnyPhG4XSWFQs8UwTsCjXtgWE/ZzZa8Rk2JrKXh9jBiPsYkQzrPVDs/U+69cvub/TcpVSeLHZ8P2rK5besXIO3/R8/9PnWFHC67f8ycM9oMw5sXSepXNEyezjTFJlaBSTOTOA66/7Klfp2pdjJKJYK4ySWDaOX8WZT/2CR86wdhUj9nzRsLQN+1Q45RreNcbEs65FkrAQgxFhnzP3zJQQaabMyjc456rm30BpDcbU0KahZIJRLrVefMcY2ZGRImxN9YuklEnU1b1qYVM+rLTfZyn8O/g+lZv/0fWGT28uaG2llTVq+Ozjx1g1xNsH/uVuyzd44afW0RuLeCgtvJtnaMGpoTOOzlqMFm7PIX5fzBNDqsSnmAuXpuVXYeQjPJe+pW8aTAPPYsemMbyLiSkXjHGIKdyYFnJlVT+gbGPg1szkObPG0jYO42oGgFWQtm5As4ExZ4rCEkcS5XYI7AiEJnPlLArM6byl1YwqLD6cv/dWKv9u0iEIGK0fnFdLPrpa0Qj0XcMyGz66uQBVysORP391BwQGMk4MK3VYY8ALczEMpk71nRgcBnJmeyYPvJxmjrk2/0EyS+d4F0euTculd6ytxTjHTefpnOXNPHIqijUW7YULLDlmGgxkOITMyWTCnFjhWHlPYxpEKpmqeEuKWjMrLNgCiyjMCe7LzMFk1MFJ6v0XcsEq7EskK/QfPjjfW5VcyNFg0CoFPEsU1cDjizXPLtY0omyWC5zv+fTjZzWX5O0d//z+VzCewML3yopWHU4BI5woDE2gRWico/OW1hum87bmi3FkG+tmMY4zH/UrPj/teN513PiedeMRZ3g0NPTe8uY4MISEFYtbVlojIeFsJTBuU+JgC+Npz82ppe97Glfbb1Ele880J4IUogeXYZUMp1F5zcTOJKwRUk4oSkwFwfCQIjkX+m+p7f7ONvzzPpGmgnUGYw2tcZScEREeXy55drOCFHlxYQhhzTBWHFPSjDmbfEOXz3IDR9c4Hq0sJg3siARRAgnfeX7w5JI15+nW7S1Glc5aXk4T+2HkfoxoLHTOcEnDFBLPmp40ZVIIxBQYQ+RNmHi86Lg7jMRwYpcmUio1wc0WtkbxrWO9qHrZN/uBhXOkzuKLZzkLLgsdgsFV5JdYLpznxnsUeMDzOs94I7TO4j9M+N9/yb/T74up//rsYsFHV0tSilxdOOah5TQEvK2OeWPrgGw2SkbJqhhvuFj3MBsGMxEFZsm43vEPbtZcmtr5H95toUBnHbcaibHwLkckT3SmY2U9Y8g89R0JICWImRASt3Hi8aLl7WFPDIW7HImqiBqyFiZRNr3j6aphypnPDyc2rmXuHB7PKhkcQhMNroBky8pWhOfNOfDrbTHscsB5S+8d7YekyfdTqqjK39ks1abLtsLjq55Hm440zXy0agmNI0XIJLKkb0wdTKUQyLQKjbEsvGPQWI3kWsNsHtmWP764YX3umx9S5NopHngZZ45D5k0ZOLmO31kLfWMJo+Fx05zj7BWHkoryLo5c+CV3u4mYItscSVpwqco3ZrEsfMNV0xNy5s14YDE3hPMk2DpLJ5amOLy3vClH1jQ8di1PfIsCt8wMObMylsZZzAcj03spNdXD9HdLTPUiXawXXKw70jRyaTyh9YxzPHtFFPUFVSWkjIZU76nG4KxjZQtfllgpfFq4bDx/tLnk0dmLsY0T16nmzbxJgcMp8MWUeWoSv7tacWk9IRQ+8ktmoLGOmcyYlTEkLpqG3WliNwX2OdOYyuzfE+lF6TvPuj+/gw8nGjLBFzq19GJZGMMQM4sCO0Kd7ruGm74OQaYxQ5PwxZybzw8T/vdVVs6hq6YOCMIpogbEOS4uN1xe9ITpgeuuxXYt0zhjnRJJTKU2x7cp8AgPJdWgNyd4b3gZB3KGYpXHpuMfr59wdT6DT9LMo6ZFCrw5BYY58zfHPYd+yU+v4dJZQlBeNCtyyVgRGmPIMXM7T6z6BW/e7TjMgWOJODGss2NHIqP0xrG2npgT745H2n7J7GGZPCvxLJxlmhMXxrKVxCPneNovWK+WAOwOR9YGFuqr3Cl8u7h7Uf1uCdD2+z0XFxc0N4JxBucNvqlM+v/DP/0pP3zxKU8WHS2ZeRpJZ25+Ebh9OPL1fUUXzST+5rAnxJrOt3Kea99jM0jJtGJZdS2LztE6oZTMV8eBLJAoDGTucuAwZ6yD510HVF33C9vzB8sLbG9xjeWUMrfTxJenE6+nI4esJJSN8dyYBi3KbDNfjhMbcSRbGEzhkW/5o/4RQ058NQ/sQiDlglgwGBa5rkqNq2vyhTXsTearw+mcLChozvzl//2O3W7HZrP5DT+934765gwunrjKKS/AOcjqf/8//yl//Ps/5Grd4jQRh4FpOjBNCSmW++OJ1w8HXm9PjGR+fjwwh4IBeuu58B2NsbiU8WJZNZ5l5/GdRch8dRyJRUkUZpSTWKJ1uGXLjfU12C0XbsTxA29pjMF6x1hgGxNv4sjbaWbIiWSUFZYLLCXDwMjrcaA3lUgxSuHGdfy0u+bAzO08c0qVjFVQFjiMwqLxlXNNoTGFYyi8HGf63tE4g8bCX/zJ9sMZ/Huqb87f8qYDc274VTFW+E//V/9DfvLDz7hegMkT4zAS48Q0RwTL/X7g9XbgzXEi28wXhxMlQyOWzjoa17JQRVN9QbTOs2wbVguHkLgbE3OKzERGLRyznjnliadND2dp0KXx/IPVumaHdA1jKWznwH2Y+Gq/J3pDLJmNsVybaoa7y4HJKktjmbWmUd+o44k06MKwmxMhVVJKoLCwnpwLS+/wjrr6toa7KfI6TFX/aoVeDf/yv3z14fz9PdU35+/qexc1q6ZaxzEC/+n/+h/x008+onOZEgbiMHKMI5wKpcBuDNydZm7HQM7Kl+NIivW/d8bQu5ZNZ0ljwGShcULroXPgbObtOJPmxFAyA4VZIMww+8Jj15CoJOwrPH+w2mCNwXjHVAq7nHjQwOvTiCNz0sSa+g7GwZswARaLciyZgcxT27EugmkdYyykXP+8U4mspH4c997/egvhyDygPJSI94bGGNps+X/+1x/O399nfXMGP/7jnpyU+ZSIY8YI/B//d/+Un/7e77P2QDgxnvZM04E8R0qxHE4Tt7sjX28PzDGzNcIwzmhWjCouCxvfI6aw7Bpab/Gu5s+0ZF4fJ9DMSOGkyikpY8kcTOKjpiedPXqPrOcfXt/QNJ6+EYZUeDsGXp+O/Hy/ozWe0WQuvedp06IqfDkOlfZEpUQNknkuHatBkQvPOBdyyiQy7zTwkV0xktj0LQ4lzDOaM+9MYUdm2XkW1uOj8J//X1/+/zyD39kJfxULV72WasXQff/5Cz57/oImB9J4IBghqeJKIuG4aluW14bPLleMOfGXDzvmkpmLEFMhzIVGhLHUCb0tDleqmWMbR/7stOP5aokaOOVMJcIJoST2scYlG4Snrqlx23Nhh3IbJu6GAVUlAhtqEt/SGi6cYZyVt2lm6c/GSwVfFJ8Mr05141CK4sUQpeoIOxFI1X1trDCTMUZ4mANzzKwaz8pZ0gdJz/urM/9c5GxaE+FHHz/nxbNneAmE4UAyhrmAP2MIN9bRXCx4uu7IsfCXP9sxlVwd/CWSct0eDSlx1TSIWnwBSYUHZn42DzxtWkAZVUmmTtWyZqZsiCgY5eY8eUtFOSblIUZ2cSZLYSaxwDCWijjsjSHmwptSWLU17AvNJEAyfDWeOEnCSpW5hVKYY8ZZwReDzzXVepKCyYaHMBJVeWIbNs4R8gcs5/uts3kX4dNPH/P0yQWNTqQpEKJhSIIXS86Fdetprlc8vViSovKrY8USZ62x7R3gGs/bcebCORweEJLCQ5n52TRyY6smdiz1xZZViFKTx5MoGOHy/PuVooSYuYuB+2lENIERFsUyFHDGYo1BcmHQzIVrcGIJpYYxebG8S4ky1yRqb4WEkGPCnj+2HeDEUKRKO/clkHPmpuvYOEcJHyas76XO2n35xqkrwscXay5WS2yaCGEmiSFF8CIUCq0VHi9aLhctOWVevQ1ECikXMopopM2GuzBy4bpKkIoQEW5z4GfziYsgdTsq9f5rneVAYa+RhIAI4vwZna2EouxyYpdm1BTUwLI4QilYC9YoYVb2JfPRoq2ZPhFsVrwatlMiuVwlRlUeQCRjrKdJBl/AW0WsgSQ86EBCeSYNG1N/nw/1fiqOuU7ltZLy1Agfv3jG1WaNLSMxgRhLioI5J5N3jeXZ1ZKb9YIyB/6bN7ckqu6donQ4lkbZpYBGQ8qZ1gilM9wR+NPTjitxGGMqqrhoNeUSeZgm5lIQUZ56i81Q5sxDcdyHwP14JKWJ4hSnYFINDpMCacrsUuSz9RoKzGnGF+XKtLxNe8Ypsii2GtzFYBAWncXESjRz1uLbFp0TPw97khMuxHNpGjLfTlf2nW345e+ip62Ardo5o4qhYKRqWQ9T5NIbRARvLa6BVhQfLaXUpLYKBytkozQISWCfEjbEc/KfYZsSkypzyThqHPJwTigVahRzZy2Nreiln40HAOIMU85MKRIorK3jSbPgbaqx8bMWxAlxKqx8w9J5YinMqa4EX8YTRxJr46sDvRTGmIhS6KUlo1DO5iIDxzmCwKapJqKhxN/QE/r3o75JlFcqWWcMgVLqFsYag5hKeVqJQaxUSQINvShJErkoWarRtWgBrRP0KKWSdVLCWkN2hiOFIMqsSs0ghVkLqhmfhWKUxgrOGDLw81Dhu6qWkDOhJKJRFtbyzLe8ixHVQigZawyq0FjLEkuTLS4nWoXX00CwhY3xvza7h5Q5ClxIW4ljWiUbnpohYaxh7RuufMOhfKeWhL819Y1XHKpxUlBCmEHzeeJqMMYyBmVtDFpqMnIrQquGQCZRKKZQqB6NouCSMFHoKHUgkjImKkfNDCT67HBS1TpDqQ2/aSwiNSHXGoMKfBkGAEyJzDkzp0gi0znLE9fyNgZE6rlx1lByjZ/vrUMwmCK06niZTmAMa2NxSDVPlsyuRFbG1pW+1p/BUmAqGZW6Qb02DUc+3IHvpaQaxPV8A4oIY0rkXD/WvsFszrGcmxTBWougtGKJUlCpCaSqNR03FphTpKgScsSonBPNhUEKocBQtBoRpd5/4mtCeWX5G5zUs/jyPGgwmphLZsyZbJTOGW5oyKHUbZEqVqpvLuXCwjlWxiJJaRXeaKQkYYNHtJBKZs6FBxPZiMFy9lqdaUUxFlDo1bDEkj80/O+twlBl3OXvJMnGmNCSQEuVnIlwmGcuvMecfRneWhoHCeGQI1mVSI1e7g0UU+/GKUVUhSKCYDnZumUcbMFTlRXD2avmrIGi9AhNTeXk53PtA8vsyCkzh8iOROctL0zPm3nCUvs6bw0GQ1RlZTwbo/gSsRnuiISsGNoqhdNCKIV3eebiTJqsg28DYhlLwUShL8JGLMdvaWP6zjb8qgrl3O9bg7HCF+/u+PjqkovGIOeGf4zKqqkvIWMLRQUjik2GhbNV2lAqyFqLksWwaVpygWNM5/WxrVpAV6dWrlhMgTlnkmhNST1fNgIccuIu1JdMmEqNsTfV0PRxt+Bp0+Nmw30I7FOisZZUStXQGkekXkRWhX2JnErEO1ObvFK55qcSoWmJpRo0ohb0jIzqreXKt9w0LfaDYej9lfy7f+TccPzi9S3f/+QZblnDq8QYYlS0sYgFcfWH2pZCFlg6x5TqE69peAqibBqPKYYpZ3YhEIwhuHoGi9Zf1wnEMwS7LdVYa7UmOw4ls03n0LVQE/e8BTA861qe2Q5rDHfzxDEnFsZVbwGGRgxGIBVDAww5kqihYEYh54yocsqJq6YnCmgppKxoYzDG0DeejWvY+JacPxzC91m/to0LfPH6HZ88vsG3NeFBjCUkBV+pN/kbg2UWonwzMYesSjmnQZoS6X29M2MpnEIgYoi24Ew1xhkxOKPnVrqwsC2d2F9Pe6dcGM54nJwjHsEDWeBx0/KsbdAZ9iEylUJrLZog5YI1QqOGpNUvMmtBgBkhlbMpPFfpxLpZkLUGghUUKzUIqhVhiWUpnsCHhuu9lfyd3EGBl9sjL24GrKs4SxFDiIXiTDXNOqn3otbBmjMWkUyRGtyXijLEwsJZbFZSKozUxiw76MRhzHk6inIkM5XMumnoijlPAg2hKLemytI0ppqHQ0XyP2o9j0yLmsI2RoZS6I1gM0wxsRCDV8ErmALhTGqJquRSiDkSU2Fk5tItKFpBDXL+PVypZnNP3UqZD1v291Zprk29fkOMQvn69p4XTx6z8vWDVIxwCoGVbXD2POkXQaSgIsSSSVqHvgAYrbhYZ+oHXvomxFwpTWFlPI01eFOb85lMSpG1cVgtZ9iAcMqZU6xDt5AKCzW0YijG8KLv+NitcM6yizNjySys4LEMIbJynkYtKWdySYxSUKRuVUshlkQohVfTyGW3IaqiueDQem4VmgJtqeCF+Vt28t/Zhr/kqtkE8I3Ft5Y//fIVP7za4G8uae057MA6Ys4VGehNvSxyASP86GrFcF/IIZBLXc0YgefLlpyEKRbuQ8BEeLLq2HQeGwVTBFsqp3fRC2tp6Yxll2Z2IbIynue+pyg8pBEpypX1fOZbfrhcIxga68hZ+dtxwroa/qAq9esxJ06a6ExlqKe5ElaSKNYYLpzlNo501pOUanyiso6vfMPKWC5Nw9q0BP/hZfe+Sly9TOR8gZCVf/Wr1/zkex/RmQt6X8f/RUxtmE1NeiwiaFSMgR9cLZkfjhzy+bopQrGGR8sFkqg41hQ5jPBovWDdNvhkaYzFCjQp0TjLUiwe4ZADY8lc4Lg0XTUlMRIMbLznedPzvUVPKfCxtUQyfztMDCRCSKzUMZMYc2JMhd44lk3FLmapkwhz/lAZc6Q5h9SkXBBVvLM8XqxYW8/GtfTWMxr/G35Sv811pjgZwAh/+qs3/PiTJzTXa5pfS86EORtaW/DeVFObJoIVXiyWfH46ElJCS236R4TvXy7ojOM4Re7nGcmwWTVcNg1tNCzEksg8SASrXOLwWHY5cMyRjXier1co8HI64sVw7TzXzvGjxRIBXhhHYeDlMDCYjOZSJWeamDRz0sjSwNJbijPErMRcBz1dNmxLwXSGIee6JRBYtIaNOHoD7dnH5P6/jKUf6u+/BEGs4Rdv7vnxkxXNqjsPByDlKkXtG1/lh1YpOWNK5lFrmCOMWj86KdVc+zubHheEo0YOKSJRWDvHZeNprNBkzgFumZQy61I34NucOGo9f5+uV6gqr8YZD1x5R98In7QtDYbGLUjTic+HE6diiFqI2TDOmZHMkUSPZeM9IoZ9itWAqWAyZM2oNXVzQMEbYSOOi+LoPDRa06sb851to34r6hubaV30CX/x1St+5+PnNOsWc+6rcjJMMbJ0FucrxccUAas8ajxfTgOp1GySicge+NFqTZdgiJEhJU4mcSUNj5eO3lX/2pAjxznxMEc+Ug/F8lZndhK5Uc/vLuod+NfTjmCEZ23HZ82CH65vEGDRNfzyeOBvj3u2miFWeduYQvVIlcACz8Y61Fl2p0DKVWXSBeFABgMjkUjGJ+ECx2NpWHjLwnoacXTf0or7nT2pqmBE8I2jXzc473neLXm5feDdfkeLoQMOx5F+vUATnEJiThkPdM7yH3//EyIvuR8nci7MKXMsCsXwvesVt8PMm+NI6yz/5Eef8P2rDf/qly95ezpyzInr0PFmGnl2tWI/Bbx1PPOGZ9Lyx8+f8hDgp2Fm4w2brgEDf73dstaWgLIjspWED8Lvs+R+ivxtPoAROmv5qzhx5Rqu+oYhZsKZL9sZx5q2strljK4rMO0Tf/j4Ea/mE1sKu/HEw2H4DT+p394SJ9jGYlzdMAF8+mzFF3dveHd4S2+FTizjIeEWDblpGWIixBlbCg7HP/nkCapwP0WiQkgwWrA4fvBoxbt55M040FjLf/TZR3x8veLfvHzD/XEkZOWyddyNicsLz5ACDULvPU+k5afXVxwopOOJzgiLzmOM4VeHE01jIVtGhEkLc4DfKy3bmHmZJ4oRGmf4mzRy6T29cQwh1hAdqixkg0dNJSV0ztVzGD2/9/wRb0PgIMIhjNwdjr/ZB/VbWmIrUQJrEAe2ES77jp9/8YrXL29pnaVpDCFMlLZFG88UE2NIlFLogH/y4gnlZeY011S/ORfuU2Ljep4uO762JwYSzhr+0ccv+Ozxgr/8/A0Pp4kpOzrjuIsTvfWEonixPHKGZ03D713fcMiJT9qelRM2XeVT/3x7YKHCjLIvgXca8BF+7JecDLwrc91wIvxtHvFGaYMyaJUeNdbQYbkoFs11qu+NYBCmyfDj1TV3YWJEmcPEfph/w0/qt7PkTOkRLMaYapIugT/7/BWdsXQGOoExKF0jqDpOMTKmiEXp8PzB5oJQoEs1cGgcZw4x0mXHZumYXGYcC401/KMXT3i2cfzszZbdaWaIBRcXDFZZWYc2jlQSbS48k5bfXW44lMRHrqXz5nz/CV+NJzSNlCg8hMw2ZVqUP3Qd7wp8FUaiFFpn+YoJBeyohJTIAt5YNtawpg47jHG0pdCmKmv64WLDXQnELGxTYDt+OH/vu0TAOItfeFqb+fNf/AW/NEIrjsZ65uFIcj2nseU4TYQY6KyltS3/i+8/57/64g0pVGLidowMJbKyLZulZ2/3tQ+0ln/6w4/49NGaz19vOUwzxxDoA9x3LZd4TO/QYlmnwPfNgp/cPGIbEs/bnmVr2SxajBE+P51oi1Iy3MWZ12GmRfgP7IqdLfwi7AkUeuv4KxPJGlkcHXOqgYK9tbSd45FpmEWxWFoVuqIsrfAP1jekDuIp8/p4YEzfTtb4nW34AVxraXpL21tWyxbbWh6mmfv9iTAFrvuGf/TZx3x0fcHu4cgKWDSOcpYl/Nnbt3wxDOyngGSlxSAU3sXA/t0WW8AruFzY3T4wNK6mliXhYcqMpapo30wnUlZ6K2xcA8byi9sdL48n/ujJFZd9Ry7KX331wC/DiYPZsvEebx2/s15zqRZXhA3ALBgMSxw/C1tGMiRYYmmNpQi8CfNZK5jP0+NCJDOR+T23YiiOz497jiHxgQj2/kqLollRq5jG0vUGu2qYNPPmbmAOgevO8Q8/fs6L6zW7fcD5jlQ8c44Q4M9v3/HFFOoZVGiNxyLc5YnxISG5QIZiCrd3D1y1Dh8NKZmzUbxKOu7DjKZMZw0LU8NutmPiXRh51lg2rUeM8qvtia/DidNoWTiLOOEH6w0btdicWAFhqHrYpVj+OuyZi1JiYIWlcZ5slNsQUAwxZVQMUTLRFI5F+STBKie+Gk4cY0TNB0nPeykjv/Yy/Xp+YwsnCl8fdoQQuFk2/PFHz3i6WbHbH2mN4DpPVMhD4We373g9BI4p0ohhQ8MyW16OA3fTiRJLDWszyrzfkReCQZmksCURcsFhGWJBXPUxtQjGGoaQeAgjzxrHpvVghFfbE18PI9uY2DQWMcJnixXXxrIsjhtgHs/8fGM5hlS9ArmwoG62EGHLTDKFVBqcGLJWSUgxmU9sz9Yavp5GQsq4D1HP76ekaoarbAKMdTxarfFOuBtGhnmms/D7N5c82iwZpsxKhL5pSArM8Ivdnod55hgSJKUrlo0RfjHsMUfFFGgVnCi3bx9Y2w0ShDnDsdSo84VYhphpnKXHsBDBN5a5KKcUa6BRW70Ct9uBt2HgPsysnKVz8JPVmkvbsMJyCUy7RIiFRXK8ttUHMJXCQizd+W69yzNWLC11uRa1Bm5Fm/iDpsHGwtdpYqKg9sP5e1/1TUaNcQbXOqwKz67WuMbx+e0Dh+PIVdPwh997ytNHV+y2B1adQzsPaslz4pdvDzwcZ8aYcRgahEscf7W7w2+rtPqKCqfYPewZFoZ5DuyGiX0IBKM0BUqjNK1hHT1NUVJnGYD7MPCs8Wwaj6bMl+8OfJEH9jmzcg4Rw082G27allX2XAKnU0ZjYaWOX8ZT9QrkyAWO1lqMNexzlfp+nDuMCKkIW028zYE/ul7w9eHA6zAzlwLf0kf3nW34nTM0vaPpHM4JlxvDx+sFY5yIGIYiaIpcXS9Qk9kejsxzQpzBtdXB75Ock9kKIWZG4NJ6HuaZZJRr33DhPYgwpExOI6kkeiPcOFtX3UZw6lBTkAQ5wGgKd9OJQ5z55fHIURKlKL8cBm6JhFwoAR61hpu2oTGGcr4UfmwWtLkaf+5sh1JAhOu2YWU9U1FeDgNYw17nXwczFYGdZv7twwHnDdsc2aVAnz6Ezryv+qbZL0lJY4ZO+J0nl+RTRLznpAls4enNBiRxfzgwhwQidSNQYJEsrRhAmFJm1sBV27KbA7dM3PiG66apyZMpY1JAc6FXQUXYp0iLocFQpDopS1GCyXwVDhxSJAZhFy1GhJfTzDZVz35WWDvD2noahCJ1g/TDxYom11CTre1BC7Mv3DjP0jrmorwZZnB1QmuopnkVOJiRv9nf47xlXyL7HPDxg6Ti/VQ1kHxj0G07y6PrFa1Vegs4oZC5WnUgyvY0MoeIsRbnHYnCwjp6sZxKZMiJWQorsbydT0Qt3LiGy67BiZBzJueJRgwrcSTNnBQaJ4Tz/04l80AQw8vhxHGcobXsokONcB9mtjExxYworLyvww8V0lnz/7Hv8Fq1+EdpiRSyyVy6hqV1JJR3eUaMZaupJrICSGEi0x4Faw1HEiciHR/O3/soY+TXxlwxggWeXi3JKTFNMzN1I3O16jEC29NISFVzbbylFMGr0GbLMWWGnDhqYpGFbanwg0vjagqzVOJeTglrhYVxNVXeFlrXkEquuRKpojOjZB5CYlSDlsBJawr4fYzskpKiMpXMddvxqOnwxnJKJwA+9i327OmLuSGRGQUuvGXpHAnhfpzBKu/K9GskqTgYJPO3wxFvDKeSOZVE80HD/95Kz2raehVWXPT3Hj1FNTDsB+I4gsncXKwwKKfjSAipgl68Q0vBF2Epln0OPKQZClybhnfMqCqPXMOV8TgjZC3kM3ClAToVVCyXvSW5OgwxSZFYQ+Eehpmowv1p4jAHooF348RDTmQVpqJcNo7rtqP3jnmqAa8/bBY4U3X5Y2kZ8QSbuRTLqnVkZ9gOgeSVr7WiPM3ZwrIvAf9ui0XZ5sigmd58uz7wO9vwd2vP4qKhXViKFnb7ibSOvLi54slizTwMWBNYeMu0PeA0YtpqvNkdThTg7TgSY8YodKa6+60YOg/ZKJMWYgh4a/jb4cTVziEpcWWFResxVnjIGTA01tO3DivCWDJqhFUy5ASvDxOzFqJRNs7zMAcWavABAgnXOxBhbWxNLk2JMWdGSTgVljiGXBh1Zs6VibA2rl6AcjaJiKE9Tzd6DJc41CjefnjZvc9Srdrh3teAHyXz0aMrnlysmcMJQ6Dzwmk74MuM94ZYlPtT9Y28nWdiLtXcZRyOaurtvMVKYS7KbZhxIrQIy+0RSYULAwvjcN7wkOumoTOW3jqcVALLrNBjGENmjKlSfXKmt5ZTgU7BJSUZRZuqwV1RL76TJmbNjLbQZWFpHGMuDHmua2ypNJVMYdZqanOlhsJ1RukLrIqQ1fDhk/M91Vmfuuhabm6W4IVHF0ueb1aMY2CeR1qb6LxjOB3xGnGNIRbYH0Zizrwdx4r81frFZoqiRunaep4HzYQ00RjD35yEfmfQJKyMYNqG3gvHlCAlnLE0zmBFKGeKSqfCac7sYiaipJwwRuvPTVacKCIF4y1qhLV4tiUxlzMNhUyjhs56ZgrzmahhRViIIxollAxUI6cv0DuhE2GFoVC9LR/q77/q+9LSNZ7NqgPNrJc9q65l07cchxYjqTYy44xVpXP1Hbw/DswZbqcasCVJMbkO35Kec+EUTqUwa8QZoR0t7mhosqM3grSe1lqCWmKsZ2Llbf2PqR+oTpUpJQ5TpbCEEPEGxqSYLGRNDHlm2ThmzVxYzwSctBA0M5RCg2FpLEELY5xJcL6PHXMpTOehXGMMnVrWraNXwzF7Cny4/95jVTCGsFy0XF+tKUW4WK1ZLjucbXi0XuDNzKoR5tMBrwHnDaHUcKo5wZfHIyEVHIZW7K89Ab3UwLaDZsZzOGB/ONJ0IAF6AdfWIVgUuJtHfK4DtHVnmHLl4jcC45TZEpgozDHQe8N2jFgFLZGpCF4LU5m59B0RGDQzlsikGauGC3HMFI4xkDK04miLJZTCUBIq0FpDL5Z14+hUOJSMZvB8u4/O727Dv/T0a4drDCll3txHXl7seX5zzc1yRcuKRkZ8TmyPE21rsM5xP0ZePuxADLfzSE7KwlhaZ3BYjjmz6qrs536cOYVE7yw5KStr+EHXcdE4oggltxzGE6eQ8c6xbKtRYpcC6pTL1HIIiYcpMmhi2TgW3hI0s4wGcuEUIzS1eduI5Ys08DZMTJp5ILLG0wH7WH+NoAURoTeWgSrh0DNO71Ic318uSSmxM1Uvaz687N5fnfUUzgp9a5lj4cv7Lc++f8XjzYZeFnRlQPLMeBxZeKHxjvsx8WZ3RDG8CTM5KwtxeFvJKEctrLq6hbobJu7mQGcMIRScCD9a9Gy8I1mLGMt+HDlMAeel/sA7y6EoIWdW1nCcC8dciJpZOkPvHLEUegTJMJeC80LvDGvxvNSRdykwl8xOEqjDqWEbZw45ESl01tOJYyTSnj8qpcClWj7uO8qkbEv9GP/gmXw/pVoTnvvW8/TRhjFUedXV5pJnF4ItEw0DmgrTONF7g/MN2zHxZn8kK7yeRlQtC+MpWuq2s2Q2riFq4d08c0qRhThCUFojfH/Rs/SW1jQ0YjnsjoSiOCMsXEPna9hgtoXGWk4xcQqZSQudKKvWEk3BF9BUCJJpHBhjWFnHqxjZaiRqYqeB69LirWFfEsecyFq1rb1Yikm0BkoBClzg+bhfkFJir+fX14fz917KGIsxlkXb8PhixZwDU4EXF2uulh1l6pF0IoWacNt4W5/jFHl3mJhVeTtV5KUrSpchJSWi9M4QjbAvmbkUOjWYOZJ38ON+wcIanDW0ruP1OHEshd561sbQGBhTIZeCjYUcM6eSmTTTaWHZOk4qmKRMKTLHSCwOvNBby1elcHtutHYlca0dCytsU2JXIlELV66pTZQq1hrSmTx0aTyfLVfEKbFLNauHb8lA/1D/f9R5W77oO549umYMmSElnl1csegXxGGNiXfYlNiNA40XrPPkMfNwGBkivBxGJFmW4uisJZZCQrl0LUOJvCszp5hp1eBONU/id5ZLVt5VKIxveDtM7ObA0gh94+i8I+UAWrBJCQGGXLHGLcqVc+x0hpCZQmEKgZIb1CutMbzMmbdx4pgryfGmtBhj2cbEbQkEKXzcLmizQVQpQDiTem5cyw8vNoQpss918yXf8gh+Zxt+a+oKQ7UQYmHIiT97tWUc/4Z//INP+b3n11z2nv2bLcF6kmnRkHi7O/Dn7/YsnadtPGtn6I3FWWGXIlPONOIYc66BGUXxueq3/ux+4LPvb2j7Ds0KU+I4Jb7OE5scSSVx4T0F5W6e8CyQYmnO6MRr77HW8KjpmGIkiCJiGYaZ710Y8jnB957EqFW7Kirca6joKSqZYGEds4FG4EerBUnhq2Fk4x0frTZ8td8RRWooyQcG+nsrMVWrLNaQtXAaZ/7l52/ZzzP/5Aef8gfPrrhuFty+eSAag7iOIRXeHAd+tj2xbjydsVwa8MYjCIcSmTWz1MyYajOugC/1w+6v9id+dLGk71tGDDkqD1PgPo4cQ2RKiVXrKMA2RYSm0nxM9YZsvKexlugM81xRX2LgIUQWpqPYyrnelsxUEvWTUbhLc8XPCcyqdKZSo3yBTxY9BXg3RNbe80m75Kt5IFtq8J1+6LjeS1UCIQWIQQgJ/vzllhyFn37yhE+uFnQlc/vqQMERG0/KysMQ+Pww0jpHJ46FrakOM5ktFTmYz5PLoFXa0GCQDH95GPj4YsVF1zNlYZpm3oXAQw6szx+VfXYokIr8OryoF8UY4cq5yjz3MI61eXfWMM6BJ76rhKiS2OfEWDIxF3IuPEgm19EGE5kGx6wFJ8pHbUcucDsn1rbl+WrBy/0JPX+QCx/uwPdRaoEG1FW5zZANf3m7xXaWH11veLRYk4bA12+ORGtQY0gxsx0jb8aE8UJDDWqrPiDDXiCnQu9qkBqmvgNbHC2Wr8fM72wcTesIBbYpcBcC26SEPBON0J6vmylbbChYEex5Q3ptPKkYLlrPMARKUSTDcQ587DvGUhizclRlpNJ3JGcOKuRSN1OBwqSKL4nOGj5bdSQVbsfEunXctD0v5wE134Q9fZjxv6+qOThCoW6Txxj4159/yWKx4MXTJ1ytHXl/4t3XWyY6YluHDO+mia+GiKI1qbsYXDGVbc/EmDKrzuPUoFko6Rv8uuOvHk787tUFq0XPrMI+K3fDzOs4sZbIHBwLqsytaw2n+wip4BB647hynlYMF21mPgUmLQj1DvzE9MRUOKTIuxjY5UCKhaviuHOZfKbhzbYm6RoVOgO/s+wJWXl7iqyM4flixS/ClnTW+rhv+Qr+zjb805Swg8U0QtKCLbCfAn/2JvEPPws8WhZanzgtOtxpYHeYyHMix8Kl64gpc9m3jG1EqT/MJsGGhoto0ZAx6lDrUIWomVPK1ZjphVfHgf/i7euaeovhlCNPOs/lqnLSt7NQv+zrKqUzlh90S2aUP7q+4eXuyJfDwOsY2KeAHITDAk6lstA9lnWx+GLxwIVtCKbwIBERz6WHP1xd8NlyTSrK9/3MpW+w1rLqWy7mmWNKDKTf5GP6rS5rhHbpsV6YU3057IaZf/3VLf/446c86hXvZprWA5F3+0CJkThnbpqWkBKrtmVsE4nKuHdBeGZbXDTEHLkQQ7a+4gjPjctiIRgHr/cj/+zujillGuBA4Unf8nHXUoD5mBESUgwmV5LOJ8sFAD+5WvHqNPF6GLmLE0PKfDVOHKxj1AK26nMXGBoLPjoaawjiOGjCWM/GGH64WPO9RY+qcCuZRe9ZWMNN33ARPAdNBP1wBt9HiRP8yiJd9X9ANXb969fv+OSmZXG9xkuiaQwTcDhOmDPb/LLpKLPiveOOGYxgjWFtPEvv6IpQUuaqeKLUSea69YyS6BcGMfD2OPL/uLvllDMrFQ45s+ngclUzHX51H1gZiy01qNAb4dPlgpnET9ZPeLWdeDsHHjSwnSP2IMxt4jTXYKOkhWvT1ETJKDTOszKZA5FsHM7AT7olzxc9uQj3JrFoHM4aVr2li459qhzrD/X3X5Ya1IfAGBMGZTtH/sXPv2ZF5NGTjsYVmtbBrBzHSEmJmGsoWswZQ8PRZpJUusQ6O5atoRRFEW6MI9k6rHi8XHKXAsuFgBZenwL/3fEICks6hly4Wlk+XtZ38M/3Iytv8cUQFcQablYtpSg/6S94tT9xO4/sSmAqmbfDzGBrsxVTzeC5oMFY6IAlno1xDKYwGHAt/G7T8aJdUNTyIIVV4+ia+jNwGw2HrMQPwVvvrerISkkZUhLaxvPzVw+83v9z/rd//GP+6JM1xg74FjjBfjcQYmAYAn0SjiVzbVrumsScMzZrTad1HjNCAh7hWVuLFHi2WBON0q49yRi+ehj557dvmRXMLNzlyOWV58VlX5HExwlsoRWp0klr+Ox6w1wCnz655u32wO0wcp8i+5J5kwOnh8i7MHFK1Z/03HeYeM4VsY6VeA4mczxn9vzhZs2L9YKchfsms+5arLNcdB3dcWAbC/G/76bd/buJ+VT40Uc3/NN/8Bl//MNPefXunnE8Ud7O/LO3X7LqPf26I82wdnUisHKej/qeFsvHT1b8ICZ+uTvy8jgSgUJhJtM5QzGFORdctNjO8tN+xb/4YseUM4cUyKlqo4MRNt7Te8cnqyU3m550FPZ5YpfGmjAoln97PLGh49V8xyEEosJV0/Bi0fOr04mf3e+q/l9qWqoxjrVv2aWJoVTtqkd41HmuLezIvMtVd/h00THHwPX1hufdY6avvuT+beDtbvxNP6rf2vLncKwXyyX/4Q+f8tNPnvHm3Qjjifh64D9/9XNWnWez7pmmwtrlmraXlXWxNOL5wcWCsSi/OJx4OUzMKCUr3hi8ntNPjXLhGjRnnjcL/uSLPafywDFnplxqcJar3pPOwuOF5/qi4/ArOIaR/Tl51Ivw16eRlXV8dXvPFOuEdWMtj7uOL/cn3sWBsVS9v5OKG/VFapOVC+ms139iPUsDI5ltKmy843FvmUKgu3rC7/Qtp5ewfTvx8zn8ph/Vb2VdPtnQ9J7PLjf8R5++4Hdf3PDFmx0pDBy/OvLffLWn7WHdOZgzF8YSSmZUYaOWxlueXvfEEvjl4cSrIZBFiJqYMagpqChGDCsajjny1HT8t39zz6nUCTxFmEvC9IaVtWxsw2fdms26Ix3vOUwz25wxQKPwF8cTSyxv45bdXCOxFs5yvVnweorsTzNDLigFp1Wqc9E2NRE9AwkaNVy3LetSOFBYJeXCOp72NbRmsWm4vtkQ/B3Hu3u+SNNv+En9dlZIEZ8szxYr/sPvP+HTizWvdntSirz7as8/+3JH4y2brspu194TVcgWrnpDColn13Xw8eUw8pqZAWXKStd6rDFkA94YVsZxlzKbLPzzz3cMmonAAsuJwrFNGFewxnHddFxdtgxjpYRt03zGeMPf5IiZ4evFwBQrTMOfdeD7VId6g2asAY+FIlw0LcmApJoT0KrhyjRcJWXqlIMWltZy2RvCHGnbS75/seJk4eEh82p/+k0/qt/a8q6hcw2/++wR/5v/8Md89OiGL7/8ihwG3v3iDf+3v/6atrOsFy1zDFy2DVkrxje0whXw8cWSUTJf7I58dTjyUCJTzPQLh6ZKaFKt7+CvphNPaPjvfr7lmCNDzjixxJQ4moSSsUa5WXY8fbQm/dUd2zRxlHxOYoM/Pe7pRpBhYoqBWApWlWVW3h5GbtUwl0KvNS4uFOVm0dF4S57Ba6E1hWfFcmVhT6GPyoVveLZqyCmwWHT87s0FRwu3b9/w+e7wrf4+v7MNf9tanl0u+P6jDc83K07bPfu3dzirpBBIWte/pnHEOXNMitUzxsv6mtJ7nlptlg07TdhJeDhN/Gh9gznHMe+mwGAKj1aWNZZ3c2IoiaDKSjzBKrPNFKOcpsT2ELhZLNhYgzENr49VA2uN4IxlWwJNqzigE0+XK61gIuMMgNJZy6VtKGqIJYMou5xqwy/1Ejoo/E+Wl6ysY0iJl9PA69OR7n7D926WPG49Txc9r04fGv73VV3neXax4IePNzxbLThtB7a39yxtZBpmSi5IyVjvGcbMKQZMKYSsdFLXvFlg0zouU8NBMzZm7k6B37u+xACHEDjESCyw6Ty9taSpkEvV7bVimI1hNBmbDYdh5mE/cLNouBDFecfdMHJMCZOExhX2Gml6wWqhl4qyE1WmXA3sqkojwlosWmAuGQT2Z/20P6NgDxn+weqCzlpOKfF2nng9zPTvdnz6+IJL3/Co7XgpH7Ig3ke11vKka/l4veBy4Xh42HJ8uGPdmpqZkAqlGGxRjkGZY8IUpcSa5ZEpiCksbMOqSyxLYYqZaYLvX/SIwJgyQyokgRvvWeF4Pc7MpQax2XMjNWuhxXAMmd0YuVx1LEXQxvFwmogoVgwxJCbrkJChVO/KmgYRYYwTC6kIWq+wEoeIRwG1wi5NTDlhxaAUBuA/6Fb0zjOUzG0cuR1mlruej65bLpqWq67j1fjhDnwftWw8zzcLnq86epR39zuGw8C6MxxDYkw1kM9ZxxRgSjOaoGSDs5bilGIKfWtYFsdCFWscGiKf9QuMCEFgRsmiNCbhRDidIklreFI+h8sNmukFxpjZTYWLZGhtTfcdSuSUa/ZEGgudbZhipuRCj6U3jtko73Kqgz5RHMJSHFoMzjgKVeoxlYzHsLJwQvi95YaFqf6Sl2FmO0X6Y8+LZsV12/Gk7XnHhw/O91WbrueTRxt+9HTDyir7+zfoacuihW0cmcZALo7GG6appoabouQMzlSsdDHKxjcsGkfrLevsyLHwe/0GA5xiDb8MwKr1LCM8SOGUM3NMrGxDzoVTSfRSA1sPQ+RZNLRO2JiG3SkwpgQ5kVToxeNyBa64YrAqqGSiBpZWGChV9mM8McHa9mRJvJGJMSeaYlha4aHA/3h9ydI5Tinxch65O000Fys+aoVHy56PFive7r/dHfidbfh/8HjD88slz1ctHnj55h05TOxiJIdM6x1N1zDnqv18ezyhWnVYF8ue3TBxDImmbShSzZLOGkQMT7oF1ggLU5msDyHzeh7A17jtFQYrMJlCJ46gNbRrN87cHUZu+o5165iOmbV1hFwjwztn2caAL45AwZLxIkSqWCNLoQgkCrMU0KpPSxRGMkrF7wUpBGDZtnTA3Tzx5ThwGyKH4cRdp3TO8Gyx4HE78te/yQf1W1wvLnqer3uetC2dCm/fbSnT2fA6BZpz2FWIiaLK1/sTuRSW1nOz7LgbZ44pUsRU8ZcRvDWIwuO2xYrQi6HVytx/FSYedzW2e4VDJHO0hYVa9lqYU2JbZt4Yx2XbsnIwD8rGCNHIr6k9u5xpiyWVwnxGcWoBpG4UMvV8jQi2yPnfC5PUM2gFpvMKftG1+KK8m2dejhP3MbI9jixagxfD40XHdev5xW/uMf3W1vN1y9O+4dpbTCm8uduSw8RdUMYxYxGapqmoQoU3h7E22c6xWbbcTxNDzLSNASt4J3WYgPC467AiDDGxl8Q+Jd6mGWkMrREQS0CYKKzOMq+5FA5z5P4UuOgCq8Yxnwob59iXTFSlw5C04IrUPBRRUsmUKBRVRmrEvQjMmmnFkVQYqenjSZRepKaiAsumxRvhfgy8Hmf2MXIYAvtuoLOGx33H1an5TT+q38p6tuh41jkujCAhcX8YUC3sT7CfEorgnSGGmiXy9jjWvBrjWHnPKSiHmGgbSzKCdxZnPUkNN31//pCEodRhyW2KrDF0TYMvmUBhliqXHalJ5VNW9lNme0psOs9hKqydI2lhOCeHq1S+f4b6Iar1/SwiBC3nOxCk5LplVWWQyEETEWUlQhIlAV3jcQpTDNxOM4eUOUwTD6fK7H/Sd7xtW372m31Uv7X1g2crPrtZ8nhpKdPIfn+gxBrKtj9WCmPTWWLIlAyvdud3sPNs+obtUNjHwNJAlGrAXnWekAtPFotKXQyRRYjchcCreeSmWJquZeMbhgwhZ7ypGOGiwhgyu1PkYTeybh1hVNa+QhGmXFhZj1iLl/pxiWSK1jtPqMPfJIpKwWjCnP17p5R4yBWmscbRWFe3XF1Hi3I7TXxxPHGcEtthpO0MnbU8Wy150u35i2/x9/mdbfg/vlxy1XqWIhgt3B9PPO3g1T4Q58xFX5v4MdSEsbenE0NOPOoX/Hiz4PUwMk4Tkgu3YWafIqgixtBbizNCsKY2YGR+PgzYteVGPWu1WIEjdZ3joiFn5Uji7TDSv3N8fLnCHyIf9T3WGB7mSO8cd/OMYBlTJkok2GrKdGqYamo8sxZyjnixtOc0v6I15EsNjGfL9ajVVLyPkbsQmYoyp8ir48Dj1ZLHiwUvlh+mW++rnrSelUKTCu6Mmruyyt0hMYyRdesQEaazpOXNaeSYIs8WC55frfhqGAhTQELhXZg55IClnq3emHoGTf24zCXzy3FAjOFxbljgwBoOMtOqoU2WlBLHknk9zDTv9nz/8QpXlKddA1F4SJneOnalYLSSLEYKQ6mNvDtPyhJK0EI4rxWt1uYra0EQssD0zRksSk6ZY4hsQySUwpwzr/YHnm7WXHctz7oF8PCbe1C/pfWosaxRulIQrS+4ywa+OkzMY9UTG9o6WQLejSNTKjxa9lwuO6Yh824qmJK5i4GhFDprMEZYuYoY1qKMkkm58Kt5oPGOa2vo1DFoYZTAwlQ2vhZliJm7YaYRw7Nlz+GUeNq12Bh5iJHe2LrJUlN9USURqOg4CwylkAUyhUhhjaEpnoHabCFCMTCefSGjKikrx5jYzZGcClOKvD2duFkuuelbnnbtb/Ap/fbWo8ayLEqTEuTMOAVWvWE7ZA5TonUGoy3zVJ/V3TAxpMRl27BsDMcYGaWAWg4pkQRWvqHLwqJrqvutFEJQclJehxl1LU/aDpOVscRKeLKeZQGKEouwixl7nPl0tWAMieumoWiVSnZS6Xa2GIIWBsn1/ivQGstJIyDMWhhLZIGy0Hz2ItUhR5ZqcAc45vpRcIiZYa6myrkUboeRx6sF113D00X3G3k+/z7Up5cdj3pLTyGHmdNhYOGV3XFmd5xxRvDGMU21D3x3GjikxM2i53LRMaEchgGfZt5OMyfNbBpHlzxd4+sdCEy5ULLyxXQi254fmiVLZ3FW+VpHFs5ykRu0VD/B/RBo3u355HLJbsg86RxWYDvDunEEBIdhlsRIIpSIKrTUTJQiwqzKsQT6YrjRwEOqW4J0Nu1WQWSFbGjJHOfIboikogwh8vX+xJPVmptFx7PV4lv9fX5nG/7hFJm2Eyvf0HSOpmtZtInWOcg1mMsIbA9HCnA3TtynSFB41rZ8MR4INnK/hbdxIpN45js654g5IWo5zJGvTydejhPGwolClxMLHMUKI5FchEVxVeZg4PM0s72LfLpecHOx5Eoy7mApaWA7z8ymsE+JEDPRFbSp2KSL0HAsBmvqlHXOBYTKhTXgkqk0DmAsiYLyZrerHzshYFBcEYIoD+PMsl1w0TZ8vF7+Zh/Ub3Edd6dzAijYp5cYa2htphNBz6hXY5Xt8YQC2xB4CAmVmUeLgS+HHVNS9vOedymgBl70CxqrpBwQNQxx5vU08qtxpLfCqIlTsSytxYitNBQHm+BBLGoKb/LM8SHwo+sljzYNCQujJQ0T9zkRTGYfC8OcSKZulVC4yA5ipaYkgaJ12kpRlGpqV5ToMqHUiezXDweMKncholQ0Z/aF25S4SB0b3/Jiuf6NPqff1hr3kZJnLmxL/8xhG49rZ5pjDWVrjMEa4WEYK9M8RbYxkQdYW8er8USwyvFYuM0BRPh+s0QMpHNA0jhH7oeRV/PI0htyTGT1OBVUIJpKwXmsi/NsXnkVZrZh4tPVguuLFhWDDDMxKQ85MpeCnLGxo8nM57fMU9MxzwV83WxGCiebscmQpNBgKUCSwtEUiiqvD0ecCrs4I1o3VdkWXs0TfduxbhqeL1e/0ef021rTFDnMibWzyDVkU8EDopZGCr0ITpW3Ux06jTFziIlUFK9wO9UgrtMs7DTTGMsPTYNphWwExJBL4ZQSt3FmY+t5VjGVhSFQznjxx7Ylq1Ak804j+2Pk09WCq76tpCeEmOF+nsgIsxRiqVS88RxH/7FZELNFXc2QCNSp7zektL5YIoUZZZDqc3q1PyGi7FPCKrgkqDU8aGZdCivneLLufxOP59+LyofC7jiweOJ5dOUZi7KMgTmkSneytTd7e9oDFY15lxPzNLI8GF5NM3dx4pgLb+OEs8JP1pc0rvpOxBjGFLmdB748Hdl0DU4caEFQjFOKCAnlh3bDbAuzJF7OM/fTxCdXK67WHSIWZy2icJcmEg6PkKjDltswI8Dv2B6ncLLKSSvKePK1ZzyS6DB1207Gm0gBvn7Y4oqym2c6EU4ZjDjupplV27FqPM+/ZR/4nW34f//TJ/ztdsuf7w68/Bd/wzudaEWwVmiD8OZ44t++3uNVeTnM/MGLGx77jv2c+JPXdyys5casSTKyVTgW5UhmlzL/2ddf8D+6eoTms85B4Wm7QGbYlkLrq9HMR1MvrxZWVK1pJHHwkBvHzbLjzbsTl22HXhn+6uuvUYStmbFO2HQtC+d5N838zXEPBi4WHStjKUU5aeK66WijsPeJaBRjDd5ZXscTn0+Bm9ZxL5nP44jJ8KJZsly0uKaG36zlQ8P/vuoHj9f8fHvkX7+95/PtwF2ecVqwDtys6CHzp28OqCq3Q+APH1/wUdOxT5l/c/fARbPgkbO8ShPHmDjGxJ4AxfB/fvmG/8HlFUKV3PgInfMwFB5MoHGGDocJcNLEwtQUyKJKlExYGCbbcL1e8PV2ZOHh2Vr45f22TizIGAcXvqO3jtfTib8+7jDAVd+zMA1ZlaHMPDWepsDga3iSGIM3llfzwOtp4qL1nFzhTQgQlRe24apfId4QKVw6/xt+Ur+d9cNnl3y+O/Jn91te/asTb0sVBxojmKzoOPNv32yJqtyHwA83K57Zhjkpf707srKe533Pq2lilxL7NPNKoYuW/+rtO356sSalTCiKQbjEc0qZKWee+IaFtbhUJRfWTFw0XW2iSmYwhmSEm3XLy4dIZxueLISfv3tDYy13pdBay8Z6RJW3aeKv5wNO4MJ0rJyjWKUYy0qqgX22SlAlatX5b+eJr+aZa2vZlcjLNOKAj/o1q76lcZXWcmk/NFzvoz6+WPB6nvnZduD1MbElV0NHI0jI6CER3twxV+sc123DhRFCUt4MiWXreYrlgUzKE0NOvLUzCxx/lkc+7ZaUoISUKQKt1ibsVmaufaWBPSTDnoShYdEIY4ZTLkzAQOJq4Xi9jzhruOhbvhgnjKnySYxlo56Nwr0Gvo4TpRQW2bIQS2sM0hpWxWJVmKQwlsxMYYxwmwYeqeeqbdhq5vMy0hrDM+/ZLFpc41GEK/fh/L2v+ujJmp/fP/Dyq9f8/M2W13miFMV4MAnyfuBPXt6TKGTg6brjCYYcMr/aD1w0nh/7a27tyFgSuxh4czjS4fivx6/5/csrNGbmOVMMrLEUzfxiv+eJb2ltlcbeRcW3E5e2ZS6wL5EBQzKOm8sFX7/dI1roG8uXDyNL66uER4Q2C8+K54HMlz5CUtoIS6CXBttYfFEusmXuLEMuDClxmBJv0shH2nC9cLwl8FfpxEI8LxY931ts8I2jFOHGb77V3+d3tuHfjRPeCtbBkcBBI6egPF32DHFmPq9w/KrhAsO7h0Pl3reWy01P5wxvtie89/xgdYFSSHPmTRqhCH95v6OTGsfdOM/36DBS6C4bPDVd0mI4zAPXZglSGEgcS0IS/MnLV/z00TX7U6oMa6oRbZ8S1lWp0BQzKSlDjBgDeAOilf5r4NI1/GS1JJWen5+OvCuBcOZuOwzHHDiFyCFHOmtRlP/T7Vf8J8+f8ZHvWFqD6T4wgN9XPRwitoARZSBUn0Us3HhHyIkYEgis1p4NllenE1HBNI6LfkHvLbf7iYU1/Gi1qkmkU2YXE83K8ovjCac1fXLhDR/TUJyyXLR44zhlRaxwGANXpkdL5iSZk8m4IPyL27f8IZdsh8otb8XSBWV7nsR6bziUGug2pVSHZkbIqkStZJ+lsXzPL1BVvowzdzkwaU2t9AI7TexSYdRMJ47cZ/4vd2/4T54+4SPbsHSC+3AG30sdT4lGIFk4oUwlU4AL5wnHiXmKiBP6ruHCKocpolLwjWWzXtA0ljHXoJePm46UGxyWPYHWe74aZ0SVaITee544Sy6FVddg1XDKVQq2zxM3ZkXQxIHE3mSsWP70/h2/k9cch4wzHmfrh+IhBooTkhpycRiqj6lxQgZmOSfnYmgEPusXzBTezYGHHMmSaoKuMRxSZix1Etb6BlD+y/tb/qdPnnKlicYYLj6cv/dS25SxzuKMMp0lWLEYFmcp7XyakVzoOsdcMqchEAXEW9bLKp2dUDocL+wCFaGzDftQsBbeDkdQJRnDsmm4zoaSC6tVS2PqNFckEmIBMlPJHDRyoCbU//n9jp+sFtztZ5wxWCt4bxgKQKGIIloJUvVXoMrLqD4lEWGdDB+3LQrcppm7XL11EaXJhm3KDBrIprDxLRnlv3h4x//MP+FGlMY4lv4720b9977ujmPd9FjlSCXezKVw7VuG/cRpP5OlsFo3jKmQjoEMuNZxvW5YW8sxZDpj+WG3IrdKJ443pxPeOV7uj1BgztWr9FnbUbKyWHsa6znmjCuGfQxoyRx05IHEjoRXw798/YqfhEu+vD/RiOCcYeM8p/P2PBbFoFgL4mBIiRATrQjunPOzFsuP+wVB4U0I3OpMccJU6kbpNgW2YyZRuDyfwf/s9ef8L599wke6YCGWYr8diP87e1Lvp4B4wTeVZNOHOk08hESaExoynbMsmhaMZXucGUrCGguzJUTLwnku24Zg64Tpi3LC2KpZPpZMNsrSW551LZ/0HVbP09icyCjPmp6uFbZzlTMEcjV+GMPfHk6UDC4KDdUT8OPFis9PEwcSjZqq95LMxlhOpnLdQ8yoAe8dN82i8mBzwS6XvNCeWeChZJwW7lPAIrgkXMeGIsouRH61P3JtGla9kPRDyt/7qnfjjHHgvEElYzJkLxxTIcUCqRq1F11LNMJ2NzGVQuOk6q5jYeEcl009g2/ixJdlxFsLOTOnhDfCwloetR3PmobWGL6MM8dcUDHcNA1NKRzHumKeTGZGUWP5ap5x7/YQoSmGRgyfti0mwr4kGgXJhYKwEcfJCGIMIWVmrcmpj03DY1+nBI0xPNOGCeWo8DZXlJ0TcGq5KpZ41rt+dRi5sIbGWOYPGPT3UvdhRi2oEWYyRqrMasp1Ck9R1uLYdC3FKsMxEkvBqcFqIc5KkwuXrWPhLA8p8GoewIHLmVQq57k1wpOm5bl3GCO8TYFJM8XCpWloVBhjlUUcqTKdxsCX40xIQgrQSqA1hk+bBS9VmYvijEFVSRQujOW2FJyVGmKXMs4anlnPpXdoga4xXJ69A4dSWGuVuDmxeLVcZ0sgs0uB1+PAerGgN4bpAwf9vdQu1omlWK3hQUnIRpljJuW6mWydZd01aEzEXOq2SJVUlFPKeIRNY1m7hoMUbvOAILioFVF9vocuGsu1GloRXpXMSQNGhEscXiHE+pE4aSaQEWPZhsxf70YOY8Ap9Nbxwi24C5FjqXipIkqRwhWeV4xYMdizREMpLMVx0TR1y+qEy1KJUNuiXOI4lEyhTmkvkiUaOErm9hRYGUfTVP76h3o/9cX+SN9IHXyVeM5vgGGMzClijLJqPJeXS/ankTGUGq5ahEUpaCm4bHjUNFybli2Rr9MRLBiEYy4ULTgjPOk7ni86jBjehIkYZooKN9LgHKRYtwiTyYxnwMW7IfKz9MDtIeBE2HQNL/oFb+eZXU44UZJU/PElloc84ETw1hEppJJ5kiyP1i0Fy8I7Hqe6ab3LylM82xIIqdCp5SY7ErA1kZfDkc05XT3z7e7A72zDv82Bzrqaml6Utggjyj4GvFGaphpck2YOJA6uppIhsI0znXW0xaIziK061M44vDhaNeQzBSBmJRjldbE89j0PQ+SYE9YYVjhufMecCqpQtE7nvVimlJlzZt00pFQYClz1HW9TYn/m/wpCa4VHrePNJEgEi2CM0BvDWg09NXSk85ZjLhynSFHo1TJTDUOO+ucacmaWzBenE99frFj7hil86LbeVx001bhtqRuXlTPca+BYMo0TfG/B1C3RbJRTo0ip53KfIpMxNECJCqm6/BfG442hUcOsiTkXohayKo2FJ77l4RQZSw1NWjjPjfekqOfzV1n5XgwpKqPJXDlP0sKpZK4XC+40sQsR1Zog2Bh41HneTAIJjKms/VaEpTX01lFM/TMcY2GYa6DcwjjGks//vxYMhFSJF1+dRl4sWhbWM8UPL7z3UfsU8RiMCE5ggWdL4JASYuqHaLRV8z5ZGJoKBxArHFNEStUlJymIsRjqs3ZGsEkIFEKpH38F6KxwYT37WLHEThydsfTOciiJWCoZyGHoscSozFKq1KxUvvlF2/BQPCFHEEFQGiNcec82JyjQffNnUsMyC/6clBqccMzKHDK2CK21dagilattjZBLfUl+NZx42jT01hPDh6HH+6ixFCTX95UYS28sk0bGlDGiWG+BqsefXL0/bAZrqFvCDA2KxIxTUIG21OdtUiaWTJDCDJRUG/9L5zjMiaRUj4oaNsYyaCboeVoKdAixKAFl5R0xF2ZVHjvPIWdyqZk2Rqov4MY5tnNCU6YXhzV1c9urpbUGo8pohJSUMSoWw8J5YlKcFVo1+CLV96TKl8PAo75l4Rpi/PAOfl81xIiow9oaAtd7x7s0c4gJUJwT1AmqhdEph5KxAk7gGBID0JYasOWtxxphjQNnoBgKdYA2o0ip+v9N47mfIykpjRi6LHTSEkxNGvcUWixLcZQE2SjXnWfKldJzs2rY5UTKgRaDk7p9euIdb2PAJlibBrGCqLIplsY4jAizWA45MaWCx7LyDXNUrFF6NfTFMmnhLgV+cdjztG/prSOkb3cHfmcb/gORmJRWDaZAQ0VqzZq59obGW4oqxxC4LTPRwwUOB+xJZAOnKZLnSqToG8dHTU/KIFkZVTlqYkiF+xQ5msT3VbkLgbEojVWcCivXcNO0pFI5XyVXNroV2HjP00XL/RwZ5kzTNqySp8SJkAuuQCeWja+RzRoLjTW0YuiTpcTEqSRcUu5d5Msw8nacWNNijHDtPI2pF+VYClNM2KJs58A+B8Ycfy1t+lB//zVoImfLotiqEfUNt/NM0ELfWloxaCkMKbJNiblVlrmejVNOzMYiKRNDZiGWhfd81CzIKCUV1BQOKTHGxAOBrSb2UngIiRmloTb2SxEuGkeuX52UAh5hoZaFsTzuGrYx8BAzTeNYFI+GkVAKVqE9f6x0akip0HiD5/zvZA6qOClsTeKlBt6FmSvTYY3hyhlabxAMsxa25wjxbYwcY2H2pUqbPtTfew0l4bOlN4bOWTocdxo4lcTaCc4KE2BTZE8mtrUxccB0bnrmUtiNkc46Oud44ivRJmg1xQ45MeTMNmVmKTzRwjakiiS0wkYsnRG08Uyx/ncILMXSq7A0lsedZ5ciu5RoGssye+7mhEgdVjRGuPCOVbBMc2LhHJ04LELJhWPJ9FnYSeRtmrgLkQs61MPlOXHXICSFQwJbhPupvvQvbD5Pfz/U33eFUur7Ti2dOHrjeYiBmURnQJwhqnLSwsFUCc1S6sdcrBgAQoHDHOliZmEs18ZjXM3+iKqMWhhLYR8zoxeO32zxC3ipg7GldyyNQFY80IrQYXAq9CI87lt2MbFLGedsDXQLdQhhz+b2VeO4yS2HMLM0joWxOIEYC8cSaAs8SOBlnNnNiUvbY1z9UG2swSJkUU4x4wo8xKnmV2Ql5g/n731VUWUKmc5algvH0nbcpcBI3aQbgdFk/Bx4IBNdPYMiwpgqCvOYMnchsbSejfc8cS3ZFY6hhrBm/t/s/UmsZlt23wf+1tp7n3O+5jbRvnhtpkiRTDKrSMs0MpnqXJYICSpARkkcEVUzQYAhmi6YsAccpTTiSPbImlnyyHBZqDLgKsNVsBKyWJZISqQadslsmM3roo+4zdecc/bea9VgfxEklcziS+aLly/z3T8QDy9u3Ljx3XvWt5u1/g1svXI+tobqbe94PM7UCgtRVq4cdYkuBfYmLN0xhJU2Gu1x13Fj0fFonHgyFboY6FKkzi0lOEmbXB2nxJ00MOXCSiOrmEgIeZ44L5WFOI985uvzyONx4npaIFG5LQMptGwnU2FXmtHGg+2O86lwMxnlPa6BH9oD/7NE2lKNUJxbJFQEpQnMWjiLczkbOQhqyr4aWaBPAY+ta5DV2Fch1sDxIuAJnuxn9rVQHZIrMbTb4G/O5yxUUWkJgPsIESNEYXdYQJIKZpWXu4G1B2rh4PELnQbeGNZ8/XLD3iuTV0ourDaBmyGwd2EMtNcbnK/Zns22cg3l7c2eCyvtIBbaYzlNyjpFxIStVzalcEOUIUV6FMuVctXdemGYD6JuRzCDY9HnPHgVITgUg6dzZpfbVCgboE4aFAuQ95APC08KgVVqthNPS2WmjSeTtA1lXypfON+wCkoQpWJsaqaghBiYS8VVSdIWwuNeWVSwbNTqqAiLpLzBircuN8zVGDGKFx5uhRsauIytI1HVGdX4mhXONk+4qZG7PnNJuxAMBMA5icKyi0QPjMXY6MypBFZdoteIueJX5/0XguxOoVBMIQeu08T+UVtHPJjgDntvjiMdwjhXDGWx6Ji0MI2tKx+k0tG6ZABze7yoBRJCAJ7WzNM6M4iSJFBwNrT6M3dmMxQhirCXwk0d6B1qrpTa6BmdJu4k4f44tfWbRt/ZjJXroeeJGy5QgjOL8Y7N7LfGNYu8Vfdc0NbALghY5FSbzd0zGuYFMwtPLCWSXCi1MOerpseLwOxO4VmOAiSsXfhaTh8mHCyljYrTW6RWpyisQpsIjhNkL6gFehWe6ftHbRfNUu3Q0INLKmdTIVnr4heHYkKmEmlNL9e2zk1euamR3qB6C6/spGnnrtNzNmdCUIo0/cHTsXIrdsyaD7Q4o4jxiD0X5xPXtONeHdl40+QNCkLgqIusQxP17t04z4U7MtAHZaDZ2tYrSs8Lw+iVTJsG1dFJKNXbhDMERXAyzuiCAMekQ/6McRoEVeXpnCkHaqsGIWpzgbLaArf2xfDDROjRPPFgv2fpSieB0YzRjS2V3iOlVFAIUdm58VqnLIK2tVQCQ2z5Ti93Hfe3gaBCcSfnyhNRXl4uuDdvwCv7Ak/ceNs2PDmfeDUs+FLe8tiaZrOLkUGE00EZkiIGG8k8nideiwv6GOhRSjWm+t424Q/tgR+Dp3UieOvcbwkk2kgxi5AJuAA9nKI8pVFhBlFuauKcSgwdZ5IZtfLSIPyZGzcB+H+88w65WqPSaDvc9Kps1Hlcd2287QGq05XKDDytM7uD4GfQwFPP/NjqhK07T0rhTGau5x131kv6M4XqZDOKGW/tdoxWubbqsdnY1cwUhJVHfnt3znVS8+SXRKDZc6rC3TwzTluuxcSdbqArgZ+8fpsYG93nSZ65tKvN7kUhBGEjBbxw5AEpTo+yp1CJuAQkBsyMVZ/YWKHgDAp3CJzhqEUeSmFH5XYS/szNEwD+x7sPcIfoQo8yiNBJZBeMpzZRvZI8YDhSmnBuq5WdNB/zPgaeUvjEcsVkxhmFM6kc5z2vDiuGJGiF2VpYzdvbkckLqy4yTUaRinawDsrX854LjQwhcSzhILJ0VOAuhXGz5yR13F4s6KryZ45v0HeRWY3zmtlxdel8EQiq7KiMVsCcYJVeBUMIkgghoMBEpjscgpQWXHWqgUcYx0QeMbKzyios+NHT5ubw/31wTsYI6hyhrFAqgQ3Ghc14MJJWFh6QKaBExoNxQcYICGde+f5hyeTOZTUuqGxs5uZ6Rbc5Y65GPYgt3xzbNKgPypZKqQXEOeoiX5623KRrlA8JRJRC25yeULk7TqxD4FrXEQr8xMlN+q6JmTdmbP2Kw/8i0KmQDyGQ0WCypvcwjeBCcCEEyEwMFsnRCSp0Ejg97MEDwrnN7MisU+AH181C9V88eYqpEaxNIHttbhU7g6dMZNok8ZhAlNA67MHZe2U2YyAwqrNeR+bsnNXKBUaqMy8tOnQHuTahY8G4X9s++YySM9vMLIWhC9wvhdHaFHPdSHTsDI7UeJKdd+rEUUjc6gcWHvnUyQ1iaHS6s1rYXk2YXhiiBMZQ2HkmuxGAnkiRTNRAogUF9r2yAs7nmSTOsUaOVHlKZUni7bLhrBaWwxF/6vZtAP7Z2/dRUYYgdKIchUCV5ub4xCYumAkirGJkKR196NjZxMZnxmIsQmAPHA1LRnc2oXJO5b7tefX0mHhxQTZrZh0496eJkGdycHpgmycufeY0RL4+jexjS5ZeSyASGLOxHCJvjyO7uXC973h1tWRRMv/B9ZvtHJiUC5wN7+3S+aE98F+rkWOJzSJLKk/ZkjxwEgaiC5l2oxtSYGeVG6bkaNzuE585PcWI/N9373JU20UhlMCblxNvHPVct0RIzs6NWZyYhLUJb4QV4RCG4DTbpwfzRKYQYyAZbSoQhAnhNy/3vDNumNSQqNy9eMzN7QX/53/nhxhi5HfuP+G333nE4uAl/CRX9upUHKkt4OP/cHqTG1W5dbxi2XVcTIX/5d173Eg9D6aRC8+MXWGtgc8cH3NpM/e2E+vQbELPp+k7+JS+t3EiPcehCSb3VN5moivKaewRh+3hoNtrB6HSz0JJzu1+4E+tTjFx/sfNXdYo0QIyCl9+sOOV456jEbzC1lqsvKWIVOcl7ZBauKwFoVHaNm7MJZP6RllTa4m6jvCl3cjdvGdWR6LyKxePOb285Kd++IcZYuRLjx7x+Xv3SQ4qlfPReZgyxQ2tzc/9z51c59QCt45XrFLH5ZT5X+/e56hLPNiNXFphrsYa5ccWKy7rzJuXl6z7DlAup6sN70Wgz8KgidkrOxrta7DIIgTMjf0hKG2IEUcZsqNJuN0PfGK1woD/d3nMtdp89bss3L/I3Fr19MWZHcyc6s4cIVblliUSrZsuIhxLYvTKVPbE0C6DYtDXgCfnS7uZhzYedALCr2yecPPykr/6w3+CLgZ+9/EZX3z4hMFbd+2yGE8tY7RwOGbnM6fXWM5we93WwE0p/NrjMwLwcB65rJmjGOn7wI+sjrmcR97NM8vYbBE3V7TGF4OpspZElWbNeqGZnsRCFatNvyFApz2kytKUkJSbXeBP9C0M65/kC14KA8GFzpS7l5nrQ0KLsHblYm5d1p06gwZW5aBBETBag+WyZgpGUAjWLh+Lw2X4y5cj594MDQTh1+0pp7vAX/i+N+iC8s7ZJW8+OSdFY9DAhVUe2oxbYOGB5M6n1ycsgJurgWUI7ObMrz7dkIszYVxSyMFZdconF0su88jjXOi10Yq349WI80WhK8aRdswYFzXzlu7aGniwNs/W/PhTjvQB1q6ETrjZL/ixo1MM5/+2e4ePDWuiCesp8ODxjhunSwLCqUbOc2ZbJ6agXGfgpdqxiMITa65AJ0RyMR75HglKMCEc9uDZjN+4vORRmahmqAhvlx1fPrvkr/3YD9PHyNceP+F37z4kTsZiETmv8GAecYc1Hb07n7l+k5uuvHS8ZNklLnPhl+4+ZT9OTBTOSgu9XLryp46PmKh8bdzRzW36unmPe/CH9sAfYnN4iC6giloLJAiqBCDXdttPuRJDYBkChnAUE4vQMRdjTWwcLa/EXHg0TrhWHs0TL617lgeLp1VUSoGAkWvrIAjC6M3OKVujdqiCmTGXymmKbMtMTApoExCZMVf4lS+/w6tHRwQz/sRq1cRDzBQyl7UlR5o5xY3vG46p00QngY5Ap62LNpTGAXMRLAjVhIUkxpq5yDPnU26OA1fTxBeGEBUTSCgEQQlkKwQVxGE2Z7RCUkURViniOKugDAHmsbmcbOwwRrbK2TxTdpX708hLq4HeldmdZWrx8AGYqzc7L3VGdRYE5gMVQmnWrpNXroWeHZUuJgJQzdkfpgy/+rW3eWW9RM34+HJFqI54Acuc59q6r2ZUVz6+OqLsS7sYA6LGhkLIkTo5HmgdPZRl7BovvDjn3uzwlPdmCXaFbw1CW3eCtKmieqMQPPtpV/MmfPSKxiZy1SB0QVlIIOfCKRFXB1OqK+dzYRTj8Tzx0tCz1MDolRiVcXZUtQmzaRPQvTZKUHWQ6IeDW8C0TSC2VuhDoBMhm3FeC2NV/uVb93h5vUSr8Vq/IJoQQiFbef59ZDdEnde7Y4pNDNp0MbO2KZqi8EwQ7oIirCWwr5kzz5zX2gRxV2vgC8Gzy12QJrSemnwDl+bu5HijndXaOq1dpNPGsQ/WaJAn2hpTz37tzbg7TlzmzPWUkOCot8P8XB2vzQJ4Vm/BcGoMrsy0pOb+IMItyQhWubSD5SGQ3ZitMGf4zbcfcnMxoBh3+gRmDALbqYI77s5szSL2laGnzIWFN51MVueSmSUdJTtFHDtQiXoJZJqN49mU4TClvcKLQa3tV1TlWBJ7q0htZgDhoG/MZjydZrpOWIqSVFlGZRlgHOG29u2ZaxP4bhx2uy1nc+bWYkE8uEaFIOxypTc4r5mNF9Rhxuk1MNVKiEZ3EOFKEnZzm95HgT6EdjEpmS47v/qlN3n5eE0E3litIBWQyuWcqaVpWEycvRf+g/UxdT/REekkktS4sMxSIzZpa8wcnHiOYkfBuMgzY67t0i36nn6eH9oDPypMtcUMd96405XmD15pzhSzVWoVjg/v+OMQOQ2pOaUU5+Vu4K1xi+NIoHHxrTLl9tBUAXfEm6vAeZmZ3fHD5hL0cMghUgVcDHFhrka2StYWRKIOyYUbaeBYOt4+31KK89Ji4PZygbpwXoxYDGrm2QS6uV1oE3ceosMdZ7KKR5gxTFsQUtRA3wXub/fs5uZYEFRJV4vNC4OoMlEwb2NEcQMxsnvzL/dKdsMNlt5U9kttrhKOUd14qesZD8nJIQlp0Th9U/XDRUGhVkRgwsAyBUfk4I4hgtCsO03aBQQRpmrNz9xBgx6sGJ2T0LEm8c7FJbUWbg0DN/sF6sbTPEIukNvGKrQLxOCBUStUw7TZzI21cpSaC4bpM92C0veJh5sNo7ck1eBCtKsafBFwgYkCIgwa8NIcoNxb9zNLSwUN7gwuBI2sgrKWRo+watxOPQ/nsXmSK0gU9hj1YCigqpg3T/JCYXSjHFJQReSgMqElnNM2TbSNqVumqZE0IC6oCyeaGFDevthSqnFr6LnZ94gJZ95Sn4u3FFS81Xnvgogitflt14P16BBbvLwLICACQxd5MO7Zm1GrEUSI9ar+XhQmb5Oe4K2rGVWo5lQxirRptTp0LsQQWCkspYVC1uLcDB2Pa26HlSCEJEyHjnwnSgnK7Ao4O6+M0lLA5eDcJNJCd7sDX161idWzttpAaAFaDlqdY5SlBB5u9pRq3B4S11LCHZ5Me/a1NpqFNb991bZ3O80RqigUF+ZSWXYwmlGD0fyBnC5FHu1H9rVpU9qB/zv8kL7HsbP6XMCdq5O0Nd5Mm/ndLG0P7i2QYuA4RY5CxA578MvDwP39vv0+gHW0GnQYVLHULDIdY1MLG3Fmb/tjUEUPy0tSpdZ2loyxafTqYS1dxYAIYHDikSWBt84uKKXy6nrFrWGgxsrXL87Y5MyuFCZvmhTEWDpMqnC44BSHqRSWXWRv7cwxuCPmDCnw9d2e3SHZ2t3p5L2tge/tWnDA3/7bf7sdQH7fr0984hPP/3wcR37mZ36GGzdusF6v+amf+inu37//rfwTzyHA5IfY6+r4QTC2t+ZsMx3cItSbeNJxjkLgNEQwEBeudR2rGBiishoC11eJELQFZdXWtZpxttXY18KjeWqBRdI6ZKchMYTAy/3AzdSxComggYxzWQu7WugPXafTmPj4cNS6CqHRjFyEo65nPfScqzKrNDqPNMuxQSMlV5JGgjfbxnJwYelCYAqGNV9OXCF0wrvzxDa3A//kznn56IwTP8j6axBmgQkHaxSv4MK+ZDY1M1lFDh2errZTyUoCRxIwAwKcpsgyKoukrBaBa0cdixgZRBHXRqdwY/TKjsqZzbj+Xpf2mEACbsee6yGyCpEQlCpwWTOjG11U1ilwGjte61acdh0hKuMho2EdO5Z94lxhJ1C87VAq0hbPuS2o4o5XxypYdbogrQZjO4gVcSQJd8vEvlYKbeR9UT86lIoPugZnmhUc5k1YFto0cTzQEV1AgxwsCIUVyppmH9gmnuFgaenE5CyHNgVYhHAQhrcmejF5LhKXIEQNdChLFzqBmzFxKolBG+XCxNhaIXtFtdXRShOvxoGjFEGliSwR1l3HYog8ffa63SjPLhKu5HluG5G1ELpi/nw8PqpTD528Kk7olPs2N4MGM6ZqnJer+nuG97f+jNELeytUb1PpgDAf3HVaiJWTJDQTg4Pd9EICzZ8EloeJPOpIdBa9EBL02jIfTNq6UgDD2B+oYSkogwaONBKDcj0mVtpyP0IMiAiTOIbTHT53LZGXpOc4BvRg2Y3DIiRWqeN+qWxqYayHRs1hr89Tm1yVw1qc3Qi1WcHutOX1GIdDYBLeyXsuc2kXH3c2V3vw8z9/v9e/QDuc76y0dcGdGJTJnY1VdoemcAjSzAmCchRj4+M7eHCOu0iIgodWg7FvgZZDCAQRTIXaJJtUd7ZSiaosDm5O6xDoFW72HSehUSpD1GZKoG1SHmMgRWWpgY/rkuva4SqM1hIfFimx7DveHQtPcmZrhdEL1WqziR+bDksPQZzZQGvTt2zJZG3C+GyGRHhzv2WbK5M1aueT9+iU9y13+D/5yU/yj/7RP/q9LxB/70v8p//pf8r/9D/9T/zDf/gPOTk54T/+j/9j/vpf/+v803/6T7/Vf4bOA6uY2EsTxTiN3pJrRWgii5VGVhqhOIvUNj2AEgEV7o17VkNEFY56ZRXhrBinQ+NCP60zD+rMkSS8+GGA3saXpxJ5VZulwA8t1+RgfGna8zt1x5aCeotC/lPLY5apIzv0CPenzNxHbg9LTlLjMQZztrmwy7UlY8Zm55SCQq4MQ3Mgmmpllyd6EwbVFg4RYNLCfd/xaDfwYJy5zIWVJnqF9zjJ+Z7BB1V/AMkDqyhMWtnkcnClqOynuf25tho8CREqLLpmFWcV6sFZ5/7mkmWKiMKyi3QSuNCR9SKyUOFhzjywievSAy0FNyh03hL4XpYW0f19izU1CG/lka9NIyPNS31w55Onx5z0Pbk6pRQel5laIy/3A9djIuDgznbOrQZV6YdIPPi7MxdSF0GU0VtgTu+NYqbaqGwZ46FPPBpHntTCNjvLoHQqrev7EcIHVYNisIiJ7MZZbqSGYMLWMpV2+FpK4DT0WGkH7/qMWhiaddy9zY5F31K6uyh06jzKmS5CCHCeJx6UmZtphVYlqxEEUoWlBW6ntga+1g+4wN088fU8sjdQa9axP9gvWcdEqc0e7mwuWAd3uo6TQ0I44lzOhV3JoDTrOoRUBcZCWLRAmVIqc80MKF0NuDdqW1Vjo5ltnXlSCmM1VqltxOGq/p7///tZf4rTHTzMtzRqV5GWuFvckOp0phwvegrNBUrMMakQIRC4t9/SpYOrVGgHmn3NhAiqwnku3M8Tp9qoDBVvPv3emic3Do51r3ZN1P3AKvcsY4DnzFDhB44WHKWOORv7semfZiq3U8dxTI0W685cSktLD82uM9DoSuS2/glN6JtrYdknOiIVQ6U5m51ROB9nzvJMKZBCy2gR/2i1+D/IPfiZji1X40ke0RgZtbKRlgui1uypjxeJyYxjDS23yB0UZIg82l6wGlpzo0sQzLmsM12naFAejiNvTTtuekcfmn1ZVZAKawvcDm0N/MRp0+W9PY+8OY6cmTGT6Sv8yOqY66nDc2WcKo92Ey7OK8sF6y4yW0GssiuFHYWa/NCsFgYCdWfE4wjRyWRKLpz0PUsSVZ0oQlbnPjNP88y9aYIs7UYk771z/y0f+GOM3Llz5xs+fn5+zn/9X//X/Lf/7X/LX/gLfwGAf/AP/gE//MM/zC//8i/zEz/xE3/o15umien3CU8vLi4AWGvkJHXMFLZpYpbKv3/zNX777CmPponijgblvGaWRF4+WuPB+M1pw1uPHnIaWmKoTjBaZXu5ZXrwhJvDwC0NPB1n6kEoZMCKiJuxGAJ7q7yb93xl2rBMgVc0sghds3IKzkkf+OkbrwPNGirF5uhSqkKCmxy3SOcx81tnlzyYpxZaZBU/hDYMqjxlbLaJObOb9ixT4lrs+cTRCfemdhE5nzLVgU75nc2Gt/d7uqgUE5iE+SMmmHy/6w++eQ0uU5vcZK9sgVmcT9+8yZfPN9yf9+ytoMBlyQwx8PJizayVL84j756dtVC2ZMjcOpvb3cg/e3zGrcXANU08HGeKOL0E9lNlVSJelcVSmTAeV+Nd3zF0gZcZ6Emt0xmcZYz81ZNbRHOIStRGGXIG+km4s4isg3IxzXz57ILN2NxVYnUozYKsV+FMM+d1Ypgr066NrFdd5BPrE97NM2uJXI6F2oEl4QuXW97Z7OlU8ZzYlGYF+VHCB7UGLlMihkh1Y06ZosYn1zd5c7fjokwtIfJg5yoqfOJoyayVr84j//R8w0shcaaVYTa2tbAphfLoKTfSwDVV7l7u2WslBmFTJ5amgLDWxOzGxjK/wUQEbtdE3ylVWzd2FZX/8Pg2MwEN0GsgRmXqK8tqvBIaxXIzZr7w5JwH80RQo0PoSjsARhUek5kw5rkwWmbRRVYp8rosuF9mljS7ZYvKLIHf3o88rpmoSpA25dzbVf3BC6i/0BOCNurEIeDtkydr7p7PPCwjewpRoNAum6dBqVL4Sp64tyncCj07hG4sbGrh0gr/xpxbw4K1wbv7PZM4XR/ZYhzVnkUPi6jsSuUsF540cR0nKJ0qY81clubi85eObrT1j0ZpPO4j3nc8mfdcC4mT0LMrlbe2ezZTYSnKLRJPy4zhRJRNMKbYTAnG7KxS4jhF3pCB+8U49cC+GqqKJuXLdeRhKURtegJxZ84fLZeoD3IPPoqJaxqajbRkZjH+wuuv8PmHT7m/31PMWYXA3o1FVD62XlOp/Pa446tnj3mtW3FGZTkp41z5Wt3zLzjj5WHFaQ68ub9kUmOQyJkXrtEBcLNLbGvhaa48yVvMCq/WgeM4UKpxllsez//llVeAdg6MUdFlZF9hGAIvxwXX08D5fubXHz3h4Thxve/oLfBonnBvTZunzGy7Qp2McecMXccqdbyqA4+tcJPEFiOpMoSOz0977uWZiNDTXM3eY9Dut37g/9KXvsQrr7zCMAx85jOf4Rd+4Rd44403+LVf+zVyzvzkT/7k88/9xCc+wRtvvMEv/dIvfdOH/Qu/8Av8nb/zd77h45c+4WPjDJ70HYqx7CKvDANBYVtro74QOE7K2Vg585mNF5YxIaW5mUSEtUSSKqMW/uTxmq8/vOQoJfB2i1sGZU7GNUtsahsd9SiGgcGvnl9yGgP3a2FTM+sucmkzR0PHW+OGsnc6AhIjd+cdD8aRtbeR9gbnmqbWjSIylMBsjVt26j1f2l4CUIdmyzjUyDI028VoSqrKPle+utlyrwSO44CbE6d2rfuodVff7/qDb16DmzyhpYV79DFyIsZxSNzue1SdXcnkUpk7YRkSj+fMOTNbL6xSwt0Rg0hgTaCXyJyMT6xP+d2n5yyiYiaIC+sQKdE5ipHRHVelj01cFgz+9WbDKiaeWObcC+suMVklJuHePJJHI4qgi8Djcc/9caTLwmjOKM612LFACRFE0nMf6pOUeGuaEclUFTotLOfIOsGiKpc0V4J9aemmixI5iR3VDcZm3dm/kCf94cUHtQY2W8E2xetj4CQo1welWKSbjV052HVGZRWEB+PEBYWtF3pV5irE4i2tlEQvgbEzvv9kwb0nMzG0lGgxp5cWGX9EZMoH0a5AqC3W/ovTnnWNPKgzFzZzHFMLKExwb5yoB02K98rFnHmc983C1oxttTaNTR1aCziMxZhrZR2Vr+9HQJh7GHLguEQSTi9CUqWYsy+Zt/eFY+s4iRGfQefW4eo/YlPOD6r+alQ8tmdwFGNzqiFxLVaEjq0qBSdoIgU4mwp7CiOw0kiuIFWwqiw8EQnMUvhY6nh3NxJpNT5TGDRQUmGgY6yNRx+CIlrRCl+ZZhYKT0vz71+mwGwOCR7VCZsnEgGPylmdeVwKSfbNA92cFZEkbaqwrIHRKlkqxwS+Oo0cUuJYqrF2BxqHO4VI9sLOMpdz5kYZWGmklkKdK5EW/vVRwge5B8+HTKSQhNNuaJqNqLy0XKACu5KbvXWMBFPun+05C5lLyaxSZPRC2WeqtByIEwILU35oNXDvckYlMOaZy0P+yGUo3NSOs8u5JYtL08hB5NfPLlmlkbt55EEZOeo6LmvlpEu8sxuZqqGAKTyeRu5NM4MK+2rsSuU6PWAsFVauXJbM1lsg3dfPtm3C1CsrCqeW6Zip1vKdJhUuLPNonHilLrlNTylGzo5Hb9kC7wHf0oH/05/+NP/Nf/Pf8EM/9EPcvXuXv/N3/g5/7s/9OX7zN3+Te/fu0XUdp6enf+DvvPTSS9y7d++bfs2f//mf5+d+7uee//7i4oLXX3+di1Kw6lzrO15er7nWKcmdl4aBo67jIheeTBOXXkimXOTMKE1g1KHsyoyL0GlHEKF6aQmlNfCDJydUM/LsTPNMZ5ATjGL03jjTkzjFAp5huxJ2XrmsFS9OjfAvLs84ypGnc8aseQ9HlNEqT0tmK83lp+CchsSlVW4sB+oMU55xcX5gWPHbl+ftQZQANdO58n3dAhEDVboU6RyCt6CT60NiVwpLa/SRzUeHPvhC6g++eQ1e1hkDTlLitWHB9S6SrXLcRZbdkl2uPB4nzr3QCezdMRWSBKTCJrcJwEDjuBqVYkap8P1HR1Sr2OjU2emqUkNl9pYB4dYmCu5tpj4tmlPPtraQEDPjX20vWCbl7PBeSaLEOTDXylmtRBdGaQmYp3RsqnFjEanAmA114fu6FV/ZbgDQpEgR+qp8rOuR2ATpvSk9Tb9QcU67xKYUFhJILuzso1OEH+QauPOKVOMoJl5eLjiOgVidmzGxDIlNqVyMEzspRFMurVJDCyASV/ZzARQ5BHVlc4oZlgOvLBfMZuRSKdaMEWZpmSNq3qgKaDMYMGHulcdUNlaxAkWd37i8YLGIPMkFr635Ilko5pxTUWl8fVe4pol9ySyHxOTOjooKfLxf8vXdDoBYlGjKlsLteNBZKQQJrEVJtekMliEwB+M4RvoQ2Nbw/j/oDyk+yPor0kIBYwgcD4FFbOvaSdcxpMi2Fs5zYQpOZ8KOggVvvvkujKVNXuRgNGDWEnanbNzpe6pZc4Sq3pyfglILBIReWxiheUDUsaBcYuzxg/YOfmveMlRh64ZY2/cpwuxGDcJ40F+pOqeibHNtFB8zRsrz+vvKof4GicxSmAKsoxBKpR4cylZEuqpQnCMNbEJlnSILAlP96HT4P+g9eKJpHIeYuLHsuT50aHFudh3LELicMue7ib0YSeDMZ6oZQ2jUnk3J4EL1pinJTtOA7o1XlgNWjK1ndlZbiKC2GoV20FaVg6YksgPO88zZnA8Bc8Y/f/qUVYpc1goVkglFnNmaBft5KYzWLoZLUS5L4fqypyvt8yPKJ9dH/O5mi3vTdu4FssE6BrQ2eqYf7EEHemyGVQqcq3HTEyuNzO/RvOVbOvD/lb/yV57//4/+6I/y6U9/mo997GP89//9f89isfhWvtRz9H1P339jj1Bp/udFjF6Fo5SQ2qgM57s95/PEZS2MWBOdtbAzzFqwxmjWvMq94toEHDsr3J9GXuuXbL25r0RvAqOCsaNyTRKzN2FjUKVYU25bdXK15p6C8E6eeVn8YMfpbLw5Rjx/7d5G3+rSREAaWMfIQgLX+o6JymXJXGI4EAvgTczkKfB6F7l3vqdISx0MKKrCG8PAg3liztbsG+Wjwx98EfUH37wGMZiplMOBdxUiXo1FUB6PmfM5szmIZqo6Is0b3w4C7GzO0rU59Ai4OxvL3J92vNEv2Irh7s1pSSDjVCpLjRQcwwgHoffOynMr1yAtg+LdMnHTu3ZwM2eHkWqrB7EWe18FxCFbJYqw0sDQtRCjCWdXja02jr9Uw2ujZ9TlwGtHPQ8u9u3Q5UL0Zgn6cup5GIQ8W/u3P0Ic1g9yDXRvicguziDKOrQ1cFDlcm5OD3v84PigEBsn1ByqGSOVtXe0xyO4wNYLD+eZV7q+iYEdkjUua6UyibEmUGkCtpZo3jjctTYbxiiKuHC3ztzMUA5Ww6O3aQJA1PhcExXwNhFyZ62RoROud4lZnH0xLqV1xqI7Wo2izkvDgtckcH8zti4yzaK54rykPU9TRoDZrRk4fETwwdZf4++btpTwZYioQZ+UbZ7ZmzMjzLW2xG1tyc/mUGszIlhLQGhrkNHWqCdWeCl0zOIHF7xEVGGv7YK30NBEwt4C3uRgDlBwqrSk1IBw32aue8IOa2u2g28o0MVmkVzdETOyHAwMQmQ5CCdEZnEuS2VLE4g3y+3ChLFaDLw0RB5uC7k6HUJwZbbKndgDFbF2sBuv6u+F7cGzVbILgzTr9ZOuQ0tlEYWzuXI+53YOtEqSRkkUa5qNLG3fvB56rDoRQTEupfD2PPID/Yo9rTF2QiSIcClGVmeVmn6jiNNpa5psvTDX2rruKNGEN/c7buWBg40kk7XwLIBljODtXBrcmWl278sYGYYFN1LPLMa2Vp56e/3ZnJILBWG9GHh1UB5tZiY3Fq4khEsrfGw5INmRIsw4u/dIa/y2hqGnp6f84A/+IF/+8pe5c+cO8zxzdnb2Bz7n/v37fyjf64/CSpuyOlPZzzNTaSm3Ls672y1fPDvn7WnH0ynzwFs3X2hK+703L/KuQCmFXJrAY2elUW6miXfyyFyNDiULTTArhRCb8ty90YlUYbOfmKYC7gehjpJpQTVHkuhcKdma+t+caM3qLpqysMBYGt0iufJav+CHl0e8Pqz5yrQHERxtvujeHDd2UXjlaMBxZq/MNFcBBO7EjqOo7DAeUdiGj85i82/jRdYfwIKAOhSrjCUzldaVjAL3tnu+dH7B3XnP0zzzsB6MvQ6iyfFgQZiKNAtXa+4Peys8nLY8mifuTnvGaiQCVZpH9U6ap7oGEGnJlSEql+PENLcwri4oQZTsbWS+8kDnUGrLkXBzYpW2yBVheFaDKiSUN/qBH1kf8fpqzdtlgqigylSNXJt7xQi8vGy0t4yTpW3+INwKHesY2KvxWAqbqxp8ITWYWvBCsyDOhVJaTbnA/f2er20ueVgnHk8zD+rUrFMPdoh7b2FBvQtW7eDjDJMYj2zkack8LHOjL3rARZjFmdVISdEgmILGZmd8WTNTragIQwx0EpgPwraVtc1vNqNYu0QMHuktsLTAUIV9zog314nXu4EfXKx5eVjy7nx43apMOBNOEdgn5eV1hx6E8rPX1rl155b0LGLgwgt3beSpz+/Pw/wuxIusP3Fa0q5A9ZbjIFHRqDwthXfzzLlXdqXy1AoirThzNaaamaRpNp5ZTnM4DF1QOS+VR3WmOqwlHsSSQgkwpEiKAVElBCXExM4rc4UgypBi095Ja4QtJZIIFG/GHkEVrUpfhVUV+gK7aSaa0KnyyjDwA+sjXlksebs0OpkeJvIby2xrYQ5wfdn43NVbZ3jEmKicirJE2Fjhvk2c8dFxifq38aL3YCvOrmb2lqleKaVZWYrC3d2WL12e83YZebCbuJcnggSowjRXNiUz0iakqkKknd0mNd62kcd55u0ykqtx4pGVJhynqLPuE30fIQmSlOKFbc2UYs0iNCY60ZZIX2mMC2tTVPHGrV9Y4NgT10isPHBRMtGFQZSP92t+9OSEjx2t+Oq4x6S55mWBjVcuamGOwktHPe48d2bbWmFvmZfTwEmIbLy279/eWwDrt3Xg32w2/O7v/i4vv/wyP/7jP05Kic997nPP//wLX/gCb775Jp/5zGe+5a+dUKIEzOGyzlxUYx+MGps/eiCgJkzWoudzqS0cSPTQE2ge9pO220/OxprETekYizEVO7j9hJZ4Ohc2Vjjqer5vWPMD3ZITiaxKo+oMKbJMrUOfrCn8vzzv+Po8ci+PPJ73nG/2MDuP58xUDLd2mB/NeVBnLktFqdzfb/iNx0+4rT2n3ri1qJKi0kflrXHLrzx4TBRlSWDhkUECZsY784638p4Ly6BOFz864+x/Gy+y/gASQhKl0NydLkphG4U5tm7ps+FKNWcslfHg7RwRUGkXAG2HqK1WMs4RiZvSU4sx1xZu1ElATMgGOxrf+fU48LG0YBUiQ21WsovQpkSrGOkIBIO35g3vlj0PSqvBx7sdORuPx4l9KYhBqkqejXfzzFktmDr3pj2fPzvn5dhzSqIPseU9RCWFwL3tzD998JgQm93iShNDlyAI9+vMO/PIhWXsqgZfWA12GgkIORsXU2asmV0UagxUF3IxppJb6i7leWBgkoNjWQVVo9DCBKnCmo6b0lOqH+gOzR7YqzCasbHCcVReix2vxZ4jTawlIeYkbXaeg7Y1UYGvzjvul5nHdeZJHXky71GER/OW83lkLgZVqXPlsWUuS8Ew7o07Pn92zp04cI2O/tCdU5q93t3tyK88fkJQ4Sh0HIWeVUyA8piJR3ni3GZmqYT40eJQ/368yPprtK4WaHVpzf5wVCGroBrbFEeFqoKLMx+Sx+OBPlEP1MNMm8K4w7EmTiRSvFlrqzTtmtAC3zZaSCLc6iJ3FokuRLrY6q1XZRESi5igCyz7gfuSeeyVp1TO1dh4IWrg6TxxXjJzNYIFvAQelsJFac2JB+PE5883vN4tOAmJZE2PgLT1+9525l89eEIyONXEde040QSuXObCozJzWQsmTt9d1d+L2oOXoo1ynStP55ntnLnQyBwSqrFl0pgxuzNWZ+cZFT+c0xQrUGublO7VyMApHddKYjcZm9oayQsCXVXGuXBmmYUqr/cDH18uWKoyEChmiEKXlNQJk8KqH3hLRt6aRt7OI3frxFPL9BJ4d7vl4XbHbsqICVLg7jizzYWA8/Z2x796/JQfWKy5nXoGCY1RgCFuvLOf+JcPnpCqcyN0XI89yxgRFR6MM+/ME0/L1ByyXgSH/z/7z/4z/upf/at87GMf49133+Wzn/0sIQR++qd/mpOTE/7G3/gb/NzP/RzXr1/n+PiYn/3Zn+Uzn/nM/1+xxjfDszjrsRq/e7bjrakwoBwlZWOVNAQEZ5NnjmuHavPStQq7ufkGI819J8VAxqA4T6eCLiv7UihFmK2ANCuwrjbuYegSp13kphd+PV/wg2Hd6BYqWFJqLyx2xkWdDt6wbQwdXNlp4ZIZcbguHesQ2EtlVQLZZ35rO7MrjV5xGgK3+sC9bLyjI1VbF8R38JVpz831gB2sm1aq7EPm7phZENl6c6p4LS353W/5p/vdiQ+y/gAuvTBp6yp+bb/lQRkZLgMnnXApTrfoCOJczHtuMhzsL4VSIZeZag4EliQ6CYfnK+xmY7OY2ZdGP2smizDENrKLMSAhciSJG2L85vmWN+LQKBKqEJUcjcVeOa+VOldKM98hIOy9sO8qVttIfBEiOUAoYFS+ME6MtY3Tr9HxUux4s+zZqePaFgXPcHfKnBz3zULWld4Vjc7DUljTM1obDryaBr72/j3mDzU+yBrcU9hLq788Gve8cDxNDAZbywzpkOxI4QY9ubTsjzZJapOanVWcluuQVDGDUpxNbKK0fT0klGIsU2SlLTmcoKxS5CgKX73c8jJLcD94qjeq21ENbMhctAgkHCeGyISzDY3Xf0JikMgmGCcECpnf3Rd21UgoK1OOYuBJgRxApYUs1RneKjO3+yVGawANBLJUznLlmI69NXeYV8OCL7+/j/lDiw+y/kaEGWM25+EUOStbQmgC8V0QQp/oKTyqlevWY14wq+RizbkmWHO2Mzt0PYVAYiqQY2E0cDcmMrkaKSprejQILsIgkeOF8LX9xO2wwvRAdFTIyRmKsA25XWxR4sGi1USYe6NUQy3QB2GSyjUdKMn4wrRnXwoBGAq81geeTEIJjbKbCJDh3lS4PfSAEmmJzkuDpxROpCMfrHFfCQNf4uz9ftQfSnzQe/CIsacyZufNi5H700w4V467yNk0ERBWwDs683GOWxirtSyPg3krOyvspTJ4CzoVeqIqD1JmmhutdnfIOxk65VgHOm1N3WOPXF8k/tXuKa/XHo+/F0g4YvQaOWPCY9OQJBF6US6lsuubPuUaLfPkTDLXYs9E4d/sztjOlWBCdOPjMXKfwigB0daIrrPxbsmcSKLTwOCCFmNvwoOaua4DOQii8HK34Hc4/yN/nt/Sgf/tt9/mp3/6p3n8+DG3bt3iz/7ZP8sv//Ivc+vWLQD+y//yv0RV+amf+immaeIv/+W/zN/7e3/vj/GY4azO2CHsw1DW+8Is8LS2QK65NpeHirNIkeyZvbcO63U6sjxzpxiIrmwsk21kJnNjWpDnSjYYgSyVuXMWBF5ZddwcesRodopHxpMps0yBc6mceSuSm9LxyJQ+BkII2MFRZfLKrdSxIFLMOSuFYVAupsr53GLo2zFQeDl2nJuRGQm1ea8vu8B63XHJzLaU52mmQqAv0vzSgV6MhQZO04c3LPn9xgdZfwAbJqo7fiCypgmmhXE+0wKLxJkPose+D0zSQl2kCqfWtYwEgzV9uwxaplgTPt4sAzYfgl60OaRUF65Lx8urgRt9j5gjpTIt4EmZSSlwQeVJnRndueGJaEKfhOVBmFRx9p55NQyICKMbT+vMEJSRyjZHFn16nmR53AUu6sxYKupCV1vHd73suCQzzrXpV4CioSVqdgDCoI1beeTp23+43yX4IGswa3NBqu5MtbLIHeeWeUShmLX6cyNTWYXEnpmt1Zb8bMpa2yRoIJFMmoOKV7ZWuEXPdBA4TsBWMyVDTB0vrQaupa7xT83wvvBkMlIStlZ4Wmf2wXgpLOi8EoGgYNZe84aZW7I4pFIbZz4zePNcH0zpPDyn99zpu5ZwTiaY0IfAKgZigstdYGMzbkJ0IXtLR/cAHKZvA8rq2xtUf1fhg6y/Etp+6tkpOtPTMWPscsUPeqX54NO/UOWy2EEbZ/QmLEJ3CJUEL82EYKQwhcqd0uGlokHxADsK2ZQQAjcXK05jbBqCWrnjcDlXlqnnos48Kq1h8bL0rLQjWJvpJ4danIs4c0MSlfYe2eHEqFwUa9azLrgr6sZpnzibMxsrBNdmAxkTHoy5NsqEurWUYWtcfj84+AyqLDVyIld78Ivag7M6Crg541xZ1MAcK29PcwslDMZkRimOJmHjxq62KdHtrufUAjfoWO0nxGGvxrkUKsbrrLmwlqBctXJeM6MZUQIvHd/gRtc1/Uk19uvKk3FmWCSe1JkHeWLG+DgdJ7EnZSceREujFs68cCcuMGvNvPFgAb/1wrUaMWsi9lDh1qLnvExcUOlcOA0dN/q+pfpW59IzvTmzQ7Da0oEPnP2VCyuJvKTde/p5ivuHS3F3cXHByckJ/+6nb+Ch8fITymztDS0mXEphS+N0InAce3pvEcuGk7wlkZ6UwLrvMYVLKzwoO250HWotCXW0gotxFCOXVjhKgU+fXOdWP7Cvxu+cn/PVaYtG4Y1uhSs8sczDkrnFAonGk2lirO3fjarEAOs5MpqxywUQ/sTxipdiRwnO/f3UVP8acYyntVC82Ws+42xLUnZj5qllqjkrAne05wcWS2acu9PEIik3+o4lkb/3//xNzs/POT4+/k4/vu8JPKvB//2PHz0XvQ6Eg0WiNCcRKWwP3GJUOEmNb1yeJVJaS1RezMJx11EVLmrmydS8eGNIWIXRMi7GOkYurHLURf6941Nu9gNjNb64ueTN/Q4Jwit9EwddWOFxKVz3Dk3NAmw8jCb10Jk4qYnRnsW/O2+sV9yOidrBk30Bb+Ihw7gomRmofhBPiiCq7HLhjFaDC5RbkvjYYoUI3MszvSrXYscS4e//o69c1eD7hGf19+/96ZchtPrrTKmiBz40bMjNFUWMCpzGoXmii1PN0exYFNZz5CQmSjAuvB3Wb3Q9vStWhZmKidEF4bxmTlLkR1cnXEsd2Zx355Ev7C9QUV4NPQXn3As7jOu6xKLzdNwf6q8J4/oY6LMylpZg7gKvLQauhUSNcD4VMGmJrGpcWCYDfuBSB2nOLpu5cKEZF1h44AaJV/qeQrNnHIJyEiO9Cf/gf/nCVf29T3hWfz/x73+cIo6iLEMEoenkSjs4zdJ0IQQ49tBcd6xQS0Unwzvnli+aFgBjS2uYncbIghZWWBQITgrCpcCqC3xiOOI0Roob784Tb5YZrHI7RKoZ5zWzw7gpCzw65zm3IDBzaq70nZJys0OcrKI4d1LP9b4DnEfjTK5GJ22/viyZlofKof4al2kcjSc6I9rMDm5I4k7oKF54nGf6GLkWE4Mrf/8fX61/7yee1eCf/TM3yIcaXMeuOe7MmXkuXGplG1oIXAjCtThQqIxeUBdOSFRVXvUBzBm98sQz923izmLgOPToLIxeyFIJ2kw1TlPPv3d6netdz74WvnB5wZfHDQJ8fLGkmvN4njmvhdfjET4YD3Yj7s0hLVslRaXLzX54b83i+PV+wc11j7lzfzuSs7PQyJCExzW38wUtFE5VqAh5rjxgIqpyrIHbMfHGop1P7+0n1jEc1vPAf/E/f+mPrMEP7dW0TZabCE2tqfSjK1KbYEOkdcmDtuh3qU1kW0WaAEKFqs6lzJgKe5plp2gT7nTeLO4qcBQj1ZyJypNpYiGRnRlfnDZc1MyQIheHDkA+HOiqOC/3Cza5jacLUDFEQnPuOYhwk4Ca8Eq34KlPnB3i7FWVEbgslWNJJFGqNMHnPmeCN7FnEw9HjrvAncXAVCqXVlj3gWtdItSPTnfrg0YQwZWD0t6ZxOlrAPPG4T/UYApKh4A3h6YqzeNeEIo6lz5TDlaE5oaLE4MwaECqU7ywkkBJtMCteWIQZe/Ol6ctl2Wm18hFKaQgbXOqTsW41S24yJmNVaobYtCrMtbKbN4EvAhqwqtp4GmobLRiDipNjLurxqCBXgIujeKxL7m9/lqp3qhEixi43ie8wGWoDClwnCLpo5V79MFB2yFEDpObHZmuhJbmfBCuJVE6h+RtU1RVTFrXHyBTGeX3uqvguLR16kgiO3Myrakwa2Xyyvk80Xtzf/jatOWpFVYxsPNGGarSGi+lGteGxKUoldY1syqIgBcjF3Bvxgfqykspce7OTlqjJoqwF9hWYxmaS4YDxRofXGhCdJdD/QXhZmoZEmMw1l3iJKWmqLzC+w47NNDcW3OsiNMXpZqQg1EPibXRA4G2JnaimLRkZMOZvBA0UA6TKjeHw+RqIZH9wQllUKWERsO4yJkeIWO8W2Y2OZPU2Vfa2muGe2XvmWsxcKFOqYa5YVTEGiXRrLn3OO29cisldlbZaWDydrk0MSaclbSbdTm47mUccadYRRDQpq+7lhJzhb04i9Q0VfrRcSX+wOGxuUWZNWpOBTRXcq7MqQl4ew10ByH1FugkoN7Wp6otVTepMok1Hr60GhSBdYpIdRRnERWvzXnpfJpYqLCxypfHDU9qZhkCu1oI3rRGIOxL5pYmHgdlXwvFD3Tyg3esIbi110807qSOs5JZhECyll1SE4wGJx5BnOzGlCsz3qZjQiP9Bhj6yO3lwH42dsVYdIFVFwnvsQY/tAf+LYY6SGnhHHtxEolCs1sK0jzCowSuacK6dsCvOKU4EahqnD2L4ab956wU3hgSoTqhtM1ly4x3cG+eWO22qCsehHPJ9BowE57UQsUZqW3ErgWvbTGs3haqWo3RjLE2xXbzcFXOc8ERBpSbfeK8VCY31l2km4UooN6+lrgwlwootTpqQuigSy1UZHA4XbSF8oLK6iMW+vFBYiu1nerN2VRjVjiuwijNF7r5TTcq1qkniO0gVqwyzq3mPBhPasasPV8HnpTMx/oBrc82FefCM6wDD8eJYdQmiRTh3DODKGLCec54bYe3bMaEUHPbRN2bZaJVYxZjqs0bW6UJiC/mDIs20r41JM5rox8tU0L3bWz6+yPiJ6s4ipW24oReSX3EgxCqsO5S06to4dg/uqLdF4mR2jwRa6PuTFo5rolZBQ/Qh0hywYtxzSI+aOPwY0wC1QQnc2lNrJbFUHWelolVjKgYuJGtclkdT81cYD1qc/sRuJcnunaV4MJarsgo3vQkZeKkBNwdox2UajV2Xumq0HlsTRYRtrMhC+gRrsXIvrbO3DIGdBLEed7IUYe51hYsODcL2hiFrm/OLb0fgp3E2dNsm6/w/mNTm/OOm3FemwPOcY2NG61KQulFsUoLnwqCqZCBqVqj/FAOl4ZmFxtQLrxwHNJhzYHixqUZ1sGjOdNXbfuhOk/LTMpO1zVReS6Vfc3MapS5sAqLlkRdK6VWzJvV66IIvSmKU8U4LwUH+iDcGBLnc2FTK4O2C6rRxMYBQdybzaO24EStrQGpCqJO8MAywujGhsoyXDXdXhTOqag7tTibuifEwFENbbqpbZp4FCK1ONc8EtPBHrY4c81EazREc8dp3PtOlCc1cz00vQgO2axNqMS4P82sRRFxZuUgwhUGD013Z96m+8F5PO05rc16dq7GeDgnXs7GUY4sUyJJo04+nWYwY1Dh9qLnUluIXNdHuqytcRHaRUQcZq9N0ydNPxJQNAoWAkNQThcd59boQyfvsQY/tAf+x/PMjdC49I9zs127lgIjRiSQaAEHXoXzWvgzH7+NBuNsN/H4fOZyLrwUl3yxbNnWdkivbiw9cEsTT3JmVytPcya78YaswIW38x7jWaTzwN4qfY0skpK9dbAcYSuV+7tdc0KhqbyTRrY5U9WJ2g5aVZt94lgzN4eeWuFxLdwdx5aWi/GwThwTEYQRO3S4MolwcMaIDCFCUMyVoxp5e7zkUZ55KX7Uck4/ODwpmZvSQYWzWkBg3TeqTEsBFYq1ic7TMvMXP34HjcLDzci7D7dc7CZeTh1fdGNb7LDoQO/KSQhsS2aqhcuaeSrwsboimPLA5kP6buCGduz8IFjXZt+pbgRgR+XRbs9szUu4k0ifGle6hsY0FQW0+VFf1MpLiwHceVIyd+eRNGeqGhsbOfImGNrTBG+VSlIlSeAoJI40No/+ZKxq4N155GnN3H6P/MErfGt4vC+caERduKQFtWgQ9lJJpiRvh+mqwoVV/sydGyDwZDvy8GLkYsxc055364TVtpFoCMQqnHSRrWW2VrgshaJw3SJkeFcz2fasJHBSA3sxljWyTrE5S5VKlTZpOtvNTTuFshClD8IlBVND2siLGqDQpqDHfUfwwmaauLefobQmzVmdWR0C6iZrDkKOk2jTs4U0K1AnIp5Zobw17rmMM9c+QjqmDxJPp6nRHlzYWyMcHAelBCPhxNomNwZsauUnXjpFVXi0zbxztmPMM9cQ3jVnxBGEhSbE23RwKs6+eAssxDmdFTfhSZ6gOl0IDFnZTyPXpaNPys4ruTTHqKzOfnLMnY6m5+hVOLOZSSpmtTmlhYP4GDiNHQTjca082ueDfbpzzsiahLocLGAL+XDWWKCsCC3YKyTUW8bPvXHDk+Dc/MMyXK7wvuD+fs+dbkEMyrbOUIyjLlBMGIKw9BZAOkW4O038+e97lZDgycXIvYdb9qXwSt/z69MlezdiUJZ9wqtzXSNbK1x45qxmrBo3aP77b5WZsoGlK6dFGTFeWjZHp/M8knOl80CNznZsdtYR5Sh0RLxRLs0IVsje3CIXpkwY1xYteOs8F+5uJ5hGUhTezoUlAVzYF2fU2oxAqjJIZEVg0IhoJCbnRHq+8nTLQ3FeHd5bBsKHdqW8lhMyGdmMxYHLj0awDAjVYaqFVVBmjB/74Ve4tT7iC28/4f/1a59nD3yViaelBbSENhfBzfnn01O6GMleiUG4oUvOSybV1qF4K4+EPLEO7XY2eaVU5fuGBScx8sVxxwh8wS7406ub3NKepMJxp/zK+VPOcluE2iJTGBV+e7/jzc1DorbuWXHnyVwgOFsKD1COQuIkJnprVlOqyg+vjylu/G9PH/KLjx+0QVIEk9ZJ+dfl4jv5mL6ncb10LXzLnCXN7vV43SHWMhlyroxz4Sglshqf+BN3uL5c8dtvP+I3v/559m5sMc5qJRwsB3MBCfCbFxv6GJjVCSFyOyzZlkygeeXe95F7FZalKfw3pRAcPtYvOQ6JL+ctORpfKJd8erjOTe1JQTnuAv/6/Jwn+5k5tonUhDGlwFds5B8/fkQkEqti1Tm3PRKEDZlHCGtNnGjHgHDuFY2Rj69XFDN++fwxdt7sSi01J42K84Wy+U4/qu9J3DhYD8/mdM10jOVxwksge20bWBGOo7LH+aE/8RI3Fmu+dO+Mr//Gl9lR2WnlHKNzQQ12c2bZ93x+d0nSyIhBhOv0WHZEAxl42yfUYGURScLjMjJb4PW05PVu4CtlRw7wxXLJjw+n3NCuBbsF+I3LCzYBxlwZadSOOcCX88TXdk9IFkgH4e5oRk4tFPFhnVlK5FgSRxZ5zExKwhtDq79/sz3jX26ftk6dOlWhVvDtRzcH4kXiRo1QvXGSvfVHw8LoDGopjFKosbIiMeF8/KVrrFLHVx5d8vWzHZMID6IzF0iHsMApV9Zd5Ou7ShJh1Iqoc8M7pikDmQl4d56bFupgo/nVzZ6jEHmt63k5dXw9T0xUfkfP+XeGa1zTRBBYBPjiJUwUzsPM6LWNjlT56n7Pm5s9oWh7P9DqrqqztcITmxmInGjimMiZZ0KEO8OSYsZvbM7515szQKlquLZzyJfn/XfsGX2v41btYd8YFNc1IQhHKaIaqKW2gFRgMTVt2yd/8A1urVZ86e2HfP3JF9iJ83jRgiiXWdAiTLlylCL/8uwcUdh7Qd25EwaeudmPNfNla/qj9WEy8MXdGTdDx/evVnx8teC3zi+48Mo/r4/5c8sb3A4dvSo3usC/ePKUC5yzMnNhLRdq3Ue+sp/4jcf36T0w0OxmpwobdTbBuJcneg1cjx3XS+Ds0Dx542iFAf/i0RP+twcP8OpkNabgFHH+9faPduiBD/GBP9LmGqpN4DqqsSiNp9rHjqJOzu0WvgiRd+9fMG0Ljy827Mx4XGdu0FMPfGcQNLbb/JJINBgPm6aiLFQ4pmNpTciYMarRbBnVcVPOSmZrxjQbY9dGRL8+XXAj9JxqYtgb51Z5ahVoSb29RgYC79SJEaczbx7ZjWTEEBUvAT9Eg3coYpWoSjbjnd2OjLPzikborWUQ9CEwKFQqj7+TD+p7GCkENLaRbrTGrz8OkT408eSOwhgre8v0GvnqO485X+15eLZhssoTm7ld+nY4qY3Po50cOl1KrMLoziRGkpk1yg3tWZoyFWPvBa/GLrTJgJuwqY0rzdS6oILw2/WC695zWjvi3tnMmafMz9OihxDoovLOtGd0WKrgKtihxlcxUOaKe6vBXgX1QJSKmXN/O1FoXFdJzcknIiQNzaLRr0j8LwK9Jlr2ljOYsPHK9TSwDI7VyrbMPPGJM9pze/PeUzbLmUcXbfL4uMxcjwkHZmsUST2s+M82m701P/RJjEWK3GZgMGVvjc/fa3N3mmkUr23NWHW6omzTjInx+fmS64c1sB8LezfOMWatII16pMG5Wxszv1cliSIO21JYETCEas3WrgsKai2oCXiUZ7IZe9oh60jbtVhUqOLkKxL1C0EjSjk90nRtJXMau8P7PTBhXHhbIxz43XtnHHWJR7uZGeeMwhGJKRaGQ4c8BQeUDhiCMntl58aFzAzAS3Rohp1lJqylj7qRD4FzG2vOfJqFOToW4Iv5gmvScyIdas7szrkeXPtU6UJAFR773OyPQ2BAcTe2JdOHQCWibvTe9uCAUcUIBJ7mmezGSLMtPgqKHaxrTZ1arta/F4VIC+XrERJwkQt3Vmt2knEz9rUFuD3znvnaW/e46BfcfbJlNxfemffMpbKphXVsmUdiRhAlVWFBa3pckumpHBN4XQcWRdlg7NRYo1yqoVQswMVcqKORRhi7pmv6V/tLXgo9t0Pi3t7ZFrjU9vcBemnr1b25hYMttWMlEQxGm56Hfrk5vSmDKRFayrgqD+bxIHxvF4CFKmqRzpue1HhvOqYP7YG/1ObhW7WNhQdNzW4pBPwQ4jFIoAtKEfiVr99j3SWmqXmbHkmLNS7iHMLXKG5MXnlFFlzvO7w4tWQSyoKIC+3G5S2spnoj9w0hcumVMY+IC/tcOep6ekIT03nBzNlOmTG0xSlKExSHg8itmBMPXeL5kLxaoxNj4I20YJxLE4CqsjmEMrnCKIYILCUhAr23rsJKGr1iutrsXhjmUlFtdVPFSSnwdJxIQRtnvhq9KCm0i+SvvHmfRYqMU7O4PA4d4kqx1p51bTS0Syu8VCMnfcTNMatEaxQhaeXePu7eKDwGIbZx9r1qBG90noUkeg8Ua783Mps8U7wJ4YI07/VwCA8r3igScuB5z1Q8OFHh9dWKMVfCIfBuIzO5OpKc/KwGNTShqCnVnKMY6VTZ6Uc3afJFYiq1iXBxRIWBwHae28e84v7MHjCSzfgXbz1k1Z0xz4YX41gSijJpboFWDtmdMyvcTj1rjWQqtR7cmbxpn/TQkHCaNqRvkkz2ZjxgJkkmH4S4nYRDMFOmmDHOmaBKkeacEQ8HvaajOlDhUEyaoJgIISmvsGSXZ9SFKMLukA4s6i2IJtKCt0TochOGrkMkqLJ5lmV/hfcV2Z+xnp83ydmU3D7mTUtk7nRBqNX5rQdtcl5rE80uJRCgJSTjzLRaLlq4Ln2bzntlLhUvzXgDBEozNyi0KTeqLIEZ57Hl53TegNJby6kYaZTLXSn0EsgBkgYCoRlitONAs5CVZrAxU5FmPsQr/cBYCm6CEphrM10QFao2n/8j2uU51CZWXsaICmyuNOMvDM8Eq8WNUR0R56xMzQZYmi7JzVh3HXWu/OrX7jHEdg4sc+XYm6h6T8uH2HqgRlh64FrqOInKlAtzrlCalk0PushK4/UXVVSFVJWLWsm2p7dGE4soPYqZsfPCw+psa6vBrVdSCAyhBSiqCMWFLsbmJOnOLMYcjY7K66uB8ylSc3OaNKsICgqTNwOXhTc73GTaEs1TE5tv6nvbgz+8B/5ixNRuRRkjqWC1dbo7a24ORuvCOs5b5xt6DRykQAwaUFEWGqlu4K3Tb97smYyWELqUpoTOtEOZeAtgyAf+aaD5nG5oAovqzR3l1IQlerCiA6HxFPdmdLRxtddmmYe2gCU5BBU5zeKlU+W1xYpX05LLceai5KY3QMFrc0zhcBsNoa1YuYmhrA0tnhfnFd5/lFyIUTBxsjpJA9Nc2IfWeajSjkUpBqwab1/s6EQPb25lqULUxj+uhw6E0G7tYzWOcLqoLL0d6mevB6WvULyS3ZpI1oSjkNjUwt6aG0UR5+jALS0cnHjEmXH2UulpHVRqq/tyuGSKCxparQdpB7I7fccrizWXY0tC3ZhRD00rp9Vg1HYZ5eCY4DjV2uu7kqy9GJRqdAcnshraQXw/ZUpsIYPFW/coiDADdy929Nri411gkEgKymBN04EDtTmNZVpXqFNlIU10PR2+XqLx8wuGIiQXjqXj0ppP9diszDkmsPTQbPHccXEm2sE+NBImcqiVfBCaPxfnwnPt062u43ZacDaNXJbMZC2gLqI4zXFIRVFplXZwY8aiE91JfrUGvhB4c7szabQBDUKuzYEs0NzwoAmt3YwH2z1JAlEUEaU/7HGp6mG/PjQwvOk2qhsJDqYEsD8cWnqrZKtkaU2/5JGVdmw8k7118F2cNYG1BSotcEvE8QB7r0DTtwRvgnOncfPd20HODof+3pXbfc+dvudizpyXwtYMJZA8ggrl4Mimz1a64qhIcxxCiH61Ar4ohMP5JtPWrKjOtswUhe6gIzIOro4ivPt0R1A5KCJhrYEhRoacm3vioRc+u9BMn5xehWUMSG0ULxzWEtr00I29V2INLLwFXW4w9ofz19IDx0RMWuMMIKuQn029pTlNhsMata/NJrtIayjP3uiWtxcDrx+teKIzj2RiWyvRlc4CmcrkzeCj/bPynBL5rLEf5LtctOsH6ksVmAHUSAhPLHPsLflulMpKOpaubMXxwxtbgh9u53At9Iy1MJeKSLMDe5wnmJxhkTjpEhRjKk0vIAcqkYhgB+3A4lknHzCMPgk3+56UjdEqPdLsyFLHu2VPtBYrPh8OZ50IOYFmZ5naJrwkkCTwo6tTrg8DZ93MV7aXPNxvSBLopLKXloCZpI21AGZvj3zrhezP/Yeu8AJg1Qja4j9nmp1XcuFemTmJjbM8eW2x3Nq41iJCQJ+/s1IUrtEzlcpsRsBAhCdlxmdYLjtOUsRKJc/NNiy4Hrq3jh3cL1YaMbzZKLowiPLSYsF2VrZW6A4Jf9Z1vDsX9GCbaCbgThRhluZVvYhKFwO9NjuvH1oecWO54lwzXxs33J+3hBDozJncmK3iGtrPwiHXGUE5rzP7Z97wV3jfId4ucnJw5XGcOlUe2MyxxudWvgV7rv1Ql4OZc1sv+qhcn5vwe8aQoMQaOC8zFpwUlePQNaex0hyjVFqtC8KkjnnlWugp1ja66hAFrvUd3SyM8qz+ArFL3K97em86pGJGxYjSaEJanaEL9BKb+YIrf7JfcTosWGrgzWnbbEFDZHbYk5kOHuum7RLrZgQXLsvcsk/s6sD/IhARkjQ/cBPHo5EkcIZxdGhmiDSXp3K4zAF4cCS16VMkckykAlWMORgpK2fMTK50UTgOgRycTakUNxQHt+ZgBkSHXiLFjMkP3v/q3Fj2zKWyp+XX9CGwlMS7855gQq6OY4gowZTRc2vQSbvUJhe6EviTN9Zci4n7MrOVHfucOYqJ7tBVnluLjhLbpbnRgZzzMhOCHpqMV3gRiN7OcY5QAJP2DB7UPTe0o5OAaXOVe34A9nY57brWyFikxPXcMapRDhPD6MLjOjO7EpJyLXXU4mznzGyNMhNoh/XRKktTFqpMZmRvDWcV59qi57hUdmJ0oYVWLul4a7+ll8DeCqW2mokxcFGm1iCOkaTNFeqoRn7k5BrXhp7O9mys8miauS6JvlR2OHizKc6xTddW1ia25yW3dfy71aXnGRdrIGDuTOZ4Eq5Jz5mPFIykofHycqFk4+TgVOPe3szLrsPd+erFhiFF+sODMxcGU84187RkPm4dr8mSRRSWXeJ3zy6oXaM+7KzwsGTGZliOaeuqAqwk8R/++PfxW795lycXO57kma02UcnZKGzqjERBTKgFgrXkyG2tSBDS4Tx4A+UkROaxMs2V7VTY7GfWErFilFCJBJSWNCkemN2w6pTgIM0i8ff/3K7w7ePZzzJ5aAr7gzvTqSUuyRQxNLROqsxQ9nASA4l2GFJxll3bFO5tp0N3sr25i8Jg2iy5SuWGKXdkQS+wXChvX+yYUsGkjavfrTPZC9GFWSpNsg6rEPk/2ABpfgABAABJREFU/ak/ya//1ps8OdvzqMxchsq1mLiYEhsaX1UOiX4LArET9l4Zc2nhTMBKA2sSu83EWCu7ubDZZo5ixMzJoRIltU5ZkdbJre3yUfOBqlb+4M/tCt8env0co8FWMpMZNsM1EllaZ7Rlbzchrs7CEcKOZhGsDicx4u48uBwRhEibiGat9FV5LC0R+k4YuBFS0walwP3LLWFQqoe28djMlkooeyatFG2XirUH/uIPv8aXv/SIx9uRi5qZA1yLEZsWPJw3ZPwgVg8kE3oN7MrMlAy0aQoisCIw7UamnNlNhYtx4ob0zF7Z18LClC5EOgStTpnBkjGXtjYHu1oD3088+zmWqTJGIavhwVmXyK7LlFCpCKHQbCvNWR2m5DPNGvM4tD34wTTRHaithlOK0RfhQmfQjuOYOD1MRT0ecX/a4dLsMjszzqrxVGZkdiatuDZqxEoCf/mTH+OLX3rEk/3EWc2M3qgdd8qCu7ZnrvXguS4M1iYPWx8xSYgExB2VwqIK2zwz5cx+zmznicWBAryNmZUoA5HeIl4dKe37rNXQ9Hvd1av6e//w7Gc5j5UxVkZtNO7r1rfuuAhmv5eTIxOkQhOyqqMKt7sF7s7blzuoTqJNmSYqnStPQ6vB1+LAS93AOikMwpcvL4hBqO6kojwsmYdMzASyHqZOKCck/uqf+kG+9jt3ebKbeJBndlq5MQwgC96ZRva1NDplEI5mJTnsMY4QOglAs0O+FhJ1LJRSmXLhcjezCs0x74yJEyJHdCw1ttiR2dg5TNq+l473VoMfuqTdt99+m9dff/07/TK+6/DWW2/x2muvfadfxvcEvvKVr/D93//93+mX8V2Hqxp8f3C1Bv7xcFV/7w+u6u+Ph6v6e/9wtQf/8fBH1eCH7sBvZnzhC1/gR37kR3jrrbe+56OqLy4ueP311//Y36u7c3l5ySuvvPKc9nOFbw9nZ2dcu3aNN998k5OTk+/0y3nhuKrBDxeu1sBvDVf19/7iqv6+NVzV3/uPqz34W8N7rcEPHaVHVXn11VcBOD4+/p5fbJ7h2/lePwpviA8Sz94wJycnH5n6g6sa/LDgag381nFVf+8frurvW8dV/b2/uNqDv3W8lxq8uo5e4QpXuMIVrnCFK1zhCt/DuDrwX+EKV7jCFa5whStc4Qrfw/hQHvj7vuezn/0sfd9/p1/KC8dH6Xv9bsFH7Zl81L7f7wZ8lJ7JR+l7/W7BR+mZfJS+1+8WfNSeyQf1/X7oRLtXuMIVrnCFK1zhCle4whXeP3woO/xXuMIVrnCFK1zhCle4whXeH1wd+K9whStc4QpXuMIVrnCF72FcHfivcIUrXOEKV7jCFa5whe9hXB34r3CFK1zhCle4whWucIXvYbywA/9/9V/9V3z84x9nGAY+/elP88//+T9/oX/vw46//bf/NiLyB3594hOfeP7n4zjyMz/zM9y4cYP1es1P/dRPcf/+/e/gK/7uxrdTR9+LNXhVfx8srurvD+Kq/j54XO3BfxBXNfjB4moN/IP4UNSfvwD8d//df+dd1/nf//t/33/rt37L/+bf/Jt+enrq9+/ffyF/77sBn/3sZ/2Tn/yk37179/mvhw8fPv/z/+g/+o/89ddf98997nP+q7/6q/4TP/ET/qf/9J/+Dr7i7158O3X0vVqDV/X3weGq/r4RV/X3weJqD/5GXNXgB4erNfAb8WGovxdy4P/Upz7lP/MzP/P897VWf+WVV/wXfuEXXsjf+27AZz/7Wf+xH/uxP/TPzs7OPKXk//Af/sPnH/v85z/vgP/SL/3SB/QKv3fw7dTR92oNXtXfB4er+vtGXNXfB4urPfgbcVWDHxyu1sBvxIeh/uL7Oy+AeZ75tV/7NX7+53/++cdUlZ/8yZ/kl37pl77h86dpYpom5nnmV3/1V/nZn/1ZvvKVr3Djxg1EhD//5/88v/iLv8jf+lt/6/1+qR8opmnii1/8Infu3GEYBj71qU/x2c9+ltdff51f/MVfJOfMpz71KS4uLgB45ZVXeO211/jH//gf8yM/8iPf9Ou6O5eXl7zyyiuoXkkyvtX6g49GDb6o+oOrGvz9uKq/PxxX9ffB4WoP/sNxtQd/MLhaA/9wfCjWwPft6nDAO++844D/s3/2z/7Ax//z//w/90996lPf8Pmf/exnHbj69W3+euutt97vR/ldiW+1/tyvavCqBt8/XNXfVf19p3G1B1/V33cSV2vgh7cG3/cO/7eKn//5n+fnfu7nuHv3Lp/4xCf4H/6H/4G/9tf+Gn/2J38UCYGgSheUnB0LwqPdxOwZVSch1ATrrifPGRXheBi4c3zMNO754jtPOB0SyxS41kVeXXZ0S+ViNB7UmaUEAsKDKXOzj4gImJMILFPieN2hUulCYHZjM1d22YgYWpVMhmxc1MplrQyqDEMiRsi1EFUICttcWWbBg0Btj0YFFiLQBzwISYReAoMGOnUM2seDkoLSxcCQeq5dS0ylcLmt1OrUufKf/Bf/H46Ojr7Tj/K7Ft+sBv/cX/rfoRpIKhylwGauSAw8uNxymSdcnD4GSHB9WFKsEoOz7gau90dcjnu++M4jbi4CQ4pcW/R8/HhBWjggvHM5klAU4dFcOFZjBhKBzoVFVK6friAIHYlSjc08sZtmBGHwwBgrXa2cTZmnubCIPcedoiuYs6FACIoBm22ho9UagDgMJnhU+j4AQqcwKJgoFWM99HQxEdRRcYau5/S0o5bC2SaTi2PV+U/+7j+6qsE/Jr5Z/f3Fv/zvoCEQgjD0galAnitvP7pgrDManCG05/bKzWMMZzYjauCk76m18KW3nnBrHVj1kVurnj95sqRLypidu9NEBMycd3Z77vQDfVJCMYIIfZ84OunQGBhCIGfnYj+yG2cSIKKUWpj3E4+nzM6c211PF2AOoCiLFFn0iuM8vsyoBNQKVg1HWHeBbMZARCLEJGgUJiAJXFutEA1EcYbgdF3P+iRAFi53Rjaj5MLf+rufu6q/Pya+Wf39H//6n0ZjoIuRdZ+Ys5FL4e0nF2zqiGP0klCHGzcWhKSUagQCq9RjpfDmgwuuDYlFL1zrIm+sB1JUSnUelBFFcIPH+4lrXaT3iCgEUboYWS4CEp2jNFCrsSuFsThaoSBQC6UYm1LJ5pzGyNAJo2VEIKZICq1+tjmTp0ouRjVDMI5CxBH6lPAouDiOM4uzUOFk0aMoitMF6LuBk5MOK87ZdmauTs3O//Xv/s9X9fdt4JueA//Sj6ACXVSWi579vrCbKl+794j9nAlBWfQRtPDxO7fIwdjlmaiBG8Oa/W7iK+8+5vWjgfUQub5sa+B6mZinyt08E0Uxh/v7HUsxBo+Yt3V0kTqOjjqGZccQlJwr5+PMbqwscEQjNk3MtXBeMntzXuoHljFScDQ4GgMxBBLwaMzgMM2VKRfMjWtDTxBlmQIeABFM4ALnqFduLobnNZiC0PUD108StTjnm5lSnFKdn30Pa+D7fuC/efMmIYRvUBffv3+fO3fufMPn931P3/cMw0AIgd1uB0BIgZP1wLrvWKTEfixUCWzzOaVWECOIIghJIgXDzJmzsRkzXp0YI5NBrUYyo4ijXrmzXmCzUE0YizNLpusiihBcAG0LXRfZlMrN9QIV4ShX9nMl58p2LpgoIpWhVsAYRFgvBy4xShX6FFjFwDyN3EyBB7UQYzvgqcAqBKZBqQ5eKuZONWM7FzZWEVd6DRwtEv06UqpxchTJkzOPmalURA2gXVau8C3XH3zzGjSM0/WC68uB077nfJxAlfNpYlczLk5MESIkCcwUxrlSy4gVxa0SorKdYe+V0FdqBAFe6jumCvviXM6V87lwZ92BCJ0EMIOo9IvAxWzPa3A9d+zHmTEX6uQwKInEMgZKrgwhcS0F7ulITspJjBynyEXJXC/Kea4sYyCq4DiLAnURiapYqbgZ2doldeuVeTK6kFn0kfUQmL1wvF5RZmG3mzEvBD1cIK5q8H2tPxW4vuo5Xg6sVx3n+8w8Ow/PR4oYIRwunBo4GhYQhLEWprnwdDfSK8SobLIzh0pvlapODXBjMTDunCkb52PmohgfO4qEFEjaDvzdkFivena5crJaoAirRWKzn8lzxV0Ya6YUYxBIolzvOsSNh2RiCCyXHceLxH7K3MiBx2VmqaHVm0NKyhAjMkHxQslOKc7dKROBMhuqgWUfCcsEUjhaDzAZ8zzCVJBwtQb+frxfe3C1wsmi43S14Hi5ZNwXdlPh3sWOUAOI0oWACAyhJ0Vl1spcKpfTSHInBmFvTilCnxxTw6JyMkTGOTEVYzNVNu681PUooCpEEboYWC4S+2KsFj0qwqJUxlyxGWZgrjPMlT4GepyTFEiijMWISVn3HUNKmGfC3nlcnUED6iDiJCDEgAIVp5gxWeVhySxEsLnRUYak6BDRkjleD5TJ2Y8Fr22Nh6v6e4b3cw2sxbhxtOLm0YqTkwUXu8x2V3nwaEPJoArxcGlLJIhGB+RcebTZEuZKCMpZrewKaA2YOATn5Lhnu2v776N95u3NyL97bUWViJVMFUVT4HjZQxc4GXoEWE2FzT5T5xlHKThe24F9oXCr74keuKTSJ2XoE32M1FIYq7C1mSNPrEPAqCyioiGwiIG5tvfPpla+nkeuTZG4r5i3ps+1VYeROT1akWdj2o2MPiPiwB9dg+874azrOn78x3+cz33uc88/ZmZ87nOf4zOf+cwf+ff+yT/5JwDsreIO6uBmiFdCrYgbaqBVwJRokdkKl2Nhtyvsd5nNdmTKhitM3h7oxVzZm3Pmla4TXl0NGPDObuTB2DbHQRUBZgo7MhvPfOlii4sQg7JKgeOuTRyGFLg+DAxd4qjvudYNSFVSEZ6MM7vquCvRA5ZhdMhVQAQPioVADcpUBZ9BLRAkgAgF2KoTJGL+/2PvT3psy7L8Tuy3dnfOufda+573HhHZksksUmySZAEFFVSSCoKEGqiZENCABGcaEwILmvAzUBBKn4UTTSRANSiBVWKJTTIyo/Xw5nXW3Xua3aylwb7PI5OAkEEiXmVE6q2Bu5u53Wf27Oy799pr/dfv75gzvDk1HteMOSP5nrCB9UbO+/g2/kPX35987ds1mGtFWqXVxt2SqTmzLTM5FwxDnGBmSIXXy8Lr08qbY+b+KXP/MJO3DQJkMWZVTrUxV+N1U5wTPr/Y00z44ePMi3lhxPdkH6hirE45auEHx0cQiF64SJHrMTFGT4jG8+FcgU2Rm5jwIogJ3+TKozZyM3SFvBootAa1gVrfHCQ4mjNyrtAUzChqFBGKAxS2Urk/bXx9v/H6uNFM8VEIDjxg+n4Rvo1f5vpbSkWqEhq0DGijlQ1njWBCEI8LHomOuzmzViNIIIqnrJVaKuaNRZW7tfB6Ljxk42VTCPDJYUdW+NHDzKtl5TJ4kgO1nvQsrXAshR/e3eHoVbZ9cFwExxAiyQtX00gYU++sjiNDCEQXeTClesX1TIp5q6gzMpVTbZyqktWIBPaHkWGMTDEweAcIq0F20NQorXB3XPnRy4VvHuZeMYuO4DxOHPLeTuZPxS/rDK61IqZYa8zLSikLNW+IKk4Fh4Mo+NFzP28cc0ENnArlVNnWjHolm3GqjafaODbjURoxeT7cTZQGPz2uvFkzo3gkgDVDa6O2wlIL3ywLRt+vohdG7wheGLyw20V89IzBcwgek0ZpypMaFQUFar90rGbM0liasSoUEbwIIXqaGqIQDYL1rlcTR2nC1oy7tfLFw8rL44KaIr4SHEQE/46f569b/DL3wPm0YZtCbqzHhdIKraw4J/jQE3JJAqPji/sH7rYNM4crjvnNRt0q5oxVlDcl83rLzFm5aw2XPJ8edmy18cd3j3x9XNm7wBAiUQJRHN4JzZRXpxPRBUYfuYyR6yGQYsCLcbnbITExpZHbNCEIqv38bE4QBaqSDY7V2FRZtZGtSz323hOjp9K77qKCmtDUqNbfC+tWefWw8ZNvjrx+c8Q5xxAd0Tm8CWK/2Bn8TiQ9/+gf/SP+wT/4B/ztv/23+bt/9+/yT//pP+V0OvEP/+E//DNf9/f//t8H4FmYGK1X9h9ZuYiJ02lh3QrmBRccqiAKWgUfezXLDJ5OK4cUcBGEAAbDENiPA79xO3EVAilFvjje8fpUUXNYNt6Q+xVIYMCorVFy5ScPj3yymxhcl0Y013BeOSRPLo4nzTy1yqkpKRd2wXFIngvnic24bIljUHZjopohwOA9JE/bKuRe1VgdYEZtSvIBiQH1RhPBDGpr/NGP7vjgYo9VwxtU1XfxCH+t4z90/b197ds1KCqUCo/zRrON5z5xPx+Zt4aFvhlgxn5IbBjOKt4pQaFWqOcDzEVPFGNMXeLw126vuQyNlCL/6s2RN6cNM5hd404NqY3gHQdJSBZCNn72+p4PLhJRPFszNhqbKd5AC5SmHKk8LQ31AzdD4sZ5LiQQVJiKMAfjqjlqAPOOhGeuBVphqIHWjAKYgCZj7wKisJqBGVaNlca/+dEdH19PNO2HsFp7x0/01yt+WeuvNj23kBe2tnJwxtPjwrxUNArOebI6YnQsFJ6OG9EJ1mBtRvDgBkeyvn8MPjGmkd/5cM9l8Pjg+Zcvjnx5v+C8UltjwSCCRxBg2wq5VX72+olnuwStkXOl4fCuMQ4T08VGXoW2GV/VzCX9YBxkwBWPViO0wFNrXDOyuUqj74NPraJLAKtEJ0QCoyjJK0MCxbFR2VBMjTzDT370yO31REMRB9rep1z/bvwyzmBTyFvj0RbwKwcXOR6fyOsGTnDeIy4w7buk9lg3fAYpQm2NoRkkCAKCEJxjcInfPOzZe08Knh+8Xnhz7PK0zSr5nPUM9OS7NfDeOK4rgw8E73BOwFesVpwf8L5LhNamPG3K4PrlNJjDWk82XXNs4tj7gSaKbw1fGk8edrieCFmXWnrxhODZuYRiVGlUNTChVuX7Xzzy8cW+J5bOoLw/g//d+GXtgU4cTZW7eWbNjZsxcXf/xFJWFMMjNIMhpX7mboXqKhQl18YoAZ98l0a73hF1MfJXP7whEBiD57/98oGv36w4ZzzVSgMwY/C9W1SbwzblYV44BA/mEUnEpJRScZMjBUfLRqvGN1T2FeoAuUIFBgdRIQSB6vBeiE1wVfmmrtyOe0I2NjNMYHDC4B2DczwCK5VqiquwLI1/9aMXfPf6EmmK67TNX+i5vJOE/+/9vb/Hy5cv+Sf/5J/w9ddf8zf+xt/gn/2zf8ZHH330Z77uJz/5Cf/4H/9jXrSV18fMLgRudongB/wBPglwrIVsrbeYayAN8J3bDwBYa+G4rYw4bvyeL48rxRq7GPj8KtGa8kjFA6et0HKlS+uFGxchwaYNj+Oagd9MVzxslW/yEa8wIVxKgAw/aU/8tGXUIImgvvEDVf6K3xNUmKvx0hprUK5d4EEr3ztMfLSbSM7x1ZuZD4AWlKMo67lo72ukZeUuZWJxTF7xqVFX46tT4wevZ57vBp7vB3bpz30M41cu/kPX39vXvl2DOgW+Xlf2PvDRfoQRJrfnO1F4UwuzKmqgx8LVwfP58w8x79lKZjmdGPBctAMPrdBoXAbP53vPth05tZFjVeZFsWxIBMnCp+m8BlEijis/8DGVL5cTP8onRnNcSORiiLQF7vLMF+uKF8foHHNTntrC30gXhCrM2njZNu618CwlfsKJ35+u+ezigA+Or94cSSRyUBZptHO13hUgV155h3hHiuAHgwxffXXkx18d+ehm5IPLgV1638r+k/HLWn/Zww9PM/st8ny/g30kDZVPP5q4q4Wl9YrHjSYSjnF/ASLkVhjiyrUTni8TPy2PFDMuo/Abl0KbF+bhgK+FXCqmYN7ziHCD74k+Cgi3jDzNM39UX/Ovn8BnYaiBcQi0Vtn5jYd5oajSxHjQyo9x/MEHt0QnPOXCj7aVI8p3LkZaE37r8JzbywkLxk9/dgdAaJG5VqoaivA8DZALdylzIHLAKFRcc/zLH71hTIGPb3c8v0pcTu8Trn83fhlncA59vm1X4HYcYAS859ntyLEpmynQ0IeNQxSGw1W/lLmNLCvJRa7U80CmYhyC49NDIG8Z9R6a51QbqoZ4mBVuXEC1f311wq33zHfw/fUJC0oyz0hkiIG5rQzzytOaaWbgHJvzvBHlu6FL0J5K4esyM6tysfPg4dNnO67HEUT4+uUbcgPvhWWr1NbX0gc4QlDuXWNASAalKrXAD7cnvnmxcns1cnMxMKR3/zx/3eKXtgcO8MNlYV8iH1yN4Ed2u43PP77gxZo51UYV4cPaZ02maUdzsKVKTSu75risiRe20My4CML3Lj13d08MaeAUPLNWJIKXvgYvcec5p8Zx2Xi2C3x9v/HfbS9o4kgW2OPZBc+beeHyVCi1kUtl1cadM05e+b1wCWK8bpUXG9yXzEUCkvDRxZ5n+z1iwh9/+Q3zbFwnoVZhU8M7zx/c3PJinnmzbdy4QHKB3BplVv77P3rNH+2e+O7NxIdXE1F+saKH2C96NfgfKB4fH7m6uuI/+S/+gMM0cjuMfDTuMTXu2wNfvpk5ad8MUMOtBRcc18MAYhStlKpkhX2KONeHcHbB8fGhJ8e3w8SSK//65YkfPSzEBP/5d55z5zOTCUWN6BzfO+zJmzGLcdcKrRihylnrDxYLPzitmMAhBibn2PnI9ZBwIiiQzXiiy5LetI3PxsRtCiTx1OY5+MZpWTlWA++IwfH0mGmqVECDMCTPPjnYKosqBtyMkYvksVb5L/+r/zsPDw9cXl7+OT65vzjxdg3+rf/897neTXy02/HxfuKoK3Pe+Pq08GYrrLUhBvvNsGTcpAkJQmlK3hprbYx+YLePII3kjdshgcCH+x2nUvg3Lx/5yf1M8o7/5W9+wGvfONBbekOI/MZhz9OxkiXzRjPSPIMLxMGxPi40VX64zTgcVyHiAow+8WHsMynNevvwDZXkHa/yxqdp5HYYSDFQt8p1hGOGx1JxrrfKT6dMa8oTjeaE8TyP0qpScqU6eL4fuRwj1pT/8r/6f7xfg7+keLv+/uB/9te43o/cjonbcWDVStHGT+YHjkujVkNM2GvAB7gcIxU5VyMbWhtCYBg6BGAXHd+7GgC42Q0stfDPv7jj3748Mg2e/91f+pxvZGZXeqd0N3h++/qCu4eVV1p5k2ecOvYMfQ3Ghqnxg+MRrcbhLDEKMfDZYcI56e3oUrlrFZ8SVZQPh4H9EFHnOJ1WPp0C9/PGWhxOHM4bj8cFjC7B0EpAuXCO5CINR5HGs2niYkxUGv/H/8v79ffLirfr7z/73/5trnYTz8aJj3cHaoWfPb7g6zazZKM1QQyGDARjChG1PjNnrWI4vI+Mk0ecMXjHszECcOU9ixW+/+qJL+5nUnD8Z7/7MY8tsytdqppC5NOLS47Lxik0nraCUyHhcQI719ia8jqvgDD4LrCJKXKZHCJgrVFLZWmKRUfzxoULTCHiRDjNKzfTwLxslApeBCfG/TGzS3AvsNReRd1JlxMVQL1xMwwchkgz4x//n/9v79ffLzHersG/+T/9yzy73PPh4YJPLg8UyXzz4o6fPj3xZu1FD2dwaMbVYY9XI7dKbg2tRq5KcI6riz48NwXHp/ueB15f7Tnlyr/46g1//ObI5CP/m7/yOS914VIFacIuRL53u+PVcWUW7Z38Krja9azJ9TXz9TxTSiOIwCAMbuD2nAf2iopRxbHUSmvKmAKHMTE4x8PTzKeXE+uaOWbDnJBSX4dta/x4OdKakXBMzhFdYJGGiHAzDRzGhAH/p//r//PPXIO/suXheW0MqRNGdoNnXRvBh55EF6VY1zsNqqxFyTGSnODU0apSDU5NGZ2hpqxr42Ht2usPx8b9nHlxyuTWcCqYwGNTXBWic4wx4CUwJhgDsDWetLG0ylJaJ6kEZYqe1ZQNJYnjchdJPiJ0fbeqUmsfzJjEI01ZlsomxpAcxy33tqUI4xCYhshaGjYb3gyjyxBVDW/CU8nsk+ekQt4attU/3wf1FziKdN2d84GLaYdsnb5Ua6OtFT1TcEyErTRKrEQLYEJrgAhFGgWPqjLnxv2poGo8LX3a/+VxoxYjSpduPdSCq4HJe4bgEAnsJmPvJiw7lqKUqtwfc5/aF2EXAqspjzQOLnI9RbzvA+2YEBpIaewYuAxGUCHnRqnGKHBcGtkgiDAmz27wlKxkq/jWcNLfa630zXUWOIRANrgvlZrfS3reRSxL5pAS6RC5Pex5WApHnaEZWhqtGg5BnSM3ZagOH3qFPudOugmuFy9qU+6WynFpKMbz3cabdeWrh5naFG0eE3hTN9Q8k3QtfgiO68uR0RT/oCxbJ+Oc6sq1ixTLOCdsYjyg7ELgs4uJFLp1vDpPFaMuFT83vFcsNHIRVIGmnI6ZhhCTZxoCyQvzaQOBHULVhhNHdB4R44nKhGMrjdY21vp+D3wXsbTCwUaC8+xS5NQaMQbIQstKrdb3P4TcGsk5vLi+75mjOsXEaOecZy2Vh6V3lG6i8Fg2Xs8bVRXfujTjoTUwYcKTXCB4z2HqCXpowpobWRsFxTsh1wriyPRi3xQSzw4jo1bAUBymQlFh3xxFGzglt4JJH4Fb10JTwUVhSI4oMK8FnDCZoW9luM7hBAqNwboSoGajvD+D31kc18LF1IheuNoNPM5GiAlVQ2ufOzMDU091YFURE5wJW6lkFMUoEjGMeam8ftwwDx+eKq+Xla9PK6UaySkCvLQNr4Ern9gNkRAGbg6Bm2A8rhurNeamPJTClfO9sGFdr69OCOL4YD8xpfMeWBulNooYUws0ydRamRejiKM147isNKOvwbHngaeHE6LGhYvknlAAHsyQ5BgUqsB9LazbL3YG/+om/NtGzIHH4rmrka0ZUxrxbu7Vq6JA30yqNxaraPO0pqzWEDy1KasYTRu5Kjl3rZNT4WHObLURpA8Gv1gKi4CvxtXkiMHjnaAOHnPmzWNmtUZFObXGpe/DkZcpElTJ1luBwTuS8yjK1pRqSgSuhwSb0nJl00ZwRjGllo2JSEqCl67bbY5OsWhdtoRBboZXY6uVwQteGoaj/IIP+n38+0fYeSzCSSqvt5VtLeyHHZ4nXDNcM3BQHdQAszVCE1qFVRvedfLIVvsAzloq29arooN47tdMbUbyDu8cL5bCDLjacIPjUqRTCJJxNzdePuaulxfjaSvsUiIKXKZAUO1EKu36vxQ81YyqkLWvp8s0UEqhVSVXiL4PsuXSq/8+9O1grcpivcWp1qlS/RAHGixi7JyckYiw5PcH3ruINRee1szDkrmfCsvW2O8HJgmszjDpcohqRo3KghKtJ9JLUYhCw1hro7TGmhtb7vsmOvB63tiKEl2v1P70ceEoXct/HeFiSOf1J9y/WXnxZula7OR5aJlRHOqMXYiIKMUUHxy7FEiha6eLKdkZ0XtufOKhLMy50vSMVS6VpwZpGkgp4L3rP6sqk3dYU4L1REvxZO1dp3hGJddqLO8vnO8k5tPGA5FJArvgWbKy300Mp5XVjGaKaj9/W4BN9TzEf5a1O8AaWzNag60qW6mIghsDj1ulNuu6fIGXx42FPhelAXZOcL7DCh5PhYenDgzAGydtjC5iep6HM6Uh+CAMvhOjmipNoDmHeOHgI49nbbcXxQk0M2ZrJJ+QINh5X2tiZ1xj/7fQ/9/alFmU4ISiXQK5vk/431nMeePu5LkYI5e7yOlUuJj2JHdPxFFNO93QwyIVLQVap/uU2vCjQ7FeWbd+Vq1LAQfRhDdzpjZlcJ2c+MXTzKNVohp+ilx46Vhk8Xz5dOLruxNOwAXhaduYfCLGwOgCXvq68eIZg2NIfXZqVdikv1+eTxN3S+6F4AaCUmvhtAqESEgC0uVjx1xIDcRcH54XQb0wt8pigheHO8Ntlq38Qr/PX9mEv+rGqRpfb5XZK9ocf2f/AYeUzgeG0tTYHLAT5i1zKkIDNDUO1WFqaO7o+6b6rQYUR8eJ0Q9EEeEP7xaejxN3opDggOCDgsH3Xz7xRy+P7EfHs4uIqbALwugi4h2j75PXvikUiEk5aWZtjaLCbYh8OExIUb6qlaDKhTde5wWAkBKT9+St8bBtnGjc4pnNOgFAYaVjIlUdWzZGo/Ou32N63lkcbhIpOB63lVevZ7Rk/iff+y0u08iaGrhC8casDUZ4yAXLuVcfzNhZgEpvzYlQTSnWCNovd9G7nlWfh9q+f7dwuZ94oxmNnj1K8JmG8oNX9/yrnz1xvXN8ch37rId2nKaPnlEirZ7f+FmJQVhK4aSVDWOKgZvJMzfHi5qZvOdWHA/LRnXGFQPihadcOa2Vh6Z8AKxOCCZEBKIw50r2xrE1dirnpO29hvpdhKrytK786K7xapmJIvynz7/H1W6PSmHeKuu6sZkSdr37szSjFaW0xnWMNBrrplS1fkFzlaCudxRDQM4oQoB//uVrnu333OWV49iYYq+ol6b8Nz/8hn/900d+4/bA73xyQM/Du9PY3yOH0KugwXeuuveerVbmWshNeZ5GPr+5ZH5TeXVa2PvAsziw5YL5wDQEYoysW+HVw4lXufDdaeChlE6eksAJx6KVE8aQGgFhkF5Vex+//JjvM2V9YF5WXi8nRIT/+Hd/i4uH+YzGNpasLDT8znM6Niw3tIHgGEVobUPVowLFjEojAd4nphA7BUU7kvpHr5642l3whsY6VIaxd4QU4Y9ePvDjlyee7wIfXqVeMTUjhYFRjFE6JjQEkHVDhsTalE0VdY7L0XE1DByPlddzYTC4CI6ileZin0PyniVXTsvGSRsfEHgCnHi8QMFYSuXJN8zBVXUMCPqrpYr+CxW5brw+Vra68WY5IQL/89/+fa7GO3JRhMzSCltSNlt4mlfaokjr+9uzi8iSG9tSqA4KiqazkiM49jEQPei5G/TPv3nDwUW+CsYmheFQ+W3fwBr/9Q++5vs/e+J7H4z81sc7SjYYFGfC3kfEDFOluS61RkPHxNfKUQs7dTy7HnhVZ0rubDFvRqkF8YmtGU6N05yZ18qbsvIJgUeBrSkhOFJQHkrjtDZqDNw0ZUDw9de8wt/zWKVJZfMbiuOJlYudp2hAxDjWykZGmhBCRJyjoKyuV8LzplynSERQdSQNOOBpqWQ1qvZqq3jXK5YZ5lC4v89sVfm9ZxeYGX/p4z0lF1YxXPRcD4752AgSOaaC87B3nkMbaE15yDNvaiWlyPV+QAvU6riKe750mWPdMFWqA83GQgWrmBqlGi1BDcJjzkhNxPPQ0NQcL4PHGxydYzkPKb2PdxS59i5acHAQ2tFznx+5nDzVIi4bR2vkk6LZGFPvxrQKJQs1QpsV7/qhEU0Q13F2b0qhqNHoyZYzx5SEbWkoys/WBZrxdz7qery/+ekFNVdmbVTXEbFPSyG4gcdWGFPkOiSuLCICS868XGbiEPlgP6Frl5Z9MO746SlzXCuo4JOjbZUHlNhyr9BZI7dM9oFTq0iD0BzRe3yDxwbRQ3F9aLS8J0W9mxBQp6yWKaXhfO8iTTFyWmpP9BNUjNYcZkprDa2AOhYquRT2wfcqKo6oATy8XmdW69V8mgGeOMDT40YY4e5U+MptDL85kJzxd773jG0xYnIUD9dxZD4ql9FzXDeiF/ZDlzPmVmlL46fHheAdN9NEaz0p+nQ/8rhlSlOq1c7cTgCVvFXKWsm1ol5xTdmcsWEEawwNlqacMNKp4gbH5iHzfv29izBV6gYn7bJTl4S8GochkWuhNiUnZcXQpXHhJ3TsktuaK0UaNTdGA0LHB+5aIIlwLAVz50Kc9a62N+Pp6UTYBU6b8rgUhtRlDP+jj/dYblQvtBi4HBL3y8pN3agCQRyj96TNMY/Ktq283FYG73k2jFA8tTqexz2PZDatpF7PI5N5nR2JgjWlmVKD0VQwYKZh2pDaMcerN/wGYS/U5Njceyzsu4p6bOjQzR3X2nGuj5bZDZH95ikKWSBXRVcQ691KgOJgboWlNg4p4J0n4QitG9N+Uxc2a1jrBDBznp151lq4uB3OSHdlCB7znv/x9z7oxbTkEBf44DLy6riwb+A9XITA3gfWBrkJy5L5epkZguf5uEMybBt8Z9zxo/JEqw01h8fx5OCJzHXtZMdSKrPaeX8rPLiGqDDNjoenil55lk2ZkgfvqL/gGvzVTfgBPfN4tTW8h1fzhhfpLURfEVWSJmqr1AamhSbdCMN5IeEwVdba0KZci+ODXeJLVYw+oMj5F3V6WmlUwsWZNX3Oo0WEjy8O+E+Un60r960PgfwxCzdUaoFUAiE4PrtM7IZEGmA8buRq+AIH59G28thqF0M7IWOoGjc+sIU+iOut55fJOWaMcTcwmici3X1wEK7ngM9KyY3NN7b3cop3FloLOfTdw6sRLyJfPq2MCBlls564RAdbMRqCtN7SdgLO99e2qmy1s6svouPzi4mfaiO3ijtTURBhmRs1F6ZrzyEKh2Co9pv784sDf/2Tyo9OG69qvya8JLNoRb2w1YbTxufjjtvLwMVwgIfA2iq+KgfvUFUeayH5voE+bpUQPM9bIifDnbsNzjw7CczAznsm9XhxmHP4nePZtpBao1kfMELfH3jvIswbeJBvK9iOL+4e2IlgUih07XvAs2Yjur5/NG/ort/KUula96qNoHAljo/2A384nyhw9nm2Lm14qFx5cJMwRccuvd0E4bc+vsGp8bMtM4vj1gV+FI8ca0UNJjy3OD6RHbeXjos0kJtSq7JXOAyO1rrN+DREytbYikEU9k+V++3IEjwoVKdMg+exwjB4nmsAhROKMFDbxo3vLfRqyqm+r7C+izBVzDlKrbRTJayRLx5f4nEUUapriIOQjXpUtrEbE+IMlxTnHQFPq42SFYdw4YVPrke+XGtnlHvfufdNORbjysEoSnSeURyt9b3l+c2Ov5qVF9vGSYzJOb5ByXTJbMSj4rkIyuXuwG6A4b77OAQFnwAyuWVi8kgFMWUwx7pUFrfSfB8urqKMMdCqcT04WlZKERYLtFS4QrhIHrRQ1kJd3l8431WodoqdqXVsdHH88OtvmKQbaGWpaDRccZSqjFPAku/kJ4SqELWDNGpRQjNuvePzqx3/dl5ZTcE5nOv4zMetcElEnNFqpm0R6APgv/XZASeNn50yJ+tr9UcUcoIRR1UjYzzfJ24vB3a7xO5NopbKoDAOHihkztLtquAdlynw+FBpsXJKgYYx09HceLhKkes8sGbloVY0CUmNKxcwM061cPp1l/QAvWJVu3W6D8ajyxyKEAgkF1lY2Vo3mNGgON8PvKiwi57sKq217rqrwuSF4JXRwfUQaAhLE+a148WCU3becz0FLofAOjcudx4kcrWbeKmNsqyUpkwORjohwp0HdJs2QlC24qjVaK1TXLJ4vK8sy8YUunGWqsM3R+Z8mLdueNOc0slgDkdnGEek82gbHDxIFMwZWfS9pOedRr9Vu7ec5lZZ0P6xD+zjiJnyWk9sS6GpJ3rBiRDMsVNPcZVWOz93QLjAEaWRonCTUjdWq8bDWgBjSELwcBgCh5h4WBr7fUKAaTcQc6OuhSrKrfMM3pFF8LjOj/ZCw3O/LuRSqdqgKWqB/ejIKBchkgi0qsTWKJM/J/oOcN3RMjjWls/VXyWKwzmHNuVKAiEK6h0FY27bn+dD+gsbLrhz8eJsDgK8elr5eD8QQySFbs++WmPNBT07hjqB4ISJLgV0RXCtywMnDxfBuAiOD9VRonEMjaeiqCok48JHLqLnKji+eTzy4c2eQOCDyz0v7xvfLAuj81x5YY9wdJ1f7nCE1NiFyGatM7IVcmmszTFNK69Omck8U/SoaTekAYbSCx7FGzXS16cqY/OYdt72hQu45NjnPveiAg5j4Bc77N7Hv290PX33rxKaVb55PPJ8tyOII+JZSmFrhbVVtBmxebwJ3gk7YHZGq4JXSGJM3kgozlVuXUCd5+QcedmA2hHAErlwnj3Gadm4ngakRS4OiVdaOC0bLhrXMWGqZFqXkVUIkycAp7WxVKFZN+BKBUKEY67s1Kje0UxoW0GAUe2c7IOKMBShWoMVaulKgJ3zXPuBnCvWXCeyOFD3vuj2zuLsHGvNqNp/71+8uefzy0s8jkESW62cysqaCyEIQbtTs4+OCccazntbMaI4DsFzFWEcjE9kYAXuW+N+7fvIkIRd61LtUAvfPMx8dLMjEPngYsebptwtK5jw8TARPTwUpakyeCUkxy54tu2sJDGBalA2pmng4ZiJFgiu0ySXqrQg7IikBpvrmFjfFeLEKrTWCUA3aeCzuOe0rSQ84oTm+gzXLxK/sgl/R186nAnOrCO2hsYWewK8U8+p9JZga+CcnpOWriEF48ZHilRq6ASd6xggGq00nlCuxsQHKZFUuF+U3Bo1dmJPE0NFaXiSGEMKXTJUe4X+N6921CKo9SQq03hVNp6OFVuNVZWiRhDP7eS42kVSCBzryqKFVeFp9T25NzAvJB8YHawCsXho3ZBJvYEoOSsPNaMmOOsHXn5vevTOwjlBMN4Kb4ITSp45IQzOMYrjsWxoUwzDWkMRkF439bUnT9krljrl4XKMlEGgKUeUm13g4zQQ1PH62HCtcPLtfJCA4WjmGAMMKaIeFqsMJvzGxZ5ZoZSuk1608MWxEbeF0UXmquRa8QgfT4mrfcKb5zRvrLmweOFhEbbz4Pd1cuySA++4t0ZosIsJqZ0W1aRR1HjKlWJGjA5xnVbxPn75kabAsO+Q71Z6lethm6mWuYh9kPK0ZCq9LV20k728CJzdQ2+8Q4auUR3E8dwlNFSyNKpXnu8in48jIoEfvHriwgVSEqYhsJsi0TtEe4dxHBLiOxEIF/mdqx3zpviWacDSKq/mhblmWu2HdM7K0SAcdnywH/k4Rk7zxpILc1Xe5Mx4bhDtXWAfzhbzFZYIVxIpNYMZQYRtU46tsmTrTpP+bF7yPn7pcQaOIUg/fxHe3M2sx8LNLjHg8Fvv9Al8K4fpp3egiXGdIgyCICRnXERovuOCn6TwfBr5NI2gO748ZqbaENcvuiF5vO8dAw/EmDCWLt/wwueHice5sGgnn62mvFg37mvrzqNniMEqyuUwcjNGXAjkdWFr3XH3XgtyTioPLnDwndW/tj5sfEF3c+7EoQ402Ioy18qgHaOd32v431k46V1nzsCI1owXbx5ZT5nnh8RF8Gyl8tD6GWXnfVKdIL4P7D6PgebBRpic42qMbEOXxJirfLSb+O54AISf3K3sKoiHi9DlYGMM/RMOxnHEh+47UgS+d33BaS2orRTtwJhv5pmnWhERrEiHx0BHaO5GxHueTrCVwmaNoypLa2BwLYGLGNmFgcdcOVL5iIHqFCf977huhSLGyQq+9mHjUn/NE35RQLseSzDECZKUihCLEHq3AzlXf+SMZxIRkjh2OPbesznDRHBOyAk2jFaMWeHWOz7cJ56ngfsZ7reNF63QxChmmGhHYtK13FEcOx+YfORicDxslcH3m/6C8nIrsBVkredNDZLzXO0iY9pxSMKUK8WURZVSjVq6BncaYteZIdRakAY7IpsqDUOtUc+t+Ux/yNCHlN/Huwnve0JrZzMq74RMZgOiDR272gpopzMJZwqUwOQ9FzGwbx0ZZ9KxN8sA2RvaYFHlw+j45GrigzTyzZhZt5WfLHMvCPQFjZjgTRGBGITd4NmpZ4ie42IMOJwYx9r4aunV9n0a+oWw9er8RxfdzyFK5CBKG5W5Cot2BG5DScFzSAF1wr0aVuB6GMmudl127Vb1pSlzU0axXul/n3C9kwjJE8fentbWq4yrFta1MLodA3KmNHS5hIhg1tFygzh2XrgSR0t9D/TiyM5YrVFMKR4+n0Z+42rH1TiRnMdX40QmxDOmMPx8Rsh5RwqeXYzs48DFkDiuhYN3VDO21nizVN4sUItykSK5dkLL7aVjGBIfjEKiMAUhZXhxKmyhJ1Vp8FwOCeeEly1DMC5iYlaj1Uaga/iLNo7VUDHE+X7Jfh+/9BAnHSpwPoNBWE6ZRTKjF3bB4Vo3aPOuz4mgrXddvGfnhQsXsUBP2pxRgvaE3TroIgXh08PAzTByMRR0WbkvrRd2HXjnejHFGmaGd44hdGxx8GAmjN7TzrNEd1khV6Q19jHAuWt52MGYAmGIZN9Z6EuBuwWaM8QgRc9lSuCEtc1UZ0zeU6ET9axz3RVhU8UU9O0+/T7eWfR97ewmq3A6bcynzD5ecTklnPZzKYjrFz0Mh2NygQsfuAG22Ato3glL6qS5ivEoje8Ont++OXA9DlyPK+1YeFNXdsGzj4kx9QVs9ItECJ7pTOZJ0XP/VNk5RxXIDV4tGywbXhx7FxEVvHdch8CQIjF6BimU1ljUODZ4LEZywpQSV9MIXpjLicWMKSbK2Qm9tcpTK2iQbnzXDG/Qft2Hdls1JBsuKhUlGh3zJUamUVU73ss6ctBUETXGKDzbRT7wkeO8dU41jtkaL8oKwCWJpDCYMIhjiiPpAIcUWY4nFmuI+F55R5jbyrYZOy98sh8ZzfNynblfGx/tEocQ8Gr8bO3JVmmF2jib3QSKgWqvElwdPIMPlNKZ1ifgicLNOHCZElmV19vGTOV2GvFV2Wo5o8TgmU8czSHBUAGr8c/rEf2Fj4CAE4yGt95mc2c99ZIrtWhn8HohOI+o4hyMIfDROPHxbuDhYSO2fjg8ofxsW4khcEXo608dg3h2Y+IzgTkL35SV1vomVs2gGWsrzFvmwjt+83JPqp6vTjNvnoyPd47JB0yFl7m3Jee29Z9NjDFFcjA2bSQ8N2NiiLBa4ak67l1goXKxH9nHRNZGKJ5VKochUKLnNMOybkzBceUcowVc8DgP7v2t892E9M4RZ42z/onh6NoMh2EepIGPnhg9mGMS4aM08cHoWJ4yW6k0MxapvHaFyHleyOhrL0Zu9om/qjcsbeNnjzC3Smm94FERRLt86CIEvrPfceMGvp5Xvnza+O7Bc+UcK8arc7fn0SpFewfWidBi3w/NjJudJxwCS4Hj0XOnijjPfpe4HCe0CTJXosLllEjOsW2FVitDgKvcjcZiFFxwzPZeQ/0uwotA6MkWlZ8nXXSmvogH3y+a3nviOTEaxfFRmLh1xrIZp1Y7GlGUN1aYci/WefMkdSRzXMbI7x4ixyGgD0fmVmm19sFGCWxaWLbCFOCTi5GDOX52OvH6pHx44dkFR6metfX1d6wbhZ4bDMHjpFP6sMDlLjB6JVfj8Zh4NEWqcUiR3TRQzZCj4LwwDJEQPKE0am1d9hMDVul/dydUey/peWfxJxt4Qv+g9eR7XRUvla30jnhwDlACnkNMfLLb8cEYOT3OLNql0iep3LeVi5jY4agiDOIZpZ+Lv3+bWKaNH9w1svVLgVonlUlrPK0byTs+vdxzYY4vHmd+9rDxnQvPpY+sdE09wH2tLAGm4DlINzMs5/3x6uCIPrJVz9Oi1M1zMTg+uDiwHwY2bXh77D47u0Brxrb1bvplctTmMBMKHRVffsE7569swq/qOsu3QsxQs9EVTV2j3JzDp0BbVxjBbY69C3wwjXzncMA75b5u1NrRlSdrLK1LMy6B5B1JhZANQkaCZz94ZFZ2TriMnnUz7rcHQlPuTxUXhDE6ttzlNV+dMtdj5Nonkvfclz72/yYXvIGKsTXjvjZ8bWSBxxaYF+U4V/ajpwVY6FU61IjAhXiuh0iCPiHelIcCjcplmpgWI5rDC0zvCRXvLqy32ZzrmmHnO3rVjI46zJDwVDraMnnY+chHY+K39hMJuJuUtSlrg9M5MSnW8BK6XtUMnyt5y7SqBOcpApPzXBE4nha+mhcuEV7cH3HeM42JBtTmeHk6cTuM3A6RwXm+CRtmxiJCVKM6o2mfHxmuEktbmWvgdCecZmO/nwhD4RWgTahiOCdcSuTji6FrdZOjVniYGzgjDRGyEcxw6gg2/Hk+pb+w0dS6XOz8FlfoJUWMUzOa9/joyb7gknIxJlIVnvnI71xcMVTlx1umnh0nl6asNLz1tnHXv3swjzTHkFaCBlZRXOjdzMey8eqYSQ1en2Z88lyngcet8vXdyh++PnKIl3xvN3KT4Jj7D/s6K7lUstFlQFshbxurwCB71iXztJx4fntNeqrcbwVrDtWuGw+qPEsjMRjJR+5VuVtmEM8wBMgw4Ppb9P3Q7jsJcYI4h1nXt5v+vNs5r73rLQOYb7So+DSQqueZBL63n6A1TrZQWq++Z2td9th69z14z2geqmPbOi0nRVil4Z0xAcd15qtHZQe8Pq2kFNiPkSer5AwvTivXceJ2NzBFx0M9ffvzqyqrdcrTvDTawdGkogy8OQmn1bi+Hkhz4ZEVNUO1IGIE73k2DMQQGAI8WeZh2c7eR4rLfSBZrA83v493FwZdy+96hd+sD+Q+bisdzmtkLch1Vz5cWOCzYcdfvrjFKKxWCLnQinY5tAMplRufWEVJ2uEw2wZQmCbH/Nj3XcN4c1q5207sUF48rezGwGEfuauVN6eNP3544mo68Gwc2EfH13kGwDVDrPVuQoTbWmlbpiIQJ14cN+7mlcvDFcFtPC6dfNW0Qrci5DvjgeRHfBDMNp5yY5c8j4uiayUOHuc97RdEE//KJvxvQ5uR10aa+sT0tIvEg+9M86oMVwYNvCi6GWUtaCicWmWIHdPpTJgkcOsMlx3P95HvpQsukyd5Yal827r+y7s9qt1Q5HHLhKDsppFT2/hyzRxL5ub8tb/78cRDLTxtp86ddoVj7oz/rRiXY+DDi4HnYQIKCfjJqxNqws0Y2Ytys3N8EhKvjjM/Ph1Z6XNS8ykzZZhSZEqRTy/2GPBFnmGCRR2+CtHeE1LeVYg02gbLqfF6Veqm5LN7smQhSmDcB9KNoB6kGOXUWI+F7DYeWpegaXVEp+ydoHh8Fj692vOd/Z6L2AeMllmZgsMDf+vygqa9urq0yhA8uykRt4GvTgtP68xuEFyD3/3owF3OHNfM4DwhBr5aVj5Ika0aexf5eBp5nmIf2gS+OM5UE672I7dA9cqtD3y1zfxwa2QFI6C1kahEHGOKfPBswDf48XaE7iPXK3T+PRr2XUSeG9rK2Z69zx45p4gXFrdg4nuV+9zkO9Uj5STceGGaGsfl1J26VdGzk/KF88gqfPp85DvTjushMXlhzgXvIt7BX392i9GrWvf3hd0usrsZebGt/OTpiVkazw8jH0+Bz3/7OS+2jR+UhSSep7nxIi98ekbBfjhGnl9OXA6Og1cGHD+9u6e0xj44rrLxSXLM1xNfPa384OHUZ5/M+OruiYfHgSkFxhT56OaKCHxxeiClbvSk2mVG7+OXHxbh7a9WgxCaoV4wNapvVPGkEGG/IM1xKjNlgT0jLVQsG7kVamtnQRBEgAYfXu34LE0ckiN45Zi7NwjAX95doNrnAea54AbHbjdyp8qXp5llPnIxJnY+8Lc+v+HlcuKHy5GAZy6FY6t87EbmrbJLwge7wO0AO3++jB5PNISrcWDaZm5RtuuBF08bPz3NVN87X3d3K3MKpBQYQ+DT6wtMHV+tDx2hrF0JMA7pz+Px/P9J9PmPXnnrlf23Oua59CLsYReQ6z5HQoFtzRRdmS4Kc64sW+WpZezcsT9z8fj4cuK70667mUtgXgph6Gfwf3R5g2oHsRyfZi6nkZvbA0tufL0s/CjPXAyB3zrs+WS/Z5XMvTasKHOGVyHzH11d47TPTl34wFWAiwEyji/uHqlqXA+B53mjosy3Ez87rXx594QBOxf5+v7Ij968IRdh9AMf7CZu9onKI7spccxKUWEXfrFU/lc24XfSqwu4rn/WJmgTWvOICE26vakXAQ9ajU2Nu7LhmjFKRPeC0ocvozh2EjjsAp8ME/vgCM51fRgAQgRaTJ1IoEorhdcPC2/KiZMaT9o4FWXeGkH6QOZcDJVCCpVBYPSGmZBDIyXHh+OO63FPa5n7deG0KqspizQ+GzyTKlv1LJtwyo2TVapzeO/IY7/Uoo3NlIct80Y72i6pZ2fh2xbr+/jlx92rTs6ptdOiynkITKpQm2GuQRXMC+YV2xzZhLvS+MHdyihCGbpDrZOuH9wjXI59UHdwHfclYhiFgicCwxkxp/SO0YuHwlfrwqrKkcZcO4owBvgoNZoquSnZV5I3xlGoBsfQuEiBmxSYIqwZHpfCaVVmUx5bRn1ktMasgTXDWmFRo7rCzoM1R0Gw1thy4y4XXi0rBlzFkSkIyPuW9rsId5aQCZ02AiDdKQGtSvZC8w6SoTTy0Wjq+Cav/MuvXnOBp0wwV6M1xQVhFyK7g/Cd3SW3wTNI/xOBb4cX5Tyo6aQfji8fFr4uJ+7qxlErS1aOeWGH58NkXUZhYB6G0TGYxwSeXGMfAjeD52aKrDryeFrYlsaxVU5RmMaElY15DTyWwoM2shplUwY6VSV7qCbUqrxYT3w9d8PCgx+5CoEk7/fAdxG9str/YdYlpF4NdYp6o4gieqaoeKXU3pV6lRfcalyGhE2w1XPC74SBwG5nfBwSU/AEcfgGSCN7JfXv1mVgBmrG/d3GXdl4zJW1Ka0ad3XlyTuuZU+pXUqZgmfvB7RBpbEFZRc8uxCYJoeq43HZOOZKUWN1wrU4IsZSjKM2jlqpCrM0ptGTrRfgsG5m92bN3M8rYBz8xC4ErL3XNL67sD+l6BHk249VjVKVrAax3wNcVtYqfLnM/DfzC65SZAtKXhVEcMmxS4lrJ3x32nER41kKZGirQAL6vJCKYCI0NX748omXbKyxsRbltJbuMD95klNQ4dSUQuNi58k14KSxeutu0aPj5pBYm+fusXCaG6saa4EwOiKFZa2sm7LVTpbaqAwusKywVWPZNua18IqAaT9zvXqS+HOi+GfHr2zCjxjOW2+/IEgzrHQXSaeKVkWtozjNrJNEmnRdnmYsCiKeYopZH24tBtnBZYyE871RRLqDWeoMaK/ajRsELMObUpClUXGIwmhCVeMqBrwJg++LwiOUVqkYwxCR/BYn1djqRrVGbg4zx7FkXrZKq5HbkOBs/by1jlE0b2Rz7CVgamTXB6MaxoUTTgpJBGfKseU/v2f0Fzy2rYB1x+a3lQW1n8sKrcure8LUwKnhVNBqnGpFhoBhbOeExNTITXFJ2MduAudMCHTk5Zg87TyL4hRMBS3KYymctKB07fWFDzQ1RhFsa6Da9dxNONKpTtE8vlYwo6pxWpRaNgyHWeNUK8dSWUPleXQ4a+SmaOtj6k2h+j78bk1QA+07Llc+8VhKN7Qz41jeYznfRbjgCcGfkb+9COKcA7qdOvq20y2oo9N0qlFK465kJPRuqLj+/Kop1mDwjgsf8XSXced8N6UJvuvs6aSLPq8ivNoquWXmVonmuBHPUZWbyz2qhZ3rnHyacZKG+v5adf3Tqp0sEWRAFZrASRvL1piicNk8q/VCSfAO88ZcGt7BTvofUHIFJ5RN2avjqbWOijU4tvdYzncRot1TBPc22bI+oG99OBw6EcqJ68WJ2tdXqcpj2/ACgwsgQkVpZrRqJOc5+F5nNe3D4MF7YhJEDdOKaicEWe0O5m0xcmsEutRs1UYKjlwqCemzembdSCn0j13tgypNjdPScGaU5tAGc8m8scYxBp7h2Upfp148OGFpGVFhxKO1kbVTUjRXDjiOWnG+J59Le1/weJfxlpX3J+NPnr9dctbzOdSwBmtuvNo2nBnOe5wIhe4qLgUseKYQ+nyUGcH1wdoxOZoaThuioF3Fystl4/jY9yDRLnktprRWeSyFyaV+STCjnCEx1C7rxnXwxtPcKAmqGqq9Q3FXM5t5PjLPQqMZBOdxznHKG96MMXg2U56yciwVmYRLJ6ymDP4M7DjPp/5Z8aub8Ptzwu8dch54sGLUXKEYepbTTa5buIsZYvJtgtNE+6AQfarezkxTp0YQdx7IhU4YEMbkmYvRTDv/XxuzNh6s4osi1lsze4RNHNHom8BZUWNqzLWhDlLopBZrypoLzfoDTnicF7R1l+CXpVeuksFJy7eOkTvnWEUI585Eo1srN4Nk4M8616LKrO83m3cXfUhN7bzdtLc0dPv2shi950qMJ+0ZWJBOTGlqmIMqxip9dkQblKI4pxjSjW3EI94RvGNKkcdcqDRUlILyWCr3lslnQs7eeXZnKoUzeCqF9rYihnHCzkmb4rXrbtfauxRmmctxB47+tbUhojgfmQyy9gPdibGT/jMFBIen2s8ruaPzLNKpGWurPJX3Cde7CB8cLnQggWtgruMx4WzE54RRPHtxPGnXr3r6EG/D0HQeOvPdVKaaUWtj0J6wVQyHx+Nw4ogpstWGnmEFjT68+1ALay1UU55J5MIHlMqUAk+njeQDYKylcKTSpNNVkghmsBRFNePpF0NzQgGW1vdXx9AHIhGG4LqRXW443wlU3jlaU45F0dZNvhYVnEKulYfyvujxTkJ7AtOzqj7k/XaIXKS7iw7Bc8D3fUf6ILlwfp30M0udkc066aYpu+LO+uiO1zR60j+lwFJq3yvFaGIsqsxWKbkndtFL97GpndizlcYo/fKQm3HSgkvn9Xwu6q3aaLOB5X4ua788HLXQvJDE086zWcF7vHNkLagqwfciS63KYg1tfe5lPpPXiimn91jidxgCJm8bTbzN2uxPXAGic+c12DABzLCm/RJKT9h96GSlooptxlZ74VYNohjedyrfkBynVb898xVjaY1Ta6xzN8O6lMjeBQpKqYWnXMF7Ri94OuFRXVcDmJ0vncV4UzOH5kjnDmgVY7EGWdn7QLG+9uPZOHbOG2p6fo85jnPmfilcLIEwhk7vC4KinOovtgf+6ib87nwzOg8OVYO+rzfy3JDsmHzkMsI3ZWGWij8b50Zx+Og4aeUJJdBNhZoKzStbNkZniHgq3eAgiLDRWFVoRVlK5uuycXJKUJCmJAfRC0XgZc0UheDDt5eMuRlDc8xa8GoIypprZ6Rvxn5ycJ783wfDvHIvBa+9glDFEUPgekhY8IjAwQbW0nhYjxy1QWtAIFMx0/dIsHcYIQiqhtXzr916QmXnauQQAlf7Pc9S4Yd5ZvEZFwzve4U+RMcs3VnPmiHa7YlCdTyWwoXzeFFWBbXGXlJHXmaltsrcKl+smTvNIOBbd49OYmxmLKXyhsIF3a6+OaM5JVbhqW1YE8wcmZ7MP54yzTwyut5ed45ddGxAc7C6PiqUnOfWJyQKkmC0xFMuvJxnsvZuk5o7J/r2fg2+o/AiXe7lDBc6gtD5M6rVCykEbtOO20H54RFaqDjf/SIijpgCD7mQRSlOeyHk3Kp5yhu75BELeIWGos6xamGuFUVYW+XFNrO0zJFGUqE62HyXd7ycjyylcpl6z2umsbWGdz0BO3hPxLEUpRXB1QU/+O4XIB2nCMJR+pxBcYYEGLxwGwY0KCOdjX5XMi/W5VtFLy5w0gKmbPV90eNdhEqXFH4r2+Gc9DtDHMQYuZwmbl3lp7qx+gIeohMm7xmc41grlUoz7WsPcNV4LJUp9mKHw/CtogTm1piz0mgs2nhZCpujO5WLIzsh0Pe5nI2s4ILgTaiqFK2kFrHQE3kPZFNKMYwj0Qv5jNMMCJMIS1XUKtUZOCN45UIjIn0tTm7gMWfu1hlBKOowAkW70/P7/e9/gDh3NPvd83wDNSF6x/Vu5KPk+eM6szhFRImuQ1x2yXM0zoWSzvHHuvzsccnsfcSJUL3hzDCEdW2c5j6UPqvyxVrIprTVmDxsvnUkbBCOTdkEWs1M6ggeKop5yDS0Nqw5cm2dqFOVQwpk65fcvQQmpTsGnzu53hvRw8F5Ij0PvPWOh1B4Wgv3R8f14FDXjS/V+sX6F4lf2YTfmydoN30xM2oRttYo2bM+Fq7jwO98fsNvXIz8q5ev+OHTG9aqjCFwux94JYU7GlfNM+KBnth8rJGHPHO4OuDFUcR48IXTE9ykxKkpX8xdp0zLXPQhACbfD8NXpZKBT+LEpGfUHDAY7N/y2qETW/CgHvOBr/MTjyi3EunN9EhuyscXAwN6vn0aThz70BGd12PiuGV+UlYeSsYTiQSKrzjpnQ/ce0LAuwo/GK51EohWMDHM+FZe8exyx9/5nc/4NBlXP/qS7z89kjdl5yO31yN3Xjl646IFBumGLtkb15o45oXrwwXOOTZtvFo3XtSND9KO1SlfnlbuTiuuGFdE1BcGHJtWflYzm2/8pfGa58BjLR2laY5nJeG9I8a+BkeXiDbiY+D7eeaPuePmyTGe+/QPm+f5deJiGAlOKa0SMXYysveR3U5Z18rDUlmLsPcjKQUe84l6plN4/35w/F1EyZXWur60l6kgTRHv+354Mez5Kx9/xKep8S+Wr/jD+0fqplzFyPPLkTdt45jgI52oVZmlkgfjN9sF66pcHybEw2yFp9X46Wnl+eWOUzO+OS282Ta21hAJfNgCO4PVGl9qowHf2RLOw1NuVOt79ifq8LvA2P3BuXKRmzCyOMf/6/Urvmblu8Oeg3q0wDenzM2kjEPE0TXghuPzmx0XKbIbB56OT7x5WMnAJbGztMmY9I7A6H9lj7Ff63hL5DHr0q9zsRUfHSlEPjhc8Dc//5zruvEvvvqSPz490lbl0nueXwy8oLBiXLXAVPscmgThIxk45sJhGhDnWE15LBtffTPzfDdwco2XpxN388xSFTxck5iqY7XCa21kg4/LQJqUtW1dhoFwqRHfArsQCM4R1BFLwHnhjx8eecXGp25itICKY9aGb4VhiDgPzQyrxsfDREqRm73n+LjxMGdKaUxxxHlITamqhCBcvF9+7yx6J/1c13+b1LreXRcn3F4e+I9/7zf5zSnxX3//B/x3p9fk3HieBn7z5sArLeDglsTQlKM1WlA+TgPltDJ9GCDAYsppqzy+qgweXtXCfS682Ta+fJqprvKsJJI2TtG4TwXbhI9TZFNQJ5zo42yhCJfe4cVxcIFLH9gTKC7yzx++JDt4rgODul4sTo7mhN004odGaYV2NJ7vJm53B3Y7eHpamVvmTekypHmBiwNsS8YDz90vRsr7lV2q4gze+ma0cwMnAXTd/n4cebY/8PLxHjcXrlxg2CnNwZNmEsInDJTzSHekt4K36nixVmLcuJmMyyFxNRxovrf1PAXcirnC0Bw4h/cezhV4FceVKlEhZOPooJ7N4Lzrla63Q3D+jFBMw8DV9sR3h0sOLuG8YxXlLq/cZWVCz+pIY3Tw3DuWnFnOhjbQvQsnutvYIQ0MTXAGJ3vfzn5X8f9rINopTEPi2eHAh7sDX7z5ktIytymxRaWJcBLleho4tMBTrej5QDqYJ2vlZ8dKFMftGLlMkY92F0Dnlu+aEHlreuMRp+yJ+M2oYsQgHKqnbYoP3el5wwjA5Ps8QFHFgidFTwyBiyHx+TRxmPYMEhAHRZTHVnlaKrVtmPQ2RnSOmwGettKHx7PQ9OdJfdPKM0Yk9ArDQ32v4X8XYWpn75G3UjLObeouxLkMA8+Gia9ef4nlwnMb2FLDOdhyZYdjILCVt63rQNiEp5LZWmRMhdt94DB6dkOi9m9F8cI+Cqv2fSdhDAhkUO9JUdg1j1chaeBrnTlZZcARLZHuFZu6g2nBk93AYQg8mwY+8xMXPhHEUZryal75ZqlcZaV4Rc5I5IupkXNkGHIvqEji5lzcyFQuXUJpzE152N4XPd5FSOnVfPzPB7p9dKTJsfOR6zRwPXhevnlD2gqfyMgp9Rm0E8YOz4CjtA1T8OZwTXjJxrIKY9y4njz70fPhMNFqQMjsmnLAU8N45ucXdjhUO+J1Hx03GlDouNhSWawjra89kCuzd6TaZ+xC8gwhcOMSn+wmRukGl82UY155zJWUK2EI3VDVCTvvaBlygILivXCQCE1RCs47qhpPmzLn95KedxpvzXbt7YcCDvaHkQ+fXfHp9Q1fffEFrlY+czvWqZG8sKlxYGCmoGcZYzIY1bNp5aelYg+R24NyPUWuhkgGtg2urU+tZO8YR0cpjkP0bFXZpO83FybcLyu1nbvjIiSEGwK5NfyUaBgbwuAiQ4p8yMRhSuzE9zWoykPJ3C2NtSyEfZca+QKXB8c8K97B1owUAh9NIwVHoHE6FRanrGKUX3fjLQvyp7jTAK54rDguYuKjyz0fXAz82zeFtVRupkBWOKryQCGrka2bgLx1pDXrer7ojR+cMs+Bz4JjbyM1Kzlnam1MCM9CIJ5P2SlNPLUCFhi0sq4bd23rNSztGCcVYXEO1QZa2EviJnmup4iIcpDEjRNScCgOp50vPa8bTxRm7e6CMUa0KVttlNPCqTbWUjl4zw7B+0SV1vWPZj9/F7yPX3q0JueLZ5caCNByl70cDhPPbw5c7SI/+NnGcS3cDgMVOGrjURuvtw21PmgWgkMMWjZmVxnN89PTwqNWPnLKoP251yqUat3ifRzOA8Nw7YWjN6I0Bqmc1sLXLJAhhEByHgMeLCNVaFW5jQOH0fNslxARdqPnMnSyVbN+AA8+smpmXSub6wSO4LtePzeoJ+0JYq3cuEik4S3hfCdvNATv3zudvov4k2/tP/UuV7gcBj663HFzGPjxjxeWVni+G6gNZms8+S5zWUovQFQMacJehdduY2zG6aHwoQ58R/Z8ZxioxYBKy4bHcwiJnXlcNHY4TtLYBaEEYWmVB1eoKvgm7LS3nh+c4mmciuc6Ra6SsJ86peqZd9zuR4SAKVSnyG7kuimbFQp92DeEgGqg1o37k2NeK7kZowR23ijNA8rmAiOGhfd74LsIdX2ep7+7e0LhfJdUXe1GPrw8cDkO/CAXTlRu9yOH5pi1soqxNuWkhdGMRpfoHqLnsSinWvn+4yM3LfGpdNrNphutVWo2gsHBO0aJiPMc/NBnQUIfCs+b8UYaD6VhzUjWaWeLb1Qgrws3ceB6HLmZRqBySJGLdN6Ha59FOKRAMk+mdRM737u3rSlLbdTF8bgV1qKMIgwYDU9xAiJ4EWJ8n/C/yxDpWnr7EzQu54Xb/cRn11fc7nb84XJizpnPd93MajEjB2g03tSNSQMbDYKxD4Fv1kJSePX6nk/byG+5A7thIp/zwNaUgHAdEn4UXGxc+8ixNPJ5vqQV5YttoQJJPOksKZ9H47g2fF65ipGr6NhPnijKByFwmQYwj6nSqAQ/UgblKH2mBAfBhJ6eV05zlx/lpuz2kT1CnSv3sQ8bH8T1hfsLxK9swt8nzc7T2WaIGNU5am58eDvy4fWeKUWeSmG1xkWK+EbX6YvHBd+rns0hpt2e/lyKD/Tp/3mpvGClVbh0gdYap7Kx1NLNkZzHcOyDJ3phb5CtsTnPi23lMniS8xS6udKggeaFwxQxPGutfH18ZPCOAUe1xiBKFBAznPWt9Fi0u1pKpw39f3KlCuxd1zQ6hBs3EBCWM8EimOLNyO8Hht5ZlGL4cNauhn5INOkDjbf7Ax9dXpCCY1kLgmN/1ifXJlQcwXk2GqH6TqrQntj41nWrrfQD8YWCFriNCdNegb2vmdUaows0VYY44QeYnJIJXEniy7Jy5SK7GNlMmWuD7NAAVxf7PkPQKj87PjHh8F5oAsl39r9qd6EOKGVrLLlRrFGc8G/ziYKwb8KTFYI4rkPC4VkUHvsoPGrQ6vsK67sIbYq9lVK4bn6EdWrPs3Hi48OBMTnmXKgKl6PHTPDN0bQLXoM63Fkjj0KwjvP1JuiqPEgBm1lq5UM/AsqplJ60tUpqsAp8PEVGiRQH1QnZJb7eTl1COQSy9sG2UiE5uJ0GgvcUGnfLiUQi+Q5fSL4fjM0J6jxSPW+ydhpPVR618G/yE1WVaz+wWMXUuAqRKMYRZbZGM8GLY3K/usfYr3W81at+G4JZp+HcTAc+3F8yeM9WelfpkCKtBXxxtNL3RIcxes/O90FeV2AshkNp2Tha5muFlhs3IaBqHGvjqVZKa0QDjY0hgo+CuYA5KMnI2c7ghO4OvrSGKgzAB0PCS2ArlTd6wtEIzmjVEb0QQu/UVg2kwbgvwlwLWo2M8oPticWUZz4xW6di7b0jALM3qikN64Pz7r2k8V3Ft+7O51wJOxffPHx0feA7t5ek6HjKve59M43UZjxslYdqRIFD8Uy+G1PW1iiz4XMf9m1VeXjK/NBOHBfjs3GgtcasytG6O71lpQVjnyJJujGmOUFDL+wFcVymSEU51kKujUtxPJ9GnPdkNe6PM8EM730n7Hk5/zd4Om1nyYXT1qhmbAo/Ph0pCh+EyKkUEOMmJJLBw9Bn6Vw7d87kF1uDv7o7Ze24SztTAsR3O/mclcsx8fxiwvs+oeyD43LXLbE1N7ZmDCmSrA/mOuu4wdyM2FU6WLOOkdsqpa0Qu3nGXc7ct0wRo/o+OFdNmZxjEodKwFJgNuWZD4gIT61SoVe5guP5NHCqysO28Pq0sI+BAyObCDFERg9CP+CCB1mhtE7UKFb5qlYkGtc+saJc+sSt7xqtbI25FJwYDr7VUb+PX370iufPCQGqfXASEZ4ddnx42BOk03Z2MXF5mKjNaFtlqcboPB6Pb4IhZNNzlaLh0I7wLMZM5WWF8dDfjq+3lVdlo2BcBgM1TtE4eMfgA7iIRGFeGp8PE+LgvvakL1qXoH28G1nFeLNsfLMcOUggjQObKsFHRvE4bzQD5zxswlobW6tkFV5LxSJcVsdJKpcp8kEawITcCk92Zmu3Tn55H7/8sNKljCK9SmHCeXDNuJ5Gnh+mPjwGJB+43o8YRlszj8cu9dtrv3iKKE2UYsKB2PdAdVjt3gxbKUy7fqg+WuFRC1urDM1RTKgj7FLAvKBO8INjtco+eg7B8dQKbss0g31wfDSNrEK/vC4rexkIUdlW+GCC0XvMG94MHz1u694WmyqrVuYzYaMEY3GNnXNcnKtYzcOs3Ysg0bWy7+OXH2I/l5KdP/OttOdymLiedrjzYO8UApfT0M2KZuNu2/DATh2jj4h00tKmldE6NtNMoBqnpVCKkoZ+xj1J47FWSm1d7qrKGirjmWYmrsMvmimj693Tp1aRraCbMTh4ngZWFR5z5tW8kRCG5AhNuR4jg/ddgmuGREOysmSlaMd3rlqoYphvlNCHkC/PbV6VDipo1me63o/RveP4ucijxxnm8sHlgY+uD/hOVGc/DFwd9qg2Giv3y4oI7NUTxTOaIzd4ypWxOXZvfZiq8HDMHJfC1fUVACeMI41NG1oq4mHDGIJn8K4T1AyetLAPiSl5nlqmrhWZjasQ+GAamE04rd2lOSD4KTCsyoc7RwgBL55gZ+zVAkupfdbFYK4FA8IwMdNI4hjORqs1yrddAvv3WH+/sgm/quK0UxwAMKhrT9Svhsj16HFSuRwD++D47PlFx849zPzw1ROUjHPCld8R1HWUpSirb9QAzinee2LwRO9Yzonzy5p5sgJOyBUuEV74mduUuAyRQwiIS9yOkYMLna1a+rCZuMbBRUITkjpKMV6vhYdScLTeonQJN/QksZUNHzxqjoZSMLw5QvNsLXOfCqsH8ZVFO/pwU6NopUjHL9Le7zbvKkzBznSeDgkQrIETx/V+4PYw4ClMY8JH+Pj2pk/6Pxz5w1d3AEQTrnUgWEe5Oj8QhsJGRXOvEMXgmXzg7TTGy7JxqhUnwj2VCxxfbjOfDYnrMDKFhI/GTU7sY+BuK6xbNwcjdk5+awXvHNoqx62w+EbWxohjkB0uWkfriaIkaj5fOBFMO+WlUHmkcZSKB7bzGsw0UFjobpje3if87yKk9c4SZxSnO0untBm7MXLYJZw0rqaEAbfPLlAzHu+eeHn/BAYX6ng27vBnIpmZYsERE8iZKuFcT+4ec3++j6IcRdnoyMF99nx5WvhsP7FLiRgDyQmf6sjghdaMo1a8OUbnuQqdeuatU8peLBuja5zWzDMSo7vAj71SrGrgG6U2lpJZVQnazcAUuPcbc1NK8+xdv/TkGMgI2SrV6LNN7+Odh/NGGvulazcFdqNDyH3/a55nlxNNlSfL3D32uZ7YPF7Ct3NtKQVKagzn4RTnzgZvIpzOBlaLaOf2u8apVcbF88JtfDQNpOBI56T/snqmFNhKgwpOHYPBGKBp66hOK9yVTMTzpJUrHMlf4a2TpBJQnGC1kVtl1YZvHaGcAjz6Rmsgal3GQzf1IvaOxabde+B9vOvoSo+3BRBnwuV+4mK/63vgmDjguL05YFo5otw9HgGIDta8ErqqjHHopKUQe8U94XHSHedPa3+YWwA7p58l9nmUL9eVj8aJ6+DZxX5h/LBELtLIXDZaaUiDqxAZh4BYw5ljqZXX20pQeDTlgkhKAbzrSg/AYqBWJdNN4ULrl5oYjG+0EM4+A8vZxG4x6+fBmRpZf8Eu+69swg/0jOutaRGgpSHOc3UYuNwnypa5TB7nB9bakF435ZGKYcxaGIi4drbZGj1OK2+0nQd0ldsg/KVp7DIfjENNTJpA4F43ZpQ3a6VY5/eP3qM0bt0Or92ZxJ1f+7JthNqYcyGXbsjh6RW1l03xOCLKzhrVlJNWBsDvHcPmCdUIZxzeVBLZC8HBtYvcpP6ojnkjOTm7w/VF+j7eTbyF0Rn07OOcDLvRs9snxqnLeW53kTrDcc14J2xibL5z6r/Kles4ERFaPTt3OQEfOWlm1YoJfPcwcZH6M322DtyGPtz9umY2jJe6UDbjt13k4I28wfMUkeYYnGPwjrnCsWau/cDreyXXwuOZ7Ts24clnBk3sfddXFzNe5cpAw5xj0G5QErxDqzLlyGMq7IhcyMDuTAJYw0b2iifiDKq95/C/i7BgaDgj5YQ+B4LAJlzGictxoJQjH13vaA20VvzZv2M7a17vfGZg5EBnPzcPUFm94BIUHIcY+Gz6edpspbGvjsWEr3XlMThelIVlbfxWuOCjkGjN9bZ0M7ZcsKJINda2MTJwd/eI0bF2/aKsHFvjkDqa1luffYq+MWe+lR+NzYjNIRJICA+lcBMS10Nkd94DT7myd0LyDo/g7H3C/y6iV/M7iOJtpMnjW+Bq5zmMRtkaN97RCGxrx8eKd5SzIeaDLkw29G473VdnwpFj12F7hDF4Ph7+xPpbM/smZCe8aRtvQqFtlWqV77odk/MspTA4j1aPVUALqpW1wDgEXjycaE45au/u+2ZU37rTaghcpAgYrWbWTdgMAo6xCWyw1Y19HMmxsnOBq5S+XX9v5iOmnafuxVHC+zP4XUXf++xPVfgdwjBGrvd9aDyvmY+mSM5CKY3oHMEHzPc5qDuUgxOUvt6S873464wQQB1cxsR3Lid25261VdirYs6Y95E3y8bdbPgKhwthiI5M5SJN3SizuW6AaN1r53IQXt4tPLXGkYp6w4ujikHryOK3OV2tyl0uOIykntBgbA5PY0fiZTN24jmEyG7or3l53KgosfTLz1s4zZ8Vv7IJv6mCOeTtflPhf/V3f4ff+/BD9jGQl8y6znx2u4MNhMSbNeOa8ftxYqGR/R6pUKk4FcIauEgDV86RQiBGR/BGzYbHuFs2roNDpd/cN0Ln9LtO5/nxtvJH28zeJX47dEvmTy8HblviMTeO68YXZaG5DKE/oO+RWFCu2kLWzH97f0/xXS503Qau7wvxJhC1O/qtrfFGKrdjwqXAhfe0Yvyb9YhDeU2jNPDBE7y8r229w3jLPNfzbHRo8L//T/8Wv/O97zDGwrad2OaFz24vYN8QIg/zxljgr6cbSHC3FU7HhYemOHPsNRBzYAAufSJFz+A9thlz23ix9EtjSA71yliNTDeY28XAj8vKv1mPHAR+Nx0YvHIVBsIuEGPgYQ380fFEoLP1Dy7wmUsUB+AJHv7tfOT/vcEqxlWGq5Kog0Obw2o3/FpEuZoCexI7F/EKP15mABavLK2BO/PP9f3Q5LuIMDjGi44UNO2Vrf/i93+Pv/zBx+yjUOvKOm98cjWejasSxzUziuMPrq6ZvfHy9MSSF3LrJn7BeyYNsPTvcRgD++ipdQNVtgynssL54vfxuGNpyqUXLsPAF/PK948nLgn8zm6HTx1Pu6vKfivdr2HNmOtUlb0PPBdhbZmGxwE/Os780elINuOWgRtziOuM7FaUIPAmZD5JE2j3UFmzsrQN75W3x9Y0JZwLaH4/NP4uQg6Cj935wAmEQfhf/7W/wW9efcgojVZW8lb55IMDOWcSsOTGBcIfHC6Zm/FTP6NzZnWAB+ccPkOqAMJ+SBx8pDYFCtsGpy3jHKQQ+DAl5pbJvnHwiVfF+FmecWr8dpoIvnE5RAYTdsExR+Xr9dTtv1S4cCMfj4FVldZORHX88OlIc0+A8UFL7HCk1CW+nsaQBHcR2KtDLJEIbFX5WTlCVeoY8N7hzgUaWd/vf+8qtBniz79f14se/4f/xX/C7/3Gd9kFWNeZ7emJ79xesW2ZwSeWrbATz9+8uWYumR8v3b8Dke6DY44UA06VqTp2QyB5T82FTOUxV+5ad7jdi2OfgRxxU8N54cfbyg+2hUmF74wjQwrcXEwMOnJRCsec+WpbiICLkU/jxME71tq49kpojh89PPH9x0e8d3wWRhIw7QbiCUrrTP4l9dmASZXQPKfaeLCN0cFFTGSUtu+zJCH/umv4ATVBWq8MiMB3bm+4vbxAWmbbOrPeNHQmPcLeez6ZRp6FRNXGfz8vrGfTD4djdI7Emb3rPL617oLrjCcyP2sbB+u0iXI28Yh+YIuNx5YpKOZ6C1nrQBFQ5zlRma1RvRAMvMXe6sMQcag6sjj2rg9p5HNXYBc8r7cNmwvhPCBVxRicZ0i9tOcRAkLAY/jOn3bG6AIToc8ivI93EkaX1sE5pxW4vd1xsfP4VtgAcUItSpTectun/y97f7JsW5alZYLfGHPOtdbe+5S3UFUzNXPzCnDHIUKQiAyIkIwkAwnJB4DHgA5vwIsg9OjQpkcrRZAkEclIAhw8AHczt0pVb3WqXay1ZjFGNuZWdUeygVmmX3cz9zNMVExEi3PvPXueWYzx/9+fGELglfXU5n+9zKzeWM2AzpR+FQL3zbhoTnDBtedTPtbGF3lmK5FU/ZwOLdyQeEPm2DKzGxW4kUhyekKkSifqZGMAkgZC6VOkTjUXKM5+bNzIiNFjAIPBWIQPnlmLIFhnHrsRgzFawKJB6Aah0RUh8EV7Qky59J5mmZ+j5T9KuUCtjUggDQF3+PzqhpvdDmwm14Zqv+irdQnjJkXCxYbrcWS1wlM+cTyTJbIYG2BwZbbCNg4946Ra78Zr5b5l9rUxxh4KI6YMtVECPNXMyYwGXMVEqw0zITflcS08LStjOsfKr/TU8tBdMKXA7MLOAguNVY1mUGrjJ22hTkpVJ0ZlcOFWAjugmjJKILlCrbQiHGJGY4JZCLRnH9NHKgnak+7pqrKE83q64nKcEFvJtV8yzAOD9FzbISjX08QuTLRWeH+/UsfGWh0zYcQYPLHWzDYG1M6pqNpTnU/N+OALE4FLGRAFWTuB5+Ctd0gFbhGKV2qDEpSlNZbazbVDClhzshlGw88NvJM1Ni2ytkIOXUqxmHCnlbJ2TX6SLnVLreeUTDGi0gMMsYR57iCN2ti2Tk5uz2n3H62sGeI9Wfxr9v73Xr/k9uICqTM5O6s2qoCaY2JEFa62I9sxUWrlpz+dKcHJzTBvNITL3KVlkUCufX1FVQ44hwZv15WtB0wS2gQpwm6IVDMWeiPwNiRac5a1UTRxbI05Z6I7Gw2YNVYrDAKDRx5K46Gu3KyJg1dycMYUuK3Kh9b32KyGJiU2JRXAjW0MRA2oOoP3e8WDFdycC42M6sy/7B3+rqGQbyY54nK+dTVUehdIVVlyYStTf70JpBgYVFmrsLRGPWvjhX6J8dDTzFZvWIWIE6KzilPdWbyBQzEnV0PFEBOsOUHO0fXeeKcLAJo7Aai2zkNNMXLJwGPNZ7lD5wNzDspK0g9Ab05AeKJh1thZ+CYt0AQWaVzq0JPWsB424ZCbEYMwoexcWe25x/+xyu2cA8HZrAuU6ri1P6YlDDzOhZsxMsaBBAStmPXD6FQLJtC06w9NGmZGCOBVKM1R6X6SVZ2ogeJCM6eZMVvXGZo4uTaEnpCLC1/06Gmi9bS9ao0FZxqUa4k8tdIfr3TSE83J2lDvY8DYHKlw1MbJGltRVPtaFhcOWrjoqxeQbkCWwLE0RhWSBzau/Fyuoef6mcuaUbudCJE+7VQaanYOQwJx5XFe2YWIhkCgSw1GNVLpMMUQ9JwIaqQzVrDR11epDRUYpJtzG0J2upmxVWp1tDotCrH1h0FSRcz5au067TGfKWNmHJshAS6HyGMtNIxM9wlY60xzLd412kAV451kpPZmDMD+nMoqDQYPqMk3jNIgyr0vpAq3FhlQ8vOF66OUyPmSxVlaoV3uhRXkGymr8LRkrlMiSCCcO/lRhFpaR0eHvkWY+Zny05HS1To/PJwvc9lgwVnMcWl4LRQyFEfEKDQ8GEkFCHzIff1tWnd1WmvMYqQQGBMcSqVhnNxxEaz1gCVah2QgkNX54AU1SIR+9lKxppRgXHn4Bg8u5/9mb4XBYSzhfDo/N90+Vn0NbcHO6xHBvOCWUWrHxkrk8bhyrdIfqd5zl1IIxPMaRr3frRxcI9qcUzWigp7x5h4D65m4mM2R2rgHqsHkQiTi1glNqFDEuTunfE/0Boe17j8ZorAZJh5apmHM3mXkixmHVllL5/nXajwl5Z1UgkNfUd17Qutp17sYemNaOjIWD3ywhYQSa2QbBlIYfqbv5y/whf9szT5/3i7C3fHEJzcTW+nhGKhwWivjaP0VroD3i7l4Z433yxZgdEqFGgMJw8nnqPnojkRl1NCj7K13V6s5i1dC7SEz3Sbbo5TLQMflrZXkvQvvocs0XupI0I75WqsRpV8OmwQmBG19YeA9rKEB2R1t/fXWgD2VS+kXO6eTMaL3JLdBIlsJbAm4PB92H6vcpX//v97PHe4OC98tlVF7y19RntZOK9mEs8bazxcyOj9YtD9cvw7yWr1xEQekeu8QeM9g8Em4iANzazRzihlLq2SEwR233uEQh+zwjrN23gqTCEmEJsKLYeBlTEwtsK+F3IwhBoJBtkqS85/pnGra3KmtUkKPoq9ueFPuYmZnqWu/pU8KAt3InAIMKBsJNP3ZGMDP9fOVV8NUsNDHfyEIT6cTZbcQtXuClMDDvLK9HJAQ+uGlvfkRmvYEXO0HXmtGQ5mpxHBOefza9C8CURl1YAiOeM8CeSoVb8ImK8P50SEBFi+cztPFQRoJBXVmb2zTwG0c8OzMrVG8BxdRnDlUhtYJK0Ugx8aqDq3h8jWUoO+BB5zPiTTpF0TBSCkwu2FWUIkMqiztWdLzUeprOoqeDePBOSwrpWYG6ahsETismYsh9SwQtW4MpxPJutpPcO2nZ3Nn9UyIirtTaoVz19VCQJB+8W7GyQtP1qB1Wlj/Sl3GukDHbAPZFgaRc9CbcREGLkZFRTi0ykL3xolLz3pAMOu/lyUZGSG4f2MiL95oBkmUsY39EWMNaQZRyXae6KoQPfSHwHN9lPrmws/X57Hz9vDEy5srNlrPnf/IvDaut0MPSfWvdeBnMEVQxBomRjv/oyL9cti8PwTEHM+waMeAjhIwc/alsbdKcOFlheRQcMxg75XR+xV6WeaOPwZyMC5T5DZMSBWOVlmbE1QJVclnrJOYU6rzSOUwdARtRM6PikbBWT0Rm+Paz4Ak3WtyqJXLFGkSiOmCIf1sV/lf4Av/H12QcMHU+MP7A9+53RGmrz9QYWnK0hbGMCDBiThqzhSUmyHxWDsBp2dUGqfW+DROuBmzNhY3hibshsDVMBIa1NI4eSGHTiK5bcpARx/uW+E6Jj4fJxz4qq1EjOsQuQwTnw8RIRDDxBuct20mBCdaoLc6lCqFVZ2dwS4kGsLaSh9f0S9SR4RKw7z2bhsCqtyEgY0MbENi0vDM4f+I5fwxBrADTfjq6cBvzDNhlPMmUshulNKwcUakA557B0y4nQYevZJrZ6ObCQ9S+XXdQOhj5rVVci68HLeEUdClP0YhENQ5WGNnwuDC3muXEnnik82mG4PrTDHhRhPX48DnaYIQ2FjAF/hyyVgUdAHLTot98tXcQSdScyakB5PQN4Vk8NSMJXhX9OBUrYhHXljkRgM7EQZRkj9f+D9GWQOq02LvMg1j4Ef3Jz67OnE5RMR6M6AAtSmDd9+J4J0mlZRNCl3aIF9Pqzqt5FcuL3tAWymstZDd2cTETRoQcdZamWvPA3nvK9/LGyrepTihkoPxnWGD06lSA8KVBLaqfD5uAPgsjdyvmfu5YARS7VzrJkqlU6FOVrkicMLYt0o7UyswekqltB6aqH0qNnrgsgVGFbYpMsQBffaQfJxqnTeuIoSghAhv58wnS8WHfmF36eeTNYPQCLELgJoZQQO7GJizgXYTeWlwovD57oI0O6UaczUWMbYXW648EQMsVpm9IsD7UNna+A2GehVAKq/iDoB7X4gi7DSyC4FP04QAY4rIWrhbC+CMdN+bA5yxmqfWG2srxqGVPsl3wbTvv2sDp2N7kjmjR6YWuEzCJgVGEuv6/OD8aOXfDPcw6ZLq//z+ge/cfkLcCGKACOM40ugPxo5bFZoVQnB2UyCXdm5cNZacyUQ+TUNPTnYjm9FKRcfEzRBRNY6tcrBCxnjvhXRytjGRpSfeR1d+c9vX4JdlJrfGGITLqLyeNoxEYlPeL5kPlolTZNsMp2KDIwSqOsfWuJZAAY7eqGKgfWoqJbI1h9RQNTYijCmyOSnXMXA9jdxcXyPnPfe/Vr/wF363PjaM20iwwve/eM8gwqDKgEAutKjUpY9JihthgCiB/+GTF/zu04FaHa+N/bLyZJVvh8Z2k6jFOFSjifCbl1f8Ny82fHg4cVgqx1Z5yCNN4HI7Ys3QHNnUzMsQ+fZm4pSdK5RNFC6GhLryPq8MoVHMOdSVu5YJBL5DZMF4X1cMY1Dlq7TgpcfW1yFgHqAJoRgvWzwjN3s3VpoTJfCreoFN4EU5FOf4zED/aPU16UoaqAVkG2j5xL/7wY9IMTCKMLp3/wWRp9lZ8kxpjRiUDYn//uUN/+79I9ctAcpSKkdzWmtcbiIPofI2F1IQfvsy8b3bS376sOe4Ftbq3K+NHPqjIw2BoWRKbXw2Tnx+ccWDrdzmyDYouyHhQXi/Frz17v+jwIMYU658i8jdINyxAs6E8hM/YjgXYaLQfSoSYGjCJzkRpj7SV3N0bViE39y9Yo6ZvHTN4ikvfzYf0J/z6koVp4qR54aGyHo68Hs/qQQTBmAKzghYbRyzsrZCbYV4xlX+Xz/7jH///oHFDGuwLJW7pNxsLpgG+CovPK4rSYTvbSe+92rLD97dcVqcFiKfsOPghXnODEG6dGMIXISBTzcX3VC+zlwo3AwDEgben/YMQSlm7EvhbV0Q4NNt4m519jQkCtuUvvEgfTZM/DifaMUYvAc2JRNk6I2drxG5243wVzav2OeKF+e4VNbTMyXqY5TZSvBG1MgUByqRp/t3/N762GVgwORObEatlSOw5EKpHeM7kPgbn3zC9x/2XZIA7JfMHALbNrK9CrxtJz6UlaSBv7S74Du3F/z+V+84rU7zwCvb8OvReWy1s89Dn3RdhIHPLze0FrjIkSkKlykSga/W0n8mzGjWPU+O8Fkcec/M03maNKVADyKByzCyulMwkihWKikbcepoxexd6nMLfMcuYK2sxdnXhacy/9l9SH8R6tysUIQUlXCY+Xc/+H2CdU37FGGeM3GbYHVOuVFbZQpGJPI3P/uE/+D3vMrG2hoPmhFVRlMuLre884V3dWYMwv/6yQtub0e+/9U9T8eFeVVenQb+Ugzc28JVHLDQL/zX48Dl9QgktHRs8E1MiCr3a2aNZ2m4NWarSDG+M0QeBN7oQq7GJIlXFxu2k9AW58dlpjYnmNJal94amWDCLJWn0Nj6ht8IlwQbsVPhyAO72/Rf/TbCL/iFX74GIzqwwjgMlOC8Oy6suXIZlF+52PHp7YaH40xUCOg5AzTwZp55qiu5GtJ6h/yC3pVPxwUVZTobYyET6kDxwuqN3JxmCsFotSEiTASCpHMXI7FvM6/HyMUQceD9/sS72jhaNySJOt8aB67TwNT6B9LcMFcmhLtSaHQsXTp37C04+zIztsqujSDyjW7sEFa+s73gwTL33l+U9pxy+tFKWif09NZoN9Hc3lyiWvnqYc88Zy5j4DdfXPHp7ZbTsTAOESNS6BrsnzwsvFszc3OUwIBw4cIX+YguQvX+QxgdlrWw1oVahbUFljOXGofBIGSYXInapw8P84EvjjO/crFlN0TcnXcfFt74iSeU69RV0d+OEy/GAa2NS7rvpLkxoTzWzDwIc85sUaJEXOBgC4tGUinf6FQNQ2vhKiZKWTmKkwdnfW6wfqQykICErk2lRcZxwKvw5fHEXDM3Y+IvvdhxeTVwuu9ymcBApcu3vnra8+Vp6d6fM7LzOgs/np+QGRZv5wmAsLSFNUfEI+HMoE5N2BZjCIoFwSWQCN9cqPanlU82gW1SzIy7D4/8tC4s0tgFpQLXQ2KniVsSryb4N/mR6s7oQmld459aY2ydiZ1UmL+eXNZungwSEDXe5MLnlxs2m8DbZeUpF/bp+cL/McpRXJUmwnr2HV1dbUCELx/2LKeFlynwa6+v+PRqy/5pIajQhkSlJ3Cf5sZXh5ljqwTt5626886OlL2TvWE4TRrH9cRauxxXJYDCEAIrhakpI33iwDmAK2e4P828HIVtFKo3vrrLfOUnJChjirgIU1CmoOyCsmXgP8wPZDOi9+RVMqRQ2VTpJsigvC99Uzv3TfgaUPrejE8nZRgG3iwLc2m05bnD/9Hqj31rRfqUc7zcoKr85OGB0zzzehz4K5/e8NmLax7u94yhkQJUAqHC/cPCD5+OnHI9zwBglwKPrPz0bu4GWuk4zx9PezZbRSqoB1SVKRq5dmXIzbRh1q4ASR5YT8ZDOfLZTrgcAtUab96d+EJXEGETutPlQgVpMA4bPgF+mnu+SHDjri60MJwR7oFLCcQQOVAYm35DYhwIDK4cmvFyk9hO8OND4c3TB8Lp8Wf6dv7iXvj9v/g/xBvfutjgOLNksjWaOlcXA0RnzkYuPYreVYgUYutu56fcY+IRZ1OU2QsiwqVENoRuGMpgbcVdiTibLqiBPw6+PMs6ckk8jRXDWc0xaxSHx+osQGkwe5fr3MTIFOScjyV8GgekGW5OAbKCBdiEHihS3XkCanLe17lvfgoSpP+784Hgwt4zC42gz7etj1XSemfdzx4MNPLt60tKmVnSQl4y1RuvLkbwxsO8UKohKmgIuBuDBzYemUvmZJlTcG4t8dQaKspGla0IUQRagyY9I8LOkx8NqLWelgqo907nUpwWK6UYh7VgLpgLT7kwq3TDr1d2IXIRAimBtb7ZvQ6ps4PNwTYkCh6U6xBIqizeeFwMD5U33o2/SQNDiKwKMi8MOFl7OFN9Nq19nBIhDEIcOvnGzfne1TWlrTwtMK+NUp2LzWuiGU+nmVz6hCYkpVTBmvREyFpYrTGKsIsj1ipmTlJho4FwxlG11v1QUSPRnUGMddzwwWcmOnHMCiwNWl04nhY2kliLspTG3dyzHxpgyRlV2CCEs4QH4JVEcGdjyvvW2Ay9g/869kNv9b6fDwnu6owbxCjEIBSU8bSyUyG3/lip/rz+Pk45qo6czxgBvnNxwymf2IuTvbKYc7vZwvnxl0vrHpIYcHdyrog5uVaqO6t0OLqqYN4YVNmE4RsgBq2DMkaRM6UOokdaLMQgfYtsQlbjThpPp4VgytrCOVdk7SZxc9wKUXrKqiA95A14qQPQGNx5Z8aYEl6d6xRJIdLBr5VBhfvWjcEaIKSu7tS6ctMC1bsm3MLzhf+j1dlHEkSYxsSLyx2/+uqW5pX7w4HTyZi9cH29Rc15OM6suaJBSGOkNHrD1uCEUcUZVKm1y7wk9Ebu140GwWi1EEXYaCRGZ5icNQuzN0rLHRVqThF4qgtP0hgXZSlCrs77ubKmHv62hMaGbvqtOHYmit1K4lKFwXrj13NCgRcxIUko5szHTvHZS79rDiEwxshTbdjhwFUeWK3fU2v+pQ/e6j9EmzFxsd3g6txc7dimkU1MHE4HBm1cjZGWM4M0NPQRymEtzOa8XyprrYh1o4MKne5zjqc/UjlJI4ownYQhNVqF5I4GaKq4B06tEQhMGhmT0FygGZcSqdU5mfWpgDkSO8nk67RIEUejkIOxscgC/ZJ0pmbQYOtC9tbNmg5TSAxBaQ6rVRAjqCASSDiTK/vWu8Nqz5vNx6pu3hemNHBzsQNRbq8vGeSSKW14vdsTfGWbIvO6EsQIqZvFj2umWOPdutKaM3CO8RahAmNKGLB6XzsB5culMO4XrDUGgRQFPHKq3SgUCWzjwCYYpUIIwk1SaoVHq1ScjBFDoJWMeIMqWAQPSjtrAJfmZLqOfwEozkA3Dx+1stAfI4MOXfNI1xW23jNhI8JWAqv3WO/wrOH/KBUGQZMwpsRN2qKuvLq5JkRnGBIP+0eCFzYK+bSgFIbQzYenk9GK8+Z0gmJMrRvMY1CC9q5RFidrJzfhzt0K12skiLMJ/cJVz96jFFYmHQmquDi1OZgzBFgLzKWx1MpsFU29cx9M0LOhNo1KFWOnkYsWyRhFnCadfpIRip51tt5NltH6z+AslQJEAs0NsYp6wFvDq/Gce/RxKo2BYRPZDgMXccIEbnY7XlzvGGLk8emJ4JkxKvM8ozTGocP0jmumVePtuhIcdkQKhlkHbqgK2c4hhVJRF97NKxeTkoJ3gzj9sr627nUaNKHSE5qzOc0bY4BcoDSjeCO7EaNwKpXd2dRrAdLYoRoDkU0L5PO+W9XR2rDWkYgu9k2bL7pgoWO0q/g3v/YnEolOl6OZE5/P4I9X2gPaLi8mPnt9yW634dXtLdOUGMPE/cWO4Au7IbHuZwaFNEUacFwKrcCHvIAJO0kQuyxI1u7qrGJkupSrIHw4Fa5PK0FhNypmwikqSEcLu3Wc+jZGcuum3xHnuLRuJD+DXjYaeVsKV6advCPCJgkixiDCtQTWruDGrXJaS2+iJMdiX08q/ZEaQm/4WnBmaSxUbjSgbvg5RPZnNY7/4l74RRBRNtPA65sLZowWlRdXl1yOA3mZCHYiGTyujTEJQxCOq3FaK9mMd+uKuTAhbCR2fFYwNtJ5qnurLBijKlpB98brFM7Smj7OnAuc1rV/DVWCRvLXDHNRjrkxW78UJYdBQ3dOm2PVWNwJKSGh4zlPVnlohWKNhR78IMDRa0d0uvAqbtlKoERQnHLujO0QPkkJCjwVoZl208pzfZRqDnq+8L+43LFUw1S5vbrmcrqk3uwh31PmRsmNKQZCVE658bQUVqu8LTPalI30vyrCicw2Roo7D7X0w4zIsDb86ch3hoFtDJgqRuRoxqFmNqJchh4SctKGRmWrA6dcOJVCoTFEYRsDjzhSOgZ0dSfGPikaVJmtcd8yK41ZnClHNBgHcw7SKNq4CIlNGECcQSurV9yMnSnf2g14M+7zHz2mn+tPviQBKiSJ3IQNzRoSA69eXHKxnTjtR8r8gFphXlaG5Kj3w+dxv5Bz5V2Z2djAlUcajqniKEkFF9hL6ZQoF+6zsJkXPk2J6bz+Zg+09WxgF2GIkaj9UAOIKVCqkM0pnVbHZQzM1noum0EVQcbOFZ5CJwvNNE7SOIox1U5AO2pjFUMcXhGRJmwJEDqjWhAicJ2U2MCb4c1Iz3vgR6k0BYaxX/ivdWKxQnX47OaG3WbLcn2BrfdQK/OaGZIQojLnxuG0UmrjQ1kYPHIpieLGclbUJ1GKOyevFGsEU94XIe3h29uRTQq4RJzIfMp0BXcnRSF9qo4626TkLKzNqUBCiDHwuCx4UwzwABoFiZ1k5goHM45SmdXw3BvJpTqrG02cW0bchVE7OaVqp+kF4NUwQHU4Z6UMz0nPH600du/a5eXEJy8vWUrDRXl984qb8ZLl9hKb3yFuPOSV3ZSIGtgvhS+ejtQmvLOMmHITIikqrsIqrSNYa9+HVjGiCe8OhXGY+ZXdls0YMBdqTexbw72Bd/9oioqb0xy2DocKqzuKMUbnMik/XSvREt2CJwyjIuIMQYkiHIBjcNbmtGWlGRxro0YnxcBnuiE3Y1IlBKFqhxyIGi/GbSeynf2pWn/JL/yigTAE5KwDnYvxg68euI4bXl1N3F5cYKfGh/dPLIDHEc/Oqa68L4YGZZsSsUQiTqHyVPsFf0pd41qtv9LHBkT48bzy7c0VFylRXWkuvGfhrmR20qhEBo8doTjCsRVKbYg3RoULSVRVivSOfXYnEGitcdsSOXQz8FMtZ/pEY7DEA/2wRKAGZwndzKHB+HQYqDXyMPeI75ebDe/ain8Np+W5u/Cxyr0TKgDWZjycFn7/y7cMJF5fX3C13VIOD7x5WoGER2Vpxt1SeLP0286k2vnU1jMZZuud/0m6Lr6e5V0behLql0vmuxcXTEMiuzFnZ8a4qys3wZFmjOfshZmKmYDYmVEcuDpHiu9iIlvXvI4R9qzcWqRK5Ck33p/XoDdIVXk867ir9JTdNEANsFH4dNxQrfE4F66GDa92G94eTudgsj72f64/+WrNkdxJPDnCyY0ffPWWzSZyc7njaqPM9zPv35wooR9kea3sl8K7fe6TpVHZ6YC5s7TKXJ0F43YbadU7Px/ngggIPz6cePXyljCkjgMu8LBk7vLKglPrwDZFOEOKc+0yIHFhJHIRhUEi77xyXBsjgXGMZIcdnSf9ROUtpcsSm/GZbana09BdnCONbQhEhGDOq3FCg1AbxBD4ZLfl8bBSrSNkw/OA6aOVew8WXDyzLyt/8NMvGceRFzc7rrZQHk+8+fKJAmiM5Nq4O2beHWaqniU5KtQKVh1XJ5fzFPJsqgXYWIAg/Hg/89lmQ4iJgrAW4+5UOIVCyZWJ2LNppHPJSwXzBiiByKUowZRHDayr03AGdU61cSGRFip7y7y3lb1XcjO+ZSOrCtHkPFFqbAKAcW3CzTicJxJOTIEXmw3v5xOtdmV/fN7+PlrFENlsRkKKvZl7Wvj9P/ySi+mS17eXXO+Mcv/A2y/3lKBEVdbVuH8q/PRuJqYAo3bABr1Bus+FfW2IGodSqdGJQRiqkq3xhw8L391dEsJANsgC+2bstXDVIvyxZGXTnl1i50CsoPDZMBJS4moYaXPrSM4AWhoxBpoH7mh85ZmDNQ5WuFqUOjihdgxpFqOkjpC9QrgJiYbzVGEaBz69vuD9cYal42i/lmT+V7+fH+uD+v+3YojEGPpr7Bw+9JMPB+5P3+d//N5L/sqrgRRWOisgczgUSi2ccmVo0KJwEy44hoy1htavyT6KnfXRN5oopmgVLoaRR5tJKWJBeLus/MfDTHGHZpwwLibhZow4zgdboYG2RvHOWL2dIqvA59fX3J9WnkruHf1cqdqQLBxyZfUeIPKKqRN7SIw0tgirCJKg0fhenHidIlU7peBy6Av6coikJVBboT6Hzny80kCIEVTIZoxB+Tc/+oLvf/UV/8tf+i5/9ZMNSQrDkHishcOpUKpRc09hrCYMaeA0GHVpUJ3tuRtupZtgLwns6Pz7DcZskDbdq/j20Pg/np4wFXw1HnTl4iry6nLEgB/tT0QK0snSjMF5fbHh2Fb+xu0t92vhaI2iTmmVJ4TjnFlKobaGAy81QhBuNOCm7M6IxBKUSY3Pw8incQCBp+Bsw8g2KLebkfe1Ma9Obs+myY9SzQkiWFWOi1FR/t8/fceXj4/8rV//jF97EZniyjAo1MbhUFnXyin3/VKKccnEsdXe3HBhY91wG7MzSU+yXQ2CGZsQOITIMCmuzodj5g8ej7TmPGXjiZUhKa+HrnP+Ua5oMELpXgINyrcud2Qq/93mJfupMtcefDiXQmvCF1L5qi08UWkGnzH1vdhGogaONB6lQowMKnw+JD7ZTkCnkm1D6BkCQyIsgdSM5M9Nj49R4iA10Cwym2I28u/fv+HL0wf+x1/7Fr/xckPkRNDO5Hk8LJRcmRcDj9hcudhEFuuBkWaw0Q4umJdCaZWAkxywyiSBRfv6q8F5d8z84Xn9PeYeRPTd3cQnu/BfrD8xMDemIHx2seVkK7+zec1+Wplr7TxzGqUZxyXzvmVmb6jBZ60HFr20QDRYRdmGiAbhYhC+NYy8nEaCC2sBGRLDADsGtrX/XJXnMftHKw2BqAlaYJ2NJSv/+os/5CdP9/wvv/Or/NYnG1QqDAoL3M+FdVk5lZVt6iGRaQzYVggOUo2Yna0LD6WSaSRTJvRsmlVmIIxKScL7p5U/ePuIm/AVC3cIv7Yb+e52wIDvL6WPkHLPCiEFbndbTmT+5u0td0PhmJ3c4NQyp0PlwIG7UjlIoUjjVekdixcWEVeqOMWdqvBShW9tlJdTb+BNQblMG4agjENim0J/bPyMQ6Zf2Av/GCJjGPju1SX/p1/7hE9vd7x980AuJ9795I73P3KmlNgl5VRad/B7TwPdDQnVwIvtSLPI23nmnVWOzTDrBsZmRpFGi924dp9XXjDwe+9nMo3VG4j0lDRtiHUd14sp8WK3Jb97Yk9ljRBdSQhf5JXUEg/txKFm3L3j5VrjPhut9XHUNvbFcqyNV0MkaOidFJyoQijKTXPWK2NxuFBhMwqrG9vtyOXlhic1HveVD6dnJOLHqm3YMAwj33v9gv/5L32HTzYjP/zqkWYH3v74gbc/vGcYhe00UiuMqTv7iwi74BAqLzcjReCruPBmmTmsjdUaV7sRLTBbD3m5EKUMiU/Z8J/enFhorDiBCAZ3YWUoYNnYeeD2cuT00Di0lVPLCEpokd/fz6QCp2nlZJVyTmQNAgdbOWVjMWeSeA6qcS5R4pC6PEeFMfbcgZcl4Aqn5v2Sr8KpLUzjLReXI0/auH/KfFmfL/wfo3ZsGZj49Vcv+J//+nd5OW346os31LLw0z98z5c/NMYRREJff6qIRlaHaA2S8fnFBQvGu9PC/bJy0tqlgEBpjYMXXOE6jtzhvCTy/bcLBy8casGz0JpSk1Jrw9W42gVudxP3338g01gcNHU524/yQmiJm41y8kaVhpz3wUdrnMjEFW6IuApFYJsUCSDWKSmbGHCUl8FoITBL56u/CI1aGuN2y/cuNxy08f6x8IPT8c/6o/pzWbJEpMJ3P73kf/orv8ZNGnjz9i0ln/jpD+756e9/ICVnnEZqbYzJia1f7pkrQ4DvbTYsBL5MM3frzIxxzJAGiAVW61PqiziwDMKujfznLxeOWphrIy4Ba47vjGwN08h2I7y43HH//QdOCoWKaIdafH8+0Gblxa5wrI3mDXA8O09kDq3gBhdEVIGgncURgCqMZ6pPDcJLi6gnChEJSsJY28p2vOXyMjA73D098uP1Gcv5ser6csduGvjNz1/yt//6r/N6mvjqyw+s88qP/9NbfvofKxeDEFOklsYudMDEYoGydonX70yXzNb4yXHmzboye2U153KToAlHb5xo3EjkMMKtR/7tTx959MJSjes20ZpBhA+eea2RzeXEJ9c73v0fH9i3wqw9zb5V4YcPM/tSud44uVXEIaGIKgcauRjJnVsSRmIOladY2YTIAOw0oKacigGNwxBIDaYQuB0DtRS220suL7csKjw+PvHFz7gH/sJe+Kdt5MX1yCfXI1tV5scDdT6RQmGtlVKt8+mJzBlqrZ3b79p1eiK4NQY96/eKMGlgBV6nETmHvpxaozXnUpVEDz6YW8XcGLVjDbM2BnPW3DgsjZupRyBvg/NYO2P1gFOrswnO5D0NVQ2CQ3FnbY1BlBycJMLGA+XsvHbgSYziPcwhIhwV/nJMbIOSa+WxZh7MmebCi+3ITUq8SAMP/Gz81ef6+Wt3MfLZzY7vXA0MtvL4cKTmE7vYQ9jmXGkeGWJfg3P1c4oyqAb8TBcYU2BqgbEGMCcU+I3tJQLcl8xjydTm7EInRD2aMZt1DWlQshcK/WG61spxWbneBsYkIBOZ3NP/gFIa2QE3ihna9ylmcQ6t/8zkYAwqXEqgFpjOQTmPWmjAVCM7HThhfG+7IwXhZI27vPKUM9fLlpdx4jpNvBoqDyH/mX5Of15rkyZeX13w6eXIUCunp0daXhiorCWzFMNzYByVuTRqNaQabj3F26wbbHcp8uQJlYauFVfjVy+2CHCXM/vaSKK8ipFUhYecOdE6/aY5pTl56omnSzb2p8r1pGxiYAyCmmCiGM7TMpMaPeBIeyKpmlDNmOkEq6Y9mXxSZTVjsgDnkbkhxKpMCntXvnM5sg1CtcZ9KTzNlc1qxClyk0ZejRN3y/pn/VH9uawxKt+63fCtq4GhzRzmPTWfmNxZamHOHRsYzvufWcOrU107qMKdGoWtRq4YKNoDCt0rn2wn3J1jLpxqQ1GuRmFYnfuSKdqlDdYqiwqz9DV9zI2npfJi29ffEISn1qcRNOexFkJVjt5oAdQUtQ4pmGlwRhonlElCx8OKgArHUMBgap3W80Dj802n7C2tcpdXDrnyeqlcRuEqBV6kgfc8N90+Vk0p8K3bHZ9fb5ha5fjwgB1mBm0c8sJaMmbKJSPH7Jgb1N5Ecwm4KxaFSRMX3jjSYDYsNz7Zjjgjx9KVIa7CZ+OAFuFtLsx0b9MqFQ+wUilWeVwyd4eFT7YbhiTcxIjMiiCIOF/MM56dizFRzQjek6abOo+lMFv3iWyCMBJYa2XrPc168T4RHREGlBnnxbThMkWyNe5z4WnJXM8Ll9uJyxDYqWA/Yx7TL+yF/9XlyOvtwFVUWs48HU/UvLJKZV4q5jAMUBxQ+LAWqjubELhMiZMbpwpT7D/gUZUYBa+N2zSgImxaYaT0kC0qFxJwDSRXmkHl7JSm89hzM465sV8qF1HZZ2WjETOnWmU4R4h3g1F3ZIOj52DghlO8a2bFOp2iNWOh8UTFnW5SS5FKd4MnEZ6s8SYXTq0jGMcojCrcDCNX8fmw+1j12dXIt3YDV0Eo68J+v6JWWVo/qEprjMTe+TR4f8yYNSZVttPIQ67sWydJFHdUlYshIg5XQ39MKkIwYW+Fd3VhR2I9Jy6r9GRJx89ODSWbs18rjydjl5TWnF1InLxPDgaUpp1lzdc+Dzubvxu4deKEixOloQQqzlwrh1Dwc3T9NgQyMKRAFGGtmXfrylwqj3Ul5m6AezkMfEjPj86PUZ9eTHx2MXIdhXyamecZa5nWGvNaqLVLfjQ6bsLb44pZI7iwnRLH3Dha39c0KikFpDlLa7wYJ1SEpJHNWljMuLeVbYucaveEDAhHty4J6wmILKVxOFX2Y+EiBZ6qcZG6sOxkRvBAq86SKxLP67YHrTI3w1NPVe155N2BZDRmbzxJzzu5sISEznL/ev0dS+HtsnLMxmdLAYVtjLweN7yPzxeuj1Gf7SY+m0YuRMjzwv5pQS2zmHNau39tiEqznoj7YV4ptSfVXlxMPJbMoTrbwTB1Yuga6qE0buKICmwIHKgsbjyWzLZ1I2UMShDhpI0s3Wvn5uRqHJfK4VjYpsipVq5ixxgurRG8c8+XWrsPUIQgyhD8bPg8pzeLo+dzGhEWGsfz+hOMAfrEPXWpx5ob97lPSB+XBaIxhsjLaeJFej6DP1Z9+2rDty8mrlTJx5nD04yUQvXGflmorTIOiWwVAz6ccn9UGtxcbbhfFk7NGDUgSRmHiBTDq3M7bBCBnSQOFPalcZd75sNcK6odB3ykdGnl2Tm5ZuPxWLl/LOxiYL86O400d7Ib0vqds5pj5+avW09A3+dCk8ZKw85m7yBdlLuERrX+GB2DM0iX+kzjyCBwrIX7vLJf+/oPqkxBeDGO3IRf8uCtFylwhTC2Ri0r++PMECqntXFaKjEGVKUfRAr3tbDUxvWQuJoSOTeOLRNN2NferZqCMpixjR3vhTuFxsmMNxRQZSeBFJQilYNZ/6aSCNI7qIfaeH9aebGJzEW4iql3F6wzp1eRc3hAp+u4NNz74VnomLkFY3VjaBCrcCCznA24SeXM/+8mTxxO1diXSqvG0hr368ImRq6GxO04/Jl9Rn/e6/UQuHAnli4l2M+ZlwPcr5XTWlEVgipz7j6Kx3XlWAuXQ2QzDRykkgsEg7tayO68SH08p/QLfUI75cGct3XllSja6Ezg0CU/6sKGSEIoDg/FkEPh29vIQSrXMSDVqd6IAgRBTFF6ymTufCrU5Ex8ElaM4pVJ+mPgaKVvViKU0CjSOwaL9a8518opF1p15tb4sK5cpYGrFHn5fOH/KPXJJnIbhdGMsmb2hxO7wTks/dIjOJsxstS+/u6Wlbk1LlPiW5uBPcaHmlmq8mSVJrAZEmVxkkaCCNsALTjFMl+VlVcGpTkb7SSJvTQ89AAup4d/H3Lj3ePMzRh4ysLloCwm5OxsJHHyypwbyYWmjnh/YOZmmPT8kUqPtB+JLF550spJjOSBhnH2pVOkG3dPpfGwFkoxTrlS1biaJl5OI6+H8c/sM/rzXJ+kxKUJIRslV07HzPXQeFwbp7Vf8rsht/Rp5bJyqsZVSnxrs2MvjfdrZvLGwXp2zlYias4oARWhiVPEyWbc5wKueHMinX2fQ2eXjxXM+9l6ysbbp5nLYeCUjeuho7NXM0YJZK+csjEmRdVxAaJQV4MAVbuZFxqjBIqcaUHn5lzBsNCNmWtnM7PUxjH3/XyfMzY7V9OGm3Hk5fR8Bn+s+vxy4lqEmBt1zTztF64H5+mU2c8ZFUcYyKX1ieWSOSyFXUx8+3LDvS28r5nBA3sqJcAmRVpzttplrSH0fergjS+WmVcMtGaMUUkOe7pPKJgyeUQlcFyMn97N3G4Te2tsY2A1oxRjK4kcG8daCS4gTsax5iy5EEf5JvCwCcSepMlRKoii0s3tX/tw+0PCWUplv2bm6hzXgquz2wy8nCY+Haef6fv5C3vht9PCvBa2lxt0N9DMaVpZS6frxN5D53Ht+uHsztENb5Vt7vKDY1tYTHiwShDhe8MWVaWdg1pKMw658GHNbMeI6tDf/OIQOqc1uPJtNjTtndEPrXA8VV5srrmeEo6e5RvC3lZKa1hrCM7izvEc9nEZA6qgKCc3ZiotGJMpq0JwwYAZI3mPqHl/WgkuzKWSvP+5RZ37+nVoU+Dl+HzZ+ljl+8xeC/EGLi8nZius1TgtgCtD6I/OD3OXtDQv3SRmzsCJR8ssFNaT86FlQoAhXhBCIOce7nGqK3d14au18GIY2IZItb5+BMcxAoHXtsFoNDPelsxTLbzc3nIxah8Zeh8NPrUFSDT6Y/WgxoM2cLgpiZy8jzvPE6dFnU0Tinb5mdHlP6P1idOb/YkQe3ehr0FFmrIvzhCcjQZuw/OF62NUyJljMSIbri5GWgV07fKxXLqchspxzR0r6M7SnCCNpRZOvvKUG7UWHj0zBOUvb69IFrFcURFyzRzawn1ZuKgDmyjY2YTo0lHHG1U2ZcS8o0LvvPJ0n/nrn1xxOw5sxgDZSSvk1nB1DmZsS8CiM8d+vRrcSSWRQvdFreq9WVIaS2rEElGUOTjRVxx4eBoZtHFaCyE7rfYL4P0qbEZjOwZebjd/dh/Sn+OSuXJYTkSHq8uRYpXm/dLbGqTQscXHtZ9XtRmtGSuNEytrzXzFjKyR+7YS1PnN6QKNSmmNIMJSG48581BnbofIrgVy7evC3RlEQAObs+9ERHmwxuGw56+9fMnFdmATA7YWhqUyt24O37fayVSDUnvWF8kiITjqStEORoh0OZHjDLVTerJ2SIcDd/vMJP2ipqWnSZsph9LYjY1dFG7TL+w16pe+0mrsj0fSlfPJzZbVnFpX5rXhxYipm3HXecUdTmvjUAy3zGk5UUvjB7JQTs4pFKag/Oq4JdUIJRNEaLVwrCvvcuf4D+dc5UEDCWUn3oEHh8b1MDHEyNGN7z8+8D9ML7ndTj2JfqloFkRAibw9nbgJEU3Cmhx3J5qzqYGTKhnnJMZl7PjheyuE1qU/x9DvEe7w9rBnwzlXYGksBqsV5mNhODd+v3W5/Zm+n7+wK/VqM/JmmXnzbub63RPvyFhQNCjJI5wy/3l/oplg6lwOkStRzODLZWZyuC47NBp7ObFY4V2Z2YbEfzg88Pm4AbOe1xwiQcFs5dDgKkQ2oty3zKkVWhi5DLGPtGsP4gC4vBx42neJzWab+OnjSqCPAgcCyQJbVx4oPCg0czYauRTYpkgYlWQwtMTSKos1ihvHVrhvjVsduBjgMWS+CCuTJW7jlnHs/OsmgSv5hf0If+nr5c0FPzye+OmbB3701Z67UPhdOp86EWlPmdO7B8wUVWEbhK32gLe9ZbYEXrLhEAoFY5XGXIxBld897vnVccPcjKUZrVUqykNbCSFyG0diEB7akTmvbDBSilSH4o16Fvlcb0fePC5U6zH093MhBQABrURVbjzw0Cp7Mq0JI8N5ZG0Eca6SMDBwssYsRhFhrz2wZCwjtx7Ye+ULKYyjcoVyGQIqfp6c/Wzdhef6+Wq6GPjpYebLDwv3x5kvyoxiiHYc4XJqnO5ObESo7lxsAgOON+F+cUJLfD5ccAwVb0ptleNSGJLwB09Hvn2xZd8qb9eVt3NjG5yf5saA9MeECKfSoDn7VlDtXihpwjRExs2WcYKHh0Krhkbjq5LZoDSMd7b2F6QJd565ssCshYAwuEALjESm0JhMObVGkYqFwLEF3rYDF9m5HgIPXvgpKzeMXA2Rq3FglAQmPS/iuf7Ea3s18qP9iR++u+Pl4573eSEER4YAJqyz8b+9P7BJUAq82AagcTJ4bwMhJH6FDUddUO8TyLl0hOaPjns+GzcUr8xUHhtM2XliRYJxNSRi6JkmwZRVG4Lgra/HQYABXk6Rdw+FtToE4V0+srEBV7jLBak9uOlkjVED+1L7Rc775X4bBmjODVCDUYJQJVCAd5zYrsKn08A+NX46rNyWxIshMY4w9PxNts/730erl7eX/O77O37w9j1fPT3yB/PMaErYRpIJ60Pl//n2iUGEY658ejHh0jg15Y0FUoh8kidqqsyScTOKgafA73144leuLngslTfzwmPN7CTyla9UGlcxMmngcT7Lb4bGXuYuZ21K0gibyO048PZpIUVhtw18uT9+k83wk3zC3BFXSoPLIfLoBWqfYiHAENgqDKa00Ik7Rk+yf1sy04PznYsth9j4IlWuauJ2MzKOiU0KmMHIL3mHf59nsK61exJjKQDKdQrkJbOurXPSx0CzRmwBU9AImyEwVWUJygbj0zZgEplUObSuC72vhVoqa2ukGPlsiLTWCNFJCNmgBWWh8oqGmXGicZAu5fj9w4nvEXhcO4UiipG0j8Ozdj1gFP1Gn1WoVO3yCVHBRBhE+PXNFTUZd6eZx5w5eSWroa3xaJVT6Smrg0R8gH99eMtfT7d8Suws9/gc+vGx6s1hoXilhsaTQV+CQgp9LO0YSQIhdd/GboClOrUJmzGyIXC0zEjge+kSFKIF3s0LV5uJBzfm6hQCV9PEt4ZOA1BVPMBCIxJ50sarGFGER3EObiRT/uNhz2+0He8OC4IQkjIOE6X1B+nJHG+lp0Kq8kCl0gkVIkaVxrYEvntxS1Xjy3LiqVWyCDkIU4j9oVwrVZxNiEQL/OvjA/9duuU1kVHBh2cQ9ceoQy6YGBXjkCu19QzQKQFnPWkfaRsbArckijl2RrYp/TzZERl1pFalzY05wHUa+dFyJLcGrlylyLdihxpI7BkASzOGKfG0FG41IMCCs9DpE7/3+MCv5h0fTgXxLpFAK5nugTqJkYKyU+W2JB7oRrirc5R99zk1fnWzBYWvlpkPXphTo6UCMzzQmKtTHbYkdCP874c9/226Ra0SgnIz/cIeY7/U9bAWnIZr44CQaWxIRCLFWvfGJQg4qCOiWO0PxXGCDcpssJOJQSOlrpRjZlElDYEfHh7JDbLDJiifD6k/HMdIRVgNLobEvDQ2In39CSzSL23ffzzya3nH02npZzBGCqlH/QKzGFGFLcJOA3dWmbWwQxnOXqUszm9tBoSBO8vcW6N6T5ALBqda+OnaQxh3lkhD4N8en/jtdMmrZgxBud48n8Efq754eKSVTG6Vr5YuhQ2qDNJzaGb5WlrrbLR/pqUBGBIbO+9Sm9iMvoMFEvCuFSYVvj/vz1JD4eVmw2sCzZxZjBVjMWMzRvZrRVoPXnN1cmiYOv/+7oG/fHHFfp8Bx8/JwG21LjnX7hHZWGCD8K6tZCrj2V/i6jSpfG+6xAN8qIX3VphxtgQ0wVNu/OGyoCJcS2QYE/+vuwf+5icvCcEZgdvxl5zD/+a4Mgz9En/q6ndwWKtRmyMI06DshsTJlblU1uKoBTQ1CsZQE9dDYieJU6s8ee4oLuBYjWp9k7pOkdeho7furdJcQOHSI1KctXtvOWnjJJVE5CFX9HDgaen6rl0QPiFwh7FaIKhh3mgIW1HeW998XLrvoLqx9ciLq871HwfjMiizNE4mXPnKqpXShFiFi9KDSQ7BeZorL0JjGLoP4bk+Tt0tC+MmMo6RuVbq6gSUdWmI9fHcZQiMY2Cly8OWYsQYmUy6JKwFrtKARuXohbflSByVQYVT7ZtKjMJFGHkRB3SEL8tMdVBRrlQh9JCk5k4JTlGQoCym/Pg0825dCQ0uUuR1itxTuzTMpK9lgY1G9lYI9Gj7JkJ1IRHYJsElEcOOxRqzOQeBJUSeqGTv4+7LpjiRrM77UrgYIrugNH42QsBz/Xz17nhCo+DBuZeVNRsRWAVqtT4ejoHtMFKy8eRGdScgJO1m7WRwGRPVhWMQZl8xGrV2mlOxbhy/nUY+CwkDHlhZWg99QWDVnqgsdM31oo7S+PK4wGI8rpVEn269IHKqjgVnI4o5FHMmjWTJiAi4UNwxqYyeeLkdwStJN1y1xMErswUuzhQf09bXXwmoK8cI75fCNioj9Entc/2J191pIURHA8xeqaWvl7UVvPW1eDEEdnFkf1o45b7+UoCTFRYgNmUTB6JERI08NLBGtq7bbwhDCFwOkc+GibZRHuqMV2c0gSgsXnALOEKLRlEA5908I83YzwU1YxThBYGqSqYwnbv4prBVpdLOyeB08646U3NeXm4xM5JHdl45urFUuCx6zouopKpsVgE1jpK5mxe2MrEV7VK75/oo9ZPDHgVigBIa0vrQ8LhUvDUuVLjYjhCEO1/Zl4LRc5EeamV1Z5TIZVKSBxaMo2Ym6RCDueYuXTznL3xnHFBR3uSFU2kUOg8/p057AqjSm3+Lw7vDQizC/VzAnU1QrjWwtkY98/1L6I/mjSZWrVQzrkgE7XkTZs7r7YbgxjYpW+uyNaqwLVv2Xji0ysaVixJoUimj8/Y4M4qwSYnyM+6Bv7AX/tUNbZ3QMKAMEjjS2fWCkIL0joIIFThpTyxNTZhLT/80r1gNaD+3SBYIOOZOqZXaW2SIV444G4mcilH8bKg059YTiFLVCd6I3hhUcRNKcbZBaOYsZuw0EN04ta/Z0+eo+RDYmxIqpCDdMY6yrUIwAzOSeg+GMGHQCENH4rk4EWEADOFA5e268GIcCKqU8rzbfKyarSK147LGENmkwMHPfOgG5o6pgQkH6XIYtHdc51oIKgwWObVKdMXcSVVIqtRirLVvKCgs5uy9spXAaj15OUr3qtwyUASatY71RIgYVp0szuUYqdWoOBchMuCs5owhnD0mcBWV4xpIoowSMXGaBy5RRlUQaCgrXYcbUCbtATcNiA5DhaLQ1HibMy/GgSjaU6Kf60+8mkFsQlQ9J4cP7EumtG4kVOlNEBRshKV5J4u4EWsjSP9cZ3NEBBVl1NhJJq4Eg/Xc0VRplJgQEebFWYthrojDjY4Eenq44iTzHrZUoIpxOXQTXDbYpYHqjTUUNhIQ6WGBG4XrOvTkXel6bHdjEiHiqAhTUmaEsAqTK1NIHKVRMZIqmxDJONWNN3nlRYsMIdKe35sfpWoDREgoW1U248RqlWKFcP7MzI3mhqdArdYnTM2QXNEobKt178d5qY4kokNr5zUgTqPT9qoEmjin3Fhr6y6mcxigSNc8g5Bcen++OlU7JSrXnpq7TUNHMwpMdGPwKMpVVO5qZCQwkXARmvcApqCBCGRT1AQqDE1ImnDvkuFBOxnv5I1q8G5ZuZ4S0fre+1wfp2qFTRTGEFANmAlzazRztHNOaN6pdOMUWfLKWjuOOlmn1IkZB7futQRoHUWtKRCskb0DVooZpgpRsLXf6+ycY7PTSEtONSOGvpdma3iFGp2rKbLURm7ObQhkbTjGRgO70PHFuxS5bonkcOEDan0NjuIMqiQXCsbRGrEYVEEs4AE8GlPracFH62vwy+PC1TgQQn9g/Cz1C3vhh/OBh54PhYEjK0trDBqIKNk70eZojZM6o/Y/UGlOAvZe8dwYgzCJcmkJx9h7odZGEaE5nMxwLex0w8Paef5JhQRsGZEYWcWYrDP7RxGiKAOBmzGwr4WnUhBNBIdcChEliBJD7/BfE8mld8Im6bHxzY2nZSVK6yFGrbEUZ4oBonJjI00qxI7Ey6GPrB5qZ2dv1J4v/B+xsjvUymiBKQ1cpoFDKWdEoWBmHKyRi/CkDQ3+jTY0n3MXTq1yrJlROvf5ShM0+n/XGuVsKMteKVQuPLLU/rgznGTCBsXOablq/S0YzRA3hkG43Y49+rs0NAUmdY7V0PMYPEp/mN6QGCSgzpkkFVA1Zmud/y+Ndy1zLLXrUtV5KQMWHJNOGcih6/6Pufa4eo09lOS5/sQrEHATogiXIbGLE8eSyefLvuMUc6RlyqBU7z4hmpHXyjQmqgoP1hjPEsKdRpLB0R23bgJfzai18SYqIsJTad04iTO4cBlGikJu3hN5XUjaE6J3KXI7TjzmwmMuDOPARgp7qwwqDBIZJbCJxusycMGAnPcxMeckK4e8MMVO0bi3wr41LlqAKNzGgezd4DmN8fyQdh5L5tg2XJjTnm/8H6VUtF9wRLiWgbDd8tXy0NeG9fDKbEY1qClgrrRmtGrgjaSB3JynOvcHmwY25yvHwQV3p9FoblipfBgquRb2ubK0hguMBK5CokiXOIrD0JSgytYjO41cj4mnXLjPmTBExDpEYZDA6L3LuhPlpQ1cyoCrdtCxO6aNx1bZeGPfCve5cMyNC4lYgpc+0kIjqBOAY3Wiw6FWlmbU6NSfkYH+XD9/DRIQusz6kgE08EXdn3NGYDFjrpmUAnFUoilWjWZnWYZCLs6xFsYQGDUwOCTAVKB1GErGMau8rxXDObXGqRkNY2PCVgZO0SjWCBq6lLc5I4FtiLzYJe7Xwt1SGIdIqA2hsdHAJIGNKGMSviVjP88RvElXCkzOoRY2CHuMx9I4ro3JIkWNF2kgDE7oGXIcWseO3q+ZQ6nsUqT8sl/4DWjqLN4oDTamWPCu1xIAp4iAGbkZI4J2OSpJIUXhuDiKES1gQZFJERTLmbWcEwEFBhXuSuUuHwg4wQLWINPIgxC0X+7MhUAnDOjQD6Fa+yEbRZhUuG6Rd3SyQEVozTlp5UIj99Kd5WsVjup8iCvr0rgZAl+VzMH7JfGiKd7gRUgonZqxAm/NeWWBISkJx1ohP282H63yGY/azFkXPzPD+/QIetiQuxNCZDhLIGrthJ2LEEgaebTcD8Fg+ODsxnD+4rWPtFtnko8a2efC45LZpIi64qYgyhoWrCmrFZzOXm/WJw9RBAzEIIgypkjUwF3NmBtW+4VOUmQbYG2N0tUeFDUOsfJ0zLxm4AtZ2VNJBK69M7N36fyKlr4xzi3zSgYsBIYzQu95DX6cylaxCKsogcBVDF1E2vrl2xqAMJpTi+CtywiDCJHEFmFGaDRW6FrS4NQASys8lIVq50mkw5vTwtIKN+OEJqHWngCxhMqxQaF1nOHXGOLUA7TMKmb9NNpMStDA40kwcxavFHEmT2xbprBgqogoBfixLtS18Ekd+ENbeDhPUC/aiDXjJk0QG+KNVoy31nidxnMzqIcr1vLMQf8YtVqB1HlhD1ReeO94GkIpFWsdia3i5LXi6hj9oiXWGFGqQjljsUWEMTgQyHXlqRQ4I6ujwJ3NPJ4q29AzS5qdL3XBOOL/ZWPBOro4AsUq1RrRlV2IpAmOa8Po94elNtyEsQmHofRd3QVXOMbGw/6O18PE2zpz9EoMyogiTdilLqUVDBOI3rgaIs2MwUBaoz5rej5azdYwjMUF1ciVdtRqMadYX4Mq3buZsyMu3zRTzSqRiFnPEkH6vzsGx+l5Oo+tkJuhAKq8K5nDXLgZEoIiBSYPZDeK9gm+eUWad1lQCAxAKU4phrozDpGbZrTmmAlrM+bWuJHApcGSYHHrCdJKf0gsT7wk8UNbeaCRojLlCMF7+rh2mfnsRl0WLiUBRjwHzrVf9uAtAZbY2fcJUGkkhX496na0IBASpJAouaBBmeLANowsFEbgQCW7MaryvW1HWJ5yQlJj8J50tj0bhArwQKZKJkh/ZNAghEJGOEmhamNnA4XuuM7mLObMOIs4ry62/CivVOsLzNS5yzAMEd2NSG2cWmG2wo7AWyq1RITIti8xZroB5a1lVstchsTLzYZdyfzWZkuMAVPnBJz82TD0sWpAyHLm25shCKrhvPp6bEsKkTQIE4lyDr6amjKZ0qhsEN6nxsn7Z/qXLy8A+LdvC3jr0hkSVzbSMGpT7nzF1IiibGpiyMqohjdhDkYLzk4CM5nvph2rGQdvzA5zrrzajLSlUt0x7Tiwp1xJQ2QJxkUIVG8crD+U37RCDjAQeHk2U85WuUiRL8vMsRk3aeTbu4lpyfzG5uKbnWP2ysmfL/wfs5ZS+TIX7siAoQ0ux5EU+s9+wwjATOEcGorGxqzOUAIPmqk0XofEb11eAfC7H+47d9yFCw/chC7VekB5rJ0RHRGmoOTciBqogAmYCNIMBuVmOzIXY6bLvUSEq8sNp/lI9S6/aVbZ15XBegbJtkXWUNhrZcrC77HwNPTx9YUr6l26eJEjX9QDp9DZ7p+mgViMv7rtP0OocjJ/3gM/UvU5tLHWwuG08sQMmggCUxrQ4ayVPfcwDi2jsfuT0tcQ8ZPzNFVcYZcCf+WyI1T/zYf1m+DBCwI3EkAj46i8ywtra0SEbeoA7qsQ2VvFFIJCLF0KlIZErY3FnCUYOVSuNlt+kA/n9ddRrnNH8LMshYthpAicWmWrgS9axXMP2bwkAcKhOS9Qvt9OZG28SAOfxYkYK7++Oa+/EDmaPe9/H7G09T3lVBuPec9QlJSUJDDGBLGDFjUJqsI+NyQFBgu01v0/myB8FTMV47vDxG9f3gLw/3j/wGKFKIFLItdoT1qOicfaWFrfV0dz6rlbP9Pxx+4NxWgW2AxdRta9Bkoz5/Z64KunlWadwrdU47AUggmNzKiRUzT2UrhtA/+2HPhct4xBuRVFBEpqXKeRn6wnanVuxsTLlJAZfuflbTepD4EV5/gzWjl/YS/86sqVDb3DROVeK2Mc2Srgjrudk/oirrCmiZiU63HkV8YLtCn/snzJrQ9EV1IN3B2NFztlCJFb3TJbplrrr0cXblokqvOklQZcWKLgzFZBhdjh5QTgVOAHdeXkBRcHVf5TW5lm4//8698hBeXd8cQX+wNWIAYjF3gQR2LggkAMgV/ZbLiywPU0MARYSuH3TwuYMZfC3hurQSTwXR1Zgfs29w3P4FCeN5uPVYJwS8QFZu1dpp7CGLr58IwuHC1SyCwZRlVe7EZ+Y9oB8H/PH3hVUsdwFeGNN17fTLjDrUYWN7Jn3mshIezyQAqwp2LmXNANwQ9mjKnr//1sSmpN+E/HmUKXfLkIb2Vheyf87e99zqDKm9PMF08nhirEEHhsKwczDGUTEiqN/+b6kpsGL6eRFAMHM/5gP2NmZ1pL46Fltip8Nw6sVrnPfXLm1Zjzc9Lpx6jRlLH1Df1wznkswJiEZkZtXba1nQawilhgFyPfmka+O420CP/m8ZGLpac5byocNfNyNzBk5YbIUSqPXlhwXsSB69lowKM4TcAtULQ/JiK9My/uBI0cG/yHw9zj401QCfze4cTYhP/br3+PFJQfP+754f0TlxqQAo/zylM1rAkXITKGxHd3F7wS4fVuYhcCZW38+/d7BGW1Pu7O1thOwl/bXdCac7CGlUq1nur7XH/yZWVlY5FAz/NY+t8kwrmT3y/slyFypPX9ahj4bDfx7TRgBv92fc/rIlgDXRtfkrm+3ODATYycWuPJG1mFXamkQ2UUZw1Qg4D0JPBDW4gSaAbZnFGVgzR+/3gAb11Ci/KTw0Ik8z/9yq8Sg/Lm7okv7x7YjII252lJPJRKxhhDn6z+jd0FVwKvdhumEDkV5/cfH9AWmFqfEDx5x83+etqwz5WZjKwKJuRnWe1Hq0kbWwlkDzwGYYjCfu7wiX4P7Gfhi7jhbl3Yl8xNGvnuZsOvDQkLgX/9cM+vkKjFiA2+GjKfXe0IqlwPiaU1jhQsBXYeKfuMq9GSYUEo5z34oc7siEQJSFCa9FDX//3xkaBy9mDCh/WJSZS//Vc/J0Xlhx/2/OG7R65ioDXhYWmcaiGKcqNd4vPf7265lchnF1s2Q+RUGr/79gEKbCXyYIXHXBmS8NvbHWup3LdMqqAKJf9sN/5f2As/rn08o4qEPl6JdPMa3p3NzY1T7cjBKUaG2J3WWxGqF7YIzbuB1lGyOXdzZbbGRYgkiazafQKHXCHBCSOfY7drDASH6hUh9NQ0jBb7KO9enRQDSQNNYPaCmPCDD0+8GAdU4PUw4TTMK+8oXWbhHdV0EuPTYcJLTzNNCFWlp5sSuiPdvctIXBhiADP21sAMdbpB6bk+SmnokpqIsgvS05CLERWaGA2nIhxKD2vZJmUTA5sUidJlYLeWaGJYgCbC7M7b08xs8GIcSM04WUMjLKsT1Zi9UeiPvK+PkoCgAoMoX/czHTh6NzSKOEWM1RpjDfze23teb0aSBL41bvBgrF4ItcuSTM5Jkup8PmzwUhANiASCOIsVFD3rZfuItNAYZKC1xmyF3PSMSfvZkGDP9fNVVe9UMYfkgmlHHdq5cwndDFnNOFG5GCLbGJiSshsCtRm3DBzkvO/UxjE3Vl350BZepJGoyrFlAvC0OqkaD7Fyko4CRkHNu4RBesYEKt1AKw1rwifDREA4tsaxFlSE3/3qA693G9Scz8exc/fVmGvXbps50oSsje9trglr7YZOUXLoKOYBJ5kSv46nB8bY8cnvS+kGZbrp97n+5Ktq1zYL3bNW3djYQJE+PXT6ZWPvxmKNXYpcpsA2CpN2qd+LMHBXM82dek5pnucj97XyyTiRVDh5ZYjOXBpaG4ehn8GD01ss1uepQ1T0zFFP2pOfZ3deDRMRYa3GSgUz/tOb97zeTAQzPtluSOJIWDk2wZrhZhjCicZf24y0tRBNCCEQpLGvhW0U4gpRBBenYkhQ3Jyn2qU8EemZAM/1UepoZ5Q5PeRtkfPdiD55b3TZ17FkDqVxMwy8GAauU2SbAsfmvJDA3VKwalxE4TQ3fsiRu1J4PSTWoCxupBg4zY1msCZnlQ7I6NlPygWRjXQiTqmVjSaqGlWUz8YRbXAqhSy9If2//egd377coe58tpsYXfFWOebcf+8OwZRZjb+6u4LZSAgjQnHhsWauhkD6Zg1CNWeMgdIaj6URazeU9zjp/3r9wl741XuYjLsTVUh0dJLR9ceVTqRQh1GU4cx73iKIG2aN25B4tELDcbWe+uj9Ej2cdfY4iPcArqKAhzMFRYkpEgxEz7HeEtAQ8Ng3QVdHYr8UisPGI5Mo7+cZ98btOHKTRhqFt3Mm06hmVHriLu6M3hGJYr1D697d3yEoXRXbST0iMET4kAtLaxTvWnHa82H3sUpdyD10mYH+IAPFzv+r9LW4WO3jvChsQ2ASxczJzbgNA+9YcIEQhDh0LGuwjsRsQTqhSfvaXKX3zhTp3ODQL9TR+qEDnCO35Zsem4Z+KwwGOxNGidzNK0Hg1ThylRItBO5OC0vrWsQqfYLhKKML5fx7bvq1GbQxhEg5/3566q8zROXtunJqldX71wj2vAY/RjURVul73ODCet63ikATp5mf95Kuqx5U2Wpg0gDSu023MbEvhar96znCoVTEO8hAgmISMHdOpZOeGp168fXDUs/EkyB97X9ttgwKVjgHxXSqy/YcyvbmeERwXo0Dt+OAGLyfT1gUpHWjup0P8gvtJAql//7aWd8fA9TSJw2xD9RIg/KwZI61dE21/BEu77n+ZKtPlAw5+x+NTutqKiAdE2zn89NpDNIDK0cX3Po6uUwDH2oBIKoSo5KtklzYiCIxnJtW/o1R3L0nzwe+TpuAQeSb5oKL9N8QTjPBVTAH007aGwXuTzPBjRfjwM1mRMx4d1ooYn3/7H5NBJiAfJZz9N+3kaszRe8T2NCNy4IxJGW/LmRzijtN+kPmuT5OFTdm7zCMCJyssWPAxKliNPfeeGtO9sYLHbgKga2ekazm3ITAV6w0cXY9rpnZGoMHLjQyiPbMJ+9ntkvfT3FB6Nr54MqFCaJ9vYkqiR64Wc9NkObWpWshog5vDzMJ4eVm4OVmRAzenlZaOJvozk1rtMvayrm504yO4D6bdGdvrGqogogzjZHHY2a2fgeM1psoP0v9XOLHf/SP/hEi8l/89Vu/9Vvf/PNlWfj7f//v8/LlSy4uLvh7f+/v8ebNm5/nl/ij35h0fnN2w7z/cEcVqhvZKyu1Y5FwXARVmEQYHVrrsdjdOBkQFSRCGJwWIUn/xiHSkWDd/UYWGCSxkZGNjlykgc04cJ0mLkJgGyPDEIkhwhAZ48CYlBhgQHkpI1eaMJzVDcTZRGUcIvfWmM/4p4rRpIcneWmEcwcL7xd+8U5WWYPjsaPLCoYG511ZmWvl1Cr7Vngs+f+n7+8vY/1prj8AaVBa716treJnY2KmseLnB+l5vH3GsA4ujGeCT3VnSIJER6KTBmE7KRKVCUFceldeGtX6hXqmMUgn84yqjCkwptjzJEJgioEhBkI8o2JV+mQrRq514LWPXISBFDqCrD8UhXFQ7lrj4JVFnKx9wxwsUs4XQHdwc85LlyjCSRtV+rHrZ63k+5o51UpplWyV/fMa/Oaf/4muQVWq9Es93qki0j2PoIJJD+Vr3vNHhI5t6+uvX9zH2A8pi4IPShwUF7iWRJLeoe2EQ+98flFGj2w9MKEMoowaeD1M7FJkCArirLUi5qg5RRpZG6rO65i41oDS6SXqznboWRbvSmNVcO2GyardJyDViKETgkwEFyVJJIYuJVmj00JfyykKdyWTS6U1o1hlX5/X39f1J3oGn9dWsX6hag2cTs9x5dxx7NhDce/hVwbhbLZtCBoCIQlxFIaNst0EggrXYeifvfYHxFytN8OCs5HA5hyOFR0Szk08PyYkkFTpZFojuPWJpUJS5YVGLmIgBqFKD7ncjZFpTLwtX+vt+8Oy0qf7nmuXq5lj1jBvROt+ur1UjtrI0iV1Y+op6u18wSoO+79Apt0/7TPYxVi89fuUdT9GlN6EdaVf/DGELnVVYJROWCzWmyIxBIYxMIxKmgLDFAlReRkGJuk0RROYSydGNXUiyuid8hRciBK4lcRGAtuQuBhGxhTYhMggTjubulMIvEiJq5R6J95ab2qkxGZMfGiNWUHOj+ZCQxHkrPLAhWpOtT7dTCY8SOUpVFZtuDjDEHmyDv2YzXhqjYefUVb2c3f4f+d3fod/8S/+xR99gfhHX+If/sN/yD//5/+cf/bP/hnX19f8g3/wD/i7f/fv8i//5b/8eX8ZVLop19yZW8NiYAidwVq9QYXQhGEQcmts0d6FaH3UI5wNYkn7wRKNSZ3VGylBCM7eVj5QGK17BkCIMfSOrmp36APfDQMrxr13dOap0YO9gM/jhkmlRyIXpUOdMlchMOLUtmDuLKacTKlRMTHEhOCBNRfGGPoL0fqfbQwjI52igkjn71tl3yp3daFVQdUR6aPxv0j1p7X+oD+0vpZMPFljDEoKyoku51GEwZ0xRE6lcj0EghnuDY/9wv7WDgyxM6RLMmqqLA5M4Fp5bCvvaubSEqMELDhD6qzO5MqtjwB8a3tGymI8YDy6UY6ZKTa+M2y5PEfEz0vjeE7ofRFGNkRqO0+4qMyhdOSn9zbXBKy5Mo4JvHdpswkTkZFGpSLScFVmjH3LHM/aflU5H51/sWbaf2pr8GycNW0cxTBTMsah9QRyFzpPv8HSQIfeI3frUfAGvFsWhnSeB8UKYyNnY9Lerf/gmTd1hdmZUEYVdiH1x6D0Q1GA715OzGK8W1feLguHUllKN/V+Pk1sVCmpUVsnT91IJ2p0THIDUU7AQ1lBlaJ+PgwjLTfi2OdnpRlLbQwa2RLJY5+uFhWe3Fky3JfS2ftn3vpfNA76n9r6cydon+DMdO55Dc7pzN7vjbjOK18NhqlPrWs12jDgVN6eFoaxT89rcNDC4o00BIo7H2rhbV3hBLvYL3GbOGJnAskr7YKtz7dbKnCfCx/WzMH6HHQXjM83iSkMlOK0UjhSuRwC1yExaejdTzcWGgdrqHdJZpU+r81LD7G081651MpkHb6Qo2FiHd/tPfH6WCqtaX8EuWN/wYLf/jTPYBPHXM4zdXAUT0Khk5+adMlzO0+UBglQhSyCJsWD8i5nLse+jjYpkDbCoRjjIFhwHqzvga04o/ZzcVBlVBgRbqX/+X7t5YZm8H6t3OUOuig43pxvXW3YhkitvXl3XAu7FLgeRkbt8koXYWn9LmACWXty+WTGWirjkPoeX5xSKlvrU629ds9JIpK1k/aWZnjhDFLoyOyfpX7uC3+Mkc8+++z/6+8/Pj7yj//xP+af/tN/yt/5O38HgH/yT/4Jv/3bv82/+lf/ir/1t/7Wz/XrDGNiiLF3y6UiAX5ns+XHi/NYViw6YwoczVCrvPIBx/hxzbzLKzchccKYEHI1lqXxQ8tcbi54HUYOzWgEkhglNVI2rMHFtmv992vmfj0C8OriBoJSauVUV3Jw/i+Xr6Bfy1FtSDRygmWF3XZki7KUyg8Ohbt1YdDARefpgQsBZ2amhYHVnCWvpBgJMXHhyqEYmxUKiSEm4hj5ojUeAaMR6bIQKz/vJ/jLXX9a6w/gUgaaKk0bogGLyn97fcuPTycea6ac5WZ5hW1QXg0bgghflspXhyOXY+QJ48oSS638f9j7s1jdtuyuE/yNMedca33N7k5zu2jdAMZQmCyTYayCLEoJOCkJhOABgaqMEOUihUEqQikSpBKBlQ8uVUkkL0lCPqB8SiVQKkqFkKiSLBJECgrSQJYdDocjbjS3PeeeZjdft9aac45RD/O719hBQET4nBs34u5/6Nwbd59z9v72t8aezRj/5vFh5is3M3f7BXdK5BETBWelkRyBuWK07kRxZ19nLst4HEueskiRvWUe2sRM5cfOX2CmMdN6FUIKHKIQqrM66g72eeKrm5Gn5iw0Egrc4E2bEOCaTGVBPdp3pqQMCdbANsMwDXSx0HUwpMhD4LJkYg3E5m9H+ZCJ1t6vGlwUQVIThw0CoVd+49kFD/YzT8rMvhYQJwQ4DcL3LgYQeCdP/Nz1ltOQuCKTxrahPLaJr7Lnohu4G5S3pokdTtSADIbOwj5U7g0BKXA9TrxzOKBJeXF9n16UiFBQLAq/985dAEIXSAFUE1OBp9OO5WJgFTpuxsKXH11xkzNnXYcQuZkyK4EYOja1UKkcZmBuOqWVBtazcx1mLoisCXSqDCnyNjNvbCcWqWUBBBTLH66mx/tVf8HfdSKDdVREIt9/fs7j/chNbvU3WeuG302BF7sFLsbb+cA711echp6NGv0kZHNufOYBEyeh41zhoU3sKfRA7CFnw1RYBsOrc12dJ3XPFAr3qjKEHlFnjkYV+O3rO7/8nqDEQfABwtRoFedhYDcXPv9kz27KnGtPj3JtFVVlULgkUxCohTFXUgr0ARbuXG9HVklZec8QlUVSHpWRt29m+giqEaX5vn+Y8H7uwXe8x5RG7aZNLL/n3l0ebjZcMnKThYMBwbhDx/cMPebOW/OeB7uZZUqMOHcnmIC3x8JXr684S4kzEx7mzFOpFBdWKmQzZuCsazTHm1p4028wnI94YtBIDE45NmF+7PT8uAcHYhTCIlErXA/Cy3HBKkQ2h5lferLl6Vibg5UJN7UQFE5VuWQ+Ni0yJjMpRPoQeflkwcP9xJlGtAh9UAThK5sDX5kODDQrbo6slm/o2X2zD+ALX/gCr7zyCsMw8KM/+qP89E//NB//+Mf52Z/9WXLO/O7f/bvf+7M/8AM/wMc//nH+6T/9p1/3YU/TxDT9so/yzc0NACpthttcAHqCGpHMyoRKZBZrFnBJoA5cTcZOKwcqgRb/TW0powuBRGAW4aVOmGZjrDObOrKpmQTUEOkrXB/mRm2gcUqh8OphxyIpV5a5qoWFJQ5zpuuMJ+VAyd4CHwS2NXOVjWBtRJlrE5YNVBZAMWVfK7NX+hR4Ox8QQKKwdGdRIGSjMhIJVCo7O7ApcFE67rDEKIwlU90aj/9DhGddf/D1a3BspE6SC6ehA9oPzAUJEdh7oeZKiBEoXM6ZjDFhaBDmauSpMB59x5eAFeOVhfAURwhkK+y8EBBGhWVWNtXayM/BimJkXp1HFlW5lMqVVFYpcMDogvJknJp9bYi4B26YeJQzASGXxo1dEaCrdAEGE8ZamcwYkvKOjYiBRaG3xGIMR6c9J3bgBA5euMp77s0dCwIYVK98yJr7wPu3BpYCjpGicNIPRDVWMXBn6NADXBVnYzMhQkqRx4eZPcbOWnz7QSemQ+FdA4dOhA7hI13k6W5icNhKYVsLXVV2AjHDmxjBmwNVEmFb4fO7DasUuczGtRXiAipOH+HpYaTQ+NXicDXPXFZj0JntVLgeMyekZnEXWpjSZMZkTofy+u7o8jQkFiQGD8ekcZqWyYx9qYyHlmx5qgmbMzMZ5EiH/BDh/ao/K60JtkqRO31HpnIaAtZ3RFoOwsYhJSFE5cl+5EBh31Rz7L1wyJlmsNk4+b0o94fAZl9ZeGAnlQ2VVBrFawAeThPiTawdVThU+PxuxyoVtmZce2XolUM1ug5u9hmzlmIvwbnJmRsqj2PhkI1tnjlBAWt6KJq1opmzVuWr46btwV1kSWIxB7oOSm2HrFKcQzUOk1GKsBDw0uhNRaxZcH+I8H7uweB4hk4D530kBOckAMOAFrB5pFhhSJEEPNzObLywE4PQOPa7w0zJDu50QflI33Fv1fP60wMWWpLywQrFhE4TIRbemif06Onfo1xT+eI4sk4d17Vw5YWFKgecFIQn44hXSBrwGLicRzZUlqljNxeu55klgYW2k2VGGHFMhAsNvHZoa2C3CAzmdFNlsom9ZpxGk5upbEvmUAPnqoi1KZPxXpLmvxff1IH/R37kR/hv/9v/lt/wG34Db7/9Nj/1Uz/F7/ydv5Of//mf58GDB3Rdx/n5+a/4Oy+++CIPHjz4up/zp3/6p/mpn/qpr/l4EZDjWOUsKuvUIdm40MAiKHt39sWpoR22D1JQaWEI7jCVguPMx7FIdmdyx/YdQ1AMJ7oTvIke0LaBUd+NoW8nmaiB2YWxVHZHXnYJlV86XLEszYfXK4Tj5yje7BszlWKV4HDHekYqpymQEFRaWt/LXeJJbi36IIFRhKVCkjbOnLW9nr4I0RRX6LvAXionngguzPOHx5bzedQffP0anDECwkIjJ8OSVdfEaMukhJBYZGVTMjNGNKFEI2oAV7xmDjmDQaGiNKH5rMa+OHdiZHKYPJKtLUb1mIBkpVGJGlVGWGuiqrDFmas3tqLCL+62dEk5FCegdNWBQqHV+57axtbanIZGK9yJHaU6E82J6qNp4OGRgy8OgzhVEr20C4dEpxRHsjDkwCzOEJXRK2sN9NzW4PNaA2cKoSpd7DjrehZdE7mepEAkERVkFHoV1Jr/cwgwaONhHMaWTeLFjiLFphHZzYXzRU+plX1xtvVIb0ggU5uIGkJyQV1ZibAtLel0UwvZjVQjv7DfsOiEaW61oiLU4mSDG8/cRCVjeGyj8ZYBEZlrZV9aUuv3pgUPx7bZyVTpc2luGCp0GcbUBGlaBZmdq5JZ9oF9Nc5N6Fw45A9Ph/X9rD+pTWg7SGTdd6TU9D2rEAmDNO5zgS4Ybk1cHVTbmlAq81zoo2LHQ0nFqQ67apz2C9wLuTq5GJMXCIKVRutSQLw54ixFOKhTamZfjWxG0o5frDcsqlJn0KZ9PDpYGYdo7F2OB6J2lphD5kQjubR0cYCP9wve2LZJvrmx8MoZkVWndDgzR71CNXyEmzizWvTsS2HtQnRh+yFyynu/92CjGQh0IXCyHFgnJ5lxGhVZ9WgQ9HBoxhTF2FmmqNBpQKVRY5K0tcvwZpjhwjInLpYDxazp8NwZqSBGT+BgM360esWcUwL7ClWbg9OUK10IfHa/Y9EH5gIUR8gwt0nBlkpWY3rXVU2MHOCkSxxmY7SMB+cT3Yq3jk2POmd6y5xYZDkoqoGE4QZTdQ77Rm26t+g4lMq5RiKwLc/hwP/7ft/ve+///5bf8lv4kR/5ET7xiU/wt//232axWHwzn+o9/MW/+Bf59Kc//d5/39zc8LGPfYxiFbMmHOykjXkRo4/KtmT2pXIwqNmbLZsem421cT4nheEofgg0x5+NZ57kkTvat8jwKixrs9ucFAjQh4CLNMERTdw7Y42XeBRmok08e+FHTpm1g775LzsKvMuTFnPMrR2mQqRX4azryG5kN/ZBiLV9rWJG8coLvfICiVensb1OAkkSReA0dkBt3RdvTkUfFjyP+oOvX4NTbW5JC2ndy0VQqEYXhJu5cD1l9rVyjGdo9oVH46Rqxt6tdcO9hYeAMwbn2irrFHFzeg2sjSMn1poKPwhV2qVXawvhmKV97uJOaOd63q4TZxZRjZg0hwk9qjAHSai3eG+kfX4RZQhtJLnyQBbjYIUNlVDkyNctuMD9PnCOsCkTB69Qm1PCIVQ+Gnuu4kzw5hQ0fYharO/nGri3TNLIEiMJLDS2LhVwfYx+zwhqgtFC39yc6pVsxqEYSSPmrbPvCBuvXNfMydBR3VhK5I42W9ksLaAwSuPGOmDWulwHcyhtzVLapfTNMnKvJNQjTlvn/BiCpVWp3tzFYlBmN3Bh1UU6i5x0zmjGmI3rUAlViKWFH5o4p8uOF4PwxTxxoDbBrgn7anxiSIQJxNthbpYPz4Xzfa0/NwZpQsGoyio0Q4kkyk2d2ZbChB1tLiu9RPQoLneE7E5/dEoJrs0JLxhbMy6SMBssXbnQxDY0fUongoajy7+DHc0DJnemmpu5gQu5VB6GzJ0pkTi6qVSO0x4hVKhWwZu700TT9fVd4F4U1p6YaK4vG20NG6nt4qLinPQLXhDhy5uZvVfMnVCEjPHCckCOttjVId+uf89tD97UQtLAOsAiNBc887YfH6yyqc0Gc6wtubZPbb/NNJrGaEYQOXbJm0B3xLnMhRe7xFSdZQlkD22iGSIdsNBfNr0oNJe+fW0MklxrY3NQ2eXCHTrU9F3jKGIUCEqYjZKbJVkKR8chEy4WgZek55TEpE2jen0U74YKeFvLT1LPR1LgKzcH9lLbWa/CHJ2T0LJ92tyKRkv7BvBrsuU8Pz/n1//6X88Xv/hFfs/v+T3M88zV1dWvuOE9fPjw38r3ehd939P3/dd8vNSKSSF5wEKkGmhsIsHLw8yDaaYGIcwKHVzEHivNVinT3pR1VbKV44YEeyk8tpHBIrtaWnR2bYelg1QIwip2VFGmo+tAqcboGbFm06gIWmByxUsgavPFzscDfwAGFYIp2doGXKgsCPRELvqeEJSbWvns/gZPARVtIiJzXB064W5IfGHak49OA5YCBpzHRLWJJ7Wwr5XiHy7+9L+JZ1F/8O+uwaxts8h1ptSOnnaxfDKOvLY/4EFYSocmWFUle9sEi7SD8Jm25xa8uapUqewxNhQOYo2yRmTW5j6FGKvYkYMzqiFFmxuOO25yXIQEqjEfJ1L9uxZk7iTVZl/ocvwF2StTNYYQWjZETMQgXHvlf765bt2HrHjX6BOuhfOu4yII87UxHy1gHWHCOCORtXKTKzuMg354Oly/Gs9zDTxYZVZYecBqRl3xY+Lzk3HmrXGmamAwo2Dc1XR0lSpMUhjdjvTAlumg4ty4sKcJY0czOg/c00iOxqM6s4jCKghTMEas0Yrq0XWsVoSWjVKqMWNc5I4Y2jQsU+mSEEUIJTKVjKiiQdi50dWWGXE/RlSVy2r8T/tLZnU6a4dJd2NSKEF5aVDyo8z+mDqtx7Tfc41gzhMrbCjs9cNz4P/VeJ71d0OmqLOW2oSpHjg6EHI5Trw9HpgEutwCCV88XkgrRtVjjkRu1pmdtUNaicLsTq2ZvWUiwkXs6dS48ZkUlXVoDbTJWjffjmtbKQWVRtOYrTCn4yE/NBEkNPczFSUYTNYmW6LCSEVN8Ki8oImkkata+dmrJ40eTCDSphRjMGqn3EuB8aqypyAISdolduVKOWoB9hh7vd2Dn9cefJVnFn3iXCNqFbxpmgR4cBj56n6HqTC6oQQ+OQxILcylUN3Z46xp57bBI8ma5e/WjXu1MokR3FlbQCWgKUKpnMeeqo2em4/1P9ZMNiOgaFT2WtEKdfZ3b5qoKDFEggh6qMxzJRzd9CY3pqMX7MtdRwjKU6/8T9eXHNyIqqxFSRrQ2HKAXhiUL1zt2FERhSEKpGapXFy59sJenfEbvHR+U7acvxrb7ZZXX32Vl19+mR/+4R8mpcTP/MzPvPf7n//853nttdf40R/90W/6c6tX3CAXZ58ze694iEhQokTElVyt2R9mmKod440bTcfHipYm/plrJZszuLLIiVqVvbeI+BQiUZWRwk5bx+t+TNzvm5drr4pYwFUJUYlJKSIsusATmXmcZx7WkUeMHCokIttsjLV1IpSAWGRTheKAGpdl5I1xzwux49wSQYxMoWpBpKWYfnk7EYqw8mZR1npozoGJGyscJGOhEmP4tTzC72g8z/qDJlqLApXKjVX27kyqFFVcAqBUEyqOVQENhBjpYiSFcMxR4BiyYYQqnFhqQp59ZTsVylzRbE0tEipjqo3nGnpeTj3rrvFIvSrxKBKWqNQonMbI4zDxYDrw9rTnQTmwKW0cflMyNzkzFWtaFnOe5Mw+l+aJPs586WbLiyTOcvsZmKmUUJEIm9l5dTuiJpySOCXRo0QCl8xclsqGQlWjD7+mZeQ7Gs+zBos51QrVC4VmFzgGGvVBaHapwYBKQimW0WosCayCcqC09EevzLUyZ6dHGbSjTpm9FbJVNENfWzLqRp2TEHk5Lng5Ljgj0hskbXSiapAzuAnJIo915s184OE0cjlnDqMx1EjW5lcmVQg50HnicS5s5vZ9PTyMfOl6w0dDz1nuidJe76gFC/C0Gr9wc8BdOanK6miTqEHZZ9jkiU2dGL3wYc59e6578DEvYXZjZxOzZyZtejPR0CykOYopScymKIGlJnrVRkmldUldjhxqC/RVmOf27FCjx4mlGSuOCmcaebkbeHkYOImJREC10cu8Qs2GGSyqck3hyZh5OmWuamZTClRlPCZRuzU3tUVoJgn7mnF33jnsePXqkvs1sRyV5LDXyhgrosL1ofJLl1tEWtr6KQEiSITreWRTZzaWmaQS+w9vAT7vPdjMydU5mHFFxRUkdcQU0aO9L52zbKk1bAvgkYV0qIQ2ZT9qQWYxRjdiaW5ku3niUDJejVggzKDB0V6513W8kpa8HJecS0Lnls/USLZOcjjXjqTK3mrTjeTCLlfythLnRrEstZCPyeKDKu8wcz0VxlJ5c7vn809vuFc7Ti3Rm3AQ5xCOaeeHzM9f3iAhcEZkYUKmJQvvauZaC9chs48F+dq70r8V31SH/z/7z/4zfv/v//184hOf4K233uIzn/kMIQT+6B/9o5ydnfEn/+Sf5NOf/jR37tzh9PSUP/tn/yw/+qM/+i2psx0oWrh2p06VS62ECkkrmwJICxjadTN3aA49ropZZapTsw+bYa7CIMeQGYZWFCGDRIrAtjqzVRZETmuPJ6UiJI+cd8LD3YETBKd1Y5FASZVE5LpOdK2JQHChBnvvgTkwqNNL25zXGslJeH2eGUt9T1V9pnCZDdHWPRNP5Kpc5wO9BiASVYi0Lt7VDIME9h5IOHf69E2/t9+peD/rDyB2MEfYmcN+ZiwzEFkhTFTWiw4QntaRC5pOw03amBejQyg1I7QpTlRhwMhzwToouXX6r8UZZ2e1SKTa04emz+hq4KxLfLXuuDuDaRMLo22El4hczwX3JqALVahMPCVwTSZr5YTAmQSyGuckvAt8JU8cckWq0hN5uTMeVmMOlSjC4EKqsDFlodJoQmKUPFNqZVOh18RsjQ95h9safB412IwNhcuS+cpux/WY26Smi7wzt6lPJ86GFjI4I8ySGa1wOOoqLsvULI69BRcujq42T5MxWtOkVBuZs7FKgY5IpFl9nmrg7rrnC9fXnDQmKeU9uk/zvt7QQuesBVJQKLwzt65nNuNEnNMAOTofT2s8OV/dT2xrIQNU5b4qlxgTbR2NVahz5XounHZCKIumy5LCoU68gyG9Qm0r+h2N/OyzfMgfYLyf9ZdiM6LYWOXBVDg47OuBe5p4NB4YPdOhbHFeSIEJY/bWlc+5ggr5yK0HCNKclcwqj1TAWqe++syEsdaBzprVpxssQuR83fGl7ZaOwCjNLEAcahD6IGxqxczxauCVqoFrHZm1sC+FlUfOaXbZvyGc0Ru8vp/Z5YxVCGa8EiNPMUwDESW5wMG4xDmNPSE3C1mnUTg3qcBRoL5Auasd/+LZPuYPLN7vPbiPEQmwqZW3tjPVE5v5KRcqXOdMAbw41zhLhCsmCi0Eq9YC6ryemwHKWpSlKEkFJmHXt0P5zjOHUJgH5xVOWKrSdnZYxcjHV+d89umWQpuIBlE6bQ5WnSlbGl2W2uhtuyRUlHnhbHJlYYGVtXPlDwBdEH5hd+AmN6riaYCPROVhMTpp9CEvzn4uXFM5jx1myq4KOWQymRllGYVdbZTLe6HnX38D7+c3deB/4403+KN/9I/y5MkT7t+/z+/4Hb+Df/bP/hn3798H4L/8L/9LVJU//If/MNM08WM/9mP8tb/21765J3zEbC3F0RBmVVZzZNLCrhizGfkYSJMFILG3SvFMAFYhsQSWXaTuKxEl42yZmRReDj3RWzDHrJXJYFRjoHAvBdYxNR5iVSQ1/33RFsO99UKhcMcifYEgbcQjBGqFbTeybrFKuApFWnd+PgbhVHOsVGIx7mpkaxO5ttS3ZYycxICZMROZpTQ+LYJVZWjRg4gIQ2yCybMPbljyM8f7WX/QLp1SHfMWtHVaO3bJ2FtuQpyjEK0IJNqUaTyOlwcT7jFwJ0WYGgf0IM5BW8DRR8LAIQszxiiFnCpPydxBuL/qOI0RP2YAlACPw8jQBUYxbijsMV6kuU8ttHUfEMjB2XpmLc3hB1F2sfEXwVsqb22i4M6Fsz7xlJmpZjpTVtqx0oTjpNosyqI2N6iKsNAEoU0klh5ZopzKh6fD/37W4J1Vz3xMf9yOzlKMWQq1CqgRjoF8I5WLauzJTFbJ1g5Bd7VrK1E9cvgVNtUoYeajrBhwplDZRWfWwkHgHsL9kzUnKSHegrV0fcI7eUajcsiVTa5UhVMUs8QshRAcdWGvRq8tlTpoG79vEGIJ5AC1GKVWSjFE4c4QuM4zY80kb/SldQgUClphLhA5UnaqcxYSTcQinFvHAuX0QzTlfF/rb+gpKuTqbA+Z4Zhv9rTPlGNnv5oxHSl9sxkTLSyz1sopiXPRY7CkUMTYkpkqvKw9VGcSYRZaxgcT5yj3T045SS3/QdzxNbwzzaxF2BwnlyCcMjADB23CS1zYKvQYi2P9Gc6NFToiu1AYiMzmzLWl3d8ZhMtamXIhFGUpwioESoQ4Qj7adhYMMedUY9MXiHAeEusYWett/T2vPfjesCCL48dU5zAbVOHRVHER1ikyurO1mSU9SRX3lpC8q5ULTZzpgo62Jpk4N+qMOC8XpRTBPTCGpl97VPfcJfEDJxesUoe4gxW+/2zBW4dMF2HyysGBEEkZlNJMY7TpTbMWNLQLwdIjnp0byyRreRSntV1+pbFzuN9FHufMHI0FkZUHehX2Cxim2ChwOAisa2CYIuMCEOHUO5YWOI3fWNNN/BvN5H2fcHNzw9nZGf/r3/NDSGrOD4vQkY4JttUq25o5eD0mfyorIsUbdSIgLLUdglcEwty6ATupXNYDZylyEhdogV0tTLSEs0OonEnge4YVq9C6l4/mkTfrhFY4SwlzZ1czOyp3pUOiclNaImESJ5dKSJCKMlrrwkZVLlLiTBo/8Ok4UbPR0WLGb3yilKOTgDTnAw0wFdjFgqiyJHDmgfMQKQhXnhlEOA3Niuq/+b//j1xfX3N6evptfXbfLXivBn/3r8eOQrVeIwuNLeiiNreSPZWqRnC4Gzv2bkxH6sPCFEd4iZ5QnVmcGwqPbOQ8dlx0A7EI+1oYqYQIVdqt/ZP9wIkmZnNezwcelIxZ5sUwUICNZQ65cicOWIRDsffEaRXB1ehzo7y5KikGzjVw1nVUrVzum01ZJ5HUCdeesVp5V+gfRPAAVirb2NyCFq6cErgTO1yMp2Vm0MBpCEQz/pv/58/e1uAzwrv19/t+72/ERLAKyZTOAqJN0HhNZqeVHNth/uU4sPXMVCtuTjIIBFYFOgk4yk4rTzRzN0XW1tNV2Ehh1EqvkK11tL7vZM1JCoy18tpmz1OfmUV4IUYmM65LYcrOhfWkZeNzV2trdRHntFfSHDnUSpXmsHHeRS6GjtkKT3czc2mc1YUoTxnJ1ZpszbVdXmOjas7JCS7H9S7wUr9g9sL1nFmFdjEWN/7q/+Of39bfM8K79fe//b2/nnqsv/44IYJAFefaJjaeqQqrFLgXFmzKxOTNUSRaG0XeKxAkNnceLTyJM3c10RPp58aDztHpJbDXymmIfM9yzSomJjMeTAcel5Fsxp3UM1rlpjQbzrt0xAU8mTJzrmCOYaxTonfhkCsmLdvhokucds0R7XI7k4uhChqabWc1MGlrnYogKTDXyqQFXBhMOEW5Fztmha0569i1y6ZX/uv/18/d1t8zxLs1+J/8zu8la8uNWWtiYYEDhVKNG89sKIxirBTOdUmWFsh1NMWhU2U5OqvQLmUbqbwTCndSx0kRzi3x2DPXUlnHyFgKZzHxydMVq+Nl4sE88bgcmCvcTYnJjSurVISLqtALl3NpAl1rgYhnXSJkYVcL1YxelLvLjvPY1sDHu5l9bU2PdYUbzUw4IkctE44HmCY4Bt4wuHCuiRf6BZMUbibjPCXOUgQz/uv/92f/vTX4gW0Pa2yx20LjLVUq0bW54khzLoki9BoZRBhrOzC3PmajIWQE7QUJirigHpGoiDudC/OxQzuIotJi7He1EGkCiwc2sbFCj7A80jJCiESHWuGs65ikddQqLd5bTKjVcBTcMHNMldM+si9G55CPtp8mMHmzrDMaP3byI/PbAyZNDOUIQQMnGsgOO1rQ0hAE/WDd1767EI4R3tY8+S1UQhaqNYtDl5bVkGiHqtGMdLQnxJrmYk9pwu4AxZv1m8dGz1poJHqbAA0iVBFmqWyOYrbZWzjNzutxSnR03D1qhGYzLmJsnTUzsjSHKj2G4ajrsfNlQOA8Rg5mHESYQ7tcuja/90EDUiu5OtNxbh4c3LxxdRWGFDhPkVoqew30sekL3m3A3uLZQmITqkLrbo2xUV6K17YmOlCdLgR6DexqPnJMAXdMmtWrHLmu3n6DGI8WniidtGd7IqE5hwnMpVK1JZg/mCemWAnEo0NKe23mzsEy57FnI0pxo4iT1di6c2aBYO1rR5ReA3dj5KrAEAz1Nhk1adkkHa3+83HtlWogzdaz0upz1QfuDx1jCVSDPgYWKbaF8xbPHqE1ETAn+1GEe9TDzdjR/7t1ThPHZYZfFgaKOEWPOdzH+jN3NEhzvFOIx9pchHDcu71Ne6SJbh/NB/be0nGLGUGUPibGUtnnwv3YkebmslfEMW9rbqgBtXaGUNrXOY+JTS2sojKLYAozrf7SsYs/u1OPTj3Q7BTFm63nECJ3uo7R26W6D0IXpem3bvFcoApJW70cjuveVEtLd6axJlRavsNpiDyxir1rS3/cmiYxOgJy3GPt6B5WQqPXDKZMOAtVVNo88VAKUZpX/qPSHKkwZVajvlsb1ThU4yL2LIuyC0eRL47XmdMckaNI16MRBe6mnqfVWadIEju68RklN51BOU4nZjeiK81RuZKOYuBljFwMiUMRqlb6qAxJ8edhy/l+Yg6OqlIrTLkQU2FVj11+EYK09MWO1uEPqYmC/Bh2JQ6jeOvASrPtChob3cELJkcrOTNmUzzAlRdSmRHabf+aSqzSPHztuAFpwNXYz8aJGeKVUgtzbQugWfPN71SPtl2F7VyhX9O5cRoCO20Ly6BKPMZzC23EIzhTNRJK8Gb1GNQhHAvbW6prpjC6M9jtYvO8cDhuNNmcrU0MGhkmpQh4dKLQ8hGArionoe2Q1Z3Jm1HWntwc702bW4ooey+s5VgvONkMDCw678wTao4kxUTYu9FXIVpgOop5ZpwcYV8zFx6Ro0vU6G0Ltmp4FRY0atpcKxsExVgE5bxP3BRjNGMgIPyyvasc/9muCEKsTfQWVQkqhOB4cRYpMHlh75XBb2vweSCLgEiznaMQg0J2yvEQLH50PwkQXemluTvkY6haEmMmAG1S6OLEKhwwQgeIEP146AZQ4apOrGZFaXV2wIkuBIfJW63Otf37iRfuexP7zlabU0+EpzN4blMhfa/G2yRiHSLeNUu7yQ0NgX6KzbAA2kXl+G/lmG/izdpzCIGY2lRgSbOz23tloR8eStn7iRGj08AsxlUtpJAI3tzBnLYuBAMrjUPfSeM3Vzcma+YDY1Ryrcc9GDoTxmqcJIXoqAMGe2m2mTd1opNm8Vrc2ZeMh2Y9W4qhsaUrVypPfWZdArU0UfqorQlzUyaoiaU1a8XJjH0OxEE5iZG4dG5yZWuVXoQwBTKNIly9/Sy4GREIFkgipBjQFAgx0FdYqjN6YW9Of1t/zw1zaJauo1WufWaIifmo/xF1VGBAMVcGh2UMSDX2tbKvmYVESoRSCz2KS5tWHUolxSbqdQF12HgmqLJRY6gZF6EAh9omSuT2zGtoDT8z4525sMyRWptl8UGdYsbTnBEbWFQFdQ5u7OaMDsJJimgv7KRwqJWyiHRTZdTStAduFByvzRkvWcvCGDQSQiSpYCGx6mhBs+Ysv0Fa7Qf2wH9VC2c6HC21ClTQWiihefX20ka/2TOXpfK/uH9CwLmeCo93RjXjLEXeLjOSp+bnr4rlROqUmcKhZLa14sC5BywolyVj7nSiDBkOufDC4pRFbF7AXg1xaZzXcWYqjnnrYlVth7iJgtbm3lIodDVAgS4pVZXNnLmaZmpbYjjkShcVORZYuzzM+NwciWIIhNi8/VFjTeTNPHGQwpl+YB/hdzye1Mq5B/DWeZ/nilkTX69DYCGt+zpX53Ed+dFX7qEx8Hg38eDJhsngPChv5IlcnCTKaUyU4iw75WATN7Wyr05S6EoThz+pM27CoJHlGDnUibv9wALYemn+1SgenENuwVjR4YR2+dhjHMxAM/XYiVvVSCmVrgssVLn2iafzROP1O5e0yZYq4EIpgUzrwiYJ9KJEbSFeqs4C550pc62Zu+G2Bp8HHuaJdegxgxsxqMYCGLW01FxRojTf6bfnkd/80ikenJtxYrOdmefGZX6jTkgOdBoYQmCuzkXXMZPZ1Mzu2DldBGOfK2/XkVya33qi0YdeqoHz1LGVwo7KIMIUlJupOf0EYHAlZoB2mWxd3ab/6ElkjHUfqWZsckumnvJ4/BpND2XAhBBcESqBxIAwEBEiWZUYYEnkzTJyXQsvaffte0jfxXhUJk6tw6qzlwK5cELHGIwER/97cBce1gOf+sj9pnkbZx5fF2ppe/Wb+dBqQISFCKVWVoslcy3s58JYjHBMRQV4NGVKaQmn4s5VKbzCgruxZ4exPR7eRCPj5NRiDAaDKa6BK+AASKhM4swGYS6UMrHs+pZymguPDzOFSiRw1RW0eKvZ4+RswulDoqMduDpNqCbUAx2FN8YDasL9NHzbntF3Ox7lkZV2FJydlMbAUGmuiyp0GokWmN14Mx/4X754jzkYD7YHHj6VRp1253XGZsxCZCGJqVbWXeKqVPa52Va3pmqFEHiQZw5H6rUBT2rmo2HBhXQtydczvUFRZRyd4tB5IIoyhYLXyByMGNqh/GBGN1b8NLOOkRwrj+fCg3lmnmmJ5do0qC6Cm2KzM2pFvUOrEoMSUsA1ol7pErx+GLk05ZVvsAY/sDv1OkesttHJqbZB9aqLHGicOnNtb86hkBG+/6P3OBsGXn+y4dGrbzKHQIgFnetxlu1ILiSE17cTtRpzMDTAhcBoQraMAbs64+YscsDdeX17xToFXkoDLxP46n6iMPO5MPKDac2ZNN/VhSpfnHdkAlubORzT3WKAr9rEVw8HhqzHrrBgZmxxcoIbWsLbmsiSmWtzomVeGhJ45aubLa8SCUEpHYxlprihdjvOfl44t0A1o5qzOsbDn6XATEv+rMdLdbLWEf/Ei/e5s+z4yqNrvvJow5ZKWCSsBpIZUYSSG4Xrtes9okJVR7vASnsOhwlPkRl4K49NC4CCwcNpx7ILvBh6XtCOL08jVOPnuyt+S3/GhSSiCCsVfuGwJQcY/d2xp3ND5Ut54rVxz6IGFh7oaZ7E+1rIATYUEsoJkYUZN5qJFnhpGKju/OLVhp8PV6QamTo7hn3Bm/9GJPotnh36HJhywY3jJAbWg7KyNp1sse9CNQOcH/rEC5z0HV9555p/cvMmh+B0i0S5ntHahG/Utui/etiQY2ttKUYtM5tdpUZnCvC6tdmU48w4TyhkdrzcDfz6bsUX9zsU4/9Xt/yHixPuSiQF5bRP/IvNU3JQxgpTALQSa+bnDvDgcEWaIMwO1XCcq+Ds1CgqDCFy6h3dLDy2kS4Y95drcONzN1f83M0l6egOtMdwEb5wO+V8Luimlqhdq78XbjX0SmctLV5plL9oMKH8uo/f53xY8OVHN7zx5DUOVjntEu6Ke2tvubcp9lv5hrElWxJUqJ6ZJpDeOCXxpIwczMjWpo+PdMSr81K34HtCz5emLZNlfqHs+A9Xd7mrHSqgWvm5zTVTbTabBwoVZ1+Vn98aj7mkyxCrgCuRZsaR50IJrSmz8kBXhIdMKMrLQ0exymevnvBZIARhq978+4vy1WNK6i2ePfLeuaapxft39WSqaFD6o1POjBMm2OL8pu/9CBerJV96eMn/sH+VXXW6oCwnPTrMOTE3xs+X85abUFmGyEKVeS4czIimrDXySCoj1jJyrPJW2iOd8VLouS+Jr9TKvN/z2XDDb+/OuCeJoEqKys9tbnhre2BUwTpBY4Aa+dntFW/WzEkJxGPGSQzCpU7MBSQ0etKKhFlmq8269v5ySbXKzz99zM8DENjEwhxbIvYXx9039H5+YA/8HYoKyNH7e0/mHolrcYTGbdod1foBeOfRDbs08Xh7YJszjzlwlgNjaQmp7yad4hWtRtJmnXiorVuxIHBGR8jGwQsFpxelWqGo4RYYcwWMVJW9ChIqr8mec+05lUS0TDZnojJSKZR2KSFxWTOKE5vGA3HYoKzpGMnMx8VGPaCmaGrpkzc1U8TYB0cCzTbMQCSRpdzSV58jTiQxix9JOcJszaN8b80dx93Z1EwFOowvPnjEaVrwaDuyq5mnoSC7dsNfhkiUgKkRTIhW6SxwTWHvhXcH1WcmiCmjVEydhSj7I0neaQEjXiFV2KoRVHi17jmXxBmBzpw8C1vNTHYMXXJFzLiqE6koPeG97tyEsQigpCPtUVC0mXADRSuXNlGFdsgHunocdxNwnPwhDp55njihI0slS8XdySgr+qPlqwOVHYVSC6rK64+uOe16Hl0fuJ4yD8nMZoi0iVDnMAejJ3FgYumBy9oyTs5qu1CchURfhJ07WZ1FVKRC6SoStNksZjgpkSlmlihfsgNPJXLhkWvLzLPgKDkaNbTsCDXYzhlqo4mlClRhAhYpIseLRZLWyKldINfmfrXJM+bGVJsZaEBIKGuV93Rbt3j2WBPb+idGcKUo9Cgzzh1tIX6PmTlYm5K/8WjDVZd5cLNnb4WnjOhsuDgraa5yk1UU5XBMIb8hcyPG2jvAWFtCC7i3Nfc0xKN+qumKZqu4GcOobASWMfGqb3nsiROP6FyZc7NNno6+7S2BGq5mw02Ix1BCR8hBWNAoY4daUG904SyF4kZV4yrPzfrzOEGlwpLAUkGCQLzV0T0vnMbEiLEvhTIbmgLns2KdcjckVIS3mZm1PZ3XH11ydT3y8HrHaMZDm3FLiAfW3rRCJRhS4Rrj3BJbKjdeWFjz/dfsVGmGF11UFsfdebbWbK6uaFEWh8xFjMQgfNlHnlA5r4l+b2zm5tRTj1TZ4M5khVyNHkGrcHRqIUXlrPRNRVKdzhuNbB8VAmQqj/OEuTMfFzu3dxvE2gJh7Tucw1/w9w7pVVuHYetzE98C7pVKZRUDtQife3RJ0sA4V0pu/HgHDp7JpQl8q0IyWGlipU2kW46JulLb4ZzahGmGYQrgRBP2WqnmdEdP3xAiQVv3YfTG5W+JpLQDmrYHF5EmHnEneUKPPLIiRtVCMOVe7DlY28waNSiiwahRyd5so5I3QbDSRp+9CO7CWG8Xm+eFA81+MNNsAIMpOzOgJS5Wb3ZwJyHgBL54uaWTPYe5kGtl6QENjokxWcGkJVAOBBaSWKgw0qw53Stmzds50oRKxSF7+zlIKhzMMNqU6kAmIPTeaECTF65pFo4RoYTGx+9cSHYcvdejgM7a4WrGmWNlqcLd2DFkp1gLHLPj56mRpjFwJ7k30bAJITvdsUNn5bbD+jwwe2EKzkzjmDahWeuK56Mo18RZdoFs8MXH1wwhspkyY6mcxsZ3b1z8phsyhForZyFwkhL7WtgeHXIUmHLbSISmicLa2ptM2Rej+EiywCyV4O3gI0dR+1MKl97W3VEccWFAj80bIZfWbIlFsOrHJOEW3PZS7NhYa2BEbxfNlUdUnL03MaYhxw3Xm77k+Jqt3qrGnweyO7MaU2jvrzrvaX32x/fcReiSkLPzxXeuGdKOzTQzlcI6RvoYGevMfNSqNe2JcyKRdYrMVtlbIx4qMBZjoW0C7kfNSACCwU0pTEdNyeSVhRzbJKUyhtaYq24gQsFRV6JBknc1KAbvholhTGJUFxYp8ELq2JaWG4ALUz26/LkwWas/P6aZ+jGnJIgg1oLkbvF8MFdj0kqWZkMnDqVre++uGiFIq8FOqdX4hbcuGeKGzTxzOc/0DiFoO+hKE55naZOpc02cdIHqE7tamSPEDMUb/czlWK8EepzOI/tsPCgTejRY6RFOPLKr9Zi/lPHSTDlMW0p0NIguWHFqbdorEahiTEdxbpeUj4SBba3vOZ4FYF2VEuDaC07LQMHbZL3LR9va0ET03wg+sAf+1s9sVIlMJQEHawrp5EI2o3ql5fM5DzaHloTmglk76HSxjezc2sG+qjd6j7ZU1KSRHtrDOy5gkeYUUGmuKErjyh5wJlrkt2MsYsdS2kg8iAJCMcG1HYrEj50EVSQcOxtVefdiZxgqzsXQcT8NbIuxKZXJCh4CSZSsRzGd01TEONGVNsiS9q18iDyA32/Uo8WWH31wgyjZwUJzWzJrBy5VIbvzZDehx8UkiNATGETYN3sKihgmbbPqCJjIkZbR/CmyvOt60SZA5lBViEGJDmNtm2M4ejctQhs/F2lfT2mx8jlUjmbRBNqGp9ImFBwvs+/WuFTnbOi533XcoGxy4VBbkEj05howe/Pd96PwLiBQoXKMrr+dMj0XVK+NDgFUAYltwZ+DE49BV9Wbm0+1yoObPVGUbEdrWAInIXEIzmhtaqko5pW1NzeKJO1Q7tIoCrMby6DvicNFjN4jfQnsPbOzClZxlJUIyxBb+iNtzSve3E+cVnO9KIMEcKdQj3XU1uKqzXXobpf4SD/wNGeu5spUneCtE5aPjhWGY6GtgTY2OtO7TlkfMGfp7xq820uSo6Ncqc2NrjUopJlSKISu0coebPetsXbszvcoK00ctLR8iKNDD7XRgQpGEFhIu7gVMQowBG3dTDNUhIHAYO1QtbV8FHY7J9ozoMzSLgtKy+2R0F6buJBEW0f1WCuqvHd4N1p2xJ1Fxyv9kqfTzNN5ZlcLKWhLjHaY8HbbCa2xkaYWdFi82SHbbdPtuaH5FjTdGBwbpaHpKbdUkjXTgZiEDLx1syWpkr1RcXuEhTQabqZNm5CWCbF0MGkNjaVq28tqMw0IoV0ORpzO7biGCVNpNtoAhhM8kqyFeUUgKlgUFqZMpdVvh9Bbq8mDOiEDsdluujWR70urJS8PA48OrQYP3rQKXgJZjAMtpEubswvRlVSgqmMB7BvchD+wB/5wPDBXabf8iXbwuWJiaYpa65rPGSoFL4C3A48cfzCHIJxadwxIarcuceMQW1Kkagt5wZ1xbJz4cNyEgivzsaPfH4WxVdplwNQ5W/Qsi5GjE6Wl8wWUJ2EiIW38LE3kGCS25FwD19B8fr35qn7iYs1FGrjKBZsP7HMmaaSrleyZKoC2rwlOd+T/T9oOg/V2oP3coJWjKO3YXVQnSuA6ZKK1g6/L0bLTDC/tUBxUWHUtCKMTZVFCO5xwDF6zyo0YsyVCCJxqOB7qnOKGWOsiVW+uPq014QSak4TRPn667rFc2VNRFQaJXGjgTdsRdrSOlyqqStLAtU0k1+MFoU27wqx8/M6SkxSJFpnqgeuS6WNqNp2eqUgT1B0DjroaqLWybaxcot+e+J8LqtNJ0y+V0FJuVYQpGLE255JqzQFiMiMbiFVUlGUKQOPEL0KmWruU+vHwcuWVUApBhDuaKGrNPcwMj0IxZ/K2uaaq9FWpFjBvtowhCOtlj3sTkidg4YpY4NKcdOxMaVASgWItsyJ6ZNZ28B9c6Wvg+xcrLoZEGhOzT2x8ZFEAMbLXplMKgh/bdLqrgDJGQ0SO9KZbPGvIsTGhKMWPTjrSQiqTB/S4P5tASc5+ymA068yu7ZnJhV6VLBULtEMOzk0p+OykqFyEtlbeaKPsxAjjcWqUNDCIM9RIsea+ks0IAfpFbJPvo4vY4mi9eCWluU9ps0Ls7Hg5DBDes6cVeg/0Fvje1QkX/QI4cG2VvU2cByUT2cmMqLWmS4ggMIxtvdvROrid3e7BzwtdE2Y0u3MxriUjolgycqHZX4dmvzmKQ83MtTEhVnKsQVECzmjtQhlDa3ptamY3Q4qBe9pT3RhjWwNTavqV8WjzOWjfnPRotFZB22WhT23yfUzfXWtgGITLUdlXI6ZAd3S7czdKMpK1nxsEeglIcb5vecLFagBGNhiP8sRKAhlpdDJ3UlC6EBGBNQFqZYMh4vT+HerS8263ZjzMeG94aPZLgyWKNU5oO9yDaaUWI5k2SzhaANZaAu5wecgA73oJUL2liV7pgTPr20jHA7EoHhIP844kjbLQEdkdRT/qwuy/3CE4MeWHXzzl9Qc7NnNTjs8Oa1Xy6DyZK4eam5UhTeQUcA7H4UI45ggoMFRhtJldnbgpBzZl5tx7ZnN2zCyz0nsTxNnxf1lhlooYhBY1fNvleoZ4972c5oz1yizefJdnZ1xWSnGqCWotJEPcWvy6QtWKqNJJj7vzaB6JVYiizFrZ+kyXhTG1zfNuGDhPHbG2rujDcccAqNVm85Uru2ScFWHWRpNIHui7xO/6xEu8+sY1N/uZyzIzSWEVAxfbyOM6U7Q2UbAIyRxPhVkCVltHVhFWXUeqTQ+zJ3OohWlqyakzzqSFZJUlkX5OFG3BcoWCFUfVCfYr37db/Nrw7vu4nWYSBkHR2ka4njKpNDtEry3RtOZmXzkfGaN9cBbS4e68sd02ipg1GtDGM0tTrnVmMSp3+8jdvmNtCXfnC7stS5Rqxt6gWOWRj4hFMpUi7QJ5ivBbX77g8YOJm2nk2ltwzF0P+Bh4i4kJqCa4RRala9NPcXJtM85Es+lcoRymzDgbh5zZ5gmqsDfnOo0sqrLIkYVHUGdVAnsxpBi9BdY5/or37Ra/Nrz7Pt7ME31IaGi6si4HSEZXlSgC3hxyyEJ/pAhybIR0pVFyXp92dNomUtmdbal05lypM2Thpdimi4Mp7pEv765JqkRzUm7GFo8Gw9yYZ6NK06SsPPIff9/HePuNJzzdTzwtmQOFl3ygHDJXmjkIjFYZq9JXofQQQ6TmxuuJKqx6iFXZbretC+zGNBd2tdHkpr4SDLrsLFAsBlIRDlRc2oV8XfRXvG+3+LXj3ffywTgy9JEUAtEC3VwI0Ri82f7iMFmFjdPRdG3qsBRYdR3u8Pp+Ty9AabTGTTKSt3Txbg68kjruDh1qTtc5X7zakKIixxC5ySoP9cC5RZrnWAtbvegiv/v7P8ZrX71iu99zOWe2sXARBq52mWpGFmd2Ic2CZENXjbi9KzMFo0f5qC4YxNhtRuaamWtm3M/EGhktUxfttdvYGCdD1yauGym4GV2G9RR+xfv29fCBS9p94403+NjHPvbtfhnfcXj99df56Ec/+u1+Gd8V+NKXvsT3fd/3fbtfxnccbmvw2eB2DfzWcFt/zwa39fet4bb+nh1u9+BvDf++GvzAHfjNjM9//vP84A/+IK+//vp3fVT1zc0NH/vYx77l79Xd2Ww2vPLKK+htAMgzwdXVFRcXF7z22mucnZ19u1/Oc8dtDX6wcLsGfnO4rb9ni9v6++ZwW3/PHrd78DeHb7QGP3CUHlXlIx/5CACnp6ff9YvNu/i1fK8fhh+I9xPv/sCcnZ19aOoPbmvwg4LbNfCbx239PTvc1t83j9v6e7a43YO/eXwjNXh7Hb3FLW5xi1vc4ha3uMUtvotxe+C/xS1ucYtb3OIWt7jFLb6L8YE88Pd9z2c+8xn6vv92v5Tnjg/T9/qdgg/bM/mwfb/fCfgwPZMP0/f6nYIP0zP5MH2v3yn4sD2T9+v7/cCJdm9xi1vc4ha3uMUtbnGLWzw7fCA7/Le4xS1ucYtb3OIWt7jFLZ4Nbg/8t7jFLW5xi1vc4ha3uMV3MW4P/Le4xS1ucYtb3OIWt7jFdzFuD/y3uMUtbnGLW9ziFre4xXcxPnAH/v/qv/qv+OQnP8kwDPzIj/wI//yf//Nv90t6JvjLf/kvIyK/4tcP/MAPvPf74zjykz/5k9y9e5f1es0f/sN/mIcPH34bX/GHF9+NNXhbf985uK2/2/r7duK7sf7gtga/k/DdWIMfhPp7bgf+b+WB/a2/9bf49Kc/zWc+8xn+5b/8l/zQD/0QP/ZjP8Y777zzvF7m+4rf9Jt+E2+//fZ7v/7JP/kn7/3en/tzf46/9/f+Hn/n7/wd/tE/+ke89dZb/KE/9Ie+ja/2Oxvf6oLx3VyDt/X3/uG2/r4Wt/X3/uJ2D/5a3Nbg+4fbNfBr8W2vP38O+O//+//eu67zv/k3/6Z/9rOf9Z/4iZ/w8/Nzf/jw4b/z733qU5/yn/zJn3zvv2ut/sorr/hP//RPP4+X+b7iM5/5jP/QD/3Qv/X3rq6uPKXkf+fv/J33Pva5z33OAf+n//Sfvk+v8LsH32r9uX/31uBt/b1/uK2/r8Vt/b2/uN2Dvxa3Nfj+4XYN/Fp8EOovPtvrQ8Nf+St/hZ/4iZ/gT/yJPwHAX//rf52///f/Pn/zb/5N/sJf+Av/1r8zzzM/+7M/y3/+n//nvPHGG5ycnCAi/Ef/0X/EP/7H/5g//af/9PN4qe8bpmnil37pl3jppZcYhoFPfepTfOYzn+FjH/sY//gf/2NyznzqU5/i5uYGgFdeeYWPfvSj/MN/+A/5wR/8wa/7ed2dzWbDK6+8guoHjqH1bcG3Un/w3V2Dz6v+4LYGfzVu6+9rcVt/7y9u9+Cvxe0e/P7hdg38Wnwg1sBndnU4YpomDyH43/27f/dXfPzHf/zH/Q/8gT/wNX9+HEe/vr72X/zFX3TA/7v/7r9z4PbXN/nr9ddff9aP8jsS32z9ud/W4G0NPjvc1t9t/X27cbsH39bftxO3a+AHtwafeYf/8ePH1Fp58cUXf8XHX3zxRX7xF3/xa/78T//0T/NTP/VT7/33H/tjfwyA/+K/+D9h6txsbthebRjzgevrB3iZKSZo6lienXF+7y4X3YrdeE31SoeyNpiYsP4e66GjrzPLmDg7v0cvgbx/jVxHhtOPsDj7OGl9wbA653R9QbdYIyHiIpgZ+80l28dvUsuMYogIRXouLx8xXV8yPvkc+8NTxjwTDoWzk56ZgtaCuiPulFp4Ms08vco8vdpzM86U6ixFGVaBk74nqhPUMXfe3M+cdZGPna1xFVIXOFkOnJ2tOBuMJ5cz2nV0XU+ejf/0//YPOTk5edaP8jsS32z9wdevwf/dj/+v0ApmEFLiYM44jbxzted6u6PWyskycX4ycP/eKY+vDhz2mSTCxaojm/Glh9e8uEosu8BFn/jESc960VPduRkLqoIB74wTVoxliAR1kiqLfuD8ZCCIM/SBUipzgVyglAJVkOnA5JlDcabqJIzzZQ9RcDNUhSCKVWcUZ55hM2WKGVHgtBOQwGkfMXEADOHajNMO7p2c4CgK9Ar9MHB+vsBzZrPP5GzMtfKf/l/+P7c1yLOtv5/44/8xVCi1okmZi7OtMw8vrzlJPSfLnjAk7p+f4Ix8/quPuLnZ04XA3ZM10zjx6tNrXj5JLLvInaHje08XnJ8smIqz2c+oCgV4Zz9RMVaudElZxMCi71id9nRRWWiPA1OpHOZMnSvZClYKlJmpOJPBILAaEt2QqKUiIoSkIHCVW73cbDPFnajCvaTI0LPuFphl3CsVeOqFF5aJO91AFlChvabFijvnkalU9rtKLs5UCn/yp/7+bf0d8az24P/jH/9dlOqUUumiMroye+Xh5TWnQ2LddcQQubizwIvzhYdP2O5Gkipnq545G68/vebeIrLoAud9xydPl5wNgbE641xQhLk4Dw4TTmYVejpx+qAMQ2C1GkgpsOxTW8NmZ5oydZ45FCOYYTUzVmOqQgqw6iKLVUctGVyIMaAC+1zYHJybacLcWETlrIsUlFUKBAUXmM15apWXho67654iAUUYRBn6xPn9njwXdrtMno2pGH/6//ozt/V3xLNcA3/y//C7KDmTS6UfFkgcuJpu+NIbb3OxXnDnZMWi77l79wIj83Of+wqb3UgXI3dOFuy3I597+IhPnvQsusjddc9vevEOp6uBy90GJxBDYDLj7e3IdtpzJy1J0ek1sh56Tu6s6TSQQqTkym6cmMaZaIYZCAUvmbEYYzXcnOW652w9UHJFJdClSJDC9XbmJmcebw9kMxYx8uLQUYJxuhgQBDdnrs5bZeSjJz13+hUZJQgs+8ByueTuC2tqzlzfzJTszLPxv//MP/j31uBzofR8M/iLf/Ev8ulPf5p5nnnxxRf5G3/jb/ATP/ETLJdrNCoJOFdHwppfmg88ePg2U81068BqOGV5+hFWfc/V7op5ngn9ku7iLoTAZloRVoJ4xSgYB+ZwQdetqNXolmecXLzCyZ0XWZ9fEGwmxkCIERclzxMeJ7wXSB0aBA2Ku2J4hFsAAQAASURBVNCFO2xS5NHVFxjUWfRKjD3rxcBeCskqnYKqMJeRPgdUhc4rp11gqo6ac3IaOVn04BXFmEpht5mYp8z9uSf1kRQj60FZhMqd08Q0zsx1QmoGa++jiHxbn+N3Mr5eDUaDF09WDKkjdpGdKbvtnt2usNUJd0dD4Gy1ZJWWPPKRUr0dRsaZIQioclkL+9mIUQi6IPaJdQx4mNjlytVh5sFu5HvWKxZDR62FKMrQR07WPV6M9SK1y2Z1pmzsDyM1O5oGNAcisHLQWrlYdEzqBDOiKjEGDNiPmWs3zhDUnaiQIpgrqy4w18pcjbEU3jqM3CToPeAoKQbCkNB5Zr1cI9mYpxkrhaQVuK3BbxVfr/6SCC/eO6GLiihMJXAzHdjtJ3oNpJDou46L1QnXo5MLTJOzLzO7wzVDckJSroqzl0pKRoyKinC+Togbm+xcjpm3NxPff2dJL0pVR4Oy7BN3T5aMxThfrhAR5lo5zIXDYWJ7GEkpUbKS3FmJ0uOsu4R3gtRA1ICmSA7gmwPbUgm9IkCKwiIJEgOroEwOuRq7Unht3JNrR9c5o0BMShg6VCfWq55FFeqUoRYktEXwtv6+NXy9+lN3Xjlb0cWAJmGsgTFXtvuRLrQDUNDIsluwy5lpqhzGws6M7ZTpRPEIV17ZZSd2gS4FuqgMvTJ2gc1UuJonHk0zn1wn1n3HVDIEYegi5+ueucJqsUBEWBYjz5V5P+L7kYUK46wEh6UIEedsiJAUohJU0RAhKt3ugFkFnAgsk6JRAOGkixS34xpYeXM/YqWSqjEjhBiwoQOck9UC6xJlnDEySVuj5Lb+vnX8u2rwky9cMKRIDD06rHmyW/Dk8SWLmOg0ICZEC1yPM1eXOy5vdjjOo6eBZRfQILx9mIjzDFGISVgMkX5xQi7K4+3IG9d7vvjONb/x3oKLkwWbfMDESL1ycbpgHuHsdIUgrA8T4/5AnWf2+5mh6xnnmYRzKuDVWA8dBCXERBcTMUZmG0EDZQsXZqjBEJSYYN11rIcOq4VxrlzniS9dXlHLQD8UJhNCFxAfAOOTyzO8ONN+x5Rza6rw76/BZ37gv3fvHiGEr7ETevjwIS+99NLX/Pm+7+n7HoDf9tt+G//iX/wLAEqFYJnDYeZmO3NHd+w2I4+v9qxOO+6crfjYnTWn/YDXHa8+PbDfZ77/4x/nt/8H/wlzf49/9a//FboyRnMKlbNVoSxeZHmzYlkfsDp7geXpPfq0wKjUeYNZR/QeN2d/fcXh5gFe2ptYzSi5YHVEzel9RxAIYSBqBZ9whNgtkTLSTuNGNeeQDR2Ufh0JUTkx6N2xQVgGwJVS4FCFLsXW0RoUCbDZT1xvR+4sO85Xd9DglLGSs2F+u8j8m/hm6w/+HTU4ZiwZ4zyz3+wIksjjxH57wNzQFHGNxG5grMY7uz3zVEgm9FWx5GDObMZsleWkTFVYuTCEjjsrePR4y5evDryzm/nNJ0uWqsxFCAjJDffMYYbzZYeKoBjmBaViUulXHdMeUm2WW7MLEBAx3B03cAdPkW2emd2pOEkhBWUVEk/nwmEspKikEAjuxKgUaX/fqNyMhev9zNky8XHO6KLw7tri5s/rcX7H4VnW3zSN5NxRCmwPE0F7xnHk8nrPzTSjQVguE092O2JS3nq6ZT5kOhQ1QVBchezCPBvbaGQPjCbc6RLdmfDOOxtefbrl0WbkP3hhRR8SUy4MKJ2AmbOZMvfXRhAhmpPcOQBRhJOh41qdYI6glFJwlCpC0DYtorZGyTg781Rxd8Jx8jREZTNnqEbfCRoCsztRE2NxPIG6s91lbm5mzteFT9gJSQNBHKUit+X3K/Cs9uDtYeIs9ZRY2UwzIoF8nbm82fHVeUZUWPWJd+Y9IUQebPaUudCJog4eDVenuJBrZT9X5mLYEFjHwLpPPNyPfPl6y5N95jefL1mFcGx4tMOJFOcwVe6t2/qmAkilqNMlYTkkJlGiORGBWjARoguOYgbuRiSxbe1YRIUggT5EYjD2xSi1IKIECcRgdAkOUikVzI3dbDzdF+4tIp8op/SiBD/+nJk95yf6nYVnuQZeba656JWsynZ6gnYd++stDx895enhgARhuey5uzolxshXHl5hVuljgCwsJWLVOATwubKZM7k6MXSshh6Rjlcf7fj5N57y9s2O3/7SmtM+kC3QqdCHgFTn5nrDvdM1ISixT3Ru7HByKQyrBQcaIyQAYgUnMO4zyyGAGpYz0wSbmrFiEJSosNTAsAgcqjGPlRTb5TJ0kS5FtrOjCyFJm8g+2U5crHu+J79Er0oQIYi81/j99+GZH/i7ruOHf/iH+Zmf+Rn+4B/8gwCYGT/zMz/Dn/kzf+bf+Xc//elP8+M//uMA7OQUdWdHZeM7pEaur59Qj4eRPkL0ylfefofp0RdZh47l2R3uXbzEC6cXkAqvvvBxPr54iEnApeNOguUAWT4KNrDqO3q5wqVSxoHDkzdYLO5SFqdkV652GdtVlInohZpvmKdrSs7UuKLsLxEtxKQohRxn5hoR1pAiQiVYoQvGOgYWVOY7S6wanjPTPHFTCrETbjaZcarM5kQLnCwignN5tefyUJgFtuOC7itXnJz07A6ZnB0J6Vk/wu9o/FrqD35lDT64OlBnCEGZ1Lg/dDy53LOdM5YgBJjmwpfffsRiMUB2elGiCjiYKkEjeCGK0IcOUs9H76ygGmfdis8+2vJ4d8Ax9mbIYQIRQmgHdZvbwX07ZzpTrMJcoBRlqoU+JGqoWC1IdfYYsVQgsIqJALgBE0BgnQJFjORKEuVJHtlVw6uwSkpKyqDCwjIrVfYVpuJkc4I4/Zj54lcueel8QSmGGFi9vXS+i2dZf6892jHtKxrg4JWXTjNPL2/YjROmEIIw58qDd57SLxRxGLpAUiGghKBIVYIGggp9SoQh8b0vn9PXACcwP97zaMyUCLvqCBXzdoL2atTDiBZnu9mRWllTDBxnqjMltMmlmYMbmpRNnWBKpABJIFVHD5UuRLxrjZNOhaTCk91ILZVKxLuOEBXVyDpD30V21dhOlckrIQndZPzSq5e8cm9FNQcEs/KcnuZ3Jp7VHvzW5cw83dB3Qu2E9RB5vLthlzM1NqrWpM7j6y0pRhQYukingYgSgiNEQhFCcIIqVYWXztYADDGQ/YbLueAR9makOTPEwKDtgH+olVIr2+2OSIdjFCvUKkzTTN8nREG80XFIkc1kEIxViERpRVvnTPCOTickRAIBc+V6HimzgQpx6NDYJhdnKENIjFY4lEpWIXaBscAvfP4JH723gpqJYkx+e+P8N/Es18BX33jK4ebAakiETjlbrHj74VMu9xMlQJeU4sb1uGUhPUEDixRY9JEUO1arhFyORISQAqnvKWng7p0LQj0QQuQmZ97Y7XCpTKZst4WexKAQq+P7wjSN3Dy5pOs7HMi5UufKZjoQlwuMAtWwqhxqBYHNVEhdTyS2hRNYhQFdVOJeCZrQGLi+3hBDIIcC2hFi4rQLfGRxoNTKVTUOY2bGCF2klMrPffZ1PvnyHYI5nQq78o3V4HOh9Hz605/mj//xP85v+22/jU996lP81b/6V9ntdu8ptr8e/sgf+SO89tpr/Pk//+c5238B8ZndzTVPHjzl2jK/70/+n3k6D2zf+EXy5VvsS8+v+4Ef5OR/88d47cGG+9PbvMAVTz73P3LS7/lEOeX87j2WyzPwJfu9MmZYvdARV7+Ot958xNPPfpkT/hXh/q/jbLGALsLlE/L+KSlfYt1dRpa8/fgd3vnyF5ievsX9F17hUYn0deJclS6t2Mdz3l5+hJdPe5bTDO5spso+j4hkTpaB3oyLvmMxdODw5puPiLsbAspksD92Sj++bmObr2x2aAY1kGw8Pmzpu8C9MXPI0KXISXe72PxqfKv1B7+yBg8BvrI/sFDl/skCSPTniY+knge7kU0uBOCkRhZT5sX7d6hBOMyZw37kYtFzccg8GveYG+vgfOJUuLnZEsOCUIx9qcwKwQITSgBiUCqGl8Ii9zx6fMOD3R6NxryvlIOxTJEJYxwNEQODgxtvMhMIvFQjNwi12nES5Jyue7wKd84XnK8HoggPnjpMxr2YjvMoiARexsEy78xb1hK46HqGRWIqmV94+zGvv93xwumSe2c9q+7WmeLfxLOqv32sfHGzZRkDL1+sYNWxZM0nkvPm1Z6bKROqsLSOlJQf/Mg9DBhzZhwnzhcdp1OjAWV3Vhq5v4o8vtly0a0RN7JXPDlSlBlhxOgDHErBJ2GxXHJ5ecVrl9fEFKE6UmCZIvuaj5e+glXYmvOVOnESlXvao9ImVSrCGIxTAqVWXrxYcHqyQEV4+vSaR7vMSR+w40QhOfyGbsGeysPDxGkIvLTo6frI9mB8/o1HPHx6w/nJkjsnA8PwbWemfuDwLPZgVsKb88TCAi91S1YsmM8Lr6jxYDuymQsZWIaOIcJvfPk+ROUwZ3bbPasQOa3GzZjJtbJG+ehSuLy5oet7pho4lIrTppJVYQssgZmAWqLPys3Nlgf7G1QTdXa0wNmQuClOuRkRq5jBrla+6gdeWa84QZgtUwrk4lh1VjHRFbh31nNyMqBBeXgJW0ZWoaeqY0AS5eVuAcD1bPQSOAmRpJFpznz50Q3vXG65tx64czLQD7dNt1+NZ7UG0gdevdqy7jq+94ULCAP3XznjB7rKl57e8PQwE3PlpFNWS+e3/6ZP4CmyG0e2N1d0SfmNF3d552bDPFdOXfnoSnjn0dusl2dINKZSEXPUA7PCLma6bHhRgidOQ2SanH/9+AEhGHVfkVk5W694dX/J95ZKZ0515apUfulwxW958QVYwtu2w68KdS7MKrwwrFl3K85eiizWA10MPH0zsikjJ33H6Mbs4C7crx10sNkVlkG5M3RtDZwLX3n9MV965ykfuzjllYsTYv+N1eBzWSn/yB/5Izx69Ii/9Jf+Eg8ePOC3/tbfyj/4B//ga0Qc/zb8qT/1p/jzf/7P80tvvcWyj9RaePEsErtTvmc18pE7p7xW7vAkVYa+57d83yssVoHz1cu4vYzniavNFe9cv87m+k3uXdxHFgvC4pz1yTkAqzixXK65evmMJ+kFNtsHfO8La9COef4K0/YR83ZPFxW1a6BDgbC+h1okpo6PfPyj7OcXmG4+j9WRzuHFwxMW1ytOzgZUhUUw1mpoXVMWibi7Yq7GtN9TayFL4eXzgTceHZgmw60JlbokLNSZr41NbZzDdQqYBhZJkU6p2Xh4M/Lq4+3zeITf0fi11B/8cg3euXvKAJyExN3FkpwL6znxjoG60tG6ULUKeRGY5kK2ypgzNVeuZabWyp3VAsOYRPhXj/YgcH+obErh9e2e0Sq9KOtVYm+FhVV6lF4Cixg5Wy+oakxmmAgEQ0xZ95GMQTaiCAsNfNQ7FiERQ+u652wUKjEqXiEAh7GSbcSDMJrw0ZMey8I+VxAndSAzrENiP1eK0ToIsyEOUiIOXG1nrnMmS31OT/I7E8+q/noNnN0ZuH+y5uN3L9CgvFEe4h4IRBKgCEYTftc5Nw5yLlCMRz7RScd61eMiFFX+5wc7BHhlXdiNldeu9oxmdBI4W3Rc1Qk3oVMlBCHGytkqEhFyFdTbFCh1ME2VGRBrHdZelI93A6d9pAtta5lzZS6VUweqE6pytSvsyp6gwpidj54vyaUwZScFJUbhphonoWOPMxW4GQvL2r6QqlKKcnUzc73PFLmlVPxqPIs9OKjw8sWKe4slL5+egFR2VwcIgiIkE6TNhDBgN03Ywci5UObCI88sYmC5iBjKAef/+3APwEfWmU0tfGWzY1cLSZR113FDRR0GNxyj74WzdcdK+ta4SI4kCBIgVaoZVp3osCbwCVlwUoWha5qnsRYwIwbAnS4oh1oYdwfclXE2XjlfMWdjrNAFJXbOnAvrFHEK25q5zjOLXNolNlXUhavdxNU8k285ZV+DZ7UGrtcrXrl3zgsnJ3zyxRfItfL4aqQICEpHJHgz1piAw36DVWOaK3U23r7esBwGzu8scXcy8D98sVGNPnFn4irv+fyDR2z3mWUXOTtf8k6ZOE2wNEFc6Abh/tmKpTTRrvWOqKAoKXWMwSjVCQirlPgNnLNGCFEBYVRjFuH+oie7sx56xpK5ut5ibkw289J5z7gXajlqDBbK9Y1zf7kihsKmZKZsLK0SAqwXHeOUubrcsTlM5G/QDva5tUb+zJ/5M9/Q+Obr4XJ7YFPWnCyWvHT/gkW3IIkR7YYX15F1uENKkUUUeuBjF0tMIocpgyr7KdOHNfHko/Sn5/SLdePWY6j3DH3HyzHQLRbsNwOn8ZLRN2wuX+dwdQU1EU8usDnjHAhlZLlYEeKaXJ27umd//ZCLruIJxqmQotANHYvTjyAa6MsBm7aUeWJrRpUDhUwuM7UYISq7MTcVdxcZQuBs1VHrjNSMFicYhBjoU6CKgChBEn1f8SlzuT08s2f23YRfa/0B+EmPZ2OIHS+er7jezdQ6tt8Ub79ooq9CZfbm4qQilGJUr7hCUCjZ2U2Vm8MOA+SVwKPNxNV+ptRKCgI4lzlTCaTYDj4SnNPFQIjGZpyxbMwCB5wFkBvJlBIUUYMIJ4seFUOAHI1pVkptriiDCnMxdrUeaSHK/lBJorhASoG+Vw6HGYnCEANzcRShGuDgaoAyWiaPzr7cHrh+NZ5F/V0fZoa+o+867p6esp9mQgiAHHuijuBNzA1Ub2Jb9cCUHTdh1naIrubsD5Xr/VH70Q083k5cHnKrP1G8Ok/zRLXAReqO7iaR02XHaVRudjMTR12HO5KcWttmBw5BEYGzoUNiu3CmpIRJsTETgjIsAvuamQ+FGJUYlP0+gzSqT4yRftkR5kySxFlX2Zf6nl7ETChFqNK+97lWbub51/Q+f7fi11qDN7uRRTrW33rNzbhHRDAHvB36hfZMZpzohh458gaoCLM7KsZcjbI3LrcVo3IS7/BoytyMhVKNoIJVuLSJ7AEJHSfa6F3LRUcfA9vDzJiNenROa9JvKIApiBgFZ9klhqEDIIgSyFitOMqiE/ZWyFNFROn7wG7XaLUaA6kLLIJwOMykqCyrYDVQxVFtVLa5GoM7rkaenO182/D4t+FZrIE5Fiz2rNYLXr57xs125GoTqNYcEJP4sQ6EKRr5aFQRAhQrhBgYzRhSYJ4KVzcTb10ecJzT5Rlvbyau94ViTqVRjx5NI8UCMUViiKhGTk6WnGjHzWFipDB7ZSql0WZr68h7EDRAFOV0vcCPVK8g0lx+JPIu+2uaM4fS1q2hT1xfj4hEzCGFSD9EztY9Ksq6S7S+3rvrYGCTG9Vy8kotlW39xmrwAzsLrTR3HTC6IJyvEjlnpt0T6nigr8aqX5PSghR7ToaIa+AQQVkRuU8XX+bunQtOVku6viNqI/tZTaQg3EnNJWITBh6/9ojN+BY3Dx/AOLHsVpidUvOMqTVe1ekSkwV1NrSbWMcF5+c9uR4ovmE2IS3P0eGicbbCgIQBDTvSYcNeOopX3NtGGnTmMENG6PtI1wX6PrA/gFVjNscRNCph0TQBm2owFqxUPFfk9rD1/LBOlLlSJFCTsjgZMFYM2w1drlQvmDk1OLMadc5NrOaOdAFMqF6ZCpTa7NtyLVRzPjIu2RxmajY6F6LD4+3ETc5MXrEOhhS4p86iUx7tJx5c7am1WR3ucbra+PlBAxJo4wYRQlDSkVc9q1Nj0wMs+0gtxpxLOxyqEFQ4zAXpezQEXIQ5t4VTTDEVXAR3oTT2DxNGwIjWvlefbmvweeBmGom7wJ39gUPOaFDO16cshx2LMWPWLBOLgOHcTBkRoSJYjAiG4UxWj+5OlTkbtRpXh8LVmCnZSKZEgQfbiaucmUqh9jDE1iXto/L4kHnz6R5VZ9EF5gIxeDukhwDiuAJI2yQjmFWyAkFAA6tFwtyZdwbWuq0qMM6VsOggBqoo+9x+VkKAetQNmAuzCftamNyIVNSa0xnzbf09D+zyxOV44M40MlpFU+RsuWax2TOEgqlTzbEgzFLx3JxHqjnFIaqTDaZq5GJMuXX/a61cHwo3U6FmI3mjfr1zmLmxzL4WSoJFSmhQBk3cjDNv3Ywo0EVlqk5wx4E+KqpCxdsUKQRSUEo1RJstZwGGFHGFecyYG31qwvIpV+i7ZsIgwiEXZnPUjnuwCYhQA4wlMzkcxOgJqAu3A87nB4+FyTP7khlrYegX3D2/w/KtRwxRKbnZWGY1ilQuRyOakIuxHzOrZWLCGXNhLIXtlDmMmWrG5W5qOs0KixRJIfD61Z7rOVNqgU5YdQMfE6FPgQfXO7708IqoMHTKTSmsQiQYx8uBNu1srXQxIgKlFmpSXCKWA+tlILsx5kwpTVwc3NkfCnEVIAjFKtupYgGmWsnmmB/1U9JqfpMzPcIKJSGEbyeH/1kgdpF13CPTDY8eCavlS+ynLQ8fbbm5fJ2OiY+/+AnWZ7+bGCCK4apon1h0kVdOE8sUGZYrNCaQAK4YgtcMgNaM+kS1a372C59j9/RLBCpnUQku1HlLKZU6XNCt1qy7BV3ocI1stOPl1fcThy26fcAiv8VhvkHjXWo1ap6YDaoMRBVWcc8uJuo8EjTShUCd9kiIXJc9i05JCcY6s6uFWI0NkHE8KIshghuPDjPvbA50h0ooxoJb/vTzwrDqqEvnajK+cjjw0smClxf3eH23OW44bXPIyckBpus95VAZho57L5zAmJl2IzpGUEEieDCYjZvtxFwyCTiRSHThi0/2dCJclcImVVTg+++dQKh87sEVn3vzildOOj55b0F2b7aH0rFIraOBQ81OnY3Qw36qbC0zirHuEqt14p3rkYMVEspCFc8zrjCJ0HeJeZq5vtmxt8K6KFucQnNKUXN2XskGs1cuJLIkfJuf0ncvZss8vtkRUIYh8T33X+AT9/7/7P1Jr2ZZlp6JPbs9zdfcxq6ZeRd9ZjIzSSZVYlENVCUIRaBK4IAaSTONNNCg/pz+gAYCpBJKQqnAZJNkZkRG627ubna7rznNbtbSYH8eyZqonEQawjNkC3DAI8LD7d777XvO2mu97/N+zFeHE1kM1swcTjMLAlp5OmVqEmIXuLrdosuCqpCTUIFqKtUVSPBwODKl5gHY0czd//bhhCtwv2YeY0GBP3q1oRrlX33xyL/4+ROf3gZ+/HHPIVk+MR3VKzebnmChSmWtlloN1ivLUjlJIRvDvg+82Pf86nliKsJoLaNzFE2o95Q+MIRImhNvH88cU+K6Uw6pkKVtMawoz2UmBN+2UdUyKHygn7+fKq7yOJ/55QP0neOjV9d8/+XHPJwm8lqhwpQrpVOKqRymRJ4rFsc4DlRJ7SxIu9g5BwXBVOGr88xcEqbCYD3OWn56XIiiTLlw8BXv4I8/3uLE8N+9O/Pnv3rk1cbz/Rc9Z1VemkABXo89wVqWLJfcFIEiTMtKFjDWYb3nZht4e8rMSeidobeOlDKhsyzes4kNef34dOaYClcdHHODJFhncQUec6bzjqMRHJ7BuEbZ+1DvpWI0lJL46vDEv/ky8sO77/EHn/2Iv/riS87zSi3KvBTmUPHV8u5hIp0zWoUYPLHbI0ZI00I1QARbFU3Km4cHDqnl5twOPeos/58vntlhmYFHElngH/34JWoy/+IXX/J/+1df8IOPev7kx9c8VOWmbMFbtrEnWkvKmbUW6iL0o+OcEyuCBo+phtsXG+6flyZftJZN8KR5xgbHHC29dUznhefjmRKFKzxvk5CKYAx4LLh2oVYj7INh5wP2W6rKvrMN/9uvvuI5JEoVjnPl7Wr4p6+PPKbMw9OJa/vM5tMR7xQIiEw4Ms5Hihl4Pk/0NSE+tAAsazEuYE1otySt5DRxPj7w8PZXlLf/kpdbx/3Z87Q4vPd8ZAsuQr99idQZmx9w1mOG73OjEQ2Q00RZEqQZrZEzK2aB1ayoZFytSIFalRfB8StrWVIbzTo8MxNPJTH4iK+GRQpHEmMGrJJU0Voxa8FKxYtvGuwEiKN8IKS8tyrVUozlVBfeHZ/4xdfv+N/9/X/EzTByOE/MSZsmXgzMueEpLYgVVip1zZzmyqZ3eGsJanFiEGv5+nxmNVCKtF/W6OmsIU3KZufJqjxlwV6mpv/4ezeUXHDW4kLHa2s5HAU3VryCqd8ojAxihKcEXy8znfe8GEZ8FaRUXvU952UlS9s0AcxJOLvKi1KhFIoUEhWqUFGetVLV4ldHrokx+oZh9IpaxX5nnyJ/t0uzIlZ4+3zm//nvfs1f/Pot//V/+b/mZoi8PShiKj7AglLmv8nkUISsC5KEVJVND9Y6eiIjDumUt+eVxZQmCSvgg2NEWGZlv/NMUvg6JbwzOHX8z394S1oK3imRjtd94HysGBTVgjEOrCFVIdXMtFbeTAvbEHm9aWQygI+GkemUEBFUhD54flMLWjPGWLQKuVaepLCrtlHaKCDgChxz5YUJ1KmSB4f1DvEfnoHvpxxaDfeHhf9+fcPVuyf+D//kn7DZjMTzCZcUb2ARoc5QE2g1hOjZjj2HUyatGRc91jm8MUQcdIHHZSFpQ1YbwBvYOGE5V/abdv7ergkDWAv/+AfX6JpwGK5Dz631HI4T1XGRcYDzbSpvjOFcC5+vM0PwvO49kts2bNNbjifDkoXgC5to+XItaG5/Fqlli0y1sCmWYoWjh6zgkpKzct1Z6lyoTlmdUuTD+XtfJaKoVB6mI4+/PPLTz3/D/+mf/XM+vrnl4XhiTomqDb2e1oK9bIvUWnzXqFDP68ouRoLzbJ1lP1ikg89TC78qtaJFccbTq/J8StxsHY8p050slkyMhn/6Dz6mpEz0jju/5cXGcDxmulhJnDDBo9bgAiRTSEn46+cj277j+9c7vDXUUtj3lndSmVLG28Iuen5zWHmk8MIGXGqBhhPKxllSqTzkQhEh0DZZH+0GJCdWMWiF/C3x7N/ZV/UslqleUXKl5BOxHPnFz/6CbAcOeaX4O570T5F0Bh8op0ecDbg4YNxMWt4x2TtsXajUZjIyZ/COcn5AVXg+HPnLn/1r/h//zf+FXzxYfvLZH7G72mGcxTjBfqMN7aA8T4i1+NCzTSfq9o6vpoA8P5GPj6SyEpzhukLfebwYSsnYshLCSEoTNU2YnCAvpJoJpeIKdM6g3jI5OGRhXYV1au/vCGy853qzIVEYsSTjOITMlIWSP4wX3leJFYJVnFOycywov3x4R0eHd4FqJxQlWpqcq3d4b0Hh9HyG3LT5WQvrWvBquA2Oj297/vq0kLUwdA6nhiLK07GwsYGrvkOMMMaASNOi3u0d/+kPrnk3C1Mxba4eBSjIxXwLTT+922y5i7DzjpQLtgrRga3CXDLdRZ5TamXjYAKm5zMxJjDK5JS1FgodK4mdb9rCKRfq5bgN1pMNLFo5l/y7+Hh+70tUmy5ZCzILb1PhX775DWoN1ghVCpUm/VoAZw1aHIqynFe88URrKKrUXIjAy87xo83Anz+fWYE+WEyAVZX7h8JgDRsf6E3gKgRapgO82G/5z35c+M1p5akoO0CcMnYetEl8qsKVD9zsB7ZdZO9mljVBWtl1AZFKKS0xdy1wqsptMHhnOR8Lc1CKEc5d08GugDq4dgERZcqVGD0dEKNnFWVKmeMHDf97K+MBFVbN3M+VXzx+jneC9RZ1FivgqOQMoW++I6RyOD81qZezFFVKTTjgzgV+sg/8uznzVDNemxNgBR7erYwYhn1HHx3XXdMuGww3MfKffLrny7VwFMNIw7Z6D0aVc84kVYLv2e079rGjc44lFcjKaE27dFYhOEsCUoW+gKuG47QSQjMKTx1gYPJQsAwOgigpK11sD8DrGKkWkhaey/o7+3x+30vV4zz4CM5aynnl57/4Jc47jHcUq2hsqsFSYLMLsAmINDljdYnOOaqBVDK9sXzaR/70bsf//e0jT5rohoA1lqxwvJ8YxDPetDP4ahwQaZ/51f6W/82ftFDKhyq4JEDF4Yihx1qHqLLpe+72N2zHgTFGUslYEWJ0SBWmabkMSmBaldHYpgo5JFIQnEIxluIu72IDV52limEW2ARD7y07v6UGw1Irb0/f7hn4nW34+7LQ7XrWLnKokTdHYT3s+N7Q8+lWuH11zUc/fs1iB1grxy9/SccTLijn6nl++xv2f/ZfsB5fYENoJ0KA+cxPf/0vcWnmV19+wb/865/yF7964O//6f+CF69+QKgdMT+y4ZG5wOjBnj7HmhETr7BhSyqVePgckmedviSvz5Q8UecKm8jjYaKox+mK1cR5FTpJpLUSBBTTIudj4Pk+M2IZbcAFj6jluM6cMog12CpQFCnwwveYqsw5oeJADd9yk/Oh/iMqREcMFnGtmXJD4s3pwG30dNEz+I6SM3NOrCU1kpMYrLEYcQzeNX11belXnYGds+wNfLQLjHScivCYmmbPWMPoLYMa+hDYBsvzfOJuMwKOq3HkWWaWmrDOEhRMMZxLbSZx6zAIHfC8Zp6WgqmV6Aw1gw+BeS4tTRowFpJtK9O9MXQ0vf5gA5fwXMbQEWpjXPe9J4qhGMVyMcqJ0n2Q9bzXUpRqKpqVX/7ma37wcsc2dIw+scwLMyvzXPHG4KQFsTh19MFRcm10pgq9hS2KofBqF/iJjTynwtepNB0zMPq2Zu47w753vDvNvLra4nDstlv6AnKaSQghtkvmJJWqitKaqSiOd4eJh/OKEaX3liSZ2wHOOeEsDNFjjOF+rmBNa6qcxRvDnkCkNWIvXNsmZRF67xkweAwqwmoADEP9zr7G/k6X/8aUaxShYir85v7I3bZn10emeeV5TWSEXAq5GvYu4INhMUJw2jqMqgRRBgtXVgkGXoyO7xOYqvKQK+/mjIhh8JbBtOfgrbOc55X9ZkSA7XYkljPreaZgGE0za54RVmnEnmssHSP308Tb0wqiDN4wFeF207HUijWG4ByC8jA3XGIwBlNbfsVGPd57QlXGPmBqZtHK4hwbLK4alIYkbTFzH+p9lUfoRocPFq+G5Bx//fZLXu423IwDz7GnLJVzWTgfM94YPtpv6YbI/bo0H0itqIBX2Di46i2jt/zgdsOf2T2HXPhySbyZEohhHzxb79luLK+uPMfTzN1+iwJXVxve5cJyOCOl4Kziq2UxgtTaSH6+xwFfPd3z9emEBUbnOaTCq/3IXOTiGbBUGs7YWsN1CHTOYmlBhbE3xCJ8tvFoSSy1MmPYqsFkyLZSAFTZ2G/3Dv7OPinfPhV2puD7Df3mNToEPu4NW19x/obR7lmfnnnq77HLxBdPz5R84jlbfvUc2Dy+4fVHvyJdeUzsAcVKQdLCYjY8pcL984k+rfxPPv0Bn310zfVoSCmTpaBZkKTge6zOxG6DBINQm0br/it6FtJ0T04zNS2c5mc+f3ei2itUmwlk6CwhCMNwRXA98vwWt1RyqTxOmftcQNuLeHCW677n0A08rjNBe4ITrrrIi2AhL/zmaWFaKta1Fzr1Q+jM+6p+iMQ+IqXiuoyfHYeSyFYwnefVbst+gL/48ktUFUmgIjjXqBP4wFUw+CHAJfY9Wki+TZ7UCvs+8NF2xDjPYTHYkvCmXRwCFzOaM0Qg+A5YyRfCzsvdwHJWVs2N2qLK01pIzycE5byuqEInjl3wjJuI8ZZ5XcjSzEBPs7DQgkIiSu8DnQ8cjOUsmY1xiGvTiE4NOVfWi66/86Y1/h+une+ljDEY+zerWrXKXz888LCeuR57PrrZEDrLT9/OqChSQWtta2VrUSfsvoksBXpriAEketK8MCncDJ6Pdj1qPff7SidNO90bx85Fog2oMWAhdpEYA861iebLm4G0aqNRaJM2PK4r6ekZUeWUCirKUh1XQ2C7GXDeczovlFLJ0rYWcumYBmfYdpExBh4Ww5MkbhQKFTWKF0MS4aSKahuaGKOUD0nP76WMu1jf5JtLp/L54YmnNbCxluuxp4ryeL544gzIRf4nXNj31hI6gzGWaAw+OMoQyMtCMnDbBz4JA1UNzycwtWBdZTSOrW+kKGMa/jNYj3MWrOKwXA8daxKQir0EAE4ob55n1lo4rwUVIRfL2EV225GYC9HN1Cqkavj8nFkvCOOhc4zRMzrLY0qctHIlDUdLNQQMa64sKFbaM9NgKB9ewe+tNp2l6z02WIyDMBjuT8+sZsF5eHW1JYtyfz+jVfDG8bof6IbA/bLgBF4P8fKMaT3W0DtKcKSlsqrh1a7n+3c7ijq+2J/ZWDBWGJ3lyo84GxDjsdYQux7siVwrQ3R8tN2QpjbsqFKoIqw58+bxiSktHHObvK/es42R7W6DG3qW5wNrXphr5cvHhaW17my7jl3Xo9bwtsw85MTrvmeioAi9wpwrc26J5SFaorW/lUz+j9V3tuFfTc+Gjq7b01+/JnrLC3vGSMXFF4jZ8/x4RrePlMORWR3JXnGfDb96StxOW07vviaEPSb3IAXyBEWwzjFVpajlZtjwyYs74qajN4mTmak6NT22ODCRWhZsWLB0KKBVOUwL1rzDpBlTBRVDzjMPeSbbitNAH0fUbLnpbcMsDorJhuphSfBwaAhRp4qa9md5YxiHgS6tDDoydM1sdDM6jufC02lGcAwhEr1HPxAC3luF6Iidp/r2sDGamXtDUmHvHV1oxhlV/S0iTgFrLaP3XHWBURXbe4xr0durFI6qLEXIznA3OL6/23C1GXheHKf5zNM0UWtLsbXOIqb9f0u1WGPpg6Wz7UJ50krAYNHWZFXlXBYCkKS0tF6BXQzE6PHe0vtGKZiL8jgVqgFvmvZ2HCLeW1aFUy6MLpC1kV3IyqxCEmEFLBbvzLdN9f5Q/4FlncVYg35zoXLwbp54N8/8/Y/vuNsP9OJQNS3dudKMXQ7GaLkKno1RapSGh1VIRlmtIWlFFO66yA92I1fDyP2VkOaFh/MKlwaruxhkC0pVJXjLtgs4UZy3zOdC/AaNp8o5tUar954slVJbI3a78cQQ8N7jKUgVlqq8mZUqEIyh955dH7HWMeWC2szGO9ZLvG+uyqLCVCtoS1G1hg8N/3sqY7V18dC24044pIlDgu9t9gzeYX2bsjvbnoANX6mMznFlDb0YXAfm0lSLtSzeklWZjfIyeL63G9iPHY+TYZ4X7k9nDO2SYLxtrCkx5AuedYieXh1qDacs9L7lgwCkIjwc52ZSr5Va2kV4P8bL88/T+YyhsGTly6OAWgxK5xzbPoBXDjWhYhicwahvF8xaWUSY5UKI0oZclA8a/vdWsTd0nQVvMb751I7LwmNe2JueLrYEXhHFe4c3FjENE7zvAy+GjhvnmFylGiUYg3jLCVhL5eTgo27kJy923Gy2fL6bqSnz5cMzAAF/afgtqkKpjYq3GSLb4Bj6yGHKIIlKyyXRtTKvx4bu1ILRBuy42WwIXST20OtCrZVzVj5/yCQDvTFs+p7rzRax8PXjTDYwxg4xiibQXFgQ1lobIcsoOL2kjv+P13e24X/1yQ0vb6/YX3/E9vqHlOXA8fkBg7K5Crhu5JBWOlm5Pyfurrb0mx37uWDT59TrP+H4/BXD8DkmBnJemM9v6bJFxw53bJp7f/WSftjhK+S8ks8PSMo4GzBx2xi/pyM+W+wOTKc4MTyFEcnfuKM9xna0KCY4zWeiCagGXIBdBuEZSGx7CGNkTcrzIVDVEmvBui1rCZRSsC5wFzrGbsPm5orNpiNaZfAdvT2yikdNRHzAdN/Zj/DvfKlWlIwxirEVKBhfMUBCmNeVp+Oxaf1x5ChE69jHjo93Gz4ePYfDygltCEVpzPosCxHbGmbTmPub6OmsY/AjRVamVcEYVJspraTMaVWCh4/2Ay45vj5NvDlkPhk9fbD/g0n7XCq1KrbN5pqe8cLq3W88nTespfC8JI5rbBO77Ya+91SthOTZaWA/DNQqzGtirit970nrilcQIxS16AdJz3spY01LSlMD0nIaRFvyw1qE45x4Ok0NPRgd1QjROa76wCfbkY9Dz2lZOZsVQSmqPOUKIROsIVrTmNXes+k7el+ZY/OTnLM0JKatCIF1befdotyNEYrhy+PEr+8XPr3u6WPTautl2tnkXhZfFa8Gq5GcMjjHfowEB6tkHhbhuDg2znC72bAZI+VCkbruAnfbnlKV52ltWmnrEVWUli1QBKp+EFW8lxLlb/AfjUNvbTPF5lqhKFNu0/1gHdU2WeIQPK/6nk+C4/lUmG1BLprltQCz4LBEHFYtYOmC525rSQGWtHDKhVky82V8vkplmjKqyk3XgRi+Psz86rjw2T7SRahUdGnjhwJg2gbSqcHgKLWgOPYbT9+1hu+Tc+S8OowK15uevg8XsY7hynVcbyJFDKc5tSGf99TUELSZxm6nfrhwvq8yHdgOzOVGp0A3tv+tnJTTWjjOE2oMXe8pKvzy/MytGfjxq2t+vNsyH2emMiGqFDVMWRG30OPoXBuWGWMYx8APfGCZE8fzxDlnikoLzdREnQrnacZb+ORmj63K2/PMzw8rn16Dc8paocztPbv4TBFhEEdQgxFLSRmcZdhGOm/YZMftYcVMjjvruBlHxrFnrQVV5eXQ8XK/4Vo7Hk8nnp7P7EO7DMtlFFRF+bYupu9st/gqVq458CJec7M3/PUps9bPQZUb/xG9C5zOX/Gzn2fWsnC7PGCu79jGK37yUiFe8+6XX9D/6i8oIXJYTzx8/W+4drdsrj5jNRt2+9dshhd4a0nrV6T5gcPpiDXQbSzJZ54eJ0aT4JDp10y3n1id535xPByveLke2TMTJbFcXjyDy9hlYdYTU3TEY8fdvpJrYqmWw7mF4Ly4e8k4Lkxn4c1T5TQfKGVmcZlXQ8fw4hM2V9d0zkCecKPjer/naS5Y77BYKh+mC++r6qVJUmpbVZdyWZ21wAs10ow6olQK1SrXnefT7cCP9tc4W1n2ik8ZK0oxhkUtEUMMDuPaOk5VKaVND7rIBR/msNFxWgpvDgujM3x9boScXR84V2GehS+eJrZ+w7YL9M5xnpvcwlXB1Er1hsW1ByM0NvrzFDguzYR7s7tm7ypTEUwByUK1bTX5ahgIPrDxDfE/lcKoSnEBnyrJwBlh+bBmei9lzWXCr4p+M8I0rf8/rglnoHOunU8L2RRedB0/2I/86PqGqCBRyani5JKjYDMpr9zQk2npkPYymzLGM3aR5M8tRGawnHLh8XRgxPL1YaLvPNshMtVKrcLXx5WX28htF1EHp4v5owNC8BSvVGsus6+BlBrH/LRajqvjetcxRljXTK2VJWWyEZIRXvUD1kDvI5M3FAqjAbwjAbUKS61MH5JO30vlC4pX5Zvzd9liqjKnguLZ+sBXZoYgVBFuushn48D3hj0dmeQc+ZKTILSLpC4rN7EZK60WVAplVapZcC4w15bca63lNCs/Pz1zEy0PzytD59lsO2bAe0s2FYdlZxzFGn5dWjDixgd666hOKRYqGUdHksrTqeP5azitlddX1+xi4rAWpFaWDNkItTpejp5qYIimJTtLC77susB62WuuVT4ED77HctG1EL9L6KPB0PkegLNUslb2fQ/uhLFKToVPdlv+9KNXfHL7goHKr60STpkNzeN0WjOH55UXMZKrEMURxZNS89vF6ElBmpS1V+7nE1/dz9w4zxdPB4a+42Y3krxhN+zp4gFfKztjqVb5vJ4B6HxLHBcPsxPmubXlaV6YVXk+F45T4aObj7jrKusyU0plnhPZCM45Pt4MYC2DG0hROJkF7xzOBY41MyOccuX8LV/B39mG/13ueffVxM9/898TzH+LH19yuLrl518ccH/1f+VmZ3n16mOc/3Pu9pX/dvdnxOcTu3zP9fLIdmf4b94oX/zmX0OecX1Adxu2Ef7Zj/+I2/6OaFvL3BTQn+Fqz6v1HpOP6LpQnyYilnj9mufnmcenJ+T0hHUD8XzPR+vMlGYeRKEK99PCL3jiH7JDUDZ24g54wUjEYVzly8Mz4Pjo7o4+BnbAPGYm56lLwJqBP4kWuiseZsNx8cxR6V2hXysfvwh8pJ7ZXLG6kSQfBITvq2oRJLcmX0Rxm5HeJ/JpIkdDDZ4aDOWqINXgq2ETDDuv9GRsVR6ez9yX0oyUDqoVnvH8STfy8T4y+oDDc1xh8GBr4bN+pFZtoUmpsHeem5uBJBMP68rTlNl3kZcx8J//4R1zVhaxkIWHaeEtie+5geA9u+i5GSK7oWu/7Nbx9bRgLHyyH4i1QixMo+er6czxIC2Uplh++bBiB8vGeEYfuBvbaGXLgkY4iLCokvnQ8L+PMtFgrENrM1iLlSY1xPHuuLCuie1oSFcFreCtsOmUrVc6Cp03vHl75mFNWGfwwaIOnsXwo6Hns+uBoWsM9Lp6fNcGFn9ws0ekIRPnqTBGy93tlkWV+2Xh4XxiGwOvupH/7R+PnNbKvBbWUng3J+au8odscAEC0AmNqkLCuPa1W+f4/s3AUBeUzGkXeJxXHuaFYhVXKr94POJda7Cu+p4/eHlDVsjTBLS8gLU4xMTf2Wf0+1y1tGeBMQZ3IYmsVfDBUK2lmECikLetkfEXCcxoBF9XnLM8nCbuS5M1eAvGK3OFv9ftebEJ9ME1CVeCLgaowo+ut1RVRIV1nriNlru7HdnCw3nl3VNmsJ7RGf7x7ZbHKfN2aWGCh1yYXeWP4kB1BiuGLYa9s8CMw/LVsQXUfXzVsSVDLXQDPMwzj0kpBlxRfvlugSiMJrDrIp+93rZcnqldKh7nyoKnxu53+Cn9fpffjLghoiUjy4WG5AApVF0b974o81Vhqcpm9PRbS+cqnaz01vP12ycelgVrDDE6/OjBGf7w9Uvudh3dZXg6T4mua8+SP3t5C1JJVTmcCrfB88nLV5QK744nfnl6YOs9Yxz4453l4XnmWS3qHI9JSE75YRzBgzfK4DzXQ4cTYXCOh2NiiBteXd3Qn59RN7HcRL44Tny1nMgG9Jz4N48nxuGRfohcdwPf//g1SZXp8ZEbPIe5khzk7d9xLOeGdzyvM+clMfaeV0OHxi2TzMg5E0jcXI+80ch6PHHN5wQfeEiOnz1Fvv/1r0glIGsB9YzuhrvbH/Pias9ViESbsEaBQkQImxec9Qp5ukKqQ2piXh64f1x4kSfOYsC2pq7qgS+fnthaSCljpWnLtgG2Z8d27DnXRLFC9kKIlrVajufKutCmZ8m0eHAzIN0dcTzRpSNUw+bjPyaMW/Srv2SZ3pBPytkqxxj52duLtiwGtvsN++Hqd/tB/R5XLYmSAyCoVqRafK0UdVSUrIYqlhJazLoRy9frwrpUnp5WbmJESiNUeOcIxoGHDsttHwk2gjWIaYnSF9gmzgrWKFnadPbxceFhXpmqULRN2tasnLXQB0sqQrqkQfZ9ZJOF2+jRYDBeKa4wuA0VmKbMmgQxoNpMQIMasghzKUyppQdb17EJnpqF6oWM4FCe8gLr2qYt3tFbxyXv+0P9LVdZCi40864a2yQWBcQUkrb2xYVA6dpyVw18Ma3Ms/DuIXHX9wRVBgxGGwM9OE+IjpebgT56vDUXmXYFLKEK1VrEWqgVScrDu4UpCeeammZUDMspkzcwFstca2uERNjuAlKUwbqmq/DgBxhGy0LgNBXWDBRBpbCqoy+VxQhTqhzXQhJp3qVNT14KKpBrZSqF52XB5Mu2CkPwlsKHocf7KAWcsZh/7/c7Aw5L0txWTcBFyUqaK2+mmalm3jFzEwLOwKjaLABYOmcZxsA+Brw1GNPkGo5CrY157rzFKtRqSKnwcE4c8oGpFqqAF5BSOA2eMbcUcwGst9yEDpMTnaFtCqxCHxgGRxXL4VxYS6VKy0BZg7IploU2rV+ysqqgprIJgZoF40277OSGgA0XvbR17ftZ8oeBx/sqYwymVCiC++05bEGCpTb/j70Ql9QK05r5t/dP3D/OfBqf+Kjf0HeWbrVkacFsV+rpt4abrpFyjIHmRDOggq0ZXEBsAFMwKfHwmJimLznNE1Jb9s2ShGqFWAvVG6y3WGd5YQdOsnJlPPOUMVHxg2UYeop6ztPM87IgZmVeA35ZeOEsJ1HOS+GUM6tWcip4b7lzPTkpaoRiC0/Tmfmbyw+BPjqQb3cGv7MN/+HpwJQFqYIVQzAZo2e6ruN8dKxrJS0r2WUe5oXD/Dm3CJHAWm55lxYsLfjF9DuuXnzExzevuLvqwVlqLlRZMbriAH97Sz90zOMN6iKaT5Tnr/j68YDpYQmR3rW45FkyLiXOVrDaMo+1toCITg3BQRCamVKE53kB6VECtt+Q1XJM8Hg+8jJeod0tNliGjcOYQLz9CB87xuUOZyam80RaZ5bSgxmZDo9sbg0mREz3YbrwvkpKuoT6tAeNkWZeFWmafGMMffCEYkhOGjGkCnMuHDQRaWadTptsJ5eKAvsusPHtV09U8RaiNcTomzyotMARQXCmNNqJk6bRtpZoHFkqLrakS6mNRQ3NxNMZQx8c2bVQGyoclxUxARFP0cKcC+dUiMHwgpYjYKslYqmmvaBFFW8MWaVhEaWRUsRZljVf5CTK8gFT8V5Kq6KuJYgjjYYjpZm0Ws/hiNbh1ZCtYIEiwlQLzyR64/CdYesCGRAx1NrwsJvOtQumGoxtzVLoLCaZFqpGOwPGGE7rynJu0i1vbQuQQREKz7VRdIxpnhNvlKAGbyDVegmccxzXQsGDGLLCkjLHOeOC46XxLIu0Zs5ajG0R9d/IOnJVcpGmEb/obddUsN4jKHP+cP7eR5mmYMH+ezGe5mKUrtIkjTG0UMFq2pkpIsy5cqy07XjvGbUl4laj5Kr0DmIwzR7Qjg3OWULnkNIgBHIZojljSblyKpViBGct3sBsKiOWSSvFCiqXnscqThVbBVMq3jtstTyeV5bsMBWKKnOqTFU4DpaPrWNem7k8Oo+3cFgXRBWHUmolZdN8S7m2DBMFYxreuH6QNL63KvPaZD00dCXfQFCrUKvijOVq0xMOLcsBlFQrx5R4SJbeOLZ9ZAy+kW0EllRaSrJz7b0pBuPs5QwGpIArDZqBAW8d81KY1sQiBeMMzjoKSozKMRXUO8SYFpIqlQ6DL0os4IMnauAwTxQVghqSUeY18XxamMqC2YwspSBZ6dTirOFUWwBmFWmGdTUk48mpeWXmtRB9aOCCb5mF851t+J9Piepcc1VnIc8nOg9jv2dxlnK5obt14VhX5iUzlZUb44gxcxYLBra9Z7h7wdWLV2z6yCZANdJenHnFyIJah9eFzlvyZqQ4JZ8mpqVwWjPjNFNswfiAcYalrngMkxScgqkGKcoqlWgNYtpLyZv2UHteV5wa+hiwvm//7FxYUuE6OFJyqOnxvcd1G1x/hbEOv32JyomUFT0dkbqwCx0SOoLvqXiO6wf94PsqLRWpBYzFqmkTzyqXvxRvLNvYsa+eA4qxLe7Bmia0NhcUZzWGVYQkigiUcGnOqzQShTN444gxMK+1mc8ANYai0sxhqpdJRHvkVQRrLbU0mYetDZ1XTG2cckyTIRmDquG5NNXpYHvEGJJUcv5G2eoQaRO4wfnWzMmFMW1ag6coa8k4Na3RWnIjAFVh/RC89V6q0S4Vo9rsWZXfpjmrtvO3i5Eb8TwZwTjwFYIYghrsBWcYvaVUoYhSi+C1bQSKKMY087ixjuA9axaK5sufryRRklRSagFezoFzrsEMamWtClLxYrBi2++FtmVErdLOToHHlFgzXMWuUX9UKEVQaxhNQAT4xttiDWst7SJrWoOnaphLxSqotZQKwbafS/qgoX4v9U3Db/49T7S37YIoVcAImxjZVc/ZFIpt77yAwemFW6aGYB1qGjogS2H55rp4udVZbZe8GB2LOKpIG6IBSdoQJWm7AVgH1RuqBS7EsIy0gK6qJNfoOVUEWy7Pv6K8WxeGxXA7xDbIRSlSSRUmY0m1bU774LHesKzNNOmsQW17Dp9TRUoz7C4Vet+e47V8aPjfV63nBUfEBYe1tqVxKyDt5+5s5MV+x4spcF8V4xTvDFEN0bSzWqoSnCMJJKmcUkaKoUrzrVlnWs6OdXh/8ZBoMw2IwlrasK7SuPfWXpDA3qA02Y9aoApShFoqMRhULsM84zDF8C6dGdbMx/sdahtiOC2Zs6kcpKLS+obeB7y3qKsUzRRtoWMqynlekQIGRy6V4JQqhZT/jjf8GUvwBiOGaRbu391zS2UMnlMQnHhciAzTwqEUJjEsS2XJlU/cE3a7JXcbrjaR1zd7dvstpSZKKtS0wRQLNYMWqnGE0z2GlqpamZjXR96cV7JV5lIIa2UNldxZpGZsdKiDlCuS29eZELx3JNH2QDIOxZFc0wfeqJK7ZhRBhNvxGjd2TMu5abZdwNiAltiwYnbXRLDuCEbp7UTXw7h7RZGR+Vx4tyy/40/q97iyIrG0lbY6pFZqEmppQVq999zFnqIbfpVmJpdx3hCxjHi6EKBWJgpZlKJtZHAuiVPKdN5jrKVWS8EgF4LAlFcUJVfhfklU3yZsgwtYbSE31lpyamjMdGmOoDX3eMtUmmwnOEi2RcLXsmD6hrkztulyQ7WsRjGmMR2dacIiVUPwHm9aqukklXfLzGADXloCZbkYmPUDFvH91cWky+Vypd90QkAXHC+3G4Y881fziZPPBDGMOG5MZBs9C4bVKOJAqqLFsKpwSCt9rBjbY9VDNag41lI5LhlnGh3qflnJtW0qO8CWliGi1rBeLqINfdgmq/kC1Z9FLpdOSKVyzsK6TPRb27S0IeC8tI2RSrvJauPqOwsjjloV46DrIpMI9/PKlpZLUdViSyNotA7gQ/1tlzX8tsH6Br7rrQGFqoL38HITKeeeN3XhaBRvYLCWK+/pvKNWQ3VQbXu+qTRpxSkVvDX0ppF/Sq2IOHJWDmu+bBHa+ZtzAQ+9Nt54UUMXPEuFmgyLgKuKF1hU6G0bCCrN8J5q5SyVZaoMtjWOXWh0NAOIOMTmS8PXvFY776k0rvs2Go555evTwiAR7yxJBF8rF7z7h3pPtS6Z2AdssIDDWqUk0KlQc6UPjo9vrviT0zV/lQ48k4hi2JnAa9cxhMgpV9S2AM0K5KqIFB7mmTEGutDCMktVaoV1XlmXhBrDnAufHyZSaYhaj8GURn+K3nGeVuxqOLkM2jbgubZEZrUWY5vhfc2VQ62clif2PiBGMAaCN3wcBrIRvOnACz44huhhC6Fm+q5nEz3TuvL14YQnYAyIeKpU/kPewd/Zhr9owCVFauaUEs8JzvNXXL8SOqvsdzf85KPPKE+PuPuv+M3xiFTP2PXsbvacgFcvbvj41R8xeMHM7zDB8nQo+CnRDQNI02nX+paHt7DrEtP5zP35mTfHJ359OpFE8SdhrJ6qF2CXwE0Z+FLO9NY1nSOKE2VN4MaOjTF0KF31bHev+HfPP+fz+we6aOm6yDhesbv7McP+Fbv7f8v89MByXqjrCPs7Kso8e5azJexe88Mf/oAw7JkOb/niL/8t8/mIm55btsCHei+1KoxiQYRUmzEtV6hJiKUxzP/k5Qv+wdrzL96842fP96xrYR8jn+33rGLponA3CU8snMmE2Obzx2llvLUYIyxJOUvi6/PMfrScS+E4ZR6XxJs8I6J8FjYULZyMsKjgVsvOwgMzm9jhnQWBuDpSS8Wis0pQ8GJxtufdfGSWhWIqpShaoTj4eO9xzvG8ZtZSCRZe9S1kaRw905Q4H44c1oWFRmDpbJP6AIwu/K4+ot/rMgBimlzhG3O+UTQpofO8vB75sx+/ZFd23Pzma/7yN4+sa2XXdXx8sydFuJKO03khyYqxgndtO/R0mvnsZodVZc2ZdRUOS2bcWLIavj6tvJ0mPl9OIJVXpccZeCyFU6mMxbG7snyVErdjjw2+ZUdMBQe4wYJxODXEAiZavpxWOK3t/EkFUUbv2NxEvPfUFZaaEeDjzZZ4E+i84zwvnA5njqkgl/3V6KGU1nBd+Q9Y2PdRIgZyk4p5a2mdrZBWJWbP3TDwD1685M9uB/7810/8xfGedSnsQ+CT25GFAKosp8RSE8kIPliSV56eT3x8vcMp5FzIuXJYM+NoqQbuzyvv5pk364xU+CgGEGGqQkrKOBXi1vEmZz7yPX10VKnE8g2g0CFeEGuI0hCbX+YTX58VazLfdOneQdkHIoFJMlNOhGp5teuwrmfsYZpXDsvKqQDB4qqwixYuW9dd9+H8va+SKhgEY4XiTJMmfnXkdEqQ4O5mx5+9/ox/eDfw//qrv+K/++uvWZfCTd/z+uUVR83sFk9vPW9TalJAKSyx8MX9kZ+8fgEKa85MaeXx+cR4GzjOhbePE2+OJz6fTrgKH297jIdzqqRJuBJPvHL8Jk3cdRt66xvNqiZOp8rHVxtWDeQK0cCtG/iXz8+s09f0fcB5BwrHpfDy5Z6hc+R14SQrU6384O6aT7vI0MHhcObN8cDPD2duw0iMnt0mgGYslis/fKuf53e24e/HDeos63SgnE8AVB843L9j3F/x6d2eu03HX/x6ZiiBKzNebuYBYyy77Utubj+GWHiXVmRa2VE4lgP4a7bDTKPzCruo7F3C8c10yrGl43oUjmmBzjJVpQ+GvXco8OXU4uU1hCZ7wLC3hk4gHWeMc9B3uM2W7f6O26+/YPvxNUPXMW6vGa/u8Jtb6umIWQOPs5CLsPceiByOB/LTzzAGuu1LxuEF+XCCw5n/2f/yv+T56YnHd2/48s0vgT//nX1O//9QItIY4kApkNaZWzNw1w9cdz0/e/sl3brwykXKrif4QJE2PYoVFm3/jqjwUgLOWh6WhD96toOy6Rwv+thep1XYOku1hslA51pTnlwlS/MTDMYTI3ydzqzV4K0grsnHOmsYDOQ1E6PHNg0GvnPEtbJzEYtDe4MYOKeFw2RZEUpNCBWJhhg7UgLvE2tNVAVXIgg4J7wlM6NUFPOBQ/3+Srmk6P6NbEWLcnPV89n+ipfdnp++fWSYMq9dRx1g6ALiLE6glpWqbVtkUF64QBws97PQdYldr2z7wOvt0IKTgBIgBcPZWaKDiiEB+QIBvjIWF5TfnBbOpXBlOwhgtK3GAeYl0duA+kD2nj527CdhPzp8cyJTRZkW4TAt1CrUaCimTWrH2IAIK7SNwmW7IU4Ya+VXp8RiKmIE++H8vZdq8jHzjYUJgJKVNAt3256PbvZsNht++tU7dF35yHXMY7ukKS0vAWneo2Iqzip3PqDB8yYv2GXmqg/shsDVePGiVcfWKsVb1uBJtmsbTLEkhICnsxbrhTdL5lwgBUtwFrGmATRMIaVMsBbrAW/ZxJFdWNgPDmv+xj+15MJ0UFZZ0V7JFLzAZ8PAdHnmn1MhX/xMvgoR+M08kSwtOPPDhvO9lbPNCGtUsWvb5h3XQloLN9tbPn15x2Yf+dc/+wo9rnzW9yxe6X2kEMCD6+F5ShzWBAivtwPRdbxZZsbpwJ0duRpHbna7tseqlUSlxzBax+0wUmtiQahJGXDcxohq5a+ezjxT2NZKcC31BtsugI/LTLCeaALOBcb9jh9MEx9tR7ouYo0h58K708Q0rdynmdUoycGgwtbBaUpQHOdUUQy70DH6yFXn+On5iUkum/lveQS/sw3/pvOUWiiltrAOlMM5YRfDixc3vNyPjH3HrAslVD66eYXxgdh3jPs9w2aLGffk5zdAk+08JOV4nvlqesfdJrDdjGw3I73tMflMMYa0JKwW9sHjGAmbkdEGTkvBeYgeilTmXol4nGlGJqRJf3Jp2uc77xn6voUZucAwDvRhw+b2e4xXL+m3e+zQsarS94qVZiTpYocs79hv2rpd4hXDy+9x/cn36T41VPn7BKnkrKy5MKYPhrX3VYaWcNt0ea3hqilDUjabyNXYEWMLuZpr4aNdRDFkNSwinERZa8Zx0ZleePv3JiMK8wlua+C1RnbBt5S+lNGsBGu56gIuGfreMtieOUuL0LKNiuJx9F3AYRq9BVhQci2oKIN3dH1gHDrUGFL0BNd02whIETYuNu0gCbHgcAxqkWxJFNZzZVkyea10BrrQjHQWxzZYgvOYb5v68aH+w6qCmJai+M35MwhaDbebjo+ut2z6nqmsHGvh46u+mb2NxTjHTOVAQa2QTdNFW1Uep4qKkt/NXG8yr696thfzf6mVnDMOuI4BIwPWGV70PaeUKaVJeKa04EW4Ca5pp7VgAKOOY06oKKEzbLrIzbbDGMPcW7yTJmUTS0YxvcEUy1kTc2kvr955cm6X65ILxyWRc2FnYO8sqVZiZxj7vm221g/PwPdRUqW93yxgBVVYzgZZhd114G6MDB7Os3Am8foqtDwRLARIVVikEDpgvUh61HGYVqoavkyJNCoGw66LQNsS5ayNrR8DoRpUI9eh45ykha5pZcqFKA0RShWS0qRdBY5VUDIvxo5dH9ltetQp26XDGkMwpm03BfrgMVlZVZlLxTvH1nXkDHNZqeIbhUeVbfTscUxSCdawiQFvPfXDO/i9lXUWk5rnsvq2Zaq1sOTKp1cjH+33dD5wOM48pYkf3o6UBKVaTIDHXFlLJnhFs2LE0uM5rCu5VH7x5sh0lfnspbAZPUqgpozWwhAsd9uBfYk46dnvR57OCSvgRHmaF25o72GDkigYDF4sKVoel8LHG8/tdmB/tcVYw9PQoaHJFo2AxXC7bb7OYiOnPBON59aPTFlJayGnTFozTmA3OG6t45xXglruOo/3lpr/jkt68nygiCA1g23rs1QFaz0vru/47O4V26Fn3F/jq3I77LDBoz5gQ4cJnno4UI9nCkJSyzRVpmlG8sxzqZSqLKVyCiufufZL+5QqiwoZiyEQDYx9R9d7nBG8q1RTWJ/P4AJdZ1EM51R4e3gmOMeL/RbvHauxHBdB44pzkPKC+B12fIXpR6pksr+B7StMfEQ1oFffY3ezxwbhKBE37ojDiLMe4yz78QVlOdFvntiVgWW9/t1+UL/PVQtlsZRUSN+Ex6yCLML+auCqH7AX09ZuM3CDI2XlsFTWuWCkESk8Fu8iFaEUbUxqA0hlEuWrKswi3HaNQ31aC/PFMIlYKJbQGWLwqBXEWJLxpKyE6BmDo6rhVArP84IzlutNxDrHWivMC8Yo3lqyVAbv8Q7EGAwWMbBeCC4CzEb5/LygCJ2xiECwnm30BGPAKiOOgjQT7zfkhA/1t1qlCOZChFJpPHStgvGWl9c7PrrZt89RhdvthmvfMILHJDzOhVJbXHu0nj4YShU0N/pPuBgvzybzpVEWrXw6DKgqhyVxyoW1Ns+J08ZX911AYzsnm+BIp5muM4zRUQROqXLICW/hdtsTTGvOj9PUplDOtE2RMTjvcLYZfFUti5Q2yVdlcZVfHSZsC+alaCFYy03o6ZzF94ZbPLMqVMV+SHp+LyWXybW5eEjIisyKiLAfR272W7wzgPByu2GvlrxWjqnwOGWoyi46PBbnL9rprGg29NaCwrwIb21mMTOvQkREeV5zI5SIYC6kOxNgjP5iIA4MSUgyE6Nl6D1VtAUqScYbuNkOWGeZq6DTAlYbxUorveuwDqw2vCMGfHaQKzULiy38JlWUSrCFIoJVy867lpBuHV4cSSoltwv4h3o/JWsl29Qm/cGhqXI4ZI6HzPazDXfXV1jTsKmvb694EQbKWng6Z94dJgLKto/YKoTOtTOYFMnQm7Y5mKfClw9njrXw6bBDa+V+mXleUzs/wAZDxPBy7LHGoEC8ZJiU4BgHR8mV45x5yIkNnte3O7xzTDVTj4em2Xe2efmswXvXiD/aMprOpWCzh2pZp8Ivzk/0xlJt61WtGm5iT2cc1UdeYFlqRUvbPn2b+s42/NN0Qk1LkjUhoDmjxhCGgZc3L3h9e4tFuNrt2BC52wSsb1OFeTmTUiEfZmRe25RMYZkKdRFC6BBxpFUpsnDwiRdje2kcEqzWgg3gApMkolV240BnDd5U8JWyVFzo8J1hFRBdid6ydZ4X2w2zVpYKaalIv3JMK1ILfYW+OkwWTE2oHwjjDbEfEOlwmzuuP36FauH5/JYwjPiuw5n2ALY2YkPPMI4gK8uH6cJ7K8kFzYacKqW2hktmQVZh4zy7LtDs5XA1DuyNY14rU17JacUKjRjgPaPzZIRJCr0o1ilBwBTlvFbOujBI+6U9rJkZqKatqEtSrMtch0jwFrWN/1yzEIKlj5ZZYRGDtcrgHFdjYBbDlApTurj5UWoVog0Eb7G26ftx4FKjChQUUeUxJzzKzjdWsbWW7vJQEatE49plXPhgmnxPVWrFljbswLYYdaQljN5ut9zuNmAr1lhudwM77ylJKcfEl8cJW0ybRA6eXfBkI0xrS0vuDOAUVTgvmaMmri4Xt9Ocec6JRSrRBVwVnpJj30WitRgMY9dRK/QjeG84pMKpFITKVYjcjB1rVaaUOS3pwqh2pIZFx7lGuwjFIsFjikGyUlVYqvA8J3yGoTN0wRGtJ1xW5c47NjjymliLUj9Iet5P/XvwIxWggCbBeNhvenbbAWzL57gZBgZ1ZF/IurbLoECwFzynDSSENSuD8Qy/9QQ0TfTxuDAM7T8fU+KYMqsqwQWsFB5Wy9XQ04U2dDDBkEtlM1hMdBxSbo2cEwbruN52zEU4rZnnuRIceOsxFQbX4b3Dm0a+woGrBlvbJXgyrdELNI2/t47gGwIX2jN9NJachVKaH+pDvZ+qa6Y44TLZQKbM0zGzrMo4jOy3A7BireHl9TV711HWwlJPLI8TW+fZeoexniFe+sO1MBjLEL9RrBmez5kv08J41d5xT2nhKSVmqWAtszGEyfF6u6HvAsZaNn3Ao4QxglWep5XTmhFXGa3nxb5nqsLTvLAeF4J1bLqeOVfG2BOsx1mHqYJxBjMpwVi0wlRXDueZXYhUV/C2QUBi51u8iTo2vqFoC2DDtxt6fGcb/pQttuuwweFQUj7QR7i723B307MbI7lktr6w6XaMQ8CajJ4nng4PAKx1IGWhj+2X1HQO70f6jaMvmagFK5UqlflCl8jiUT9g+x41wmGaqfPE0PcM3YgPEefhdl9xruOYzsxpIeXMdd8z+kitFRUhGxDfout/fnhqDdR8wD+/Yz3Bzd4wbm9wyfA8OOakXAHjyx8iecY9nug2ezbba7bbPcAF92kZxiusDxzyh+nC+6qyVLDNHGhU8cEznytUpQ/CGBqX3/eRzli2Y0/ft/RZnk+Igykp3vvmF3GO3rZpBK5pqjt7mRKo8A3OvhaDMYIzLVhkuQRyeOu4Cp7oDdFYSo7E0F6QT2tmLsptHAjetTPoLKutLKUwGs9jmpEEvfcY67E0bKgGcGv7eowoqCC1MlelJMMmCJ1vE1qAqSjiHMFcNLLuAxbxfZQWQf8HkxsF1/C++6FjiIFaFzrjCcGx226Qaphlwj5OENrUs9eAtxbnLXsLVRwutmmmwVCcMhnhdMELShJ8aUFdYiozhWmq/MhZXsRI5ywhWG7GnnG0PC0rx1SYSuFV6Nh4RymCGGVCOYnQF+W8ZjbOMYTaEHvaQpSMM9QMrrRvUWwlz5lVLEk8u2LRKJTQztmclAD02rZU04cL53uqlgVS1Tb6lzQq1xA9u94zBEMpghcHGLa7seESrePt3B5mb59XXmwu5886xgE6cXSuxSc134gyqzB/o4UvSlfBqWn+JYQvlpkuBrbe0buW2HszesbR8TAlns8Lx5S4jYHeeFJu5u+ZylkyPZaSFC/CxnV4bYjHYCvFNcOvV6U9BRty9pgqxhm2vm0Hqm09wrS03xNDexfnbxl69KH+I0oFY9r7s8m7C8clMw5bhjESg5LzehlgWTZX22YEt5btoQFNvnqYuH2xJ1pL5xQ7RjZAFxs6GJRFhbMoj5cBal2UIAbFUtVwn5vkcAiBGAODd7jgmfvI2FveHhfeTTPPsnLXR659YEkLxRmONXE/r/Q4NiWTUmUXe+Il1M4bQ8VTpRAuwZqCIFJ4ey44p+y8YG3z84FSTxmtlk0MxKGnum/Xyn9nG/5u09ENI7VaFlaStWyi5ZMXnttrzzCAHGemx7es9Wtkf0MfA9OaeJoW1EC1J0r/kgK4WthUBW9xMVBywoqwcYZXYyOSAGydxUaHc44pGc5VOK+VJ3sk2o6uu6b4keEmkFPClgvD1Su2WsbxirePTzysK4SRcbDkdWGqiWsiXSoM69p4/otn/9Fr+nrks+//iOI29LffJ7NjLcpUd3T9a7r9S672I6qKLgWhw+kV1gRG8/i7/aB+j6vW+tsJtrGGWivr3BKet0NP7z1FVm6scp5WegLRtxCtrguoKkcWOiN0CsGYttIzMNNM2ta2VNGPtn8ToLYpFoPDWMtqKl9JAoGn00RPz+jadHUXA4lMqJ6uQiqFXISrIfC2NJOSFCXiSF6ZRRmqoTeR0bV4zFIqT2tmUSVYQ0fTFqZFGa1hdo35O8TAZmyPi9N0InLBPKppmt0P9bdeprbtCxbUNClY9JaXL3bs9wN9NOSlcjNEao0c5ky0DusM3dDC3tZifxsMaIzgnAPvcM4jZQVVhuC53QfGy5+rpTIGhzFwqsJTNZyT8HA4s922bWeqlXFsn3uPZeciazCkKuyd5e3zmceaEGPp7DcmSXAENtaxcw5VWEvhKZ0pJDaxYWalGkTapWD2LUG4C5bd7rKB+PLEBBgTcN4zhg9Dj/dRRhQVqBfTuCbBOuXVzTX77UDnDbZWdp2lrpbZrgSvOFPZONfkYYF2idOWCRFoqGBrDUZcCy+Mjrsx0Nkmn+jVIU6oKFNN3OOJwLwWcrAMxpOSYYwecIxWuXKFZJo0chPh/rTwnBeqMXgXaP7bFtzVR8PYtU3mvApTKai2Taw1zcw7L4mtj5xs+zo6a3lxMRb/9PGAcwaRBkro3Yfz974qdpEQfLtIpsIyZ0pWPvvRa66vdjhvkWJ4MfSkSZiY6KPDqtJF387gaLGdRzFQKp1oM2MCIFhruO4cn24dnoKiVGux2lNQnlJizZWYHY+HhV3w7INhqbAbOzqEu36gKuikPC8LL3zkzfOR+ylRtFGuUqk4lNEExtAzxoFahdP5zBFFbKDz0jxRBeZFic5ifMR6zzb0XMUegJ+mR4qFTiqSV0r+dka672zDn8uKmQpIQwt++nLgf/9P/1P+9Md/Qu8KeT6xThMf7Xf0COe8cn9/bgmgVIYh8lVKnJ/ecLZKFzxbNxCBLmXEVIw3WOM4T5ZSLBOgrq3uovNsOgNli4mBLjjuj0d+83CEuvC9nSdGyzZ0RBcZU+QxK1+eH4mhsKuewSqjzqTScdNt2cWRv/7iX/FX7z5nd/dj/pNXf8p5cuTuJ8iL7zNPE+enwt1tYtht+bN/9KeM3UiMI9Z3eO8JG2ls4ZxZ14Xz+mG69b5qPlesU1QFyQZ5yvzzP/t7/OEPPiLayrKurItwezVy07dfpuOyUkvl46HDOUe6L6S0MpsWAb6hw1vLtRsgtEYmBoMkgMyS4KlmgmkvthA8P7CRlYSI5anA02Gl5sqnY4dzlpsxshnhlCvPS+JAhgTbEohO6TysFXZ4YrD8+vnMr55PBGt4vfGMeGpxrDm3sBAsYx/xQKVQXUvOXObK1jpG2+HF4jtPtXBK6//vH+SH+o8qcbXRvrho1Z3yf/5n/yv+9A9+TGcLSzqR1pVPb7ftckpgWYTOGj7bjnip/GU98Lw+U8XgrWcbOoiWWBPeQRcDIThIsNLoJu/SQmccV77jyvdsusqUCtkrv5oXfnmcscbw/e0VYwfj2PFR37NJhcdlYgJ63/GKgegt0cOcCyVlDPBX9yeisWycvcAR2rd4WpVaK8EI49CaK6FQnXCuhXpyjNExDh0jnpY70QLkPtTffmk1aAIVQauAKP/H/+Kf8Mc//IRgKinNlHXl5e0WvyYMoRm71bAfLJHAIc8knymyYoqhrz0x+kb7QgjeERxQVhQ4psx9Wgl4di5y1QW2rmV+ZAdfnwtfPWVElU83HT4qMXpe+j3DUHnOCzkVBuuxZoO7yB8Tmamlu/Hvng8EAnvTcd1ZHBVThec1UavgAO8sY7AYLB7HVGF9PrfL8dgQiFWEnOqHpOf3WN63lPF1TjwfVj7/euW//uf/FX/8h3+PThNlPpCXmR+8fIFdhWIsx3MbkH222wAwLZlJDhh7yWbInp2zQMZVofeBzliYCuqUNc18Pq90LnDdddzsI692A8dUcMFzP2XePM0sKfMHr65g7BjGgU/iwBgH3pwmzrmwjx2jZjyG6AOzGh7nMxn4f3/+hm3s+GSz4ft7B2ub7TzkhXktaIWPtx3jOHK/LMwIX5wm3p0nbnvLfugAixVFknzr8LfvbMPvnGsmjVLRVFhzM6aNkUYl8Z4QAn0X8LXSS0WD0tsWqNF1ht+cT4itCJacK5Ocee075lIxteKMIYSOoR8QGhbxZBras7eBZVVKBuuaGaM6wBq2GJwIkpTFBpYipDQzSGGu0OEasgsllcR5mclSKKYw55VUPHI8s7rIbX1H5ween+8pU4Luin4cMQrqdvi+I4a2ErXWY51BRahrJRUhfYj1fm9Vc0XVIAXqXMhz4cX1yBA9roLBUlCqVJxxGFogzM3WcDW2MKJfPTuKhUxBTXvhXJmelYpXQyqNflF9G+Wea+FRKqMVvBpChd4KVRznUqm+GX+abKJp8rNVsgg1FUYDz5ev3/g2ecqiHCVTg0OMkpZKFsU6wzgbVlmp6lqiH6b5RYqSEVxnAUtJUJdMMivuaoNIZVkzBWEtH15476MMBmO+sUg0JOur2w3b3mFrS0mu6jlk8NXgAsRg2G8jm8EhKfPXzycmAxMZKZmJysduIEvzYpBboqh3LR9iTfBclN5WvC1YZwhV8RmOuW2CnHG8jB6rlZRa8m2uTYI0ADm3REp1FTWOWi3nXFitoDUhWFa11GKRWjnXRNVG7XEGrFhqrixU+sEhquRSoFSWBeoQcYtgTaNWTR+STt9TtTOHgq0tQf5mP9AFj5MKCFmVkjNWLM4aonNcDR1XMSJV+euDZ6qFtVREYPWZK21G3EpLSlYRxFvEKXOCpyr0thCNYXCRTtqk8z4VTqJg4Ca0DULJleyaIV1KoRNFakFpAW/OgGjlXCqzqS1bgJYGjBpQy1RXHIr1Fmc9NhtqSjyuC5vNN/QqIWsh5UK/G8G0Z3fWQnIfnn/vqzQYtHdIcaQkLLny4uaKIUYomWIb8vq0JnpRohvYdM2jdnO9Qarw7+6fWUpmlUoW8KYyYHF4rIVUCyUJvW+kvOOc+SItbELFB0uooVHpxPB2mZlqxYrhNgastaRUmKXJ2zRVrk1DGqe1UEvbqqoKx7Kw5JWzFIxv262Hs8Mm5d284Ggp48E5lAJFeHN4xvlANQZDeyc/nC02QrCXTZhraejfpr6zDT/f0CkUBEWrYgMYKsY2XJMLlqXCxjlibCvDWhXnLMEqBm2JpKKkWjAF1mo5qTIYiMHjrcF1AUK83OwVaw3VwOQM2YBdVtQoxQnOGnqN3Jv2IAg1IZopZSVrZgiO0UbOpjmrs1QMjcG+5LW5n2RmWZ94t1o+vh6JfQ/3X4Mqrh/ADyAZZ1vyrnGh4amMRYGqyloqS2oSjg/1fqpKBnHUIuSlxapb29aLaENqWSzLKmysA2twtk00VZVqKt47nDbajqhQEKo04lRnWzdnsXhnKaJIbS/YpMpZK9EqTi1raY78QiWrxYvjcNEu+0sAjKpQaci4vrMspVJVL3HgTeKxiLTXuG3Ix+eUOGhm6yJFW4JgVSWpYI3hyrTgkFwrqrUpTEp7Ga+5IiotCfZD/a2XioELAcSoYvwl+VTK5dyAMU0bv/cGYyzWCMHStMXqsMGi1VAqFBVczazFkrKn8w1xaFCcbZ//Ii1leVXlpAXrHF1RplrIKMWA2tZoP6+XOPfa0IpSWwMYfPOqpNIkIUkrzjuCVKppRjlQllpJKXMsmeFCaCl6+UtatsTWdiy1stbmifIWshQ21rLWSmlZux/qPZbyjb3WNkpOrRhtgVwYw7xWgvFtY66WAC0R1VSit5yzoahBjSC2gmbOpeJN++/FOLwJrBe8ZnO9waxCQBhUKdmyipL14qtSw/NFb22kfT1ShGyUvvNYHKm0YUxWwTmLV2U1LVVVMaxUDinzVDN7Z3GXtGcVKEZZFa6sJVUliaAidFjOUohYZmkEH5UPD8D3VQ0A7UBbgq0KeGPQmtsZNG1q/3xaiUOPusaMC5eUaEzF9Y45Z+YqFIExCCKZxqFTSlWcCp1zlKqs1WK09ZJzKXSh/TuPc+a+LGTXcK6rsdwf5/Z1xtAS6msl10y0pv0zv33vNrVAh+VkbNPtq/BcVkouvHmaeNUP+OBR05Knl1Q4FeH71x1TbcnnDkGtY64Zo5WzCGJpPcm3qO9sw99W1K2JEdoHndvftZu7MxhrmIrSOUt0tukHrWBMa9q72KgpqQqptonqXDNJGkrOB0/oIqH3mBDbg0bbyzRJIlnLmUJcC+Lbi8agOCCzBSDIhJIQqRhr2A6OjQtgHKcls5bSopJFOdYWJ240kdORh2PC/fAzJDiKcagz2G7LKhYjekGeWRSHGteatCpkUZacWFLiw9vu/ZWU1gzVJOS13eqTNi66U73wqQ2pGIbY/t4omMsb0gBdcCylYtS0bQHtEqgCxtH0gtJkWqBEa+lri26fjJCdkIprKc5am+6/Gox66uXX15mmQ7QWsMrGuabBtnDODe8ZnWddM2uVZrbFUKUyaWVFGVXJ2iZuqwqrCp2N3KplrpVF28U14MjLiguxwWNwl2/4Q/1tlygtSAguw1ZlXSv1ogX9ZgC7lMrOt8/7G9M12vTQMVjs0s6laptUzrUgYohAkRac5sVdmjJDMJailVkEY4SDVMRUskI1jRZ0qi3SHVpaOdDQhw52fWTjLEtqEo2pFIIPaMrM1uBM+3qyKFkajaVDqZfztxhl0srGRqxxlFJZSpv+b6NhzZmtCQhgjCN8sJC892pWQtMGTKU13ca0kceaFY0N39kI2n9zReg7i618syigSmnPwEuQVWkTLAaxVAWMoTOeKpWlKk4Kq4IWWFQoRrCqTMWgevngpaBSUBVMcFwPEWs8qQinVVmK0AePphY2aDGNuIYyS2YRZbCGNiRVilEmBGcd3tiWbaLaMiKs45wzzrQNQ9vsfjiA76ucNiaEViXlhilum+1MQLDGYqzlNFdedLadSzUYsejlXTz0nlNpD0tFyFpJUkhO8DiWWkFhrB5rDc5E9i6jtMHcuRaSVp5z5iklbHRYZzmWgi0XOk4RsC2JGhWu+56N71lFeJ5Xjikx9LH1pQJe27BvkUSuheclc2Pi5QIsJKk85Iytjt57Vm2XTjFgnWHVQhT322eg5dtdOr+zDX9JmWorxlw+cRynnElVCEYxUqnVUoqQnIVaEGnhRt6BC4HbfcfbL84syyWR0VsmJ1yZyFUfiF2HDx1YQwyBznfk9cxalosmyvJYztypsIphRREqmMRd16ZbEyuHtCIFPtvs2AVPxBG7gBSYUiGYRigItSBVKGoptZCOD2T+kJItxwKLeqwEng4nap159aJxsasIVItT0FpIaWFdJmRdCObDw+Z9la6CZKhrk1CpNZwksSbF2opoIZuKtZF82eK4i5RLpE0edr3l+dyaMINQcMxkbmJgFxyptAspuTD2kaHzrFPlVDK5CskqX5bKJz60y68RBMNqhbuupT5PVZilBR995Hq2wQCRrfGUurKk1Fj5BVxV1FektgAlFwx7E6C2y0eheRZKVa6cRaqQmpL/opqupLVAUfYXX8kHDet7Km1yB5qqCjAc54WUS9OjVhB1iLVUsYhm2i1AUS04HNfe8lwhiqVeLnPFwKa3bINhLplTaS+3sR/Zh0A1laW04cKSMl+vmU9iIKdCVoNRw6nAq3279D1NK8eyoKbyvXHDbWjQg95ZkiiHVFvQjHoCFUSQalBVjDFsXTubJlqMM2hVyipEde15KdKegQakeupUKbGyCR3BexbNv9OP6fe29NK8//Y+L8yLkkrbstdq2oZPlQqI5jZ0MHqhn8A4BNySCMawVuWQCv1g2ATPLhjOqU0yjyi7uGHXWXRV5iyICikrD1XZoaxaLsM/w1QrL3ebdvlMhUfJFCl81gVGa7C+eehygXNSYrAkZ4kUTL2cJWOoThmxF1OxxwWLQ5jnxFYjphiMtsRhNQ7UUeYVcXAVPdEHFvNBUva+SrSdpZSEZanUIpykkEoBBL1kxySUnCuDlgYmwFKrIA5uu4HjecU4ZTKF+7Syj56r0RMxzOfEKTVE2PeGHa92HbYI59ICMmsVvk6VMQDVUCukVcnWcPOi0RPfrQvv0kQh8QfjyO044rrARgxLFR7nxF4jq4WYC0ZMM8XbSlFl0/mWQ2Is6g0ZRxLLlbTvxRrFOEu1hsrFSO8tL2JPF3uW/O0mv9/dhl+Ftnhr8cq+szx+/sCfH58Y8HixlFKZng70u641PalSRRij5844Ptld89TDRlNrnmrBGcuLqw3jsOVJled1JeTMP3jp2XeQpjNynljnlWnO3Dnli7pytx246zq6qHTGs90NeO+4lsAP2V8Y0ZXntZBqQm1gRpmLMM8T+2jxXjiUShXHQMXXA8clIzrz7utf8+ZRyL9O/Ch+SXUv+Z/+5/8ZMSW8i4TYN7zB+Tfktz8jDK/YvXhJub7+HX9Sv7+1zO22LllazLwxPL15y7+xzxg1OAfeK2k640fLeR1YciJrxjlHR+BH1zsScJ58I104mM+F7eAZtwOnZebttBK18k9u9tyNW64OkVSEpVQepoWPNyO/Pt1z42OTblhDh2e/HSle2GQlmL8BD5zWgncJ+QarJ8pxWRmBzgmLsWRrMBZmqQx9ZhbF20ivFqnKvGbOdSFsAp1p6LxJCy9tz8ZcE2Ng4xSpmcfzB9Pu+yitgnGXSZUx+Oi4n57587+csVqJDnrvYJ1ZfWA+tS0OUhlDwFH4/ouRea4MU6EomNDwsK+Gjhg9a5o4rxPZCX96F9htrng6rOQizCnz9vnMre34IiXuuj3qoCJsDey2gSpCHwZ+aAaGy/l7Lt/snipFm+xQSuUWOBahiMU5SxcMa27EqpUCK3htOEZnK8fDmXE/0hlD8TCReOkdG7uh6yI9jVDxdJp+dx/S73PVJqnl4iHx3vDu3QPH53cYmq6+d1BroRbHY4W6FowIIXo8yve3HXVKFBcR4JgTxgQ+HTpMhJIWTuvK7Cz/8PWWm33g/nFhWQtzytyfZjoC91p43W8Q2qazi5fzh7LLhh/6QAgN3fi8AjUTaSFGWizPKuysxRhIYvDGEZzhZMEjTHVFa6ZX3/J2rKXmxKllJGERzlIYqbwIA52PRDJlXTgcl9/px/T7XAbDcl44PE08Hwq2c3z++U95ePOLFiBoDKO39GRwiWlxlJLa8BdHdI4fvbqBok1Oi/I8JVx1fNx5zNCR3IHj8cjq4Cc/uGO333L/7om6FNZU+fqY2UTlV89PfG97i7PNF7Lzns1NR6nCD9XzJ/GK6B0pVZ6nCV8EsEhpxLX755kR5fUmksShF49WSgvdpuft4YTPws5E9p2nDJWaCk95bWGFprCUShTLJ7uXeNfRk1iXifvD6Vv9PL+zDf9vl4jW4LzFB8+PP3tNSgu/uX/g/njE1cpPXm/Z7694enoidi3a2Nl2u3t8N/OYVh7WRK5Kbz3RO97Nwro8oc60W5MxvH2bcXcjSxbmUlhUqc6zHyw/Aa42HvUOsY6x75AkfHU8c7OLOG9YSuLN05FilTpDFyMYy9UQ6YbI3rVp7J+vT0w5oebEL7/+Fbdv7knPX/HTz9/x/HDkpn/iJ//5j1jmnpxTSwIsK6aeCNsNQ3XU/Z8SxgF8YH4+/k4/pd/nKmttapXLAMfjuXt5Sy0zXz0dOB1XOmv58XbHze3A8XnFO4fHtelYgq+eFh7OC8c1YwTGCy/3aRG+zk8c1sSUmtTr68cjW2sZjOCNwTmPjh21FK7x7EMAa1GUzUUzOB0nhi7gnSMX5d3TwhobQaIzBq2G3jucC2wuiaT384mpZqwq51y57kdMLfiqdMZi1VOksLlIyNS2lMGOSBVLN2Q8mftFSRWWD0um91jSnoHWEozl+7evyHLizcOJw3FmcJa///KGF/stz48zMQI0xHAthXf3ma/TykEEi2VbLdFavjxNTCbxvGamJARr+IWb+JFz9NETvEGNJfaReUlcAXtnm5dJTcO6inA8tPOHc5yL8ObpxBrBJNh2EaOW284TrcX7QKTjF9PESiao4ZwW7uIASfDWMLhGVTmvQmdhrYpaiMZwZTuc7XCdEll5txSmWkkfsIjvpVq6c3tmGAM+Ov7os1uO68oXz898PR3pnfKHV1fc7UcOzxPVGdr589RSeXwqPKbMrC1IUCgM1fFuPvF4Vo4pkXLGO8uv4zPBbtg4h+8CgiGGtu2/EkvUZhw2wOAcvlqO8zNddDgNrIvyq+cTqg2cEYPHWMfVtj0rg3NsgJ9z5CiJqJb7ZeG1Hwh4rDGM1jHQCC7Gmib3sI2V/tJ1dDbifTt/T1PmVArL36xAPtTfctVaWUrz8FSFEAL/4Pt/wmN64Geff8790xOjN/zj73+PF1e3TOcDzgMa0Nqm5u++euLXz48sIjjv8c5BLfzy4cQjwrEk1tLSvH/25it+rEpvlcU1IMGmj9Q0c+0iV85iraGoxTlHrMLj4cTNrkexPM8LP//yLYqjRmW0EUfgejcQL1t4gL+cj0xaCAqHOfGDbsMWRxcN+94xeE/JmYilpko1hmgMexMxzuJdoZPCcc0kFfqu/1Y/z+9www8Yml4fgwue13d3nI/PPB6eOZhKdZWr6x0diqaMpIx1DomepJbOwND3dMZD+f+y9yc/l25ZWif4W7t5m9N8jZnd/l73cI+WLpSBqAyUJDVAqUohlVQSqEb8CTBhyIwZfwIjBCMGMEZiwKCkEoJSKkgEQUSQEY5H+O3N7OtO8za7WasG+7ijUhbSdQlz93C3JX3SvXbNjp37nf3tvd+1nuf3VNQqUymk+QkJnmEI9J0DEaSDUCt2IbNE3zF6xzh2dDXjnTAXY0kVrcrqC6lUpqlSvLKUwt1aWgKqKuu6somBXYh4HJkCAtdR2NAS2g6HL/j8//j3vBNeYy+/T5hgu93jbr5Np0+k8xHxge1mw82zK4zCYRZqTtjsqbFS6/mn/Sn93FZNiguCk9Z1DAE+2N/yNDsew8wkC0jh6npAxKgpUfNlXHwJadFLd9Zcc9hj0tKjbSXXZjrqgye4xnRWy6hCKW1sFwQ6hKu+o3eOXJWiRqbp/06poObIoTn1X9fEUANTLmQRNi6w9b7hHS+G3W0w+ou+sQYPpR3RvQhdE+ESnNEFz8EUq40IMLjIbMacCy98bH6Squg3NAy9rR+vfng4iIDz4DvHe7dbpkk5honFrXhv3Ow2OFFKzuRcMTHUGa62FHDxnhAbBGG2ynFV3tuNhGR0YlRfm7dIgNLCkLQYlgu7YPR9R6/tgSNrxUoz4s6zsKaCVWFxhVUrr6tyXQeSKw3PKULn5UIB4nKpUrpa8VVYmuuO6IRd3zHGABinXAgBnqSitICurI4kzaY7xA5XwRWQt6bJN1KiLRiIi254CJ7b62v8aeEwz6xlxkfhZrfBtHlJcqk4GtoymWGWEefR2tLKVYVjSTiEjQg+elJoWTZRmgY6qZKyQlH2nbDvew5LW6NzvUiKqnAOC8UcdVFmEuniPRpcZC6VIkLvHL1BcIq/rJOtQI/iVTl7T9d6i4xOGC7eQMtC7wPTxbOSFVKF5Buo4L3oqaqUcpGbva03UuuUmJbMslTEw2674frZc9wRXncPnP0R543bZzdIgWVaKSVj0szgUtpDoneCVaWU1hTOOaHied73bLxjjq3pFoLDLLczTStOC0HgReeJ+4E++KbaSIorxnleEQeHaeUwJ5ZamES58SOP6Yx0sBFjxNN1bcoPsAuOPjcKX4mBakYfHPuxZzd0YMJMZR97jqVZNQtQBJxTnk4TH3ddU8Ag6DdMG/+ZvfD/0HCx3/R8/MENz57tuLl+xraPVK3sx56SZvabyHI80wVHdM05lM0ugS4JK8agjSG8FGVZCqNdiCZWmLPgvePTtVBMCdWxcR10HeIiMUbmGqkLIO3p0EyQC0FgXhKTNle1V2MTI3cs7Kyh7BDYbwM+BJZc2OeBdKET5PmBw+mB/btb7OqWzb7j2ccf4OIOfy14naluhyJozczHR+6+/BNkeMbti/cZug3efbNI5bf145cVMBE2Y+SDmy3vPrvi5nrPMLbkv5uhw9fEtgtM8xkvFR+FasJpLdRaOZYMFQaJqFNUfygP8pi7HKah0Ufu1sTVHOhp5qHgWtJfLqUR5HB0odEmDCMrP6IEzWslWUHN6M1x0MogDmetq7HrAjhDs3FdA1NtpjixFj9vKHOAcDGlS3Ak2mWq1GZQzlEpUnnX9YhAdU3fG99euN5ImVOcd+x3HZ98cMW337vl2e0N23HAJHB1HBBb6L1nWc4ghRhB1TivBcvSDOMKG4ngYM0Vb4pWEOeIMWBeGgM6ZW7nzMY1U3mTcURqrVQVygXf6d2F+pMNwXFOhaoNDZud0gkcSqGzllqKd+zGDhciOWf2IbAqFGsktXNOrKokD8NlupW9MFujE6EXOpA3cMaLGHAY2SnVN2Pz23oT1fQs+13Hx+/u+db7z7ja39D1MyqFq3NAaGS603FCtNK5Fki1rIlFjak0v0+nDk+j62RXScXa/uYa+UccPKXM5pwYRBqn3wsxeHJuIVlFjegbnlqLsGRtRLG1NkOwQDWhc4EzRixgtO7obhOJPlJLZlc9s9Z23qtwskKyTDHPStNK54vL2LI1H4Nr2uoaYO9jkxt7IcQfxZ++rTdQn35+IlclxMif/7UX/NovfYf91Q1950k5c70ZQM/03pieDlhNeGeUCqfzCrVlgFAvybkGNRdKrWz7DrSZXoNvHPy788qmm9iJv4BTHF3oqEtrNCQVgvdsB8eaC+dUyCjTnNpri3EqhdsAq0Ffmp9KHYzbDS540prYZs+UCrVUHMYxZ2YrqIb2UGJN6niSBgkR2sS1OgcRboceL1C0UC6G8m9SP7MXfmjdoP2m51sf3XJz1dP1I9uxp4sD715dkU93rOnMhDFut4gpORXOx5lzyryaF8jCUFpwzZqVulR8H1iskpJSVwBhUs8hZX75asv1JhA6oVzMH69LM3BuOmH0gVKV0StejENaKFnxZuwHz03XcZ8SnTq4cPLDXhiGHmPFu3ZRmqxyzmd6nZnjLXLzLuOwZ/fBx5gJebjGpXNDhBVjmk6cH19x+ur7+Fvh6vY5OI/4+FP+lH5+y6ylm276jg/f3fPhO3uGzcB2OzB0HetpxJYnpBpPa26GL3e5gC+FnAvHmvEKOyIqxmxL6+SrNIa/WFPaq3C3FDbHlQ+2jj4ExDnUPMe1cq4VcZHRO6I0LGtRCOI5lzZtUoyxd2y8x2OEqqhVslXi1hEHR6VyXB3FhLMpqxbqxf2v1IbVc569dyR19DTsp2kbr9ZQeR47FkuYBxD8W8/aGylxhovC1b7jOx9d8asf3zBu9mw3O4Zh4J3TSJ3vIbdkUPGNfJKSsSxKzsZcMkGFzodGr5CGOV5yZfUV9W16IwYPS+VlyLw7NO0rzmMukNbKqRTEeTbeEbxQ1SgK3nmWnCip3br7oXVJy1KxJBQUoifuhb6LLFUJzjNJZaHhPZdaWRWmonSUS/ChIyuM4kCaqk4xnIP3ho60ZIoYWRq952399y/DwMNuF/nOh1f86rffYRi29JuOvvOsp56yHJFayWklOsE5x5qM85xZqjKXiivGQECdkCSDCWvVFoTlAQ/ejMelILby/iYyBIfzDohMU2IqhQFh8I7OR5bLFEBFWYoC0lDd4hhc+7OSjKKV6uF2M9B3gZWCiJDNMVtDbR60Uq2ymBKsEtUTcYDRqdESVqR1U73jna5riG0PgYYifVtvpj7/asJFx8cfbviV77zgz3z3PYZxZBwHuq7ng9s95fwV5JVlOeFc25NSKhweFwRjUsMpbQ0aTCljvvnbHpNSL764qsrr80IQ+GizZRMDEiLieua5cCjK6AO73tN7xaxNrQrKacmIgQ8OUyMGh68Bl62Zcb3w3Anj2GO1ZVJMubLkQhaYSmUWpeTEZEpoUHlmJ2wEevGIeNQJ3eD56HrLeVrIKbOqNmrbN6if6Qu/D02KcF5XPv/iS/7vy0zc37C56umDsNqBz48JN1wR+kidz5yOT3x2v7CkRPKVPR3t57HhmE4YKVYmK6iBZlimwmYcuD9mPth4eotNdOM6MPhyOnODIbkdTiIgO+gwlprBaAjDsWfX9TyPmTQ3XZjUwtePcFWFgPCYM/e1MlF5KInr9Bp7dceQbuj651QbmdfM3Qy74OnTilNYt0LoF8ZnH+C2A9VgSZX0NmXyjZXzEKKAh2NK/O5Xn/FXfuO3iNue/ZVnE5V8OPFwN5FxWIikkjmthcNUqNowYfvgEXxjiatDUY6sLQBODGeQk3EbA18/ZZ5vBjrnUXNUNVZzPOYFcYKqa1x/WicXgcUS4Bhc5KoLjL3neo3UtbDUQi7Gw9lzqz1ZC69S5lXOLLWwaOXGSQudUcOqtqA659ng2QZh3HhyrpyWxDYODJ1jTUJ07eKX3o6030g57wjRgxdOaeU/fvUD/qc/+z+zHQI779iESuaJV9NKdhGTwLImTnPlcbmwnDWzDU2TX2lYwVThvmRONTEGz+g8qkqX4etUuN30DWMogtbKWiuPZSX6iCTBXVjAxRxQqKJIgEE8227DGDv2lkmlsmohVOXunLhRIdfC6zVznxMZpeJRn9nFiPeNhqLiqBW2zrHtI7suUFLlOK0EHxi6yDS3TAFXm5Htbf33L3PSchy8cEgL//nVF/zGu79GH3fsd8I2FubDxMPdivnWfWz7ROHh3NZIpUkDRYQiLYxQi+PBFuZqDOIZncMqSBUeUuLdseXOZBwpwZTgoBlfPT61Tr4ASymtm+sNR8PMjpdMnufJMa+FuTSK0P15AYzZCq9T5iFnsikOaRKxPiBqP0I6AmycY+xg3w9YgfOSCAXGnXBM9iOCS0lvKWVvqtQgBI8J3J8O/H9+8O/5re/+JYb+ms11zxAr2e54fHkA3yEukNbC4bTw+jizC4E1QOcjvvNtElkr0sGX+cxUYSOBUTxWlY04Xk+J9/ZX0PUUcxzyymmd2tQyDCQ1irWMnUGEqm0i7kwYg2MXN7zYjiDCcT4xpYzzysPT+ZLOnPnyOPPqvCBADJFKZRcjripiBRc69r5R064C3PYjpRqPy8o+RMax5zglQKi1ktc/5cFbzgEBslbOR+Wgwn/6z7/Pr//qr7CL4MqR0AlXN++yHBPLcWad1zZiKcopVfwIDxmoijNlo469F+7XlckZg/lmBELwKsQobHqP72Fh4XA4UlbjOM3UAJ8Mnve3EcN4qJnFu2YAwZAo3Gx6Viq/dHPNUzczLYWUjWlNLPnAXVDwjiCVuCbeI7KuDvwtuxDoXUHLkS++es2rVxOffPwxtrkC7bAc6LnmLnlWN7I/JG7rkd7eElLeZJlrF9rjuTJp5Y8+/4xf/vhbDDLh6wEJK85HYOV0WtCipNXwtAwH1FGJBDGGANHaj9zXpxMzha04OvGYa2NvfKCPDhPl/pz59PGIYZxIlASf7Abe2bROxZ/czdAFXPGIF2J0vBh6VoHvXF3zGFamy8/D/SnzNBVeyYlTNlQgdo4hCZ0KNyVi3kgekrRuh49w3Qf2fUA7zz54ui4SekcvkXiu1G+oHXxbP345dWBCKXA+K4fzxB//4Ad899vfodMzku7xMtF1ERY4nTK6Fta1+S7WVIDQNtOLP2NwAgS+/3jP7AsdPdECQT3Pdx3HXBj7tu4fT5nP7meKOo4ommY+3nW8twmYGa8eV1YEb4B3dF3He7sRrcqv3W55WgtLUWoVTqsxrxOf1QPnBcyBj0ZPJQK3NFN8Nc+kjqMqi4MPO7jaBurgGaPQbTYE79iMPVstkKwF7Lyt/+7loqNK69LfLcqnX73if3r3FR988BHUBdKBjgnnHQnPcc5oKSwXZOKqleqgc+3CH8wIEtiPyveeKrm2h8R48enddAOHOdH3AcRzOGb++OFw2f+UUla+fd3z0XWHGvzgLrMAPe0BIPrAe7uRlcKLsefRVnxWigqHRSl15ks9c1pqy7hwrWs/AjfFXVQRDq3CQmv0XA09z4dI1Xbx7LpI3wdeyIic4GzC0r2V9LypcsFDcMxJ+frlwt2rRz771S/59re2+Pwa5k/xckfsOzjPPMzn5ucsrdFxUkMRruLYmglW2Wzbw+j3j6emknCeQPPpvb/ZczgtjL3DnHL3MPEHX97TAU8dqIPvbPd8dLXDDL56ODG5TB+biiSEyMc3e/DCu5uBjQmHOXFOmfuLv+D785FjyXS+PSRkqewcvPAO5LJfO8+iDu+FF9cD16GjVCX00G96Ru+42e2p0vxPJ03f6Pv5M3vh/+Td97l6Z8+f/+63+b/9hT9Pms8cHx/54+/fkbXJILyMbG1lOkNeMrUYYo3ysHHCe7sN01T5+pR5Pa8spZBz5b3bnixwLspajRA9KRpDMX73q1fMnxdqMa5kSwXuyoGH4AhkrrrCh9trpkdlRXnS0kbiCJ/dL6SUGbsWCqOABCPieJwyD4cJCa17UbVymlfO+T8wlk/4jb/wl7l98R7LMvEHv/u/EZ/9MmW+o9pLprXjxEB3fg1p4UXY479eObDhXp7/lD+pn9/yIdCNnj/3nQ/5f/zF32I533H3+sQf/Md/xzzPaKmMnWMTIkuGPvCjZGho5sdfuR5Y1fEwrzzOuUkpUH7pdsuSMnOqpGr44EkjdKnwH1+fWMXQCjvn8cmhzJwsc0oeNh0f3m549bAwpcJKw5e5nPniaDwuiX0MqCpCM0x6DzOGZU8vF3Z2Es4587IWwjZgq+DNMUZH2gBeSUC5eAc2ApMmer9hf70lIzzWI5+9NY6/kdrue7bPev7HP/Mr/D//8m9zPnzNw92J3/93v8M8TeS8Er2yHwamXOhFqMGTcqGwsgK/8uyapK3D/jgl6gU59evPGj96yZWcFC3Cl3mmr55//9WJJC30b+d7+prxVTnayiHB+9vIx8+23D8eqDWRfthyzYUvjxOPc+UmevzlAHNR6F3r1LrZEaxSzVEtcKyJx7ryy9set0Bn7edo52HrFSVQtZnptltY8kIIt7zzzFG8cj7Bvc4/tc/o57n248C3PtrzW7/yLf7Kr/86T19/yau7O15+/gPmaaaUTPDCZhvIubK5BENnlEIhUfnOfoupcX9K3C+Z+bIvfvdqw6CRpG1qrqvxyIJ0Hf/+iyPFAXgG30PK4CpPuvA6KbfV8fHzKz57WEAL60WSmCnItHJ3mrjpIjF4gheca36BORfmWX8UiqhFWTTzslZs6/GrEA264AmDElAygZlAF4StFOa8gL/m2fXIChzszKvydv29qXrnas+v/eqH/I+/+Zv8z3/+L/Hw8g95/dmf8Dvf/z3W45GcF3wHt9s9KVc2vkODIwdl9ROq8OvPn4PBy8PC/Skxl5bb8eu3L/Bq5KqstfnrXqcTY4z8v/7wa04lE8TzYX9DYOFVWvh8ecDZwr675Vfef8Fnr19TUFKFXI3JVuReWHNL6O192weHLmCp8Pn9xOGChw+0JOgpVT4j8ct4uixsvWfbC3il1olpDcQQ6YbAtvMsa6Je7Xjxbk+6qzzmzCv9ZlkkP7MX/neeX/PR+7e8tx+YzhN1bimhJgUjohYQq6x1paaJ1RzZ7Zl9x1EXHnXlo+DZjoGxKEOtRIHFC90m0AlsqlAjrEnZdp51Vg7nTLIKIpx8wyx6M5aSeTgaL8VzZSOaKt47thrwJqgr3KdCLjD2jZqBNYPmUpSnmnCxJb1Fg96EexRVOC/wOAndnJF0wMpEefge8uGeELd48dSS0WFDrBFlT391jSsJ//UXP+2P6ue2rsaOT57veX/sON/dMU9nltMZ5yrLvJJSxqqHoaWKltqCQJYCC5BrpQpsYiBXJRelVCVnIEDnA9ELNRlVhVvvKL1nLYrzHnMw5XJhOjmWUnhYFu6mwPNxpPMdISp+pRmBzXhYEvOa2QffkiilGYmywVETFcVfMJuGckiNenHKiegbvq6K0Zf2nq92nj5CLsoxVx7Xhe248DwERh/ZhA7H2wPvTdT11ch33rvho03H6e4V0+mJ5bTinHJYzqR55boLTD4wp0zJ4KqyJmuhSLXgXUvhLTVQqJxyQZOhF/rK6BqdZPHGlWuymkMx1BvqlElXIobzDT38OBv38bL+ItyEkSW1iRBqnJI17n5wLbnUGSLKguORhRIaA33jmvD+IVWWXDmWRI+nWqUWR/SBY4FPxkCMnlQrj2vibslsNpmrEOlCJLhMfStrfCP17Lrnw2d7dkG4+/prDo9HTk8LvRRO88y0ZvZdZAiepcC5FLTAmpowv1bDiRBDYLuBhGJzk9mw9WSfCdWzs8AaldvRo+K4X1rqsl4Mi11sGuxkyuOauZ8z766Fne/oo+dUK0UNq/CUUyPpxdBSpAXAWFAeL/r9MTgG51E1Pp0Ts1aOuXIVI9mMpJlN9kzAR888QxRSrjzMmYd5Zrvp6bxn9L69zltFzxur57c7PnnvmutYePryjzjev+R0fKBzysNyYp4Xno89dcyck5HSilRlTQ08kHLFi6PrA9eml4fCzJoMRlCEsUQ2Gdas3G4ignCfM2rGYoX7fOYKR3DCo1Ye1pX788q8KtvY02OcVyhiVCp3y8JaEi/cQC7aPCACq4en0PbJTYwMIZBq4fOnJ+ZaeayJG9cRtGJJ8Z1jXoXNOz19aLLah2nh9XFiMw744Bm7yH7s6A/fbMr5M3vh/+B6x3ubLSOB8/lEPjens6IUUxDBiZLTCiipKtn1WB8ZhhM+LZQa8MHThcIYctPeF2EXIiIwhABRuPet+6oKSyqtIxA8ixYilWrtojavlcM5cx8WVIRVKzvfISZtuiBQq1FNG87s8kF7EYoUnDhOqZAMorSY72rCaTny6rTiNpmtta4JOiO1gA6ocxRdWGWgD4JJRP0Gx8TgX/+0P6qf2/roestHmx1bFZ4OT5yPC2aJrMppbhSeITpSqZjB/amhNoNzjF07PNbadPomhnNGHx3e2oGDgDOPmnLKyikVNl0kl0JFURFSbUl8ySq5FmYTjr7wFDObGDnlxOCEapBLRUuLHs8VML38HU0LeS758gDQ1qe/eFtEYHWG+GbUE6xtDAYhRpy0iPGHnDnnypwq05LonHDTddyG7qf6Of281i892/Pt/Z4dwtPDI9P5hGozWp/WFS2Fm8430oMZD+f2a0GEXezI2sy5fXQtTTx4NhbIxRgvF+7ghRqMpSbmuXC16SmaMVPMwakoA8JqjcKzpsppytwfM5voOKXGzs/AWi8Xb2mECm/WvlSpojzlivNCtRYU18LiBFdg1UpwDU9rckkSMIixyUGWrNxPhYecWdfMFIyAcBUj12/BBW+k3t/2XHmPzomn/MTT0wQ5c77wv3Ot7IjkS0DX/XmlFCOKZz/0LKasFcxLk5RFz1gCVgs7H5sMR3zbu7SiLtB5h0q6+JOMtbZzv9QWIJiKcpwyd4eVMXpKNjoPWGuomBrgWIrSIXhpUh0zOJbakpydoBcyUOcDrhYSRnXSzm1VfCMSEKJHxFhq5T4nHnJhWStTSHgR9l3H1dv9743Vt55f8ywEZD7zlCuH+yesrEy18jSt1FLwm4FaWz7Dw2Gilkr0nutxy1zPnHOheqFieA99EFBh7DoQGIJDnZFsxQh0MSIy0/mWTj7bSqSjXuhmOSmnU+L1/UTvI3XJbKOnOGMtwloLJRuLNxzaUimkkSFP2szn9TINc87RR4+3gnnBLgRHEDY0uEeIAScwpZUvj0fu55Vfypkwr3jX1uB1/GZr8Gf2wv9iO7CVAVfbk828rvSdY1WlasU5hwtGXjPgKLVQAvi+Y7/dMU1HZhmIYmiTROFwxAo7DYjAGAMW4akY92uitya16USIZi18K1fw0PtAcJ6s8DgvXI0DatAP4UIdqHTiyVKYaiJqh79QC3wnxNI+yKkWSlV65/DBY6lwXh74+uFActfcdpmuayEKprAmAQelVGZt0oqiRl2E6Dpc//awe1P1wWZgh0eykvPKPK90XeY0KdPSHgydeHJu47SnaWWpyr6PfLjfsJZ6ecDLTDmzWmOL93RsLqmP6pTZFbIVDrkwRqNa/RFXt6ihVKiVThs+cVkqLw8zz3Y9p1UYQ8PJpaIEc6DCKRWiA+8Ef0F2pVwZYmDSQhEh4vAOuihoEIoAZvhLwjW0VEqxFkZ3ypmshhY4zondGLjqA8/7/if/4fwC1Lf3W26cx2clr4lpTsRQOU2JdWl8aHFCzRkHHKaFJWeuuo4P9hsWrTwuhVholxkvDBoIAW68Q2hozKMUFqssc2bTDa0ziuKLMldj8UKplc4ER6NLfH2c+WDXc7TCGAQzYSnStLDOcciVwRmDGCLN4LgUZReESSuGsPGebRc41YAJ6I8wjYKr/9WYnq0yp8xxLay1UkrleC5sh4HrPvLOMP4UP6Wf33oRI2EpFFspA6xzopPMYc4sqeJdQ2f+0DR9mBJLqVz3HS/GgackHLPiSsP+mrQL9FiFW983WQ3GRCFr5VTgRhyKIAaiDYlZaiOE9Rev3bQWvnqc+fhqg60tbdq0XcQC4JznqRR2ZvS+hRJirWmxcY7VWtMwOmETO8aaG3bYDOeELjTCD0BSRdSYc+ZYMms1aoHjObHbdeyGjhfj2/3vTdWHu5F+zZTjmbRpa1BIPJ0S61zogxCDY0kVBxynhTkVrjcjH+92vF5nHpaFWCu5ZJZcWsPBB57F4cJeqpxcYqLAnHlGwIDeeRzGopWVQs7NBxqqcJoSn79+5KNn16gmtoOQilCqMuCZNPK4ZMbgMGk4UGgPtlsisyq5FDqE29iRnTF0LahQkYvw7bIGa8VXOK6JV8vEXJoHZUmZYejY9B3Phm+2Bn9mL/zRD1SLFOswF1gtYesjq3dIyogZGiOnpRkwmq5/AYngI+I65qtnnM73PErhJBnqJVgot67mbImTFV7OCyEKIUHnPeHSFfXmWNfC/nrk2TjSDQ7xSqqF0TuutgO7YWx4sFTB9cQ+81U+sXfCECMutk7BzbDlkAourFSD4oRt8CxT65R8+flnfP06c7OL/A8fbDARVvPM5xMilU4WZPY8Xd0yL4lqZ/ouYPX6p/kx/VxXr8p0OhJt5PnmhqrGvMycZnBWGX1jSx/XjFkLyypAMUXXQlkSr70y5EbLqVrYOM/OBfYWcQgPtvBUF16XlY6A5sLWCaKCVXCqzMBNCew7hwZhdpXP1jPPx8Bt37WgGK1M1tB0MXq+Tmeu/MDYR3xoYVreOWJtONDVVaI4QvDsxBGdo+RC1ZYuuNSKYRyOE8EpU85YKWht3dnjmuk6R9859puf2W3kT3X1wHSecWpcDT1JjXU6M58hFGGI7XA4zO2Bc06FtShRKmtaKaXyqAmbHJttQymKKNHBKD1OhMc68bSceT1P7OhY14lN8GAOU7BSOZfKDca+78gBTlTSPPHuZuTZ0OFdQK0w5ybDQOHL+cxN6Bijp0WFGIOrdBqpVjlWKAi9i7zoLhx1KxQDs8CkLfDo6bjiqUxrQktqowPgOFdip2yGnqvd2wv/myiXhXNaCVsIQ09RY0pnlsXTmzB6ITrl6bL/paQsGL0qNTWizZ2upFIaPccLFSXElpzsBI4581gWnnLCJBDWQnCGd43aE3FUZ0hNvON6coAzSjnMfLAduN0GnDkcxlogGwSUlymRNbATTx9jS981GKpwpqDO2PrA2HdcW4eh5Nq0lj5Elsv6OxxngiqnXFFVgipeKsekdDWy6T3X27cd/jdVsRSmhwWfN1xtNkx1RacnTpNjK46rEAgmvJ5nwJhVOFbD5UQtCZ8zL2sC9RhK0ca+v3bCgMc7x7GuPM5n7s4zc87400yIShQhVGHEMXnFzcoHXdsDX2lmOjzx/vWe231PCB5ZjTkp61qIXeD7p3tuY8dV7JuaBNjHwEDguK4N2hECV74ndJ7YtZySXBXweGeA8erpyNZ5zksGhYjQOaG1Vxxd59hdb7/R9/Nn9qR+8fw5x7Lyan3g5QynyUM/sgmKnReWeW4jnsMJKOy3G7rHiaHfsnv+Lp/c3tBVeJVXLGS8izyKcVie+KwuxNjzOK88LAtFlOdXA4XSRs4CRZU8NXTn/SlzVEfIkeBhEOOT68CHL0ZeP5WW/ofycHyEYBynzFfMSDC6rkUw7+k41UzUdvmqRZlzpcuOVKHPfwD8AfNr4X/7fOTev8dfTFve2RhjcHjf4e3EengF5RGWlZwnLJ9+uh/Uz3GNN1u+//jE91/f8cf3B57M0JTYx4h3jpenxH+4P3FcEqei/Mp208yxs+PL5DA8GwJRQQqs1cjA6zBzyJl3NgNzVVZt5BTnhC/SwqYPDJ3/UeLp6BwPJA5UKO2534vHdz1XW8/Lp4wEYbtxfPZwBufocLzMM6VMSHD0OAaEOzKuAiIXY5xw2zk0G5suEH0APKjw5BJTyWw7RwVydlAqwTued42VXSpI/ZndRv5U1831jt+/v+fpqyeevX5s6y/PvOg3BOd4dV743189cjcljmvhL1xvcAGmnHh5EHzn6RgZoscy5ARSWyjbw/2B9/Ydx1KZsoA44nXktWY2zgiucZ83ePoE92nhsShUuYTCGX4zcNsHvn6cMQfDIHw9L3gCWw8vy5lcDXFt/V174SgJLl6XkylnjA/HnkRrtvyId+KFFOFuSez6FoRUEmxqwzU/C8JwwUDW8hYL+yZqfzvwvccD37s78UePjxzzisNzuxlxRXh5zNy/PvO0LKSsfGc/4oOjpMqTVboY6BcjuK6x+ktt/PuqHO9nnu871upYNWA+k7zyqq4E9TgvuB76KtTieAKOuuJzm1iu4vFdZL8d+PppQZ1nGDoens54J2y8465mvloSskCPY+M8B79SS6UaPFERP/Ph6El4QoFgbbrApmN2xnFVNr7lQFCMXXWEzvPce4bY8LFS31J63lQ9f+c5/+7Lz3n1+ae8+PorHtaVaza8ux9YfebTaeb1l3e8fJp4Kpm/9PwZMTaJ9WFaeTbeUOfEMETAyDkza+Z+Lbz6g8/47nvXVGDJoApuhM9qgTnRRXdpqrb3kr3ytSVc9TjnODtPtwncXu357NUTU84kVzlp+wOjc/xgObEsB6JzXPmBd7uOr9OJtbYck/OSEe/5ZNdTa2HvHA7BqqdUz1xX4qToKCQgEtlJk5wTlCCGVsHpNzuDf2ZP6penA8kFqmzpN3s8J67SI+qVV6XwlD3FRhg91/tnyPpI6DZ0/Za+ZEqaCJtrrsOOboTObwk7x8MdxC611EZVBoPN0DH6jsPcbmbRQfSOfe+4741zStQ5Y9ljMSDR84PziZtDz6vjzJoFwzNJgUewGIguIK7pVDce7qczxbsLcal1b60q74yRNUHxlUkKq1VGn9ilz/n8T0YOV9dc70du9wNXe8/9f/59rgNs/cI2gn1D7dbb+vHr1eFASolUKsfQLhqjD/Sj52laOc6JXJTBd2x883msVQnBs+2Uq6Hj8TKBik4I4hBRnhZQr/zJ8Ug1wwRuusA7vuOUMs57Ck0GsXUdM83oawaxaxHdDuEP7w/8Uu05L/XCF25eFl8vvPWuGeXEIJpx0kJxDly95N14Og+fdHtwytmMk1ZmS2xcxKlycoW1OEyVITQJ0+/e3/Nnnz9nzMLo4XZ4m3z0JurT+0fWNVFMW4Cbc4yuIwZjKStzzqhWthGuCSxV8Sr0nceNkauu5zArzc4lBBTxylShqvK9p3PTpTq46Xs+7CKnDIRARsGMGzfw6DOZNvHpXEcXOoJz/MnrJ8qm57gouWoLOaoKGD2OXYzMVslmmCmP6eIZcA7pHB1CLYX3NgO9Ew6p8KSVs1V6F6i5coqwzB5To+sjPir/4bMHfu3dPUMo9MGxC2/X35uoL59OlLVgWZkUHJ4dkViVc62cNQGZfQzUSNuzqjavmofr4EkUekCl+dlGlFM1qje+mBeqGoqx7Qbe70ameaH2LVE54Bl9x5EC+ZLRJY7gIwHhv7x65MO05bhmShVyNaBQNRCrY+dgvaw/gAnDqeC8J3rXcK5aeNGNjMCTyzxq5SyFjQvUnDlVx+IczoytgAzC73515FeeXdFLoYuObf8WC/um6nuff0ldV4IKU1EGAn0MiBRKKVjRprbYRLYaSM4oFw9G8oGxA+ZKSk0aqFYvnfPKQuY/3r0mXvDqt33Hd7d7HlPChkB2Ld12cI6X5wamUDViEIa+wznPH35xz/vHhcclYdXQorA2F/e263ghcKy5ncPOWDCc9wRnBGsSNUT41d0OHxxPy8JdSpzcyoBRkpJy4aiK0f5fwfj9Lx75zosdm50Rw4Xq8w3qZ/bCfzcVrraOXQcxGquuPNSIzGdi/5x3Nls6L1AmrI8cngpdtyXEgXNeqBQcA/0IzgpRKhuX2PoRqVvWvGC9sfOO27EnykDM8DificAYPWwEyYmrCzu9ujaSrNV4mFf++PDE0zkxreAl8Gzb81RW1HeXIIGmeY0OilOywrV5RByTtOCjXeyJDjabDu2Us2XyAvW8Uo6fcipf4+fIcOjJ5jkfHnGhY7xyxLFH3dvuwpuqz5/OBO/oveCckou1hLylIbx20bMdAiVEjvPKqVRyVQZgzpkW7C4t1EMENY+Jw7lCtgoKJo0HvYuBZ13HdRd5LCuLglojqZzzys5a3gMimBi1Gq/mhUpu76saXoWbLpCKkhHiJWPCBGKgGeiq0pvDXcyRtSg3F/3fSKHTxJMqrkBJMIfChOAqhNr0/WmF+2klbiOjC6i+PfDeRH3+dKTzjt0l+v2UE6XCfM44U6IJHww9s8F0Tpy0UjC2KmxVm+fCGWOIqDXvk5qhPnPKSwsY8k0Du/OO58OGZ33lLmem0ozeE4X73DCvAOY96qFo5bhU/jifWcwwNYIaO/GUUlAXGaTQ1PrKJkIyTynK6BqqrphRi/E8dvQibHxHrBmpCVuEuignzYjL+AoxQ3FGLsLjlBijMIrjbRTEm6lPH86MoZmyvXec0soSPetSMDNGEW6Hnmzwei081YqqsVHoYvs95pSxi9Qi5CqIeLoISQqWWh5IcG393XSBvd9wXxayNuDAJJWDrmxC86qZE8wZVDisynScKblgCg5hFzrWVVEniGuSy0Jr4OEdS86MBDwtCCwB1zHgDWLwRKtELWgxUq5klOwBNdxlklStcn9e6MPARiK5vF2Ab6r+88s7rrrIdQiETnh1XHA+cz4uoErnhA82Izddx+enift1JWHsMIZ1ZlM8KSovQiRKO0OrtvOS0rGUQgUkCLex53Y3ci0jXx9OyGUSNKtyrJWrrsFenPeXHGbjPCvfqwfmlNBsRHVcx8CxKFsiNTQPaY9x1fcMXeBwKly51rTLpsymPB/H9kAcPH2JvC6JnJtMeFElOUW0IrkiNK/AtCibUAlRSN+Myvmze+GPwy1dB8GMeprpNJGcx9ETQ8R7ofMw7l4wB8ELhEt8/KpCt7uimpK1GYacd4yhx1SoS8Uk4ENAnVIdDA7215FT9S0NzUHoYe892yicTSnSOhXFDFeN8zQTrBk7qlaCCe5icMNBMEcnjq33bHzAZ8/WRcwqTo0hNrnGZnD0nW9PlFVJ0rB5p3wghICTjpp7UhGqrSyWkO5d/HBDrm8vW2+qTA2H0TvH6BxVhEMp1ApBHF0wvBPUQ9dFEkZSI1djSeUSCCScreIEghOieIYgzTykholSRFiKMQfDi7GqtRGywFITjsqmc80wdnlfpoYWIWVjCJ50oVftu45KJtGCvDyCd8KuE8pqxCT0zoO1hL4gTZMfABFhNWGozTCeaB0NrxCsTSlAEGuJf1dDkyvlt0mnb6T8hXTTe8/oAr0X7tdE9kZn7fNCWmBMHAOhNHxqqsa8Ktq1C8pxTXiMLsC29/hqaOnJyVhNqaokhLkK8cJ5VhUM4VRKu7ThmC/TKCdQHWht8rJd9CylUEwZuoHVMlmMQSLu8qB60ztOtdIZIJ5kxlLL5efBE611iDsT+txMbsUBKgQRooMQDMNRO+MpJW5qpMPQ+nb9vYmKF/Nsu5BHYoBzMapxMccKIg4nMPQRtwqTFVJV5iWjURHnOKeCM6MTYdMFRjOeilymPxUVI6txzhUXhLlqMzkKTLZStDLiWKytZ0cz+xbr8GZsY8daC7lWhthTckGozUBOk19sekfCeGYBLJDMSFYYnW/mTG0kNV8Vp2ClUYKitP1Tgepb40MFTjmzakdvRnmLhX1jdd33BGlUw72PuMHxmDK1GlFaAwwxgjj2Y4+kTC6ZXLR5HX3EB3hKK7137PrAzdC1z1sFmVcWp6g4sgnHpRAHzyFXcm3eokPOmKuMEllQrCpm2qg8l/DW67HnRCalSj9E1iVzxuitTZNCcDzb9CQt3MSBao5FW6ruGHxLNrf2ANxrA3RoVXDQewjBYWrkUjAVcsm8Pk8M3Za9c/ANZY0/sxf+/faGPmTKNLMcE31smmEXOqxkLCeqdcThBcUJw7VQTUkp4bJjt7vm/HTklFIjnDhH7wJRWnfWRNDgybWlOookbFTCGFhTIXmj7xy3MTICqWTChXhS1OiTQ1ZlO/S4DhZtl78+Bo4p400I5oi0LtSt6xjEoxfSz1YCYQi4qmyCZ70kGqYMQRuuabDMRowNbQNatBI8uB78Zo/2z5hObyHAb6pG16QE3oRt7AhBOOeK4PAo1YxjMaBx8wcfKE4u/oxC7ANkx6kmuuDYxsjgHEPwlASLFqq0w+SslTtJ4JW5KC44cEZKLZEvdtJMkRiigpcmmxjx3AwD55I5SSbEiDdDa6YTjzMIDq58YEIRE8Cj1ggYfSesmtqDsmtoO9pwArxjEGHAET3gjLWCx1hyJtc28aj57Rp8E7X1kSIVzBgscB0CB1LjCRqsaiyl4M0jg2f0QqVQC5zWjLm299wvic7DMx/YhsjGdZQYeKqJRROpKGeUVy7jnHEqirMmwUilEh04E5Jpu7jR8IXBCdd95Cp6HhI80R58DcdaFoKLDEAU47YLxDTzLHgegUOpWIEuRhZrHbdFmjRI6uUcj44tgU0IeDFKKJTqqa6yltLwx6bw9sL/Ruq665hqRtUYpCVuz08nLDoUWFVJeuGcR09XBVUj1copJcx1bIGHtdB5uB0i29AaaktxrA5ElVKNsxmyrNAL56J4HCLGXBMBQVCyVZw5PL6hg8Vx7R03/cChrDymtXXpO1iLAoLH0YvjygsnLbwIkYfqyLUSKuyDZ1WlU2UyY6qFnAo1O9QbO+ebvMwpk2XUwGiIx3bFas2+t/Vm6pP9FXfLuRFtNPDRuOFxek1wAVCWqqxWcDUwDAHvBZvbBPy8ZnIUbjXw1XnGB+FdG3jWRW66yKlvdzmjUgROpfLF04IrwsOSWjqbGFNJ9M5wBtkuEtmqmG/Bqs+6nmf7ntdx4vVpJvRt3zuuK70L9N6z6QPP+8D9KfOiG3lZKqlmOnVcdYFzbXfGc8lMS6YshVJaeOtV33j7qRaOtbImpdbC41x5ftWzs4D8aU/a9fWJKh3J9eRxyxB6KCfUV+b5AWfGsN1Sa6Jbz8zdNeo86gPqK9BRVamxb3cXnQlyJIyw5C3nYjip7ARcrTzlxOt54f040AVBxHgvdDzUNqpEhCiOLgSiGtO5gotgQheEgDDEZrw8TCuuM8Q1Jv+alBvzTF45WSaZIV7oIjz6QirS+L5UnEFX4T6tvNf33MYe72Bazxxz4t39Nc+f3eJi5LiuPJ6nn/ZH9XNbqkq6bPCDClsgVlgol06X4b1jdFBLppjiMDLGg1VCrbiiLE6pKsS2LIneSBgTtcnHLlzelAsvtfJCIlhLgtxZx6kUTtCkC9JG14OPdAi9d2AFucTWh+jYWWBeE+Id2RmrKrIqV2acvDFJpdIQdGGIfF4WNuo5WksBJrTuf1Z4N/SMUVAamm6qKwOBsRM6qaAtp+Jt/fevVNqesIjD0bT6LoJW45wqVZXg4SZ6clYqinhDTXnQiqhxHXuqr5wduOrop/ZwZlYRV9mY0F+Y40tZuDuWtv6kXWq2FrgviaUTeucQBKlGRBgERhrNR7QRVaID6wJDCVTnmwTSKlPKuOq4o/BgDYHozUF0fH9ZuKqOxRnFgUbPk2Vy9vzStmfwnmQtHOlYE9caCdETxTV8o72VVLyJWq0ya8uNOZfM4FwbOwlMq1JKQ3NeecekGaqiUilOuTdD8FzhsaCcAc2F8ENbtgmhhyF5fHUUV1hS4almbsPQ1p9W9tVzoBD6cFlrDqrQi2MTWgdfzXAm9K6dv+Pg0Vmo3l+ybmDObYJ0oHJXc6NZqTCL8EfnAzcEZlEyjTQ1+dZF3saOwXuKVcwrr/3KFYEutsZH1eZdeVtvpo7rzP0yo8XYSE8OAtkIG8fTklhSInq42QbmUqilTSFXKp8uEzeu8MzvKKERpO7nxFcXVUQQx9AJvnqKQbbKU1455cwzOopXihnvWMdTySwbocdjJogJe++57T27LiBmdDiufEek+UJvVbDgMScU4Gkp5CocfOG1rmRgcJ5Hq/zO65d80m15yIm5FhSYvCNX2HaBbd+RNFDVODNxFSLB0aiTNE/WN6mf2Qu/LoF4s2UYHL1Vuq6DNGBrYdhdoTVhZeV8Nno/MXrB+YhGWPcdFE/fdyx+ZsLoLfBO3xCWa8mcTwkVwfu+PeHVxCY3VGdRJRicNZBoGi/n5dJ1FUyN2eDDoRlmzzkzWcWcctX1sFGKLTiNVAJfTwsABW3jaozJK+Y9L8ncAh3KiFEx7ovRxY4ZyLXlA8TqCDXw6++8R//utznME6fTI6fHw0/nA/oFqJAcxVdWt/KqFD5PMHYgCJtLIJDIxa7h4TxXTKSN8BwM3sg0U+QsyrZT3t83hOCrUxPdORwdnqiwdoVNbTSAkptO1V3WBE4QJy21D5o5bgxs+h7JtdEHamGbPJuxR+czavkSamN8vbZOnYtKLE2BuAYlFOOrtfKsi0SRC/3XUAlcR8+jJg5JGEPHphvZqvHxuKP3IC4wmzHb2wPvjVQuECqrGa+WzOdnY9SGY7v1AR8bh78bekIuHAp0ztN1hlkhRsfdvCKDQzBigPf3za/xvZenJjtzzeAtKhxdayktAZxcaCW0dVqr4r3DDNSagTfFSN85khkTxgGl18LN2HNM1kLqUFaMQzVyTrgIMsNalVWUXQ08zfBe7LjG0yPt0qXK89jzckngHFdd5MW4ZdUTv3yzgwDeRxKO2d7KGt9E9bUwW2VR5eUCZ80MRDoH++hxvu2BPjh8pE2bimtYTi3svPBVWogxIAZD9Lx/0/a/P355IJUC0kKJJEF1htfGyW9qNW2PB2qsRelCRCpYUWaf6QncdpAtccqZYypIKNzurjhm31ChVkmqnFZjpuI78BfJ2OSUbMZpzqxDk++ONG/JIVVuup6XywzBcdVHbi9o0g92V/ReEYS0Gkt+2/B4U1VK5WyFUy3kszFr4Sp2BKk8GyPSx0uIZMujn0Mm+iYdq1bZDgNfnibiJjKK8Kzv+fh5uwf+p09f8bhmMMHbJS3cKSkn1tDS7dWA2nDVc8n0oZHsRIRCw1W/342UYhxS4S7NVArvP3/OcS5YqWStJC08VOWuLmx9YCttajVZpq5t+lSGmRddz4vYkzFSzWyc56vjQlgz10PPi3GkaOHX339OD0gXKAbzN+x5/Mxe+G3XMW4GqlZOS6ID1nXlqq8MV88JYUMpiS8+/U8kJrx9QnTGaIXnWhE78YOSkLtX+PWR5Byvdu/yzvUVPhRubip3pxMP57VhkLoRnTOpVESarv+RjDf4Slf2zuNnRVNGcSzAHzw9cbvZNLmQCWsq3GXlf/1zv0r0nq8eD3xx/8jQdXTeMefCo69oVa4UOoT/y3jF4JTnfcSZcD9l/lCfkM5BXniaEtk5nseBT7aR13evObx8YE3CnCtzWn/aH9XPbc2ucB0C6jyPooxjR6eJFcOXZppEwHeBpTZZ165zfND3fNx1qHT8YXrkVoRcC3lOfJ8z33p+hXWlGRlL5WiFPjYU3bwUSvnhgQcTDjPhMWeue484uQy44f6ceFpyG3Cb4RHOU+HuPPMXf/lbhOD56v7A13eP7PrWWZtz4VFad7hXz5g8740bhig83w0txCsp3z8cEXWklJmsUTVC7Ni7Hq3KfVb60EKVUnor6XkTdaJy6yJV4IHMFQ0LPHsDcRfZQ6MzzE6YtDA4z/ubke/uNnhRfi8fcVqZqnIsle8jfPudK06iOCcsKGcqfefpu8DDYSKpEWPAOcfiI2MH9zmxA4I0qoTiuMsTd4cVl+3idxGeiufxaeW3fuM9YnDcPZx5dXciesF3PadVeQgrHYUNjt3Q8d0u0EnHi20zta254F8eECILK8uaOdRKsJ4Pxy1J4XSuDH5tAIT1GzrW3taPVXdr5io0nO+DFrYuMqox19p8Pz8Eg5TAUpSnktngeK/v+Xh3RcXzvdMRo4WuPZwXvleNX35+xakWxMGCUoDBe/zoWA8TvlRicGBCUcfWjTxoRorhxNBoQOSxThwPhaBGqc0k3NeeP16e+K1f+4AYHPePE6/vT/jR0WHcL5kn6uX3Ctsx8N04MIhwvR3oQmBKBZefcOqpaqxrk3sQYe86UioctDJ4D1JYytv196bqi8PE+2Og9p6vc0v3fobnbl3ZxsjGN8FXJ3CicMyZm9jz8X7Dt643+Or4f8+fEbQyl8rna8uS+bMfPCeVSuiMtVZSgaEL3G43PDwUZgodDi+Os/eYh7MWemn+uzlXFOXJBV5+tdKJw0vztDwdM0/za/7qb/4GXQi8vHvgi9ev8Q4+ZsN5KtyXlWy0SVXn+bXrG3biubnaMMRAWjLdV3fM2vJYlqVwrODGno92V8zzyqEW4sXMvi7f7B74M3vh9xhaCtSFTp+I8bqFwUwJZWbNhdO0cp4nYoQbachA1OE0o2Vig+O+KFOq9F5JWjhmONaJwcMYBlLnyOtETRVTz6oZi5XOO7Yu0CNcqbLBkUxZrWWgdV7oMN7ZDmxiYC2V1+tKKMrvffYV7263OGe8uxsI6oiiLKtRpBkzvCirVt7fviCnmS56ovdsBeYHZSsdjkA0A4MqSt/1PM2VY1k5Tw0XafJ2nP2mqphRtH0tWqjO6KAZfFwzjpkZrlbmmtlGx9Z5Bgl0IVJKYeeEB6ssl7S8ySUezzPHqlxHz+CMgoGHTgN7qZwuUe/BO557T3SRko1B2/g6qzZxH81Udt0PBOeoVZlTZc3wB5++5J3dgAOeb8dmfNTKVCoawFXwRZhRvrvryTlfIsAdOShTLfR4XJYWC46SfeaqG6hVOWtmLQUnQnqLSXkjVWkyhKzN36MIz10AheyM6lqX0Wtl0sLYBa6959o5eteM19sA99U4lYpYOxRfnjL3NfO8D3gcWRTx0HvPvgvt8y0F5zw3dHS+oxqtqVFr8xIBXfAMzjF2zZxeFEpp6eS/9/2XvHe1oXeOd7YDmKGWOawVc83vFExIBu+MW9Jam8EcQwSOVAb12FoJpuCEVZUXPmC1sqTCevESrG81/G+kqjVSWKWZah2FwQWqKYtCvuRxG5kZ6J2wc56N921aqMpGPI+1sFy8Gec18/W8crTCs9jhvadI80mFErjynmrGdAEBXLlmaCzFCE5Ya2bNBTPHpg/03jF6cMFR1Ui5JYr/wWeveGfb04vwfBMxMygVpaJSmweFNrF6NvbktTVOGvZTmLXSu0hKTSYHSgZuxvZaazWKZUQu+/HbeiOlopiFJq/NFYmQaGfySTOrV4J3CIXJtQfRUYyNg61zaKq88IG7mjjngmll4wOvTisPWnh37NmosXrDeUcnkZswMFniWDLOHLfW0TthEsOLY7HCVAoG7DeOgYAXbc0XbV4ny4X//Xvf573rPaN3vH+9pWrBrS1PJ1PxGBvzYJ53dhvSknAiONd47icqjg60Eg2oLZ03bga8Ko+5IBcE6FL/lEt6nAvNGFMyLCtuPeAR1G1YiiPrynk5UdVdxnxnQmjBGVYXSsl00pGB6iMS2gjSXERcT3CBLmSCNxYTluwo1YO0b4nDMYZAQLgtEcHR98amq+iqTAZRHENwjNEj0tIvgzm+Ph3RXHmxHbja9HgTXp+OHGtBgsNLk3qsRQkiiPNA65wFL5dAZaEEAX8RWTiaIXjKLKWy5JVcSkNmvK03UsrlYqWKlkp11uhOnnbxpqELO1VSKexiYOM8vQiYYVUZY+Aut2THQDtMqjb3/kYCeGOxymLaTIjSZBrQKCydc3gn7Al4BfUXz+bl51toFI3opGE+aZep19OEoDwfB27GHjN4ms8sKI5GPqkXOkbnHOJaR00vh3xSI3htIXTOcM4a6DY6HqbEXCruckDmtxf+N1IVyHLByBUjR0VpD2VVIFlbh51UUi30PrARx8YJ3pSkyi4G7rSiQtPYe49q097vfKAKTFZJVhsBQppGu5phqngnODVuXEALDbVIS0LFjFIrwfm2DTmjXuRtr84TURzv7TZcjQNVC18fE/OlYeKl+UJSbgbN4BRnjVOrP0TniVGlrXmCUaUxp59OC2tWGsJayG811G+mpJGSVAVnrcGh2mhdlUZ4MqAXIZuxwdF7R39p/Vs19i5wLBUHeA8xOsqls9l7j126/NkUXXMjldDWtaNdfkxgJx5TxbQFGsqP1p8ivnVXccLqDTF4fZ4Qq7w7Dlz3HdWMVymxiCIX+poJLNlwtD1X7YfrG3IxQtc0/c4Z3je0doyOc2qs92SKSHsPb+vNlHNyabw1nxDWGnG9eLIpS23Ew9E7VpTRYOMdG+9wVahUnm16DnMlSKNAbbqIGox4tj6gzlAqM0rNiSoXbwYtbbe/5Cf1TgjO4YIgfcvF8Q68tmYJBkmNGluI15ePT4gqH97seLYZyNXz5fnMRGMeO6C4SlFHMKGIIG0RXvDdgiewpNZsxBRXlRAc67myFNBSmrxSv9kZ/DN74ceHH3GabYH0+Jrgr2Bzw5IKS1pZ64z3HcUK63qks4I3h+aFoh5zHhccvdswxEjserqhY5tuiC7h6xkkkc2xWkdGGcKFkOPkR3HI7/Q9iwt0G0cXKtPTwhdTwoW2ELwTuuC4jpHihWSZaVnJMdJtG3P6y3PmoRZ2ocekjdKrQimF6MLlsmWYwYBDgCUaxdN02yZEL6woqTQ0GBdT8Nt6M2XOyE3uTrggElUgXggp2YxiQsCaDCe2yOvOyaWjKbjgL9KfwOA9mzHgveNWAoOEhqXTylqM1VIjoQRHZ9bGhL5B6K6dpzqwQMPYWTt0KoZJY+qLM3rf+NKLCcna5W0bPRX4/rnpqb015GKW2njEuSHzMEGrUItAFSQYszdyUKKTdpGMwlQqKTXUrfNKftthfSNlIpSGiiDSJi1Ku3DphRaWqxJpeQqIEYAIiEFVuzQ2ChuUQTz7sWPwwruhZ+c8Z9M2GVJFa2Wh0EtopDDAu4rWyrMYWXwLP+poLPRzrkxJuR5jI5hhdL5p/xtMFpBGLqtqPGRjNiVquzyuopQEpWS8a39OL4zsWAUXjRyEEhtpylzzspzmSlKoHswp5W3S7pupywPXD4EVwYyq0AfHqkrWZhTfScSscfP9D3tU7UpNcMYgjho8ITQJzeCFmxDpnWPFGqWnFOpaWKR5RRqKVfCuwROuQku1Da5hhU2Uo2aW1dhvutYk0ZZsj7QH0WyGIkTfHkgfirIKBJqPbqWiycil4l0jX9XL/6OvHkEpHiQ29HJAkQDL3H5mimv+rPINL1tv68cvJxdPD0LvI720PWITPAttEpNr5dr5NgXCN8yl96CgTohDZKs9VaDzjnd2A30U3gk9nXhmKyStHGoi55VcFdVK8NK4+KHJYa+6DueEbVS2XSTVRgsrqjwbR8QaiEM6mBdFrBGpzFqjwjnPF2tmMSWooGIcXMUqlFToJOCsbfJisJGIeccrVYpXvNAwx2IcUyWX9oChVMo39JH8WG6nv//3//7FqPhfv37jN37jR/99WRb+9t/+2zx//pzdbsff/Jt/k6+//vrH+St+VFUL87ww5coSer44FAIzkRn0TCknSl7wPrDKjlSE+XRmPh7QlHG+Mq2F6+2W6+2OzaYnbpTaFXZ9B32H+ku71HcM2xHdXdGNgc0QGbsO5xzOO77zzo5ffv6c59fv4nfv4nc3dAab4Hmx63n/euD9q4H39z19J3RIY1WrsqRMLpWltqfGbJWZtrGNwUOpF167pxTIubDD45yiCNU7XOfoOsdaC1sRVCF0nmEXGLa/OEm7P8n1B6BeKNr0nk1y1Vi5Zu0pHAy1Sql66ZoGwg+75K51rx6WxCZ0XI8912PHrguUUnHeUJRTqTwshUMqHNa1saitSYci7YDzTvjoquOjmw3XfY/Hg4B6ozPH7dDxznbgnc3Ai83Qkn7NcRXb4aq1oJqx2nIiqhcWZyy+pQLXlLjwV6hVqbkyqMNd8HXJWofYe9+kJaXiqmC1UkvG6i+OhvUnuQYltA29WAtk2WujNxVnIA1JqdVwuW3jgzST2WJGFsF84Oslse2FF9vI9S4QRqGUlbGPFN/G4g85cZcKx1RIS8O+RmlhMcEpwSnvbSLfvhp4sekI3rFohQobc7xzteP9Z1e8f73l3bFj7x23vuNqdHRRUcst8Avo1TXKkFaeyBgVSiG49iC7ZiWtRk/AV2EVZUUboaoKj2llzZlSKqkU1lx+oXIgftJ74FobqaQLgUEvQUKFH11KLEPN7d93nceLkFVQH5Do+LoUwhi42nbsx46ua1FYY4yYtAvbsWROufJkibnm1jFvKkeCV4JX3t10fHwzcrsLSIRZwBEYveOj/YZv3ez48GrLe31kDHDlm8l27Dxq2tZfdY1IJY7JwRNtQkFpnHcnULOia2XrHb4I2RlFABWkwjGtLKm9x8by/yGe8xejftLrrwosGOppDH3fIxeoQBd9mxhRWw5NUW77gSCepEqNSnKOL84r+27Di82GqzESO1hSwW+anOwhZ75eEo9z5rCmRvvRdrZuxRGDEYPxnWc7Pnm243YYEBNOteCK4IPx4Ysrvv3BC77z3jP+7P6GD4fIO2PP892GbYxIUaQIeblMLbxwdsbBlEUrviq9i6hElgLrkgnaQC+ra+SrKkrRzNN55lBmyCtZE7MVsnyzPfDH7vD/uT/35/hX/+pf/dcXCP/1Jf7u3/27/It/8S/45//8n3N9fc3f+Tt/h7/xN/4G//pf/+sf968hS8BHxdeEFnj3nfe5DROzJbwTfBwJTtiPHzCw43p+yTR/zVf5nnU9Edb2jXt/d41sNlQfmC2wnxKMA1QoUqiS6KMxOqH3lVCNtcB9Ub6yBe3g23WkSKEs2pg9vfBXf/NX2eAx3xLQejOe9R1lTgg9V+OGgvK9xwMpKV4VquNxXomxJaveS2ItC6UqJSvOOUIU3t8Ffu/lxORW7OwYvcd1xpco6zvf5ub6nvX8gLNA7PbAn/zY398/rfWTWn8ArmRcF+mco1Oh7yO/9PyKp8PC/bxQc2I2pSJ0Tnl/0xMwTiXz1aEx9acObiosc+XruvKZm3jWjzjgaVq5r+01ts6R3AW1FTxZC49l5YvTTPHwfvcOPdJ0fLUim8Bf7DaXN9pGgj521CiEoFQC+zhwyolP746cV6X3Lbhryc37MXph8oWCgwJLWonBMXjhw7Hj8zlhFOJJCA7SUPgyZ/5LPrOvseFKpVGGfpHqJ7YGc4Eu0DvHVgN9H/n1D1/w6unMq2nmVUkkzZw8ROf4ZDOAKQ955fPHFbSxzrersc6FKVU+9TPvXo/c4jlnOOTWqd0jzGLgwHnwrgUV/WFemch8q3aMoaNaZtVEDPB/vb1t77NzOA8SO9bo2DhPCsou9pxS5fsPT5zXzBgDNcKkLVhpJDCF0vbU1HSoPng6H3hnCLxc2s3SH1vwFmPl1VT4z3Xhhp5gMAT4hqnyPzf1k1p/RZXgHJ00JHHfBT5+b8fpXHiaM3dpZXIt4dlF4UU34q1yqplXT+0CsrqKJKUkZanGS2c860euXGBR5VSbNv6qC7zOCZAmx/COReCpFlYqH9We6AOKoA52ved/6LasWKNMmdBHT42+NTGqsu8jp1L4wfFENkdHw3Ourk3xtw5WKaw1Q4osy9KIQ95xO3Z8lRag4BbfmizecZgdf5QnrmtEqxIj9L9gDf6f5BmcS2EcO3bOs1PHRhy//p2PePWw8Oow8eVy5rHC5AyP8v6+J0vlj6cj37s/oN61AL/TkfOaOJbCf5EzH13veMd5piycqpE97EPP6ZzoIjzrBqrBY618djqiHj45D+z2A8kVkqs83478lfdeQDJ877Eg1NFTy4DHMWHsu8hTWviDxztqEkYvnLSlNwuOHmFxhXOpGAVbEi46XCdsxo67p4UYhQ2B0RwBuFtn/sOrIy9c14K6Osc2fLMz+Me+8IcQeP/99/9Pv/709MQ/+kf/iH/6T/8pf+2v/TUA/vE//sf8mT/zZ/i3//bf8pf/8l/+//t667qyrv/VYXw4NMykz3eoCK6u7H27RIe10F8/R73D2Zlshecvrli4Yn44UnSH5kqOHd3uhvk4M/lKJONywueK946125ByokjP4vc8pHueD55U/QXTlHDOITjmVPlePuLwuHGL22zxfmCu14R65uVhZs0rWEat8OmriVda2A/nFrwUHb0Xtgi3TlhdaCbNAu/0I//laUFYMGghSQjOwxMJy+C0GdjOcwGL9OunXI2VFxH6ODDrLxaS7r/3+oP/9hp05pEqhBDYbzt6aY75PjquLOIcdLkQnKPUwP3pTBYhSxscORPmxbCgSGzjxOsqvNgG/uhhQsXQIJgKx1rpYwv6ulsTemGL9zhSLXx2WojBOGdlUmMb4Vhh9J7DPF0yAVrH5aEmHqbCtmvjyVNqLbi9BW5FOPTCok2bexXgi2VqXoAQGTQQHZxInJwi2pJSC8pBC7ooo4vMNUMVzDwrv1gn3k9qD3Q4QhY2MXB7NdAHzxBg33VgQnSRfskIBcNzf1qYUVYHPghdFJal7WUuwsY5OjXe6wJPKXHQTBalinFI+UIdgbu1NVVEoFJZqfzhw8IQC8dcOJXCdhO5q5mdj5SlmdJXragzHnPl4Zh4d9O8Svc1MVO4JdBJQKIytyYum77n+5f1t5WeQQUvmUULr2j8bVdbvHyeHaUWbhk4a8ZVI+UWQveLVD+p9Rcv+902BG5ijxdhiydE3+QVJdCvjrwYrqftQwpFBDpj8I7zOaHmm98HiKrcxMBZtXXztbKUykNeGVwkeuWoiqsXXT3KTOW/HM7sNx2n0sADeyKvfWHwjpyVuRSWmpHgOaTEQ8o8GwaSKQ8pkdX4IPZcRcDDqiDq2XeRL5cEZLou0OFaYjWVJwoZGonMjJwr65J51kWONSHJqFWYf7GO4J/oGTy4SF+EsQ9c7Ub2XgjBc70NDN2G7ezZnCLBR4orvD6dWM1YreGzY4WvzwtXvk1wohN8rdx0nrkaRxKGUovy2Tpx7SOrGg8pg4MiilnllAr/6eUdN9PAY8k8pcrzYeTr08IYA6MbOUxnHg5PKI7XeebVeeVFiKxVucuZ7OC7seca4VGNRZtc+4Oh5weHJ0QOjH3PoB0hOajKPQteGzRjqYKrDpsrV0Pkbl3ZqEOyYy7fbA/8sZfqH/7hH/Lhhx/y3e9+l7/1t/4WP/jBDwD4nd/5HXLO/C//y//yo9/7G7/xG3zrW9/i3/ybf/PffL1/8A/+AdfX1z/6+uSTTwBYDo/U0wSp4qoj5hl1DrccGerMxiv90LHrA3tfMTvhA2w3W272V+yvnnOzH1AzUqqkKqQw8OSEvjp2/YbduGHT93TBE6MnuDandL5duqUqL6rjMa3cpcRTSUxl4Xw68enTA18sEy/nE1/PJ76Yz/zJ05kzhWINQyY49rHDe+g2HTebnsE1mcRcC+/HgVyNtRgvl5kfnCY+Py2cc6ULwi50dFHIVnhcVqYyE6Snf+e7PP/4z/Let36FF+/d/rgf4Z/q+u+9/uC/vQap1taKRPZ9z+2uw9QYg+d603O97dl3TTpzdTnEEiDegQi5NLPXXDPnkjhr4STGw5r4YBx4p+u48YERQczYxkhPC5yxS6JfUeOawFqVp1I41MxSCylXvq6F16VyVyqvcuarJfH1mjlnI9VGuqgCXefxwVGiZ9P1bENs5iMvfNRtWQssBe5r4nVZOKVCdB3eC1sX2QwO88pxXSlFucbTmWfvHBsH9gtGqfhJ7YEeYesDV33Pfjfy/GqD4dhsOm73A8+2Pfve87zveBYDR6ssQssKMVhTI0kcSuaxZI5WODvlflrYu8BN8FwFz+AdzhlXXdNVV60Nc1gVq8LzGqgIT7XwVDJTqSyp8sfzyp/kxA+mmR+cZz6dZ75aVo45U7D2AFCNaC2Vd/XK2EW2MRK8x3nHJ/3Ikow5GZ/nxA/ywuuSfoQbvXId2zGQo/K6zhRXuYmOXXBc94Fd1zStv0j1k1p/WEvy3rkW/PNiN2LaZF6b6NjFRmna9pEdgUkL2RkuNOP1ORUQ4UzhQGZylRIcR83ceM9VcFxHxz60KcJtH+klUlo/DJP2Hva1I5vwlCuHXDmXyrkUPp1XPssrny4zn88zXy4rX5xXHlMLDVyqoNpAGv4isd30gW1whCC4KHzUjSypUZ9e1YWv6sJDyXgXiTiuGRhCZHXKa0sUZ+yc48Z1PIuRvQ94/cUaMf0kz+ABx94H9l3H9X7g+fMdQZVt9OzGjv3Ys+88mwA3zvOUC8slEBMRplwwlBOVg1RWAS+BY0nc9B03seM2Rq5DYPSe98aRnQtMtbDWAqqYwlgcsylfnWZenRdOKXFaE7/7+oE/fHri+48HfvB45geHiT8+HLmfVtSEc1aWVRthQYxZK1f9wG1octvQeT7ZXTEtynmu/HGa+D/mI19ME84J0TmufI+I48Eyf1LPnGiEq2ch8mLouO7iN56x/1gX/t/+7d/mn/yTf8K//Jf/kn/4D/8h3//+9/mrf/Wvcjwe+eqrr+i6jpubm/+fP/Pee+/x1Vdf/Tdf8+/9vb/H09PTj74+/fRTAJbUzA4OwRR8TuSc0enIcnrF8fSKeT5S80Rej/i0YHkFq3SXQ8vlA2taqTljubAoPFVFyoyrC33N7FCuOo9TQ6pj7EZ244Zd39P7Jm8gCslVFk3MeWUuiUOeeLlWJmCV1jGw6hl81xIJW0INUltnIGMM0bFzntvQcdP1rKqsvpFgUjVSaSaQXJV9CBiNf14DmAONlU0Quu45w7PvsHnnO3RX7/44H+Gf6noT6w/+22twLpVqhjNr3S7X8DjRQS6Vc67MGIdSSQLOtU6WXGg5tRpcTEWuGlGhmPK0ZkbfaCqjCYMJvZNGBDDHFscoLbW00Socc22d1WTNSDepcldX7teVYy2cSuWclTWDFtfWXalY1R95ShIQu8BN7Hh/7Hlv05NNmUVJ0kzAa2md2ugd7276i0EUEspaK0W1BYd4RxTXiBa/QPetn+QeWARC9HTRET0X+kkL0Fpr5lgSicqxFma7EHycI4rHmTSCSVVKvWhETUA8jxcWdVQhKnTWAAXb6BnFsw2hEcqcQ7VNGhatTLVSMMQJqxmv18T9kni9rNynlVMqlARSBFdgWlJj6kvj989a6aLj+dDx0Wbg/c3QkKOX916qkkpbYyHAR9uBITRKTxYjXYyYuyGwvUxOvTjqj9+3+lNbP9H1Z4A4nLhLd7QZccW1EKJjyqwXCc9a9UK5AVNDc8MoOjWMSoeylbbO5lpQVYI1NGtH86iMru0pYwiMMTSiFIITYVVhrpVirSm3qnJImae1cL+uPKTMKSspK1rAm2MtzT8XpFHJkhldDNzGjg+GgXfHntXaJRBpCdalNr2/98L7lwYdlxla1rZOx+AZglyMvsIvEjfjJ30GT7ViQPAQHXShpWtH5zguK6/OE6dcOKTUqHnOYRfiofeOAgRrOSG9tnC1bd9dvGjaYAgmRBN2IXDlO0bxjN4ziCOqUIpiYkxqnKtefi6E1SqHmnlYFz5/euLL04lDKQ1vHDoGF9HLe+mCIzghYWy7jvfHke/sd3yy31KqkaVp+1Wb4bxWxUT4eLdpa1BaWm9SpSg8Hzr2sXlmmp3wm+2BP5ak56//9b/+o3/+zd/8TX77t3+bb3/72/yzf/bPGMfxx3mpH1Xf9/R9/3/69ZXA4ARoKaJRoeaCAx7WIw9pAYnsN1um4vHzSk0L2ZQQOs7Lwnq4R4MniMc5YyWymJF4aCawJIypchNgSZcR32bPplccBc/EWjMhDOQ0US2TS8SFAFQeVuh8BIxQhU1oI3HszFmNlDMTyloNk8Sz6Nj7yD70LAE+TWdqB76CXxy9WLtMVqV3jtdlpUYwJ/jocB30UggaoX+Gjp5y+sUJ3noT6w/+22twqpVBC8kKWjLmO5wYgvA4r3w1L8wOLFWGPvAsNIZ5zoqFJoOxXFGMjXg2eM5aWRRWXzBXEVV6AwkOZ+21b32HOmOhNO65NZScmiHOIU5YrF3OpVaqtcM2mCfU9qzf1ZYbYapIaAm6a63Yxrj1geAiZ1N+/+nAItqY+9qMctW1bsSLoeN0XllUSUoj+6gSgjCocK7Kau1i+otSP9E90IzkhSJQa6YWw4eAQ3h1nvjsNJFFmJfMEANX4vHWaDeGIztDckFM2YvnisAkkfs6c1oS6oWaFKfGJkYi7YFg6Dw4YSmVuSxMpriSMedwIsQgmIO5FDYG51wbalZ8Y+cDZsqUE6Fz9NHjDc6l4p3xzEec6zjUwu89Pvx/2fuzWOuz9KwT/K3pP+zhDN8cU6bTTg9lN5huUwlmLoSabqksgVzdlOvCCFF0I4xRywIk9wWJ1CohdUsNF20uubbEBa2+oqVKUVgtjMCoAJeHTDvTGeMX33CGPf2HNbxvX6wdAcY2jnTGFxmRsR/pKBTfOfucvfd69lrveofnYUJojKMrVVY5eIP1hlf7nq/OG8ZciEWxaogCbePwBWKBLPW1flrw0fJPmIxW3fNcSK7wXrv29TjzZJqZbWEYEwvfVBEK4X3VJDGKKwVn4QzLmXUU67mKE7eS8NYcFVGU1jqs1FmhyybgrCMWZSozsxSMWrwIxgjeVuPBJBk/wVAyRatCS2ssAhivTClhbHU+twqj1ur9hWvx1rBX4VfHDcnb2qp5bLFofFX6edgHvjYOJKlypO6opOedQUUYi1DUoObEvxd1Bl+lSN9YznJDSpk010SEMYZ3twd+43bLjMEbR3KWzgdSyZRS6JoGEyw+V1njC1d9SkobeFYmboYJ5z0xFUou9M7i1eKx3Otc5Uws3EhiCrWdtm0c3rkqx2qUZeORktnOO6YsdM7zoF3gnOHdXWI2ERMUYyyiNSZw3nDX9/jg2Inwi0+uKG29lK5xOLUsnSNjeHm14GvD5n2Z2kYcWmARHDcOhrkcg/0PluP/pph6cXHB93zP9/Drv/7rPHr0iBgjt7e3v+lnnjx58tv2e/1uOAyZeXvFtH3OZrtjHHeMeUDygRwnpjmxGUZe/6V/x+Nf+QWG3RXFJExrafoes7qP2nNMmTE54/Gsuo5WF1zfbDkcEnGeMXlkpZnzpedsbVk1LedhzZ3ugvPujJItQ7Rg/NFmxNC29yhj5PbqisM0U0QxzpCdhQZWzlVpuizEorTO8zxNXMcC3jCYwrN54h6BBY4mOEowmM7SdoFDFN7YTsSkmBnKLAwpM8/KRhzubEEJSiozGuM3s4SfaLxI/kHVZB4ks8+JMWVyKUzOI65BvK0ymarcbz1GCvbY94woJh3L0uj75jWqgs9VVmw/RYYslJLxpbCQKgVrOsty4bjXBx42Lee+rRkGW7P0qgJF6AV8rlrtUcz7mTAnihNl2fX0NqBYIobWeW6lMJZ6AbmeJ35jsyVkQ5B6SGZrUWtxatlH5Y3tgRyVpXo6a8lWwMM+R3YlcZBCtnWY+dOKF8nBYU7cTjObmDiMhRKFcbZEcaTjukaES9xx9sfVwKwUfGuw3qKhXsiyGspRvL+Isp9T7fc3AggrambeOcd58NwPDY+alrudJ0vVeS4i5GPws8BhqV4Uk1QlF4OtP4ty3vWsQsBQDbOCWPZSGFMCEZ4eDvwv19e1Rc5ZJhEmq2RfPUemqLw+zhwiOLEYA6MtiBXGmDlMwlaF6GHRfnoCrv8UL5J/cxa2ObPNiTHX/S9li6pnBg5SmMVw13X47GhtlRpMTvGtQa0h25oZz1Jn0GPMTKIc0syBzCQFSUKQmpRo8Sy9504IPGga7nahmp1Q23SiGIqAp7rgFqmVx3L0xQk4SjG1DSlURamiQsAx5cgYM1aFq3niVzebKktMYU8hZUVL/XNzVF7fTsQiuCKoCqMpFJQxTkylfnZMMKz60/73os7gWRNP55mnh4n9EMm5sI0wqiepJ6uloDxqOmQfWWJAhDkJmqqWvfp62UtZkSzElNilxHOZOeTClBIlR1qpogXeWc6XgYfnPS+d99ztG3yuin0xZ2IupKOaXUp1rilmxRaDmZRn1zNzLCytpVePEVc9bPDMRdmnQrKFd6c9v3z9nOIyGmArWhNrx0pZLpbXr3eMc0KTMJXMlZ2JZJ4dRjYxMYlgveOs/2Bqjd/UTrnf7/nqV7/KSy+9xA/90A8RQuBLX/rS+9//8pe/zBtvvMEP//APf8O/O5N4OjvemRwbAtf2gsdxxePdxNPbHTebG3a7K25EmK1nk/bsts/Jm8f041vc9xuux2s2m1viPGAl0k4TzXzLYBXjC9FkbhCeAU2BS4RF8BRjKep4tV3Sa8CkiQbPqulZhR4blX2aOMwDz693PL/dsz2MxDgzhBXaBJIRHHDmG5Zdy2dNTx8Nb40jb84joxS8s7zaGJok3PWeyxAIaikRXHZ0xdJmh4mGecpMU2EXzvnVr/wyzx+/TZ7nmo34lOJF8g/AuJpJ2sbMu/uJx/uR16+2vHNzy/VwYMwRLbU/EBy3JfG8RK4lcSgJJbNJNduAGqxxdNZxl5bkLEUMI5ZbA7dFMNFwRz3eB0rwNF3H95+f83DR0RiDtYbG1nJjYy1iDBGYciamXA8/Crc2YrwQneAtXOAIxfH5ZkEr8BvDwG+ME2MROpSXraGhsLAQjJKOJfp9VIKCTwaNVaPaWksWobWetfececdl+PjaebxovEgOGgVVw5SE3RB5Z5d483bD15/e8Hiz43YYmQ6J0So2CbMp3CJcp8Jmygyl8CQKJZuaBXdK7xMvu8D5qufMBhy2tqVRju0OnsZXwf2+DfzA+T1e7VuaxtO5eiltrKGKyhr2pSY13qsqF1ulRGcg2tpidIans47vtUsQz5f3I6+PE1AHiV+xDWfOsbKGxhiiCNssDPtMJ44z8XSlfl46ZzmUwqILXLaBi9Zz0f3WzOCnBS+Sfw4LosSSOeTIdUy8vh94Z7flep6qH8eUGS1Yp+xLVX065EKkVqWeJSEWQ8FSjCKSWAF3+gVntsFbR3aW6CzWKfcbz6JmTWgdfN/qnM+EnrbxLBrDwls66/HUhMqOQqImPDIwFCFqHcDFe1rrucSzFMtrtseK8OVx4OvzDFRDw880dQZhaR2Ns2Rr2IowSG0zIypmVqSAc8Kh1LN9ZTxnznPpT/vfizqDO+NprUNQ9nPk8W7k68+v+Oq77/Jk3HHQeu6Ntp7B26MD7SZFbsvAbpx5e8iMAtm7OgcaMw/x3O/OWTc9agOj8SRXE3ev9C2XoacLDfdWK/7kK5/lexdr2qVn0Xv6xtO4hia0xJKJRckFxBjEV/n0Z5sZ0czeZqyH+zZw6Twvuw4H/PLtnl++3bPJmeAs39m0LDxcWs/KeIrWpNwuFVRrgqUXCwWsC0wxszaBu23DeetYtx+Mg98QU//m3/yb/MiP/Aif/exneeedd/jiF7+Ic44f+7Ef4/z8nL/8l/8yP/VTP8WdO3c4OzvjJ3/yJ/nhH/7h/+x09u+Ey9VrxJLI83Oc3ODGEVtWPIs1u5g0IwojMwh0aslYNnNmmp5zGWe6fSKYFpJnPwspT+z3Ox42DYWAcZauEbxGrg63nLfwsF/RuEApmfEQeakJFOdxzrMT2E4HJG5hjCytsJfImCxGPaYVmjTjSjUKmUV4Mgy46DgLDatQzXAEJXjD2gVSgVETAYPDkKzgVsAoON/gFLrZcp49JoKTAhhCGQhzg46fHg30j5J/ABfB43xtk1BV5lkpTnhHMgct1Z0WyySGgLKilvq2FG5KYoFlaTwLDM3RcnsSJTrhrnSoCI21aOOICHsngOUzXV/L4wqlCN/Jmus4EqzhkOrsAEAohlgKWarcpiFjmv/QX2Ohtv4UBVcP3Z6OooksglM4bwP7UsgFXC4YrSZeo4vkKETrEBEscC6OsxFkddR9B1bO07lPT4bro+Tgynuc1CoQTcOqsTzdz2zSTEyFFotxlgnwxdJJbU3YaebdMbIKgTMcLeCl9vSrKqOzPGw82RgSBZKQg2dPRsTy2X5NHzyqgpTEd63OeBJHzrxjnwu36ejwHatEorWVWzOGttV6wQW8wCSZg9GaabUNq1zImpkQDIZz4xlsVYBaaBVU8BgGL0RJNM6C1N7ue9axLA1Fjm1rVlhbS+9P/HsR/FuG6vINFmM8iyaw3Y+8Pc3MoqxCIDhHTJkDtS2wsYapKE8OEyurnOHosFgx1WQLQXFcBI8oGFEaDNmDqGPnlFe7RVWMOprHvbzqaSZl6Rt2JbMpGestfqoVhKomJcySaYyhvN/dkNmXxCYLrW/oRFjQkCWSSp0hWLnAKIlINbVrFKwUZpsZY8RpbfBvrOGB8bQFJNT9rxFDbwxL9+mRJf6oz+CzEGi8o/GOZdNwZ9XxlWHk+X5iKoXeOkLw7GMiFuGiBM5MYKORd6aBe6bjkV8QsHitbbpRCtF5Ptc0qGZy52ldh1rLnGDn4HOrJYs2YFWxqfC9Dy5wN5Z7q47dFLkeZ5rGcXPIjKVgvSU4i5oqTuA8nLtA7yz7XOetOu+4NI4gVH8byXgMD7RhiJFdKahaeqtYW809t2XCi2HlatWrMXBhPW3XYKjt352vc1EfBN9QwP/WW2/xYz/2Y1xdXXH//n3+2B/7Y/zLf/kvuX//PgB//+//fay1/OiP/ijzPPNn/+yf5R/+w3/4DS8ywDLvcNYxWQ/SIhppXKZrA6O0RMA6g7MtjQ1MRRFjKFpLh3J74Ozey/RlpPEGmg66NevlObp/Qmcz2AaxHqeCdx6nAVJ1Posp82w/8ixmTGi46wIljczDgajK+u5n6A5vo/tIPA5hl6wsvaEJPSIGiRGysl44Xl10ZFU0Kt7UTO31nJhNYmEdkxR2UphLxgYgQrK1/cJ6OG8azr3HzFtYPsJOkXT7nLg//J7e308iPkr+Adxp+6NsJnTqwVi8FkzJOGM5On3TWmVJQIxgvaE1njwLrXEsjGHpPcHX4HtIynkXKFpoioC3GO9YoaQEjXWoVhMsQdnkwlYLxUOHpw2G2QqHVFjjWZ8FxliIWSla3UsX3iNFcMLRodmyCIH7bZWEzVM1AXFYbibhYASPJSqM1N9jslalqaCoV1wxXLqWl1qPeMdNjCwazyr4Y8n904GPkoN32kCx9QIXRXk+1QE2i8U7Szryb209beMRD23waLaYmZqNL4ZVcDSuDi3elMRZ53iWZppj8qH1nhWelEt1yhXFab1E3mbYaAZn8dbTeoNXZZczC285X3bMWZlyIYkwmcyy9ZhSUGdosCxV6X3Dw0VLUSEOgpQqU7svwiFLlZ+V2kJXjgehpHo5thh8MDxse15ZdhS13IwTyzawbgP2U6QS9VHy78w15KP+xJyF60OipWqJFzUkVYoUOmtQCRgHzoMpBomCN7XVbOUc4TiwuBW49IZ30shCIAHWG5amBviBmmCxVMfwWxEOWsDVCmdrHY0rHGIhNJZ7y54hZoaUyUUYNdO3jqkkJCtNqT3ZS++523oKIGMdPLLGsjvKzjprmIG9CpKqykvJQrEW4wSnhrV1PDgadt7EyFnrOWvC+xLKnwZ81Gfw/a4lH13lb0tiuhm4bKrzyyZGxqObvLemSqlbQ2gdS9eQEjhrCGJYv78HCtsC973nSTzQF6WgtI2n8RYxwqqpHh+eys8nc+J6nI+CCJau8wST2c6JRWN45eKczZg4xMSsCZzjTuurMaCWerG0gZVzvHqxJquQh4Jm8MFyI4UxC94YDiWzyUIBWu+YU6FxDbMqXg2Pmo5XLlZgDO/uBy77lsu+JXzAOZJvKOD/2Z/92f/s97uu42d+5mf4mZ/5mW/k1/62cK6w6DvEtsyHpqqfmEIyelQOCGDAGk9jbDVzsULWwpAyYj2PLnpa8XgU23T41QVZHHG6wTlD8LV9R3LBGkcukd2YaY1jysJtnNnnBNazEEVxeBdQFDWZYKv996zKhCCSiWWkNYFSOKq0CFqUtXcMRVmHULOx1pKtMhdoqOXJCWHUwso4Zi20xh7dBi2hNdzpWmYSZuEgD8R9JI2fnqHdj5J/AK1zFAPRKNEoYoQS5eiuWO3ZBcEY6IEDBbUGIwZRU/kJBAfBWZIaJAv1ZDO0pm5QGKijmJAQ9ilxjPPYpsSgmTFlMBY5Dg1ba8ii1XBDDcVkpvcVT2ovP0r9rcZgRTnzDYMWzn2gEYeoIVshxepoGalZhYzSZMMkhVarfra3hoVznHWBrIbJebyzOMen6sD7KDm4DJ5ZlKkIu5zJ4hApZAN6VEwpRfDO4LWqMJmjM/ORZTjAuarLj1Y1MVSru6MAts5+IFWJqqhymGecUdRa9qnqpO9TDbDeu3I4a0GE1juMgdkIUxEmasBH0ZrB1eOtJAsXrWcvwlls8BQwihqlTCBWSAJjqRWppbHkXIfdjZraGtR67i6qoeKUa/tFcAb5FMmkfJT8a73DIEQRDlJQLbXCbC1YoWQlF6VxjsbUIXNnLI7aj4+xeHM0cnMGq0oREJRYhJYqBKCY2mdvQMWyTxHFI1gOKTNKZpcKJmfEVZfVgEWcpQ8BEYhaHZlzKRiBXTFoASsGY6Fk4c46MKhykTyNSv27VslJMbY6Wo8iRBUWosQs9L4qFFlT349V21IUJldbMZwzSDnx7z182GfwwjhGLYxFuI6JhcKdpg7122Kr71IpeGvpQlXB87YmREKuIgONr7N11hkMlqLvDX0LjWpVurF1H3HeUETYjTPGKAXD9RA5ZGGXE+FYVVJjMNagKqzaQDr22M9F4cjFlOo8U3Ocr4uxcN41jCVz2bR4U4ePC4Y5VbXGpMKQhVmES2uYcuasa6HU57kKgTuLjlwKt8HTekvj7AfOuX1sm89KF1iuVyRnuJ62FBaUtGGKM0WoDTBFwRZMMbQtqFVyyYzzRNev8OZA9g3WBELT0bULDtkwhwXqHcZarAhZDeTEoFuGHOgIFIWhRBDBGiWhmNDQu4YmJ7aHt+gmqUM+KDNKUmWIM2vp8bFmP6IVbIrkUg2LuqVnlsKhFHIwuGjYkaqywNHlEoE9mYUNLNTjnGJdoW08xnhsryTZM84jMn96gq2PGkkEo4YkmQGhd+4oTVgw5hjwqzCrImQabyjGEHOVzypAwjFpoZbFLa0xjKmwaALBVc39ORUGhWA8I+n9NfXWMqREpjBMGSz171pYWM+GRJertXuxSqQwZWFIBStV099aS0RIc+Y71mtWweE6uCWzSQVacBMMmhFX+2BzqVWomYyIpyn1Yuu9wVqHK4Vl0zBrYipV9u6EDx9GLUarE+6kgrcN25xRA9Vvz1BKrep4UQIeDMwIUTNtCVULWjMczY+64wzGMgS8dYgKsVR7987BlAs6FRQl+FBlMpOyHeuwLcYgWFbecyMzh5RBDEmF2R6HM2PkjEArFmOUgcJ+zHyvOWPlG17uDds5ss2ZbAquwFZq1QwULUJOlp0WzrLHq6UJjtbWPds5WHQNSQpTripEJ3z4EAMY837lMAThdowE6xFjUCCqMqtiTcEZV5WeqiI1hnoBHUxNjRgDrTFkhTsmEKygWcmpMBhh0XgkFQaJ5NLQWM8cI1EKt2NCrGBdbWNbO89tEeaYKCLo8fkW4HZOqKuZXaeGucCuJCxLlsHz0qJlEzM3SRCnEKvsscXWFh7RarakQqe2VrysJXiPsQ5TCovGk0xhEDCfooTHR42YhKJahQeK0Dvl3WGmNKZm/lWZSqH1QuMd3tUqkEXAgDO1kjikjHEe56rk9SFn7vY9ratBdi6FbYksbMM+ThxkJklHsI7DYSRZw9U8k6XU6rs1rLuG2/3AZohIlmNS2qKqXKeIKxC0unBmLRxS5PersvCB11ZLrseZ2xirdGeBw/HSW8U5DFrMcUZBCRgaV9uXjHM4YL3omGJkH2eCeQE9/B8lUhlwsiCYgvOQyDAnRATTrrHGY9IeVw48Y+YHz1c457jet5hD1Tk348DWHwi+48y0LBqP1YHVak1xgXnaMscdaZ4hbYkehmxxIhhJzCky+oaX1vdpTWGaB8Y4oUkoBA55opRCr9XefXSWw5wZVkJwQjJCUrAlMcfEeu1Rpxxy5O1pIk/VWOJglOAtwTtMVlLKHHol5ypB1obaV22tJRyNPp6NIybtWX5gy4UTvlFcTYnQWDLHvr+SMa5+OK1RjKt9p1IKbzPyR+8/whh4uhnROdNhEKe8WRIdwpkNnPtAFKEXSzawF2EfMzYb9k3NTtwSMVQX3UEzV2PkMjTc9Z59KWxKrhsCypwy1hgWOFosgykMRUiW48WkoGIwsTDnxLpxiC3sNPI4TkhWgndEqTrBDeCNICIMLjPljFdHezRKUtsgmnDAVcw4Ue7aT08P9UeJ5+Xo9uhrn/wNI+IgJ1h4S/AWDKRUuAX+y7sX0BieDzMmZZY4ohTemRPLKJz7wHkIzB4625DIHKZjRdTDPICzlmcoaVYWJbNVw1tp4LL19MYy5sKkCaN1sGyXMo0YFhg6ArNT9mSSE7Ir9fAq1bl0LolFY1Fb2GninTiTKPTBQQHvweEgWYoIB5c50HJulODAB4+6gNXCwlp+Y96jBc5P/Hsh2OWE87a2c/k6LF2cQj4GwEEpqbbOXFH4ww/v0DnH7T7irgcsIAjPc2LEsjKe89CQqTwThE3J7HImUFtqGhFyUVQSrS1sJHEzRDpv6V0N8qJW/5Okmdu5YKRqqV9Qxdq3pFq5pFYcDJY5CducWDe1MrCj8DSNzJPS4SjHbH2LwWRPmdP7+99KXK1iOI+1tVIRMDyLEZszZ+7TK5zxovFsiJgArnNcLBoKdTBcR6X3lq6xqDp8qZn4/+oHHrHqG662E/bNG1wRckrclMQc4U7oeNT23ExjVUdU5TBk9nNicsrtPNGkowSrEZy1vB13NYkWLIvWkbJwyBkzQ2gsm3HCpDqzdGEttrNcDTPJGpIxZBWswE4Kt3Hm4WqJiGMzCW/FmZnCeXAs8DWhYYVga4vaHuWQMsE1eO9p2kB2AZxhqcrbuy3Myt3mg0mifmwD/uf7BWZ4TttaXr3/GQDeOsw8WEZM01M0kMfCuJvZT1s+e+ezXC6WPB/BrjL7OeI7mKcekbmaCikMAyxcZHJwO0/s9geMERaXZ1A6Whs5jHsOaSRj8er5+tN3WQfHpWtYiued+ZrnaQvB8t2+Y00d3pQSeDNv2E4TRo9GTM6RjfJrac/V0w0dloWpJfGhFOgDsSmkaPBiCdazcnDhAorDBk+2hdsSuRoTrrmgDFs2ZUcqO1bm9659e8J/HqlEhrGWocNRDWndebytWYMicIhCJ7C1iZcfXXLW9iyvdjwfE4cpsVo1hKFK0+0lkrOjBHiyn7i2+WgKA7OrWcpWBEPhyZRJGGYVMpnnBZpguNsF7kjD18cDNzYTG/i8W7DCEYzlzDX86rDj9e2OzgXaxmOdISN8Zb/jZh+xQrWuV8M0CxKEaEHVVi1155hMYmEbrDOsm0AR4WuHHW8c9jhn2dpCqmIavJU+PW1lHyWGeWYqgqphEepQVt8bcFX9q5YEhWWZ2cTCy69cctmuePdqYLd5k+clslo5/JBqBt5kFhZSSryzT2xswTmLdVXdJFu49LUV8Z0iJJMQq4yqlJjp28DLywUY+NXdjhtJqIOXmyUrHI233Fl4vrI98O+f71h3HustxirL4Pj3u5Ft2VazmwQuKreSiQ6SNWSxdNay8LArQucsucy0Xc9BIl97tiE887TOsmkSJRusWHwevsUr9e2JOSempIgoq/eUaILDmcgCR6GaTjYBSnJ85v45F33Pk9uJ2yhsy4zF4YZS5+u8Yq0wlcTzmNkWfT87v6MgkrlnHXMu3GQo1lSJYIlEZ1nRcrdpwTteTwf2Unh0tuRu8TRSXUlX3vF6HPi17Y6VC1hTA7ezheerU+Rmv6/ShAVSUnYxkUKBAiU0dM6x8I5NzqysJ6WC6wOTKfz6/pavbKFxhtkC1uEwXB1FFE748CEuV5EKcRhf26nHkrBFuPQdFsuhJJwz4CyfeeVV7qwu6J7e8PqTHTclEVxD2WS2ccJJZmV69kRe39zyPGVKqRyfJCON8kpYMGTh2e7AREGtEK1yhmUdWh6sW2Ip/PubG3Y9vOpWPFp6WmNovOOy7/nlm+f86+c33AkNampyb912fPV24F8+fY61FpWq838dZ/quY2uFhfP0WBoCT5m4tIFIxqw79kZ49/aa4ekTVjRMTcKY6l/xbLf5QO/nxzbg78PAIBPTNNM8u8IGWDUdzoE3ipIYnHA4bjyPr7cchshQagZ2OEoKtvlAUzLWLDCLa1Y28WQzk4cnVaopLBCxpP0tMUY6U1sUFm3HrD2SbmkS5OIZrdIbOMOhoaHtPBqqJrbOyrPnOw5GafuWUmoW1Ioyz4lnCq73qMKk1X1QqK6lTbGMRUAMRuuUd0TYzRPMGdsYYhCOhoD44ZomznTq6LvuW7tQ38YomZopV0VywVvD0lumVDBF8BichYNUNYl3n+7YNYntMNM6yzMLvSgWpS2GpfG0rceKcG0jK+uYUAatPyMlM5baZmEdWG9pj9mj1tVe0qKKEVjheQlDWzx7a0i2XhaGeOB2ShitlQmvipXan3gzRbIVrBgQqmEXSqMeJ1WlAlMt7bPATOaAchVBVNhrxmdPQJEZlt5VhRbN39J1+nbFnGu7WFEh5ZmFd5y5ljkVYkwYqsviTA3Yn14d2PvE7Rihs5Sh8tJiuOMDZ86RReiyYWuVNZ4x17mPoyQUm6N3iPeGEKpiTmcMXahDu6rHvlVvMdGxLp4dmWShz8puM/N4mOsQnTHve5ckp0wx1YHO4wzBXAoisAwO9fX15lSoDbeQMRwEHk+1snvIBS8wOpBUZ0ostQXthA8fUZV4bJtIObPwnnOvjEkYs+LUEqwD78kl8c6zHc/CyHZOYIVYYCnVEGttHQtriBSW0bF1Snucf4tacAoSlWutl1PrLB6HNUJna8++pWZkTUn0Cbx1rMQyGYhOcZLZHEau4sS66eiDqy1xRZlKRhOIZuQ9v4hSh3VXoU7RRRXi0dvkPf45hN08g62tchZXjTSzoXP1zn3a/V4chiMHY4zsNjesnefOumUcUg381RIA7wJSRt54+12eNbdc70eKFfZj4Z6HhXP01tMZy7OSaIunOFhZRzSQRXG5uudezZGtJIpVGmfpcVgpdcYpwVYzY0mYAvcmz0Vn2EliUGhnx2Eq3MyRC9+ybALBWFIpjDkzlEyOevx8CGPKNECjjjvimClEo8f2ICVaRbPwZDvirKkKZyWxRzB7Yd3U+YNZPpha48c24B/3V7VPVQWvgrWJtl+TsOQ0oyVX06IATe54/dmWNgyI98SmwfWXiPbkwxPm+UCSjIl3iEPCpJmQoPcKvjBGOAyCCDRdg/cgJRJnxYihMZl9zIgvJO8Qq3TqWfoG1wTE1D7vaGvf9qLxpCJoqk6rtlT5JC9VSSg7pZg6JGccPGh6NkRiATBMwCWBA1XyiVTddrEw5wMr8ZiSaTzY5mO7hJ94zCpkc4w/jKkDvKJMUjP2HAclnTMEcbzxdIN3ew65cDNFbCogFi+WjDKhdKYepJ3xLH1go4WoiUx1ElVT/1u7mWtPtFVXB9EkExGsGiYrdM7RWMcshVGrMU2ZM4dSsK6WzEuppkdO6mCPlKrMko9fzlichwsfmEQpddYXI8qZBlIuHBDq7KUlO2WQRFssEQWvx37yEz5szFkoFoyxWGrvvbOOLIWDVlnLYhWnVd3pnas91lq2KfNsGpGpCg50xZBM4aDQ4CgZFg5WfUBLZkxCzvr+XApolWeVOouCKqrKwSdEC4gQURbe04pFrGMEolbr232pggapFCyWYC1JqihBLgBHEy+jeG9xQblsW3ZDrq6qxnDpPY0L7FMkidbnZaEYYSfCGs+g5egkcwr4XwRitQ/BYfDUYUaDQURr7zqKqqEDMIa3bgaMMQxS2OdEzkJWSyOQjTAVS3CO4gwtmYUL7FGSFGatVVNQcq5iA4a631osUpTR5mo8KMqkwsp7bK57oZrK0yLKqNVPJIpgVVExlFK5nFHU1P8WY2qrmLWsm55BMknAKnTWE4rhYCYydQA9iWK0MCEscUzH89qc+PfCMKmQTHWYb6j98d441GYGUYwI4kCspVjD15/dYoxlM81cHQY0C6a09ASyZCYrrGxDKgURw/0usJPC9RzrxROL2jqEEhQ8hmSUYCxTFq7TxEHrxZPGYdUgGcZSZ6tmpziEbcy0tspmF2o2TbKwJ5FVEIVioAmWHk/oHee+YSeJVASjcN82jKW21mWFWAqzVFfpscys1FFSOs7QfzAOfmyjxTzuKSEgWBK1V9X5GaXe8LUkCkrfWUrxXA0Tzhl80xCwGBvRDOMciXMkWUMzT6jWKW1jA8iMixM+8b52tLNHFQERVARrHFOamGJGNIMNOAe9CSxDRzHVbdVZw2oZcFnwDrxxiABWscExO4NTpXUWdVVyTFW47FoeLVZ0duZ6juxKxhXL0jhiqHJUDkNrHHjQKdIWpV2u6M/W9Mvzb+1CfRuj8QbreF/nvhzlMLPUsIiaKGfReuakPDsMQB1Ki6J4rUO2FlsHapHqbspx0FzrcOzCOzKQqpg+ratqKEnr4FFjA1kKOSujNZjjUJzHVwMurYedp0rNrbAcKCDgxOAMeHVMFGpHax0MOpoCc9m2POh7tjGxTYVDyTgBZyyl1MPRe8fiWNbP80wH1UjH1OdzwoePcFQIOQoukamXgPdUkYytAZl3jmDg6X6qQ7sipFzl4IwxGGvrwVkKS+eYDFWswCjeWhbWkZwh5tpWtvIgtvJYVQmmXipNSUxadRqTKq1zBGer7rmrQZotjnPjGU39XV4NjdSe2Aig1dPBHNWjCnCnb3jU93SSuJojBzKNQlMMplQlLGuhd5V/MSoLqsxjNqaW80/40NEayMehXUutLsYsWLW8J76kHKvOxnA1zNWxmzpo6fQ4XG6q0lREWLtAtJCS0HrFY+mNxxitSlJAUEFMTUio1kz+kCMHMcRc/3ZUYW0sBq0Vf1PnXAiedSnHVjhADF4MqKMckyo1gVONwFSVi8Zzf9mxS4lNzAy5pvm9gBYlmzqz0OOo85VKpzUBJAbsaWj3haHxFiOgUjmmKsQs+CoPh6oeaz+O1nmuDhOpFOackSK01pBR0CrJmRV6VZIWpqgsmzpovnQeGyAZAQt3TUPRer6ps/TWcj1NbEui0XIUTqjO5HrkurGGcFTNOTcNuxLheIG0WudDVBWHwaEEVzs6KHBn1fFSt+JmmrmZJw4xEcSQFBAla8YZQ28cOEfKE817nLfmAwsXfGwD/iIZWwwYD9aRTUMetoiriiFU5TeaxmJnYSgFX5QuW0IqaLwm5pk5ClENRiwxjTT9mnlqkWCRMaLTTFcSrXMkETwzhzwx5AlvHd4YnkwzIEeZQ0fjG87Pes5cyxAP5FzwBtbnS8pUeG4K3jo0GAShEcetFVpTh+2ccxQVDgU+s1pz2fV4Agfd83Se6YsjGfCNe98y/MwGLIYznWg1c373JdaPXsPoaWj3RWEVLBE4iJBEyU6ZkxCcqdkoW0+9pvFMktinjJZ6QHXhuC6tRSWjoiRgQ6GYTCrKHIVlG7gMAeM811MiqtA3vqoB5VpSDI3jMM64YjBylL1XCIuWhTM4dRhVWrX0vWFZDF+dqpZ5YwzOGIKxjORqQGIN9ljGPJTCa/2Ky2VPYycmBq6l6k5HEayxiCrBGNYh1MvCmFkYiMesijnVtF8Ilq0jKYypULSgxjDMkYAh+CpBUQNeDzZxO2es1Izl0jfgFQLkpMRkICvFJHKAOBfiBGsXuOda1MFTiSQVLjrHvmTGXAhq6a1nKwnNBe+q/IpVWHae3jjEKcYaGhytwirD1+aJ4AxBweXqCVAMBOrF1BjIWG4l85nlint9h5XM1sBhTuS5MAN61KRunGPp6x4YDNzBs3NK9OA+RbKIHyV6Z0jm2IKqVa88Rmhci7XvBeWmJh+MYZcziuKNpTu2IkowpCTMSeA4N1RQDkWIcWZlPZeuBaccXL1Idr5wkEIUwUk1NJoQXNH3jSvVKH3X0BShcWCMIxhH62GZ4avjgHM1S+u0KrcMpuDKsRxpatJtVzIvH7XMW+OZZeQ6z5QxE40ezerAe8u6qeLJPZZODPHoxfJp8iH5qLH2nqTClAtoPYfnmFk1DThBVKrpaa5tO2PMzCXjDdzpqwP3JBmiUI5qizeayWR2KcEAl03Hw9BjW8PTODKXwrlv2Upmp5neBhrneRpHkgrH/BrOWR5crDBDpHUO5x1d07AylnXr+DfTVW3ZVoOK4I6xXxZTRT+OVfatZF47W/OgX9PYgSEX3pUJMxVGK+QiFC0sXOBO09ULg830xtE0DWINU/yEtvTo8bZ8vUv0vaEJYJ1lmAJnQXCSyEgtA4pyewNTGqs+vcAqQOs8qsrTUeicVtm4XIg5UrY3OBUKLZEFRqGb9zzoPW+MB/YKk1bzF2cTcxZaEqFdsVytWSwXLFvLD3/+Fd568wllbBiSkBBeDS00cMuMpEIudeBzzJFsAWPYWBCpJe9H/ZJGHcN+YsiJQ5oZphlfDDeSsZ0QbSbOQppmVr4jqGVsHevgKEWYhvib3rcTvnm8914+2Uea4HDG4sVw2GXurKsueC5SjWdUub7ZM0PtExXovKFrKgdvxogv1YshapVXVMl0NlBEcaUO6jQmcNYFvj4dKEWqaUfO5OyYRciz4ryt5TugdfCnv/sVvv76FcNs2JE52MKl6ziYjAKpaJWqdbAvUnv6bZWzy9TqwqO2oTPCfpg45Mg2TlyPA+vkmVTAw2AKh5gY5sjKBnIUtgCmlvpdkt/0vp3wzeG99/Hd3UznHV7BqXLIwnrR4k2t+KiDxlg2u4lBju1/QO8tl76Wv7ez4otArjrpI7V6422Vhz0znnVraZzjbuP56nggijCUxFgKKVskCC4JxptaMbIG7yx//PMv8fWvb0g5czDCZAoL4xEp3MaJNkFnHcY4cgYCLDJsyUQUb+BR41lgGafEkCK7eWYzTNxRy5CEtq0eK/s5sh8TZz6AFDZiiEGhwHHe/cS/DwnvvY/v7GcWraW1DqeWzZxYtwGjQrZaNfGdstlX6eCxFLyz9EFQ8x/zr7p1Z1XiUCuPHohTxnSOVetogHNreX06sC2ZQQpRFCOKSKbJVY7V2RooOQd//Dsf8MuvXxGnxIwwWUOvjpgL+1hdd5O1GAsiBWsNRi2bUkgo1hguW0dnLPv9xFAK+3nkdpxok7IVobOWWQpDnNjKzIVt6bBsRMBVMySOMyQn/n14eO+9fH2z586i48y1+KK8FSceeI9Rx1Yzsy1YZ3i+3aO2tskUoPeOtdTfszlEztqGWAqTCMV55lgTYikVXAvnXUPvPHe6wC/f3LKJib1JHChMQ2bRNbRZcSK0IWCdA4E//fu/l3/3y18lDTOjKlOGhTMMKTJlwWqpbehaOMTMOlh6NTwfI5MKwRgedj1rLNM4sEuRq3HmyXbgwgc2c6K3hkGVTZx4Os889B1BDAcR8FXBzOYPdgYb/Zix9K233uK11177Vj+NTxzefPNNXn311W/10/i2wNe+9jW+67u+61v9ND5xOHHww8FpD/y94cS/Dwcn/v3ecOLfh4fTGfx7w+/GwY9dwC8ifPnLX+b7v//7efPNNzk7O/tWP6UXiu12y2uvvfZ7fq2qym634+WXX8ba0/Tkh4Hb21suLy954403OD//9p+ROHHw44XTHviN4cS/Dxcn/n1jOPHvw8fpDP7G8EE5+LFr6bHW8sorrwBwdnb2bb/ZvIdv5rV+Gj4QHyXe+8Ccn59/avgHJw5+XHDaA79xnPj34eHEv28cJ/59uDidwd84PggHT9fRE0444YQTTjjhhBNO+DbGKeA/4YQTTjjhhBNOOOGEb2N8LAP+tm354he/SNu23+qn8sLxaXqtnxR82tbk0/Z6Pwn4NK3Jp+m1flLwaVqTT9Nr/aTg07YmH9Xr/dgN7Z5wwgknnHDCCSeccMIJHx4+lhn+E0444YQTTjjhhBNOOOHDwSngP+GEE0444YQTTjjhhG9jnAL+E0444YQTTjjhhBNO+DbGKeA/4YQTTjjhhBNOOOGEb2OcAv4TTjjhhBNOOOGEE074NsYLC/h/5md+hu/4ju+g6zr+0B/6Q/yrf/WvXujjPu74u3/372KM+U1f3/d93/f+96dp4id+4ie4e/cuq9WKH/3RH+XJkyffwmf8ycY3w6NvRw6e+PfR4sS/34wT/z56nM7g34wTBz9anPbA34yPBf/0BeBnf/ZntWka/Uf/6B/pL/3SL+lf+St/RS8uLvTJkycv5HGfBHzxi1/UH/iBH9DHjx+///Xs2bP3v/9X/+pf1ddee02/9KUv6S/8wi/oH/7Df1j/yB/5I9/CZ/zJxTfDo29XDp7499HhxL/fihP/PlqczuDfihMHPzqc9sDfio8D/15IwP+FL3xBf+InfuL9/y+l6Msvv6x/7+/9vRfyuE8CvvjFL+oP/uAP/rbfu7291RCC/uN//I/f/7df+ZVfUUB//ud//iN6ht8++GZ49O3KwRP/Pjqc+PdbceLfR4vTGfxbceLgR4fTHvhb8XHgn/9w6wUQY+Tf/Jt/w0//9E+//2/WWv7Mn/kz/PzP//xv+fl5npnnmRgjv/ALv8BP/uRP8rWvfY27d+9ijOFP/Ik/wc/93M/x1/7aX/uwn+pHinme+cpXvsKjR4/ouo4vfOELfPGLX+S1117j537u50gp8YUvfIHtdgvAyy+/zKuvvso/+2f/jO///u//HX+vqrLb7Xj55Zex9jSS8Y3yDz4dHHxR/IMTB/9jnPj32+PEv48OpzP4t8fpDP5ocNoDf3t8LPbAD+3qcMTbb7+tgP6Lf/EvftO//62/9bf0C1/4wm/5+S9+8YsKnL6+ya8333zzw17KTyS+Uf6pnjh44uCHhxP/Tvz7VuN0Bp/4963EaQ/8+HLwQ8/wf6P46Z/+aX7qp36Kx48f833f9338k3/yT/jzf/7P87f++o8wxUxMhbZvsaFlsz3wxvVT7i6XXKwW+Nbz8HxBKfDuzTWqoAWmMTHPkd+4ueJe61kGw3nX8PL5isu24WaOeOMIFuaSeLIZudLEZfAsOkfrHb0PnPUL2sbRhIAW4WY/sRsmWmPw1hO0kCUxpMJcBEVZ9Q1d0zCVROMcq6bFWpjGwtU0c7UfySJ0wXGnsVhvWTQBaywYQzHK85x50Lfc61uSGIy19I2nb1suL3vmnBjGTM5CnBI//sX/D+v1+lu9lJ9Y/E4c/L/8jf+aeZ5JUfBNi3GO3Tzw1rvPOVu1nK+WdL7h/uU5WhJPbneoKFqEYRgZ4sybuxvuOkcXLGed57OrBY8WC2YRMgoKh5h4czuwkZk7TUtnHb13rLqG9apn0TYsQoOKsJ0zw5QJUpjyTGsgx8SQhaEUYhHOVi2rEJgk01rLOgSstRymyO2YeHqYiEXpG8u93mJNwyp4sAIqFIV3JPHaquFu25EUwND5QN8vuHdvQYqR3X4iZmHOwv/pf/gfTxz8PeJ34t/f+Cv/Ww6HiZgzi8UCQmCcJp7vt6yahnXf03ctD+5eMM2Frz97m1IK1jikGPbzwBvv3vCgtTTe0XvLZe94+ayjMYaYBBccEXi8HXk8HDhvWnrnaG3dlx5cLLnoG0IIlCLcTpnDNOPzDFmxKqSY2ObMNhVSsXQLx8NlTzFK1wSWvqXkSFRlMybe3h2YSqb3lvvB4W3DRRcwQEEZVXieC9+5arhYrIiAs7BoLP2i5+7dFTkmdvtITJV///3/8P898e/3iN+Jf3/7b/63xHFmniNN12K9YzeNXG9uWfUd68WSvuu4s1oxTYl3rp9QtACGMhfGNPGrb77LK+uORetoG8/louFR39F6ZYgQfEAtXI0Tb91uOWsDwRqsNfRNw8OzNWddR+MtUpRdTgxzhFgwpdACWRL7XNimwi5lvIfPnV9QyARv6UODF9iPkW0uPN0PzCL03vKw9RhjWbcd3oEYmBCuc+Zz6yWtM2SxWGdZtQ1N23N+x5NSZhwUScoYIz/+xf/3iX/fBH7HM/j//CPMUhBRlm2H9Q27aWA3R5aNo2sCrvGs2wYHPH5+w5gTAhiBOGfeuLnlsjF0wRG8YeUNZ51jbTxDynjnKBjeHRM4xQNelVGE0Di+594ZvTMoASnCdsrs5oSawtJCbywlC0MWdkXYqVCAzy2bGoY7i7WWRg3Ow3ZOXE+RqRQMcOYb1sGwdAFroQBRYXbKq33AeU/C4IxlYR1tHzi7CGhUDrOQijLHwn//f/vdOfihB/z37t3DOfdbpoufPHnCo0ePfsvPt21L27Z0XYdzjmEY3n9i33HvguA9vg1Y33HdHbg97OiahiY0YAxzVMbDzH47IxjmGHl6c0OwnlyU6xjZiUW94zPW0jnHS5dLVCy308zVYeKd/cwrdzvO25ZJM1hL2zaslz1SCpfrJcYYurZj3c1IyaSUWbiOOc00TaGgJBUuuo7QBkrJNK5eFpIWWltICKbUIK/xFu8KfRNYNI4sypwLu5h4Yz9gc6HPhSmDawLOdHgDy8WKrmQ0JWIp2OMKGmM+7KX8ROIb5R/8zhwUSbx255zGBJwPYB2baWCzOdCGgDN13Q6HmXmY2ewnFGGcZ55d3+CNJRnhOYq3BlWLc47gHMtVS1blZoxcDyPvDBOfPW+5t+y4mWeys4TGcbZsMWo5X/cYY1gkYZ4zeZq52WUWbWC0FqdCr8qQMmd9Sx8CZ7S0vl5gUyk4Z0nA3aIUURpvWDTgjeOsDcSSiLmwT5HX93usdDQ+Mym44DELBSxniyWlccRJ0BIxrpYQTxz8cPlHyXz23hmN8zRNR7GeMc6M80QwASOWOWZu93uG3cQ85SP/Jp5e73AGcDWB4FU4t55L6+m953LVkZNwmwubOXFtDI+WHZeLJU/HEW9h0TlWy5ZgHGfrBcYYVkkYx8i43zFvS/xMAAEAAElEQVSOEecNzllsCXSiHAosW0PfeLrGs+o7Ou/ZbQvLYElFuNs2JHF4b1g4SxcCZ51nToVDzOzniV8/TDS5x87CqIpvPXbdg5k4W56RgyWOBc0ZXH27Tvyr+LDOYFMSn71/TuMcLrRoMGz3A784TQT73v5X2B0G9rsJKYaisDscePL0iqZxuOC4mhMbKVxauO86Wu+4c9awTpZtzDydZt6NiXuLlrOu5Wqaaa3lrA3cWfUEE1gvOowxnGthTIndfiCOiYWzxBxxIjQi2HHCOVh1DY1v6LtA3zTkqdSE2hS56FqyCN5bnDcsg+esC5ScGUthyomn48hd51hby5QV3wQaazFmYrU8RzKYNBMlQ5Pr+3XiH/Dh7oEOeHm1xDuLC4HiHEtriLngjcNZiwJSIMWExWKNZZgSm/2INQbfGHaiTEVZO8u5c1hvuL/omWNhVwrP5sJeDK8sPA44lEKjjvMucNb1oIVF22MwrLrCfops8kyvSrAWzUIQpVHFpMQsSjgm7vrWExpPnAuZTCOOdQk0ziJGcdaxbD1r75glU7KQi7LTwpgdLhUmURpvaTpwybDsO4yHUiaMCgQBfncOfugBf9M0/NAP/RBf+tKX+HN/7s8BICJ86Utf4q//9b/+uz7un//zfw7Adjty0QSyndndzjhr2e0Tz243/Pq7T2sAHupOH4B3nx0wRukaxyJ4XCukkkkAWVi4gi2Ks4bzRYexnjf3I1++2vJ0M/CDj85ZhZbbSWnF0WHRnNnsRu6fr/DWsGoCXmGICiS6tmVWhZKwCJoMQ4Q7raENLcZAyYIW4XacMap4awFD4y2L4/PPRQjWIQ5MLhgcEaEUKKWwO2SuxsjdPvDKZ89orOINZCz1CnnCe/i98u8/fux7HNxs91zYhqSRXRxBlTkmnm023Lwzo6o0jUFV8Xg2w4wxhcYaGuOwziDOMhthTMoqKVYtaj19F/DG8fpu4Cs3W97c7Pnf3F1x3zVMJtMaQ2NBS2G3H7i7XmKdJSAoGbGFzjv6vmGU+nOmCMUIc8qctQ2tc6DUC0IWNpJQqdlSCzTWsvCBGDMihWAd6sGqEJzlkBJqO0DZjYnbIXPWRz6f1wRn8dZi8aAnDr6HD5N/u82ec2sp1vB8s6GUwmFOfOWdd9kNCWsMzcJjrWGB4ZCUVDKI0Epg4SF6QZ1iirBWz4N+yVnf0/cNfmF56/mGr24HbmPmvzjrWTaB7Tyz8HUfLVoYxsjFxQJnDYqQtAY4WEPfd+SiBCMYlH2KgKUPnmUbaJ0BFcjKbY5IoX4+nKULlpWrmTlMwRnw1hCcJbSGfRFKyYgKt7vE9X7mctnz3d99B+cN5r3t70S/34QP6wzeXW24cIbJGvZzRkJmuk185c3HbMeIt5a+dXX/8xbrWg7TQJoinXi8KIIyGEXmwiI47jUty65j1QZMF3j73Su+/Pya65j4/P07eBw7Y1g4x9I5KJmcC3a1qL3JJRO04IzFB0/XNuTZ4EohFKH1BS3QOGh9wBsPYhATGNOIKjhrcNbROocBGmOwKAI4Y2id47xrmIE1ipHC/lDYjIl173n5sytaY7HGYMwp0P9P8WHugYdpYu0dxcDhsKe4wrRNvH17YD9nMBAaSzA18TAXYc4FstCqobMWY5VZlJgLC2+517S0vSV4Rx8cz24HHh8im6h8/zowSsFaSwssrKWoMM6Z84XDGYMHHA4mh+RC2zZMFExWghR6k3FY/PGMdMbh1IJmxqSYDC3gjEUMOASDAauo1M2scZaVM4h1hAw2F4aYOMyJZd/yUukI1oOa2lUgH2wTfCEtPT/1Uz/FX/yLf5E/+Af/IF/4whf4B//gH3A4HPhLf+kv/a6P+/Ef/3EA3nz8nDhOmGCYyTxYLXm82XCbRjI1KxmLEEwhOs+yDzgPPhisWFpnMcnjxeC9oQ0e+oaHL13iAOcdg0k8lRHtYAbOXKFzls5Aq/XGpKrc7g8s2wakBu8Bzz4XyqKgTmtmI1vmOePbwnYsXCwtDkspkAs41wJCZxKiSlHlNgoewTnLuvN0oeHSWPpxJhnDQTL7lBhFwBpsEn79aze8dHeJFIujYCW/iCX8ROP3yr/3HvseB99+vCXuZryzRGe5e97w7s2Wq2mgGPDekFz9cAqGte1pvcFbRbLQ4JBSsGJpDARj0eC5/2DNgiMHKTzLEzSGQQqlFBbq8ZjjdU4ZhpnN1Q1t3wNKTomchaEknDYIuQbdCkQlF+WGmYtlh7eWoiDFEpxHHTSupVAokrneTwC0rccC1liWvuWy6XFF2KqyTYlslL7xTDnyi195xmsP16gWrFPqrfqE9/Bh8e/1d26ZdiMhWIqz3FkvefPqmm2aoXVY5ygoipJdw7oLaCmUlNGkBGcpsbAMAYPSOk/fdTx8cIkvQmiU23cSX73a4FSZV0vaUmiLxVuDQY/ZrsRuc6B3nixCTjXVMOTEmVsg1iJGEFUigqFjnwTrFGPBGojO4gBjhK4NpFKYk6Al0wC+9RQRPJYz33BXMyYbnqSIZCFhKN5Rrg/8+6885TMPzigCFoNJ5UUu5ycSH8YZ/NWnz5mmCe8d0Sgvnfe8ff2M3TQhWNQYplwrh4uuoQkdxihRDUbANJ4W8BZUhWVo8F3LKw/OcBScD2xj4s2rPWIK8/07eKD3js7VIFxR9vOBbtfQtAYRyEmxtjDnmbLoUGegKKUU9gh3cNyMwhJYGksW2I4T6pQShcZYsipRhVWAUQRX6sXFqmFhHOsQKCI8HwqDZAoWbyGnwpe/dsOrd5e4kvEUJpEXvp6fNHxYe+C7twfmqdTkqSs8WK54Nm7ZzAlj6z4loiRncA0wWYIFgqlBN/Dg/Jyr64GCELzFtYbX7qxpS4298m5iXxRjLYP8h8ubNQZrDLlkNnlmOY4snH9/j+2Am1JYOIuxmSKZmITiLUsPIxCBJEpIhefjzJmzbIugxiIqGIU+eGIRxhIYoyGVmsWwWPYIMRVyFpKFZAvbPHH2puf+RaAUBQH9gHvgCwn4/8Jf+As8e/aMv/N3/g7vvvsuf+AP/AH+6T/9pzx8+PB3fdwbb7zB3/7bf5u9V242W3ofuH+xZMBxebni81Z543bPZko4DI+ajos2cHAGUQPURVr1lu9zS67SgUTmvHF89qxlt93TtAFXHHkqmLneDIuDmyj03jFlQUfh0SIwD5mvxVtC8OQiSBb6YPj6PPJdGZzUnsVJ4DETd+aOBuE6TlgBSi0lLZaBuy5w8WhB0wcslpt3dxwoXLSOSWEsAJbvX68YELajsAyBCwOaYZMyv/T1x/zq08Brd855dLbEdeFFLOEnGr9X/r332Pc4mHvDbxwGGiwPzhbMUbm4WPFdbeGdzch2zNiinDvLRd/gVw7vHUWE/WEmOMPn84LbOTLHwrlYPnse2G03xKbHecdhLORYW36KVZ6WROvrppOj4jLEmPm1d6/Q4ClqagbLGr42bPj8pCxNPXB2pfB2Gfis69n6wjYO2AQ2Hl9cC3ddYH23o192NMGxeXbDdo4E7xlzJouiqnxH04Mv3MZI5wKXfcvZ0nO9G/mN6w1f3254+WzNo/Mli9VJmeI/xofFv4PP/OouEYzhctEwmsxLL9+hNIav3+y5GUaCNXzn2Yrz/riVd4GsgWnOdDi+ZxGYHYxj4cx6Xj237LcbmiZgtCEmg1OPD5bBKiVGznuPVUtOFi+Wp8/2HKZE8oU5CpKUzlv+56trft+cWKrBKAwII4J1lud55tlhptl7glgikYVrWYeedmlZLlr6xjPuDrx+fYsznj2ZCQFr+a5+AcWyKRPWeB42Ded9w7PdxC++ecWvPL7hc5fnvHy5pjtvX/CKfvLwYZzBszf8ymbH0nseXSx5czvx8NE5pff8xvMDN0PEK7zaey5cAE2crzvKumMaJ5wTzlPH1WGiCCxXlleWnt12T7/sMJKYpZCtwainuJp4u2gaKBbJgc52PB72bPNTet8wzrWC2QXDr233fOchsmgMBkMpipTC2WLBlczcHGbag6XBEhE6HH1oaZawWDT0XUMeEzeHAe8du7lmggGWeBaN4+k8E03hsvO8vOi5nRNfffacr1/f8PKi5+F6gW9OZ/B/ig9rDxwaw5AiC+e43/UAXK4XFGN4PEzc5II38GrXUGLmjveot+Rj5jsAjDWR0LeB+4uWl7qWeRuhbRAVJgBrCAWKVZz3PASMWAIepw52cDVveeotUxFKEZbW8Eu7kZemxAPjMVLbi3rg3qLjSUxEEcZhRItQnIUiJGe47FrOO4+3sN3VDpaFdwwxEwEBJuB7i+UX55msykuLwOdXLc92ia8/2/LVG8/DZcuDVUv7AeNAo/rxqsdvt1vOz8/50f/jn+T8rOd80XB/1VOy4Xq84Wu3z3n72cD+UEvaF8HTh5YuQCpCKoKIkIvQ4+mWAbVK11gerjoAHq0XTHnm3z6+5teu9nTB8+f/i9fYMrFUiy+WVWh55f4ZT28nRjNRRNBsMMVgneWdPHHPN/gseAPFKNdTYuUC/SJgMORc+7EaH1CjPFgsSA6SEbJk9BC5e77gMCdSMXhraRxshpFFY9nMmWFOOGdYNJ45ZlIuGAu+bfBtPeR/+v/xP7HZbDg7O/tWLt23Dd7j4P/uz/+XXK57Lruee4sFe52IceKr6ZrHT0b224xVOMfVAMY7RIVYch04L4XWBPpQh8HaYLm/qh/Mz925YFdm/u27z/nazZ512/Ajr73MrR9pcSzxXDQd9857bjcD+5IZJGLE4MWhwOvTwMOux+WCNwacZVcSF02DCw4MzLGQsrDygSjwcNWSHWQDokoaZl46WzBOiVwU6wzGGq53I+d9wy5GRs117sB5xmmCxiGpViisN2QKf/f/9QsnDn5IeI9//81/+0dZtQ6vghe4TSOXZwt+Zfecx08GDruMM3DXedbrjqBKlvolWRGrdG1HcFr3Q2959azy78H5mp1m/t27t7x+M3DWtPzZ77rDTYlciCEUw6JpeOXeGc9v92RveD4dIEOHx1j4xatrHrU9CyytNagx3BRYB8/FWYsxhnFMDFOmbT2TKPf6gASDGrCqtCLc7z1DhjkrmJrXfbrdc3/VcT3OHHJkGQJ3u46bYWYswmrpMWJwjcM1lv/r3//5E/8+JPwH/v1p7l8uWXiLV+Xd3Yb7ly2/srnm7acH9kf+3fMty1VDECUVrWewFlIurPoeq0JRpW8dL53Vy9mrlyu2aebfvXPFrz3b0nnH/+H3fY6tTCyxeHGs247XHp7x9HaH2MKYCjEbKLXd4u35wJlvaK3BY0iiPIsT56Gts0/GMIwzhynivUcKrBrLDsF6y6oJLLPl3lnDNM0M2dRylIWn24HX1i1v7Q7sc+GsbXi4bjnMiTEqfTCkKDjnCcHzU//P//HEvw8R73Hwx//S/56+8yyc5SIEYhqZovKVzS3P9zNjFJwx3O09xSoLhSyQVLEoxnoaCxTBeEcXHOfHs/GllWMvwhv7yJMh4VH+0P0le68siyEUSxsCd8479rsR7y3bmJiyImIwwE4iZ8Hhs8GpoRi4sYWLLrA0NRE2pMIhZQIQxWBD5WpwllWw9Llw/6IjFuEQFZFarL8aZh4sAr+2n3AY7vWBh0vPfirsYkExtI1j1QUaY/gb//d/+rty8Fuu0vM74enuQLMIPOzW3L84Z7+fGSZHyQqiWAxWgQKTUxox+GNPVC4FFZhNwYpHijJMiZvbRLbQvhp4Nsxcj5ms9YIAhtt5JuG4dB0hePCWs0XHIji2w0gSQQuUWLjoGkKhKpgYMNRN53zV4JsGMEhxaCk4sYxSwAhjTAw5o6qsveWwj6i1WAMuGKy3tJOh9Z4zNZSsiFEwNYuWtd4SbRKyZoZTOfuF4eZqYBkaFhctD+9d0u4PPJOC7BWTBYfWtpsibHMmYLDOABYpYBRGLeRsEFW2c+ZqFxEHZ6s1zw6R2yETYyFSiEW50UgvjuAtxhisdSwXHQuE56Nhnv9D+86lb/GiRFWKgkPxxrJetlhT50NaJ+QsuFyzF0mVWJS5FHIu9MYwThkwCIpxBhcMrTU4Y1iHFlMMqRQOaUbFUCYhUYeUTIIxn3p6XgRu48Ryecbd5Rl32p53b6/ACyYavELjj3tCLjwbRx40Hc66epGTjPW17WeSTMzKfopc72est/yvmiVP55mbQyLFQiTjCtykjBHDufM4b7Hecb7uIVjGnCil0KhBiuFBu2BlDRNaM2THNrT1MtB3AWMMDvAKCcusids8g61VMGLh3DpuS8GGAFZxwWKdY3lwNMZw1rY4axERNmMi58KsGV+gFYuOwn74WOWsvm3w5GbD2arn4cWau4u2Duf7iMxS9z8jWAyocjPMXLQB5wwWQ44KYvAhMMwjKQuHlLna13Jj07Rcj5HNUJNi6hxS4HmaicZx6Vq8r2o963WPN8rz7YjmggJFlYU6WlOFCpyamsV1nvNVTxc8xhgMtYe65MLjGNmmwmwV6y1zSjjjmUZFxdTZpqNy3nJ0qGid2zMeZyzjrOQMFCgWUCXlzDCf2mpfFDbTRNutWfQdl4uG3WCOg6qKVSUcz2CRwpgLXdPgnEVVUQHrHJlEMYIRQ5yU7SGh1pJwbFPmNtYhWYyiYjnkhC0OZyG4OuNxtmhxzjKIECRTRBiyctE4WmBnavtjMJZWHcvQ0BrBANYagjOUXHi+r+2WWLDOMhfLK86zHxJYi9Xagm4drKMjZ0GPvwOobZAKoDQWvAjzlNnlD9ZW9rEN+K+nPc3ecrnuKNyh7xfcKRe0V9c0dibZ+sKLU9Qr+5wxhSpVmTNt4xFjmCSTc5Vnmo/lktvLmZshkZPSYHFiePtm5CZnUlBMyPRNwTlH3xne2R14/dmBYGAZPDEXzlkAtfzjDIASXKFrHS54pAjFmBrMF8fCOAqFMUdSVjpjMRbGOePaBmOVVApZhbkoLitRQbAUEcZcUEMdEkZoVXEKlFPA/6Jwsx1pG8+d1RJ9ZDlfXlKMsri6odNIpvYtFwfJCtsUMcmQszDHTOehWKEIlFKzrCkViirPDzM3+0ica/aWqLy1G9lYYTJgfKJ3mZecx3SWZ9sdb1+PoIU+OIrAyjcYoPO1pG0ADLTO4X1VqdIjNymw7jyqwhgzWYSAIqawHRSCpUjBqsEVw6wFF+uFOGdhzpkoBe88U8wkk1n7htZZSKce1heB62FP23jOuyWL1YqXvWMuM4unt7RMZAqiNfiYOEoSYmsvvQpLdWQVkihRlCkX5lgvd68cZm6GmZKEztSht3e3iY0IxUD2hi4o3nu8Nby5PfD4dsbpUW0nG+6EBo9gXb0cmgKtUxZdoAn14uGDpek8JLjbt+ScGHLBqNKilBTZREtY1KE1i2JyzYzFImQBxBCzMpeINUpWZZozjfV445B42gNfBJ5ubugWDctFw4PLNQ/v3SPJyNLccB4yvhhiyhRbGIpiR6lJN1FiySx8QI/qdVEKMQnTXBCB2zGxGTIqhkVoaI3ljecHnmliZxKxVbrQYK2lb1ue3u74+rMDBmXROBKwNA4PBOtqDwQQrGXRNDTekIXKPzw6w+WqZT9NoILTKvZRSmZzAGc9Egw2UxV/LMRcsFi8qapmh5TR2jLNnCGYKnCQP2CwdcI3js080QwNyyZQzjpC17PG0W5uCS5SCtjjmhSFsSjO1NhQBRqtM23F1JSWCMQsiBoWk2Uba6IN6sD2kB2zFqQoxQmtF4K1hMbybEw8PyREC9YoQ4Gzo0SYPwpkqCreGII1BO8px+SzWouzwtkiVBENq1hTOZQVdqMQgsVaRU0dIG+cQYrQ4/Cmzq/sk5ClXnIM9bWrKHP6YJfOj23AX1zk6W5D8Jbz5YrP3n/Iqy+/xp3nVxz2EXI9wFKn2F54fjUR9wVJgnPKvbDEe0uWQkbJtlBsgaw82w8cYsEXWGtABf7nt244awN5CVtGkhi+/zP3iFb48pev+IVfv+Lh3Y7venVFNsJF7IgOzpoGZyCVQgl10b2BIUeiFLCWrnHcXzTc7A/MpaqjnAdHnCOm9ewoBDEwZmLK7GLmoig7o+Ss5FIoqdB3lkSqxDKVoFW9+oQXgTkX3rna4bzn8vKMzz74DJ87W/L202umJiMRhpKIS4tvLM9vB+ZDpiSppe5li3UOowqmXk7Rgtkrj692jHPEJGGpHieGX3q+46JpmJvKwaKG3/cdDyjq+LVnO/7FV59wf+35zgdLxmJYOg8ucKerG0Iswj4lNAohKIcUGSShKK313DtbsN2MDEPEW8Oi9eznkULDthRCVmwRigo5KCvJ3JYZUwy5QERpF8fNRQqLhasVgZNKxQvBUGbevt1gbeD84oxX7tznvnPce/qc3WYkSWbOQlk5ut7w7GqkzFLVe9o6+D1IpnH1Mmh9VZgY94mr2x37OdKosmgbQhv4d88G+uAYgnKrEfD8YONQNfzi21f82zduubO0vHK3YS7K71+cETE87DtQGGJCTMFgCGo4xMRUCuKht4bXHl5wfb3n1283BAN328Bhf0BNy/M51X7bkilZcV7JKDdzQoshqjBRaBpHEEcehdIqwSv+lOB/IRjyyK8/fYdEZrnseeXRA17pHvLm0xta49jsBp7e7hl9ATzPng+UuSamXGfozjy7YcAZwbsq2elybY292U3s40RjHff6JVqEf/31axZNQFzmqo0ojt/32Uc4lP/lzWv+9a8/5d5Fw3e8tCKq4Xu7NQV4sGirPGica391Etrg6iVDEslk+sbzg5fnPN9MvLkdCA7utJZ5jOxmITHipcHOGUqhdVCMYUyGqRSSLRAUaxsaa5iysLBKMGDs6cL5opBEebY7IAhN7zlfLHi4vsfZzU0Vk1DFJkMyDusdmymhohggWDBqmDN0rUUsiKubhU4KyWCKxWrCAp1tuUqGnB3bnNggqBo+d8+Awq/dHHjj2UDTKmdri1rLVCzOGc6bhqLCoUSSKkNM9KGvUuspcyjCuYEfeLjisI+8Mcx4A5feMeQExZOz4r0iRatXk7MY4NJ6RCFl5UYKicx9E5iKglMaBP8Bpco+tgE/DjLKu5s9P/9rX+Or7z7mv/tTf4aH5wt2h5ZUEjoIKRqkEYw6rCngwTSOgySYE4vW46ynbxy9cWRXeHKIzC6TSkayYIKjt7YOA02W2xSxBowWGuCPf+4l0lRv8cvcEhrHYUp4D1BVCgQYsxCjoZjCm4cDy+B5abk6ynNalmGJSZFRMgdjOOs9j+fMTYEL62hFUMkUn3FUjdmDyRwkEXPmZrbcXzhMqhvRLMqcTsHWC4OppePHt1t+7ld+jVeeXPPf/Vd/nMuLBU+HDS7XD9BMnR9xLtA0hmIzgjA6hTHTeguuZpp6Y9GlYTtGJpOIJZOl4BpH72GKgrPKXmeaAqJVRecPfe/LTDlicuGu72mXgd0u0baWONWLZbZwS2ZhlDJnfmOzo28Cr52vaIowFuj6FtnvOaRCY2DddDyOmevDxKWxdNRhp5iBpkrYHVB2Khxiodkm7rqAFMd+VqZj1eKEDx+ihmiUx8Oe+PU3+I67B/7sD/4BHp6fc73fM2pBx0QSIUeHw6EWqrZTYZLMNFflMWc9jbH01hOC8vZ+IpqMFsXGTJeFRduRUmaphq0k3kkGPfLvz3zPS8isOISX+xZnDbvB4FwdYPPOIt7yOI2cSWY/C+/sD/Qh8GC5xJfqH7HsGrIo+5hoBC67Bc9iYpMzCzG0BVxR8LCwgV1RDqawQ9jnQjcLa6lBmBjoijCdqpwvBCKKaOHd6xv+f//2y3z+M9f86J/605yfn3F12DGR0caQ1WJ8bd/RpBQVMIb9HBGjrEJDcI4QHAvrEZQnu5FZEkUKKJhiMdYw5cx3ny3ZlJln08wxccqf/O5HlJyxYnjgegiGYUo4b4mxDrYH47jKI+sSMbHh3d2exjnuLhY4U8U17qwaXt9vuBoT5IaXlw2P08we4RLFas3sg3CnadmmTBJlMsqQCsKB+7blVjKTqW1n86mj8YVBRUhkrocRfXLL/bXw3d/9iHvrFcM8YYsSrbIXRY+zHHJMsIm1xKJMKYM68HVEo8cizrGZIjOFjBCcoW0tYylsDiOXrWUswk3KuKMM3Q/eXyFzxlvlTuermeWhkAtkF6tOvvG8PUUWxnAokdtU5WtfWXS4AqVYlk0Dw8w+ZoIIl53hWc5kDAsTcGowGQrCAiheiKokhSELSTLDwrGLEDTjjTDlT3iGH6ormfFKNJm3dyNvv/uY0HisO2buTYHekfZCs6AO5kRBVWmPPU8qylRmPJYHXcd3ny/5t7d7igo2OIx3SDDETQIXeOnCcfdiyYOzDqT25p9frvjD33Oft28ObIaEzULJggeK6xjVVDfI4Fic9dxdtLRWifmYCXUeSJQyc95a9skxinKGZ0FhRGltlZgrxkGALFKzs1YIAawLNK4uV98HvFViKWxT/B3fwRO+OVSdZYMqzHPi7c0NX3v2GB88vrGoFyQIqCHtha71rJuGnIXdOOG8wR7LibkIDZbLtuWzlx2/sh8opSoBNEUQb5iHBEl4uO6506+5v+qhVK3oi4Xjj37uLm9tBm6GggwCJeOALIYohhmDN4b1suXu2Tm+CcQYsUVpXSAXoeTCvaZjR2YCVsADa5kax6pt8QqHOR03wsx8rJUurKVbBxpnYBZ6LJ21RJTrkzTsC0Epim8KEjKDn/nV7XO+cL1l5Rb0TYdrB6QkzJiJ+0QTHM4ZxBqargb40z6RsjIhtN7yyqLhf32x4N9sB4waiq8TYtkWboYdMhsuHq55pe95sOqQUkvWF2c9f/LzFzzejNxEwWSth5GDKUd8qQoV523D5dmCu4sVjW+YUkJFaFsHR/7d8Z7nKXETY3U3L5k2w6oPhMYQS2HvBB8zW80MpRCc59Wu5yZFYgPLEsBaNiJcT/O3dJ2+XZFEIGUmmbhC2X5l4E/9wIZF48AbZqdoZ2gOyjQkFsHCsq0SgghiFI8jSTW0ar3nlWXHdz5c8K+f3lBmi7cOLER7lJIVw3rdsHQNZ4sWyn98Bj/gyXZkMxaYq9HWkAWh+oaoNTxYLrh/tuL8rMcYyzxHVArLxkOx5By571vEKpucebl4Hiw8+7GAlOp47wzXOQGB6zyjxtBbz4qG6zSxbaQOqaMcVNiV0/73olBKwRmDlMJhHDkcRp69/Cpt29B1LS5Vn45QEsOY6ILHu7o2zlmwBWKdc5Jc22TWreOVVcvrU8JkyNZSgOshUUqidYYmwGoRuLNoKAAG7i4sf+B+x+2sDAo5J25K3XtybujV4gy81AVeWvasFw6jhpyEpnD0lRAiMwuEQ848y4aXuhV32sLzIgSp2frZK4ejqk8ERlE0w1kx7JqWbRFigUMWsirpA7bVfmwDfuctLliMqzccZzNfe/qEs6Vn3fWswsg0FcYpsdslutZyr+txS8dNirRN1UAnW0QNrTOcNRCc8B0XHS0tmynxLEautCCSWQTo28ArF0serXsOpbAODQCX6yXbKGzmwmYWrBMMHkohS0FslVpa4dgeElMSRBSVwmHM3F11lOJoO7CNY07CuzcTvrUsMHXICIPYQjne1i5CR9GE1MkPvCppzrQeilar5WVzkkT8/7P3Z82aJdeZJvYsn/be33SGmDKRAAGCRIGsoU1q61LJTFeSma4kmfWdfoTu9RN1IbVZDd0qklUFTgByiuEM37D39mEtXfiXIKt1oaSM0UzSYpmFWSADOIkTnx/35cvf93k/VokXfHCIFxqGmvGrr77h83HiZtjyFGfybFxaZT4XasncDSPJOeLg2PhACxVrgjNj8nAz9JyHH+837J3jaVn4Zl55nxuqyu3o2QbPq92Gz2525KaMKdIK7KYdw6Ux1yee16VLyTIk8TQ1zBl3u4kNEw/PzyxLN2BWa3xZFl4fdgDsp0RMiTk3np/OWIQ9gY3zPTVVPHntG9ldFMwbzgVcjKxrocmKXE1xEbhtn7CIH6OcM5wYYtpNrrHy5x9+yyZ5DpuJm8uILvBOF5ZzIY+O+ykRk+dIzwuJAVoxxIxR4QZj640/2A1MQXhYG98slQ+1oA7e7EY2g+P1fuJHhw1LLmymTje7udnyoVTm+cy8KA/WiAhNE2aGOser/cjeJ56XlfNaMVXA+Pq58tlhYC6ZyTlepJGq3U9SKhyAUbse0jshFlitMeGYxPrPVHCYBhKwxmtmhBOcS/+QH9M/3SqgBjUqi8tkUf70N7/ifhy4iSPHOBCa56vyxPmcWcXz2WFL3Arv55l9TFQqZo5osDE4CAxB+f0XGzbqKeZ4mwt/8XwkRGFroF54sRt5tR14nBdur3S9+83E0yXz5TpzXo3oGhKUTYn42pPJP9tM7AIs55nz0pv9KMK7U+Wzm0ApsJ0Sn6fAmpXnXBi98XmMmO/0s9GM1iaydT/UIN24aThSnAiqXKhsg2cbHKP/h/2Y/imXc64HrknXs6sav338wEYGNnFgCAvrqlzoOv6imduUiOI550pw0JzDVBExgnSMdQzKbVQ+Hz3Fex6a8e1pwflA9IYi7IaBmzExt8rOByCy3STetZlvjrmDEFTxwK4pKgLOsSeyAS6Lsq49FCtbI5fK3ThAgYnArXesKH+9ZF5Ez513v8vC8U6gVi7eMbQ+6XdRcIPnVCuxOh5rJkTHRvx3Dr7/n/XDbfgjhMHjroml0Qu/eXpgXAIJ5bBLPC0XjtkQtc5DT4kUPM95xTVjFwIuONRg8MJm7LbrUmpnq28nfnS/w6Lw/sbYihADhGpYqR3lNPa/yhhC/xAE4uD4bL+lrorQ4IrDW5bMN/qEeeHcVkrrpp9dHJm2A0OCyzzjreuw/nq5cBd6szRoZBcDwbnOYXUQVVjNKNbwKpQG51JI2hBxIJDrJwHrxypxgu+UNlSNRuNXX33L25jYDHCYBh7PM1YN5wxpcBO7YfF0zojBPnhc8oD1dNEhIMFTS0bE8fl+w4/vtxAiTycjWUG0Ilkpc0b3CfEOJ0YIES+BIIHhELgfJrSBlUqplabGsjZ++/4Jc41zqzRteGATBza7EavGus64WtFW+XXLONe3gUECmzQwRGGRbuLdirCWPkWwXFhyf5Hy2vBciRzl0xr8GBWTJ46BNAWGXcKc8WeP3zJIILrGfoo8PJ9ABQudhvNqmkgx8Px8JIfKqyEQt/1yNggMwdGcY22FaI7PNwM/e7FHg+PCgJsra51pS2FNGTsMiDgCRgwJJwFR2CTPi92GnHsATVPpYUZL4cu3TxQRntaVhjHUwC4N7Hb9/5uY4hflVOBX5+V3wVmvguOQItsUmeeFKjA533XYQM0di/aWirce0BS8o3zPlMlP9Xesq/FRW/eRCfA//OpXbNPAYXTshsjjeel7gxgB4eVuyzgEHpcV74z7ISGhO81GEcbQ4wSXUhidcL+LfDaO/OGbA6sNtOXESqGUSi0eucqDHBDjdf8zYRc9Lw8ja6kE7eAyMUGz8fg0c2qVpzlTzTiHwN0wME0dVywXxaGYV/78uHAX+tBs7x2bNOAGR74sVIybcaJappjS1JAsHFuXeDQPjU/Mgo9ZPgjOG2ZdNosqf/7ttwzOk3xlGx1n6U23F2X0ntfbEY/wfFkQjBsXSINHXNf1b6IQo2PJ/fVgnzwvQuD3tnses4D1fIjjZWUQ5fUUkSjgre/JzhMQfBA+22y55MpWOs5anVC18O6szMBSG/PVUPv5tGGaQg+y0wvmDFHHX68ryfdL7cY7Uuj7dfegGMEFFlXqNVbcF1h9p1QF64TH/D3p+j/Yhl88uODw4jqBxDme24Xni/BmHBiGgA+gC4TgcQLNFMOzjYHbFLuW+Xo79AIqwuVKq3DA/W7kx/dbbvcj7+8cWirvH56pubKsglhP+jPtgVseYZs80Qe2Y+JDyQQUUYVmrKXrVOMYWKRSihIscDvGftAFwdnc6SneKL6y0hmqwTvG1NNOH3LDkrBpQjFPK0prjVJ7uE1tileHQ9D26bD7WOU9yFUTjRmqjXfHI++Bn78+kFLARbAVQnL4Clh33+9i4C4lxtqooadShusanK0TSBZRXmwTX9xuuD/seDzBnC988+6JSy5clpVqG6zzBajasZs348C4DWx95MPc8NbXZqvGnCtzfmaTelBTbhUvjrvtjpT6GvRuZaPdIFQfFTPHEBwpDWyGseMUa6GqYxsi+EZbM6VkCsYskFTx5vB8/1jvT/V3qzQ50uR7wz8F1lb45nQB4CdxZIgeXMWkD0eiOCQ4XBA23nFIgXsBmTw4wZthJpyAS62A5/XB87MXW+72Oy6MPD6d+MtvM5e8cl4csAeEpl2rGsRzGBIhOG6mkW/WGYLinEGFy9yf1sUHTmQawiYK97tAipHgAqIL26ESs/L/PhWCCVNwxDiwGSdCdLzLBRzcjAPnFjjnTM6dcHXUyqYJUVz/GbVPr5wfs6yBFgNR/uLbtwD8Nz95w36MNKuY65dTj1wR0rAbE/dT5C55WnB9jdLTTy9NueTubXoVEj++HbjdHjjVgedj4M8fPnDJmUt2dEGjUFUpZsTguRkHvA/sR8/bdSGGjiluCqe1clorS2ucaqHQz9BXu0gIvueT6Mp4lQtfHjJJB0YnDCmy34wggXc145tyP06cm3Aqmbx2bf9ilY11m6TSLxqf6uOU891HZq3nxogZ3z4+ISJ8cTOSguuJ3mIELyTvcd6BGkFg74WtgE/dIxIEQuiD1Nn60OrOBV5vPIdp5O1FOOeV3zyfueTM0RumCXOOao1mwuA9d0MEB7djQpsQRVHXlQCXUrmUQhUhq/KcK2rC59secOi952Ar21EZq/EXq7I0I3khhcCYIipCyxmnRkoJlcalFdbri8KqxkZCJxSpsXzPS+cPtuG3a6NuV859NUO2ikh3+6O9STavJB9orfLtMnOD8fnhhi8OieOHI890xFFV43luHOvSm3inOAcxBrbTyODheYXnY2eUZ/WoWk+W1MzlUogCn+0nvAu8PWd+sxReDoYTJdOI2v86xcDwBBMGcwRJaGngPNutELxnLPDT00CxgTsR7sfEZkxkNVQvRJe4nxLbPPB8WXm+XJhFGWLHiWlWRI3x02H30cpF6I6yjsAyNSR0Lm5WxXmIsfPrY/IolbfrhRsZ+PFhy4/3Gx7fP/NerOdDaNfHz6aI0mU4ZogTYvS82MAljHzwz1CMZj35cckFmnKeM16M1/ue0vvN8cSvLoU3QYhiZNfQq3/RMIIJSJ9IpOCwpgie/eRJMTJVeHNMrOfE/Zh4OW3YjJF8TcB0CLtpyzQqp7jwdIYWjU0zghlqDjGI8mnE9TEqDo40OkISxCksFYbYn7etv37G5LAIyUc0wdcs7K3LEn+233B8f+ZdK1SFaAIaOEnhuqJpKCaQhkigEXaJrx8cZ4XqOna21NKbtHklOMdntztUlYdz4VfPKz++8wy+T+C+s3MEq2QUEU8I/Vm+5L5ODptAigO7IvzoycM68GaMvLi9YZpGslXcE3gT7vcbdrXxsFx4J2eKwDZ7RhNc6D83g/xgj7F/5NXhf6aGlk6jqRVEOtqwak+pd/7qn6Pxm8sDt23ki7stPz9sOF0WPtSeFCriMRf5sK6I62varEu+xkFwoYEGxqNnrlDluv6astbCkjPBw+f3W9QCXz4f+S8fFn56H9kE16f5V09bVMitgfc9U8Q5aingPPttIHhlWI03D5HRBl4m4W6/ZZgmltoNoJHA/WFkWwPxvPAuL5RYGMwxmOuXaO/Zflp+H7Uc7noGKw2jttqDTRtEJwTf5ayDJNTDt/NMBO52iZ9uA0/HzLN2PPYg/XP9UFeq9tBUJ4ATpsHzRXQ8Xhzv55maO/HMCNSmLE1ZsuHF8XqbqMDDufH1ufHZtn9tUzhfJ/rRec6lsNbuQSoG2hRw3G27H+62Nt5eEr4G7qJwMw6kFJlNmRGSBLZTYFKHLcZ5abggjHrFdkrPpBrl++nKfrBL9ZotgJl1Jz+FzAR0wsPQ4GYc+XI+E1xlEXhzs+UP7m55vdmTzFj8im+ZjUAQYVHHrIZ3ShVFRAmq1JxpzTOFHtBhpiDK03rh9OHEZnB89XhhM0budxsqkeZXZmmsxbETz4TnZA0EDg2i7xugqnGZZyo7tBTWnDhnxyVXfvbic9acaefGWhSk0TEbnlsSQmKclFUbzI4QhDtiZ1mnfkutnwgpH63c4BDtSC4i14uiIQKXdcU3z40f+K2e0FEoqvze7YY/uLnl1XggWeYUJzZWiE5wTbksnfrQnLFaoVrCmpIvM6312/vclm7W9pHTaeEvv33i5Wbim6cjmylxv9/Q2tVs6UFU2TrH6BPvfmci6q9IIh5xgUvur1qlFZYceL5UThl+/8UXtKmyrgVrjZwd1WDEc5cGGsIUI9aUs1sZVBnCRF77C8Xqlaw/2G3kH3WF5PExgXdkK6xNGXpIJHOupKYchonf6NzN4xN8tt/x882BV35Dcsrpktk6TzDD1W7EbFUpHpZrjoRUvXo2+uEprbHFs5PE6bTw62+PDIPjq8czu2ngfjeyFqVNkSU6NHvGIEQa76wfdgfvuCWx3YwcdiOBBjRya6w5cnpQjqvjj958AZdCrdrRc61iKBs/ctgEnAzspw4oePt0ITS49RMVpZhyakbQTyLqj1Hyt1B/9rs7fZdXPF0WghNuBs/bp57jYakn6P7B4Y4Xcc/kHbk+kYARGMUTNVB9gaTMGEUEM9+b8wqT96DKVgI3YeBUKr/55gMbAt8+nZmmxN1uwpswe+XD6cKrzY79JuCd8dg6VepAZKIz+V9sRr5bIbkUSgvMK5xmxy9ejIRsVDK1BFSUSmbbPPvD1D0j0RFjA1kIwXMbPKywVmE26y+7n+qjlbnrOmxcZTD9TM61MjjPPo48yZlx0z+/uzHwIgR26pm8Y16OHJpSVbuJtjkyKxBZm6FqOIWWjYoyeUfwjl0M7L3nUla+fIJDEt5dCkNwHAaPOMfalMelcp88O9fTw99ecxle4blNiZsIowtsAKqjycpsjofZc16F37+7hxVaXdAKFUWoDAKHyeFEmMLA7IXWMl6FlBxkoOfb9bv596gf7EktpaJOui6vOZgCDcU75WLCWh2mwjxVZuAwBfYbuEnCPjiCbzDA5aycUIYojIMnZeEXd7e83m0ZU8R5YV4zIUwA/P6rO1S7SS6fSzew3d/0D+h44fT2ibvNyNCU/3Y/8O5Y+t+7Ex5aw3vjcukoqU0MvBgnNptAQME73l8ywQd+fDvhzwuOxvk28e058+GyUgFXK//260depIEhBnZj4otXe8zg+XmFFDnNK9mUGn+wH+E/+vJOcNFjKE0yeIejI+ie2sJaPZHG5X5GmrAbIuMIo1e2FNKQQB95uuLpBu/Y7BLaGv/q9iX7XWQTPckJl7X0J2cSv3z5mqa9GatZ+fFm4uWre5wPvD/O/ObthcMYSQ3+u82Gbx6PnJ3gfOCYwQcj1974Jy/cDnDwOwYy4uGr5wtOAj+52zO1Fbhw3AfenTNvj0pR0Fr5H949cHNI7IaRmxh5eTNhFnk+nmGCtRaaGe3TEvwo5acB2fbgPStGSECoOJ+oJpAd5gP1R4Y05cZHDknYR9hGYeMj2hpvzwsNOKTIm+1EW2b+zauX3O8im5gILnC5KGFIeDK/eH1PU0NNybmw2US+eHXHivBwWjm9O7ONsPGe/8OLLW8vhdV5qgR+ky+43HDO45uycmF2lZdhw3DofPNfP59BHF/c7tjOK7jCso98eb7wsBh4odTG/+PXD2zH97wZN7ycRv7F568xC3z98AAYp2uAjvukKPv4JX3gsZ4K4oSveGIthbtd4rLLuNolZPvouY2B+zGSEvynX8+8XWe8c9wOkfsRwqz8b15+wYtdYoqe4D1l7RJK5z3/8s2LjmNsjedjZjPAixc7ZlWeTgvP54WUhNfO8X/5F2/46lQ4YjRpfLNWXIbqlW30rKXwzfnIyzrx5rAneceXH04I9Bf0Bt7PzJuR9+cT88loJszLyn94946UHC/GkVebLT9/9Ypoxm8fH8AbF4xmDv104fx4JfQGvxlGh1D41j2Ol6qI7zItfeG4UNmpsMO4MdgGT0qJEw8stGsIm0PXRtLAL1/tuBsSQ+h0s7U1IOG98keHHU37K/vlomy8cneYuIjxfs58e1q5iYH7wfG/+3zDh7VwVKMKHOkp4O+ccu8GonM4g/VKc0re8fXzAibcDgPj2mi1kTfC2/OZ+dQDFZem/KenM1PwvBwSt2ngn90eMKf8+fEECUptOHMk9/0O4R/uUW1gKpgJIhCi/K0/alfSNKhXFDjlyp+9e+LDh4Uv0iP7IeIEBozceuTxvRtoSXk57RmTJ7huBkJdd/007U+UTqCBZnh4WFA8ZS7QevjB+9OKqw7bQKGhIjgRtrFTDZJ3bNrA4Dzj4LmZHA3HfKnMSwGvtGaktrChsdbGOTeOuVBN8c1IImxDxzpJg9ocS147eQAoBj6E/2oK86n+nivSDUMKqMekB12YeYpCoGvqq/Z/fp4z//n8wAMXfhw27McRC8YoytqUaMJ9DNgUuNt4Bufw1/jtntXuaKw4J4h41JRG4/1zYdVnLiVTtJKtcjw1MGGjuQeKiOCu+kKrjQ0OUUiDsNl7ttvE0jzn88z5UlBRSoPJKluFReA5N57Xeo3zdkzBc8+AU49dg7dyWXnKfeMSEWLw+E9Yzo9T0p+zTbphy6QbHl1QmneY69MdS30PfDqv/MfnwjftxBd+w+00UJyRnHT/hxmTGdvNhrvNwOR7SrhI7a9YJvjm8A5EDDWhUXl6XljXdzTteu7LXFjPxu0mEBM81YxVR/KeV/uJZLD3gYMXfHKEMfJiM1CIHI8nHuZCE0dRYaeVQ4Wjwdtj5nntmvDV9wTfOzcQcRSFczXm5cK7sgCGl8jgAmafXjk/Rpl2uSHfpXU7+G7u35rSqmHmaFEpUTmtxn/68gPP38z8bHpmuxmoVGI/ZNHacDXyekzcTYEhhr7XQU+M94o0R3Td84RBUuPpMXM+veWiyloba6nMixLGDc6MY+6vU6P33E6RNESSVe6HgWGM+DFwGAcaI+vSM0jyNQ39bnBsXaf9Pc6F41opTXmqBQRug2M00Nq45IVLLvx6PgMwycjGhy63+1Qfpby4jsbu/6kDUvgbia02BQ+MvT98Pi0sZ+Pb4njlBg7jQGnWKTbWCWCHyeMkcj8kUgg46fLG76o1h3fdFyqquKY8LY3l3cKZxik3jkvl0SlhOzIFOBXAjMHDbQrUXDF66nRMMA2ewxBpeC5n43KV7Ja2MpA5EFgWOObGpfRXh4dWUK4XFxytKSdZmbXxm9O5Y5Bj5NaH7x0++MNt+OmHGwLOO3wQvsvPNlW8c0xDxM9dQy1qlFw5NfiwQN029mMi0g+7sjbOLROTZwzuCjHqG5pzgTh4NDsaBmqI9YZmWSvfPJ7JtfbGDsHESMF4n2dwrj+rVMVrd26PCkEcQ+j66dNaKCa4Jr1pWlcul5WiC6+S7xeYakTrqaUmQrymrJXWkALRw5ob4rrhLjiPE2HNn5qtj1VybaqM/rmLfLcq+2TR+8hhHEiLo6BYg1Ia55r5QGfv77aJaFCakZvy7DJjE5J3OAzRTgMKoaejmgLS5Q3f5YU/z4VnO6FWKda6Od2UjQu8r5VihjPF0RgarKZd3+36IRhxPF5W5iw4FbIIl1J4WgpI47MQkNawqgQxXOhaxIgDcRRVpPVUyVIV8bBWYxBPM7h8z1jvT/V3K9MODJBrtHtVA+cQ8VSU5GA7jIQmVAytxro0Trmvv1Iq4z6xjYG1ddP3t/PKIQWG8F0UvHQKT/CkKeGyEsWhV5N6acJlbbxfC8U6rcVMEXGIc/zVMrOY4sXjVdiH0OVr1RDf/UrehMuau+a7eVY1jnnh8TITpSMRRR3WGkHsisH1pKB43zNJltoTXJ/qwoqSi3IbI6CcP+2BH6ccfyMVsK7d57uT0xQvwmGciIsjiyIYpVTOeeVD9cylEifHNnhaM5oa79eVQ3TdbEmXR+J6zkwMHpNuzuS6p4UA66nxzTxTpJ/1KIzWf//bZWFptb+8AqNzTCGgpVHNGHFECayl8nhZGMRDcMw5c1oKT6vj5RhxoaLXhFYRYXCeJTaiC6gKS2k0lzmumWywtsYUFKwyf8rC+WjlzMB1KW3XrnTPB8hV1mpMMeBc/xNt/TJ3WR3Hq0QwRmGxHuS6WMM54eUQusFXFHHgnOBcX5dVrSM2DZwKsTnWorwvmSKtXyBM0A5y5Ouyspj23kCvPYJdX8RqZtMSAc+alafW8BpQ5znXwuNSgJXXYcTh0Xb1Vrn+tYJBsv59rRhNhKe1dGqgGvGKETzl75f+9oNt+EW6O19cj4TvIrzeyJgZ0Xvupi13OfHYMsFBckJUwSlgHWvkEEQ7FeWxFrYCjQqt3xy9hN7wh0BuFSvfLSmjmrGqUi4ZpR9ywfdpvkl/VYihH2i9ORN8dIzB4+hNnTT4MK/EpfFymjortjV0rVyuaMORrt2efDcCqetNW9XuPm/aOC/KWgyHkdWIrm+6y6dm66OV6/0udnXtuuvhZ9dpQAqBF/s9r9rAh5oxf3XaN8E1EFPW0voFUqFo40kypfbf9y/WNXriPMMYqNmR2wJq/VkvN5ZSKFZxTqmmNJQmno1zzLX1Rkpal401Q50RRPAOoghS4P1yQUR5Ne2u6DAl50b2yiCOLY4gwhT89fneseSusfXXQ3jOrTf/CHqlA6gqyycfyUcpo5u6vRN89FgtCF1WVrUSxfNiGrk7Bp6sYuIYXTePifYpEQbJdTTxUpSHnHsAmyr9EusBj/OJYUwULdAa0glw1KKcinJsBb1eNJ2AFwDH+5xxTojSD81RQJzDTMkqeAVpxvtlwSTz+WbCuz75mtdM8YY4uMMRveCuT/SDedZSaXTaRtOe9Dy3grh+IWmmrGqfGq6PVN1Y25uXv13XGRcpeF7tdryoiQ/WDbVjcAzqQIyq3fQYRECEpjC3hnDVUzeuF9iAOEeIkUpDaw9OMoGs1hGbpWLSd94gQpSIoXwoK612P15FGcURfE+2L60bfkNrHNfGw1L5Yr/Be99TfVvj2ArmHIcryTz5Tn4aguNSGqYdt1hNWdbGpVSS97QG1ZRZM5f6af19tGodn/q7V6a/VaqKc8J+HNgVOEkPywxX/CbVyFrxJKppl1+I42J9+FZQgjU8DiSAc6TUJT9GB230lyZjUeNJFWg464oRb6AYH2rGmSAGixn+emaCUVrryOzsOTUDV3k5TD3gDWHRxtwUR2Xn5ArxgOCFA5GnmvEYzkFBOa3KcS2MuH7/MVhq5Vz/kTf8HbUkOCeERDcgAsFFGpUhJj6/v+ey3vBnp0dyaCQTds5zK4ltTDySkdZ3pwZUMWrLPK2ZQ4o4F2jtOhtQR2n9udCsp+Q+zAtz65KLKAHxnTseq++x4sVzbp3pn8zROsKVtOmbkRmUYjxRaPPM3vk+GUEI10NtvgZCeO9Jnn7jFGFVxYrnMDhybbw7LqgZAx6ap9oVhfc9+auf6u9ezhl2HXGJ9M9TpF/IPJ7tNPLm/oZ/vt7yZ5cnntJKao6tBm5dZBMjH1Rx2vnBmNBMeWyNp/nCPgUirqeZtj5trU3IuVGrsmTl3WmlasVlxxACRZW59Zj4S1OSwkyjSp9KNJOe3pt6xHirSqZyssbjMrO9Jkkm53vQTYAioN7hXUDUEFGGFKjiaSFw8J6cC+/mGTxI6/+OYqUb3/9hP6Z/siX0C6fzfejRMahCMDBzbMPAF9s9z8uG/7LOLLEyJtjjuLPQaQ9VwflOVMLwJjxV5Wld2IeEkz4pa61PzbIKc6mY9YPqwznzVFaaGjvnmZtyuVIyLqEyIZyz0aSiXrEmqAQSjrUKIo2oysPaeFpO7Nw9icBtnEh4jj5zco29h5Aijs7e3sfIaR7w1bEfIlmVb+cVh+IJjBJYakFonyQVH6kE+12PJe67CT+dThOE7Tjyxe0dJ73lT4/PrD536YJEbn1EXOJ9Wwkq1CtaeyORWfrZuk+RSRL9PtBoVHJT5trAKqVU3l+UD60grRPRsim5delEro3Q4JIbKhCip4ixE+2vj03JNWNFeSzC43JmH8ET2UmC0Hhk5eRWNkSc80SUJJCC49kbbmnsB8esyrdzxtSzS54hRs4lc/rucvypPkq1Zji1a5vTz73vJvwiwhAj99sd+fGB39CYoyMlY6OOrQtohBNQpTfqDscgjqda2a8zmxR6T0XPMmkIuRplVZoIxYxjLpy5ku+43oBNGR29D2ydUPad7855x+cpApAXZc3K0RVORThaZhBHcIkNHoKnauRCIzlH9obSB4f3MlB8ZQyBbYx8yJW384ypsfGO6COXWmiqOPt+e+AP9qx2vlNpQhSGqZtipjThm5J84vXujj/+/Mf84sbx+te/5U//8hvWtTClyMvbHY9W2bWRKcF7yeTacGLM2jieZm5fjTRxzHlFdeZ4Br/xvMsrT8fC42XlQzkTiNx6xzlWmhlJhSk61mY039i4hJfeyIfSSEBe4VQKlUIIiRgHvlwW0vszEoXqO5JxKJXDfsNmHBBgaZVV4fNpy2ebiWGA4/OR33x45lwLKW24AMn1l4EYPLfuEwP4Y5Val9boNd4d4frUZrwYR356f8e//Pxz/mgLN3/xV/zJ+7csl8oYAy/utzxZY5cdDuW9ZGat+NJYqTw8ZW7fpB6wsVaW2TifH9hsRt7PhfenCx8uC8+1khJsnOOiBWjsB8+rzcBX55kPNO7dyEBfg0V7OnRReCrXNesCw5B497Tw1/lM2CU0GLRGWhxDCuAhpsCqRq6N+zBx/zIxbTyX84W/fjhzrDO7NnJ2jVR7vPzgHfGTcfyjlI8BEXfFIhrd0h2gwYjwejfxL37vc356aPz7X/+G/+nrb5kvlXGIvLg/8H4u+BVso2Qt5NbYBMd7zTw8X9df6JfQUjJvv864reNdWXn/OPN4nnmuGe8dycOzFczDfkh8MU386tK1zAc/EHA9bbe0rjcNjnc5s5xXAo7dduLr58K+rUyTxzw0HJs2skWwkJAAuVTypbK7H/nXb75gt/E8P5/48w+PHPPCvZ84Y0wUxIzkPRI/mSY/RpkYmHxn7wDjd5PL+82Wn756zS9++jN+/iry4i//ml//+oGWle0wcHez5/1auZ0dORSKNYpV1Dselpl3jyduXr1AEFpraDU+nGc2G8fzeeXtaeFhWZhboamHUJjFSMFz6yMvY+Q/PR/x3nHnIt76sK2p45IXxI08rY3LpeBT4dWw4bQY798XkrdrLkXiUBwuGGEI4JSclVKNw27Hv7nvZ/CH5yO/+vDMqTQ+mwYuzYiWGb0jSiT4TxfOj1alo9kbdo15tH7BF8c0Bt4cdvzy7iWf+8Lm4YnfPmXqpTEFx+Ew8pSNPZXgA4spqynmMsUi20fl5mXCnLBWJanj1+czh43n0Tfen1ee5/y3gtUqFY+PjhB6CvCXa2ZQz63zPdUX46y103hUWcxxXMEX5X4ceZgXftNW7qPhvFBVGIrgQyD4yNbDqsqsyrgJ/DfDK26HxMOp8G4+ogZ3w4h3QtOKOCH5wPA9t8Af8Ekd8Cng49/8k0QFhbtpy2e3Ow6bwK9+c2J7ybxOI3OLTC4ieAag0Z+wH3Im03gxRDbR8U0ujMczd5uR3RCZxkiHyhWaVBa3YK4QgH2CE0peKwcZuImJ2hpfXk6cGvw4BrauT2fXJpAqlcIUEz4EhhQZxwFfFw6bHVPweBGqNY75QsuFd/OKTZ6Vzmf/edqSL/2ZcFXlYsa5GQm488Jfzz3mfHCBwT4ddh+r9IrsQv9GylpbBYG77cCbmz2bYeQ/fjjh58JrN5E3xpQiIUZSjmQWHkvmlAvVjCFFkot8NV8IHzwvtpGbTWK/Ga5fv7Ch8kC7BntEvMJJezrljQ9sScwrfLU0zrWwHRLBe5oJKwJUbgncxwFxER8im62nXWZu9xuGFIlOkKA8S4YGj8eVsKms0i3xPx0m1vOMd4lLqZyacW4wobxMjl/rmcWM0Ue2nzjoH6Ui4K+yG3/Vk3mM2uB+2PD5/pZxGPmLDyf8vPDCJ/I2McbQL3qDJ9N4ngunWlEM7x27GPnN6cSQ4PXNhpvtyGb0HZOijYOH966wusxmdEzN86Qrx6LsQmAjgbkVvpozrSk/HzyDDxQzHhWqr9zWxKsw4FLEx8R2O1DnCzf7yD5FguuysLkp7+YV8gU3QNbuU7obIus5k2JibspTNT4UuAEOvvHrslLF2PvIzn3aAz9GfZdy3z1L//WffXZ/y88+f81+u+FPfvvEtmbupkQLwugCtRkHP/AcL7jgyWvl1ArRIEXPX55mtpszr2RiNyXGrWfDDiWThxVbKqtkQjDuGXhojZIrUSAEeFoz3+ZMwvPGjXjp/rtLa7QEnsx+F7mPiWEYOYwD9bmxSxs2wdMtLI2nOfD2cuS4Xhg9FGtIcNxtHLpmZu9YqrE2qA3IsEmNL8+ZqsbkAptPWTgfrbQp5q9733UN6pVIc7fZ8OqwIUbl7fOJzXlho0JNI9FHWnWAktxAYQFtrKosrZG850tWdrPnZhPYjIHdGNniac2z0cw7a6woEdjg2Y8Dj7lr9cWMh1yY1Si1G86DcEULO76k8Mo7BjyHFDlMfQ0G73m18Xi7+g8MjtHzcCwc15W7/YB3Dq9w8BNtVc6u8dwWVisE59iY8DCvfJ0rh+i4Twn/PdfgD/ak9rFjEf/2/No1oWXjsN1wP+3wzvE4n/mwzny2j5QUOsJT6PrkaLgAofWEydF50ICrylcPJy5L4dXNhnHcUNtKK0arfUJ1HwduQ2IMnjQOnOb1d0/qp+XCmziwCRAcVNrVMATrIjx75TAp28mz2wyICOMQGIbCeBVFijZuUiRnWOvMvGS8c9ykgdIcuRo6a6cRmOf1OHGbPIs2ghemmEjeUddPGv6PVdrkGtumNPpDol79E3dh4D71g+aYT8y18PldouZOuHHO0XSleWGIgaE1vBo7F5DoiWY8Ps/U6xR+M8ROKs+dEjCJ59UghJCw2vhiFzldMtH3hNHjJfOTzYbn3IheaNL9Kjcu8Fwbj1a4SYn7reewS0SBp3Fg440o3VOgzdj5SKNvgnMuOOe48QN5VnJbsTOc1oJTeDEmRqwfinRCwBgiVj69Mn2MErp1yXH1NBmoCpXGIY28GEaCNB7nldkaP7pNLMVoOHzwUCrNC9sQKVnJrZEcvJQRj/LhqQIZ8YHNmCil0FZDV2NrgRd+6AngEX4St3w9LyTvmKLwvKz8fDPyYW3dJwIkEV4Hx8UaT3XlPozc7RJ3uw1I5ZvRMyaIoQe2mSob73gZB85l5VT7gXafRrR5ciucz5WHy0owx+9NG5BCK11ed0iRnQR0/Qf9mP7Jltp3uTD81+ewCC92e14f9jgPT5fMZS58th1pRVHtUty5VbJUEt3jkRxMzrGVgSk4ns7r1YsB0zDQ6GnOrTp2kpAIpo2I5/P9a97NZ7zriaof5oWfbSfW5gjVgQnRCS+Spzo4lsYNxotx4NVui0jjbRKm0EOQOoXKuJkCSQ48lZmLKsEFbkNE8zW466w8r92n8vlug1yJUEkitzESvGMp308//an+7tXzwOE7NiPQQSwIu9QpPCFCNiNHeLWN1GYYPZ8e7f6f5ByjRHBdGr5twhDhYekBXIowjJ1SVnKl1cbWO2SMSGlE57jb7Ni6TKGRtfI0Z26iR3zEXzsEAaJXBuc4VWWIjt0u8Ho74EQYmzAEj6uOqq2vwZTwW+NcrzAMBwc8UJmrIUs395oJL2Ni0dq9otXYpkBInjJ/Px/dD7bhv2b8dSmFCt7TjYwFbjc7Xhz2iFNqa9zt9tyGQE2N41x5mFcsNw7eE0Ik4lhbwzU6TtEb2ZQjFXMrizVeJIe2azR3KZxrpUl/RLr3jnEaMHrKrw8bwlrYh07iaU0558JjzkQCt9uEeM9cGvV0JnlHcA5thgzdVOLUdfyTwKk6rFRUut76z98/M1lg5jujHOxSxEvf1O5TpEnXaP9/jV4+1d9b9QC2q5Yah3jQmmmm3E47Xh1ucV5Rbby+2bE1R54bczZWE27HkWKV1RzBPLn1Z8lW+oV2VZCsuHOhuRMH3/GXz6XwVAuzNhxKFGFP5MWU+qRXOjHI58Y2JoYoaFMua+U5ZyrGZ/v9Nca+Uc4nJgnE6Gkoo3d4EfTqi0niWZuSV8PRWFzmz9fMYMaJMya94dx7jzejlto1unhMIX9P/eCn+jtWl6rCd8wCHFKUuhR2LyZutluwStPK/XbPJsJlrpyKkvHcTYnteqGZJ5kw06B2o/WQPEtpPJ4yzeBxKbxKEWvwsGbOtZCt8Vwqu+i5c543mwHvpSdTCthc2O4nboeANuO4FN7lBXHwxWHLIIFLySzPlY0TphgAI3rXn6Rbv8DsYn8dbVdgwlwrv6pPTOJ4PGVqNbx4XqQBxaNS+FyumNj2HbXjU/19l6mhcjV3XwEa/Zfw4nDg1c0BJxWlcXt7w0ECZalcVmVVYZscTTslx0XHhtANtnhSEua1gRWEhSwdWayqnNZCViVjnFpjG4SXUfksbH5H8fHe82GZuQsDk3haaZzXzFMrRByvD1uiCGurfHs6MogRFZp17HbwXOONHHtxVEonSVXjTOPP3j2z944PpV+m+0U0oSpoa7weE0WFbAafPCQfreyql4f+U+6u5mqncJgSN5sBke5lvNlMIIV1qSwVsjmmAZ7zytaEnXmiWj+HzXDBc6kNM8HEUbhwHyKtKX1oLwRgcUIV4zVwlxKNSrHu2zxqYRcd43XtzqXxXBQv8HI3oCZUbbyfz0w4WqlkB4ML+OiRqwdzlyJFC8dcWc1YTDg2JSI8XypzVQLC1nVs8mTKOCaaOHIzGv/IG/7+F2HX3wtRBK294d8NI4fNgLHgRLg77Nm5QCuFZjNfPx+JCmE1pjExpMRSG3PONHOE7xhjCqel8FgWwrZLKp5z4zlnTrVSBFYq2xA4DAM+BBBhOyXs6cQwRETgvNYeAW7GNjgOm8iqjudlZTmvTMGz846iniEqzveUNm+ABzd3XKKYsFrjw3rhxg08kxm8Z4qeFByLgsPYukDGKHQz86f6ONVNur3rcs4hAcrc8M5x2Ow47LaonnHiebnfMpqQY8WdC8upMg2R2LrhMkmkNH73BJh8vzwKwjk3np8LP45dv/aklcdcOGsDrXgRJi+82kxMV113TI72NJNSxIe+ButiLNoYo+duM7IW43G5cDrNbCUxhkCpSoqGj50+4QyCd0gpSO4b7ErhbVnZqeeBlTEFtiky+Z6XSjO24ns+BUL5npvNp/r/o66kFE+fH1lRdG5MIbIdI9YWcMrNsGGXHGMo2HllniuT88Qg1BoIPjBZYymVKkoKAdNKa8rDaeWry0zabwB4XzLnVliscmzKsTr2krjfRIbQu74UA2s2bncTIRnHubAsjQuVgwRe7kZqEd5dFp6OC3cx4b3jvFS2ya5YYaAabjDIHYGnzbiUzHGu3IWBL9cLyTluh5FtCEAE3y+pH3Lm1OoncMHHKjNM+2y/w0oMcY4UPDe7LfvthqYXvDfudnt2KpTQdS/n48rGC6MPBAIDkQnlYo1iRvCO1iqmcJoLD60SNyMATzlz1sq5VZ5KYTHlkGfebPZ471FgN0ZWbRymAeeE00WpWVm0knzk1WakNOVxXnl3PrPzHjXjSQspBrx0HK3g8AncKogZqjBn5WmeeeEDX60zLgh3w0BwgAQaxpgcT6WH03n5JCn7X6rcNQfCi7AdItshYm3FGWxDwm0CyVXs0piXRow9hE1qYDBHMHCm18tDx3KqCedVOetMnPpZdq6N1RqrKUdVRODSav93uAgEbuPAX19O3EWP856ltU5QbB2j/nKKrAUeS+F5WdiZZ8bQ1nixmfqkXwRUuw9uzdTcWFQ5Ktja2Hl4qn3wuAueyQsBh2/GPkQeGszVvved8wfb8COdv9qxucbQPK02XHVEd53SV+386OjZThtoHQW3fZghwjdPCz8aB0IIxCu3fsQx+L+Z3K40Zms8r/1v7EI3dnRsHfz2mCnN+EPveZkiU4yICHMKpBj4cJn59rJwKo1XMTGmSK0NJ0rVyoe1wFr4LHgW70gpgvTAr2RGcx2DGPCIdLST5cojAkOlVmNGWejNYVAh4ZmGyG5ILOHTdOFjlTZ+l4ugvr/MWG28uL1nN4543zX+SRLeJ/Zjokc3Lrw7HTkvmdIaAd8N6EGYnKdpY0jXcDcqK5XZ6NguYCmGNusJokV4lws0Y0yRIUWmKIwucYkrQ3K8XRe+mhdOpfIi9DW65oqqUkrlack8tJUXaaIUY4gBkx44MjjBBoctwhAFbx1ra2flWBoxeWyFxSp16JthKOCdZxMDUwyETw3/Rylx0oMAxV0nXZWcC6k4EoZ3fbrvkkNN2dxsmXaR7JQvH098WBeGIXS0nBOG5JjGSFZjkwIHTTQzzto4a+F0TWc+5675L9rD3b7KF0IVRr9j8huGGPHBaGPAJ8dX5xNfH2fOa+PlFNmG2I2Y6qlmzKZQZuTiUBWGNKLifidZYnBwggF+95rksvE+LwjGuRRASKk3VkH7y+9OEs4cp0+Sio9WYlcxj3R5hHPC/XbDdgw4D7U6ovdEpMMnRihm5A9P5AKkiKe/Cg0xMIwjrTWGADtix7Nq45ILl9TbkfPaYQWzKtaU90vpDV4YuZ8CU/SIa7xMI957vj1f+Pp04ZQLL8fIKIlSM2ZCU+XSlGbG05zZ58KQHLiEE0jOqN6z1IqYdaynOFZ1PJYK5imlMUtlCX2fa6ZMBjcxceMDuX6S1X6ssv/Z6536/gp4GBIpdtWDquEkUnLh5W7LLgmmCx+ensmrkaZAuT5PheC4GXoe0iY4dtcWeMU4mvKsfS95lytZte9fdLzs+3UhOs/GR4IXxCmfayI4x19fVh5LAYO7IeCQnqGEAzUuuXFsxoISlkzynv5TA94MC4GiRr0+6QZn5Nb4ZmlM4ikYsxgDdHhIadxKYLDeJxT9R67hlwgudoZvNIO1MB8rP96+YjsNSDBcU+43G2iwzg1/5dlvh4iZ8TR5mnQmvgiE5IgqdOGCEkQ4pIHXmw1BOo5zyIlJImvItKxcMvjmeXecGZ1nG7oh7nYzAdBSIldFWTlRGfH81dMjc1NUO8JwVeMyRHxTNk7Y+c6Rntf+jOicIwSj1kaulctipKgEC3iMm+C52/cXiF8/rMwoXhWrlVw+Tbc+ZokTnAdxeo19c/zRFz/l9c0t3nlUhPtpggancyE515Obr3U6ndhuDjjf8a+Ofln1vjcv3iWGkLgbYHtVKaaLZ1v7OltK45FCaJF3H1aGFhj3Xe9/dzX6HtxADoYLxkkLN0T+6sN7zqVdGyhHzo3mlck7DnHgkAaaKU95odVClZ5umWuhrJX1XNAxsrvKeO584rPdiAF/tpxI2g9RU6XZpwPvY5T3Qrh6flqrtNVxvMz8r179lFeHiRAatMabNJCzMc8NL1eUov4um5JcKqV1BvUYA+NVYji4DrpLIfJm2LChH3atKcmU1TmaCQ/Lilbl7bEwuswmCq0J+81IA3YM7Hxj9TNPS2G7m/jTrx+oreGcxzvPh9q4ATYucIiBmxQprfHufMRqxJmgrocaegNWZZb+sxeAQ/J8dt0D/+LtA5NPOOewIJTyaejxcaoLa/+2ZEqc8N/+s1/woxc3eCk4KbxMG9A+ZAgSrqnhvXxbUUnU1tGbESUEuZrQHeJ6KvOLNPS9E7ipA2Ie7xqzz0iGgcjjcWYUxxA2tOa520y0puwJXPxAC8IxF7bTyH/+8HjNmwBVxwkYgsersQ+e2xQpTXl7voC/XqgBRTvffe4iiWiCiWcKI2/2W6CvP+dgSP2CmtunM/h/yYrA779+xYv9QHCN5oSXe8/zc+ZcCsE80cNh019FPb4brs1QaTjvGeh7IPQVHoNwOw7srwbhnDOzFs5WOJXKZ9NAWRzPrRK3xjgKucEmJVpr7PEoxmyNcy7c+oH/8nTuDkCF0uCiK3ufmJvhQiClRGmNb87PbGrDmUdQmimqRq2QizGNgMHWO74Yesv+X9bGxXfUdzZj/ccu6RmBsTRQKE3IM/yf/+W/4Zd/+DOiFMp8Yp3PvL4Z0f5pcjo2WoH7zUhKkUuuFJuxPmOgLjCNHZfkgZg645/WMG9cVuV5ORHEsY0Bf3C82G8QifgolGL8+bfPzFb4vd2GNCTu91s205bbOfPufKSp8iJt0J7aAKaUlllbP5T+p3ePTD7yahh5fRgYWqbzeBpNu1nkbkyE4BlCZDXjcW2c3s3sguMuba4GqoYuFV0+TVc/Vkk0zFVKbWhVRI3/2//+/8gvf/YLghTKemKdT7y5SbSlG1kvS9fd//h2AIPj6QiyoiJkhbIIuzRS5xVPn3p55wm54YPxcFl4qAWPsHGeu33gf+vvCM2h3nFeC++O7yhi/OHNAT/A/WZikwZu08jTZeE5d2qVesGuiZRl15/R52D8+w8PjOJ4lQY+208c24pvjmaO2oSlGXH0JGAXA02EYzNO70/sHNyn3nh5EzQ3yJ/W4Meode6MZa1GXRXTwv/1n/1rfvGT3ye0mXp5ZD1f+OxmTzuveC8cZ8Wb56cvbvAO3uWCSiFIT0/OuYKD5VS6IXf0jHj89UL4bl64tMY+RT4Lnosaf3jzilmNXRwpVfnzb46cWuP3728YhsgXtyNvDjtOufAwz7w/LbyKW6pXnBhOjBdhpORCTo3/19ffMErgZUq82gX+08MTCc+A0KrytK58KJmX00TwkTp4SoW/+vKJ5I27ccsmeMahP/Af0ydJxUep0DX7XQHbfRf/9//+/8Qf/cEviGTKciJfTry5mWitAY7TUnBJ+IM3L2it8W6eqTWTUm/wc64kAse2MuJIQ8QFodZKCPD2cqHUjo+9C4HcAn7wCJEhwWld+TDPPGvhD/c3DEPii5e3vKjwvBQ+zEdOx8bnacOqiph0go8ztsCxKf/22w8dzBEi48bzH377yMvdyCD9RWBuyjO1y4AyxLGnov7J1+9IGG9uDwzeo3KNV/mUu/XRqgcx94GtXlUZ//2//iN++uYLoi2U9cxlmbkfPJtD95WdFiWbspkGQvCENdN8T3WuJpxWI3hjzRVPf8X24nEV1tp411Ym59mOgRd47tURm2eYPEMynvPKb049+faXmx1DSvzoNnFflfNaOefKnCufuYFKv/+2ADOBzwI8A1+en3h7dgR1vMuF55K5HyOtNtbWyGbE4NhdvQGD89QKv31cSc6z94E9nsX1IMx//Bx+9Yh5rCmWK3OpvLndMiSg2u9SKHNTQlOcH5imflNTGxE1/vwBqlMyytqMuTQ+SwOWYQy+x2+jcE3Oa63xUArJeXCOEeGQhOR6JP2q4CSwCQPOHO2qt8rVqLn2AwtPLQVHl0w0Ey4FxCtPrtIzmPoEzdrKWhuLKdH1lN3m+qo+tow6j6lgamRtHDFejIqou+rFGot+mq5+rFrz3Kf7ZtD6s97rmxuG6LFWuna4GnkpBAwRT/Se7Sax2fS1O72PzCjZjFmNtSneefwCY3KUVlDNaOi89dzgYakMOHwUnK8cpCcAfjXPnNaOpr2Z+itWy0KjsbRGbYWI9iTT1s1x4qTj6rSxU+HdemFtxiQej2HPyqlVmhopBvCdsFHVOJERAt482hraCiae3aZLnWYKBaXopwnrx6g8V1rtpjVrilTjzc2WIXazfgNMHLU0nFREHGNw3O8St5sBofL2q8yiykyjAD46XvnEZuiabCuN3AxNPfH7ct0Dq31HunAEC+x947iuqPUo+ik6zK40NOeYc+F0mZm108ZMCw5PEo9zwqVWNlH4uuY+DEE4lgpn47IWjqxsQ0TEWK7x9b9ZF/ZTZKxd6nixQswwJI82x7ulsmplXT7tgR+lrubs7xg9IsJnty9J3l9fkDpQohYQa3g/sI2BcafYxmi18v7LEydVihaaAE6488Lg+jSzaIHcWfgVWHMj+/4yFRQwI0WH941TUUrrQZXb4PHmaVlZtDDnwnleybngR0+uDWmdzBeky3OqV76tF3IVNi5y8kJeGmOCY1m5ON+HGFWpRflmXZh8YlMAFVZRnDRuVHHm+brMrK0RPjX8H636qLZL+LxIf9nebYlJcVd1g6pRCjgNiBOmKARJ2DSANE7z2iXbzlAHs4db73E0wFPVsNp5QAo8zYU2KKO5HgSIEIFVM6cz9NmtsQm9BcilUS2Qm5FL46jdo/fcGk47vTEJrKtyMdeR22YUFEc34QYPzyVj7SpiEshVObGwHSLRC9mEc1Uiyl2KrKJ8vRaW64vs96kfbMOPdkmMtkZeKpdTxTuBVjHrtxox4fm0cjt4vOsR9BJ6jLfVvlCKKfUa3OA9FGldXyoeVfBNuB26WfK5NNR6KNZaOkaxYlxc5cO8UMQxRiOq43iVja5z/9+o9ajtIA5c6Kmp9PhmC45gRjNHa9241KpyLg4txpQC/jqNRZW19tvjjUExpZiCdbzopSqTOM7aKNpwn4K3PlpZLjT/N6nedpW9tFaR6xrE4MPzhfttJMaAcxBwiDNUjHEYeV4vrKo066mp1Rq5gdZGtgpi3EkiGRxr34QUyKqEYn3ymlfeLUtPmQw9afm4XiUYudOcWqvU1tgEzy4kSjOy9hRVEyilUU2pzTjTJWTHZcGLZ+/SNbq+pwXW65pL1uVnVZVqXXLkW2XrAxdtHZvmPnGoP0aVtaFqV1qZYtWIISFagXaVmgnnObP3DhP3uxTUID2EqLS+f8yqqINdFM6t0lpPn7zU3tbfkKgezrkj6rLCXJRJjOoKH6g8rBWRPiz5jsVPg1xr/5UrJsYmeLYusjZBVcnayFbw5igm/es7OFrj/XHGqbBP/Qet+9McUTpeeXIerPPRc6sUEc7rgh8STzWzaEM/XTg/Tl25GYZhCuqNEAfMKlz3Py/Cac7shw44cNemHu9w0vef1RpLu14UB89ZM0pETZlr/Z0m29GzczweM6GoEQxoytuSeSoNEWHy7opb7AqAx6WylEKtFVVjPwbEC632lNZilUUqNKja1191wozx/jL33BQ1Cj0bAgPfDOeEyQfkmrhaTfHOmHMh+r7uC4b4T/vfxyqR7l38G4QLpBDAeq6IOCE44UNuTIC7Dqxi6PuImnKujfM16d5J94SWZjQ1mutDOBrsHYziEO0I+Gp9Pe9i9xt9nQtzNZJ3bLwnmKNRaQanpadEV20kJ9zEgDSjZb3emw2CcKxKc0YzRczhu4iMbQws1TDncALOdQ9hvVKuMEc1I5uhrlMm1aCKErwQ/7Fr+LUVmnPdeT9XltO1Ub82W/7a8D8dF3ZhQ7xqlUUMkwbiiNdJpV6f9ZzvOmz1xqqNiypSIToYJFBUSATMlLVVPIGHplyc8lwK5hzmIH53IAHzmikoOCE4z5AcXiKtGueSKaqk6GFRHIKao5lxuT4dxgKbMFCsJ7s2NZbr9zeaUK03YKaA6zSMOMo1wvk728en+hjVp+TXWG/rxsdqgmrrUwcRVIT3xwvbsCVGrkE18h0EijEl2nLpl0uucKjWaNJD1Z5rQYEUPLgenjWFCKZUGqX1i+h7rTzlcjV2C6dSidYb/nXtzTiiBBz3o2cbJ9ZaqXOmtIoXKLVeQ0P6WpvVuNTKIQ68mSZK7S9JpWlv3DQwiWc1ZaVffnHKpWQG6d+nd47w6cD7KNVUkSYgvelv2jCJmCoiivOdNHJeC9tx6Km8/nowSsO0oxWzGdV69oKYMbdGrbC4TkFpKl19GAOmjsE7jE6UShjPy8rX0jjmeg1+6broQ+ghdMc1s7SGYexjZD86tnHDXJTjvHLOGQSWBolAvk7aMsq7deHHccvrNHCkv0SYOYJ0g/utJC4o2Vpf497znGeiBxXtQ55PQ4+PU991WNpRmAaY85i1jjUUh4jwvCxs4tD9I7+zWfY9EBEqRjPDq+DpZ/JFGrl2Il6zfn4eUiBFj+BRU1aDQGBeC9/WlUszBu8xuA7xupTwuKycS0Hol9GbFPAykEvlsmbOuaDOWIoRCKjr5uNmxmPO3KSRQxDmZiyiFIGAcB8G9jGyYBRtNO2XgMuaGZIxIIwhdq3Jp/pI9R0DuA9VnYC42F88MZxzeHGcS2EIAe8ER/c9ueuazdYbZENICgmjNUcTmK1xao1m0KrweeqfeQLWpjQnJOeoTnmqlVWNjQt4ugHquwymc26cm+KccBcS+xQIBguNWq+v4NFYasMDxeRKF+sv8FvX0aD4K7TgOyoWgclC71utofRojLMpUWEKnsl75Ht6OX+wJ3Upjbw25rlyPlVa7sSRWhtaG6a9eT+XyrIqqMf7gAsBcQ68ctht8CIkcwQcqzakeKZdIqVO7SnXpiv6xGebLbvQD84iRjb4q7VwaQ2jH4JFG1mFIQwkn1AJPNbGh7KyDZ79ZuSwH7jbjmxiQtQzmmfpWh6i0CewMWBqRGfU0phz5VIqq1VKhH3oGupogmsOKhTgnBeWvHAbI6/HDdGnf9gP6p9wte9itxS0AtfshK7pr6g2srWe23CdxroghHhllQOboaejDuKJ0mkQrijb0REGIYbOFT4XJXjH55sDL8bElDqO0czxmzmzlCvDtQl1US5F2QTPdJ32v8uZb3JmGhy3m8g4RvabjuxcSyNUKEWRpgwi7KPnLnmS90QTUhJKM+asrE1xzjj4cDV3OtI1XEkM5ppZSuE2dC9K+tRwfZy6oonNesNUW2/e51rJrVG0v14uCLmAM0hBiMldX5qE3dAxgh7BmXBcGkk8Ej3FuuSwqvJcMtE7Pt/uuYkJ76CgZIPfXiq1OaJ5vDpaE9YKyUWSxM7xr5WHVtkOidvNxDQmbrY9aAuD0XWaxcF5tngmHBPCznnuNoHd5BnFkdR1BLMqOxwDjtEgWpeRJTwnKnPt6+/zYcPh0x74Ucq4yr74mxA4w6it7xVF+/q4tMJarrh0D87309J55XaTCHSNtIgw58pBE8E7itr1UiqcSmMzRH68PzCFzv1azTBzfDvnLt1Vh6/QVmOt4HzHIeKFoykPrbEfErsY2Y8b7jZ7Upyo6hldn+In5xidYwQmhS2JoIo4xyCeDZ7BCT7Aj+PA5LrBM5ogCh7PRSvH0tj7gVdxw/jDnZv+E6m+Dzrt+MlMoDZFWwPtL5SldKqOuNZfOIPHXaVhuxRxThDpPVjNMNFf5I0e2qZmzLWwC54vbraE0NUg2Rq5Kkvu63qMHmeQs3IxQyQCkSJwlsZMYyOCu6KS7zcTQwxkrmkWHrz0BN5IB8pEArn0rIvo+V0wJjQOQGzWUaJXbCzmORVlLcbBR16kgdF/Px/TD3alPh8bVgrl3Miz4YeBv/jtO3777Vucap/KJ3i5nSDBWRda6xxnqAwkfvb6nhQ966qUCs9uIOeZWwbCi4GhZJ7XTHKeP3h14PZ+5P27E+tSuOTKt88Z74Uvc+bNpielGcZt8Oz3W1pTNpvAH4RDl1nUxvkys9bWPQgKYo7HXNjQsXNlNZoYPnh+lCYe5pUPLAQ8yQdCCHgrtKzM1XroUnTk1JFMd9Oum0+KcZwvfHue/2E/qH/CZWqI7/Hy4j2bOPIXf/UrfvONg1ZIZoweXm03hM1AMUMvpV9K6briH90MXJYdVXvTdvCejR9wrhJuNoy5cJozyTv++Is7Xty/4umbbzldTjwthbenxssY+fV84cXUkyxbbbxIif2LiZzh803g52HHNkZac5yXCy1ccOqxbEhV5mBsBhhqoukVt+eENERejZ73l5mzCRI8yTynqjwwY4vgrs3+1gc2OFzcogLLnHl3OvHN5ZOI9WOUi4YLSitKXip2hv/wp/8jsRX0OjzYBoDK6ukX0tL/+50U5fjlj+/wX6WrJr9xnteuDzXjZz/ac7oUno8rg/f8dz95w/2re7787ZecT2cuWXlcHdu7wG+XMy+2E602aMrLaWB7u8OAPzhs+OdRiNFBdTxdFqBRioH2CZk2ZaNd7ja1jqpr1tgRSQ5++7zwvDZaA4/DjwNNC6e2ggi7ENnRNf7J3aBinC8LX5dnvr58wnJ+lCr01yUHLoILnj/5039PHBy0SgJG79gET/ONXKFVRZsCjRQcv//6hrb2iaZ64dQKgwrVrfzksx05K/Ncid7x2WHH7d0tx3cfmJeVY2l8uFTe7PbUdmKKI0E9weB249FhwJrjZzeRX7w4dFksgXfPJwa6V06ksY8e1QzDxKYarQmlQcV4OTj2yfGoXb4mBrp40MbzWtDOXuA2RF7HSNPMYXNLa8ppWfjt8ciH+dP+97FKrgMPw1Dp8p0/+89/QhTBt05aDMEz+A3Nw9w8rvXndcMjovzyzR75xsja85dyaXgRVm28uR1Z58J8KURxvDok7u5vuXsnzJeVZa0cTwWfIgOBrUuM0ZOcsPGe7WZibcpPQuDnEVLsKbrPOdPWjKpiaiQcuxq50OXj5itN+wu+SGBIwm9z5k2ITOKYCzxcrUnLNTF4K8JdDJwbfJE2/Qy+rDyeFh6/JzjjB9vwL+eCFkFXEDzJRz777I75cuGrhw+clzO7JPzis9fcbxPzeUZR8IIx0mrjdDzz7Xlhrn36mnMfkz+z8pvz8Wrs6YbZX6eE8/0mn4HSesLg6BMvqNykgJjRmjKkgG/K4/NbdvsBGDjPld+8f+pTCYGtSzhx7EbPi3FC14IBv3p8ZNZMNE/NxmsXeFwKbvCMvk9Sl9o1Zcf+zRNEGMWx84kWlACcS0Ma3IX4D/o5/dOvPt8S16UVP//Za07rib98e+Lh+cgW+OX9HW9udsxzponio6BNqCs8Hp94v55YtaeKrqtRgrLx8J9/+9xffkyI3vGbFLshLhd8Bffdz7A6djgOHsw5ShBSCgQ13p+eOYwDjsjjsvKXH55/92Q5DD3z4W4/cEiRTAWDXz2deSylv0hU4SfjLbM3QmkEgcF7jrNCa7SomHNEoZuHo+eCkqicl4o0uPc/2G3kH3VZg+K7HEcbJB346ZvXnI5H/urdOx4vRzYe/tXnrzol53nuk9ggtKZA5P3jMw/LhayGQ/BqTDHQSuZ//Po9rUBsQvKOr56fSMM1HyRGGtqbMzVuPWyTZ3VCaUpIgUGV42UlTh6TwDEXvnp77C9grWekRO/ZbUa8d2ytyzH+3cN73i9r51OXlX8WNqhUYoXgBOfg7WVlbsZd1I7fVEVMe5T8YORcyBjiAnfDP/AH9U+5RLoOwAk+OL747A3nfOLX337D0+nEJnj+1WcveHHYM58v3WviQZtDDd69P/H2dOphW8HjveBjoqnyH799130p2ve/r6ehB2v5BgF8FYZrrs0bRlIYrhfX/hqamuPxcuzPqM5xKYW375+otXJpCyFCFEcQz5g2HIbevf/Z4yPv15VmjVYbP92/RvPcfS6Aj8ZlKZyKcucFJ46qjeYNd5UvnnLFJDBF4aZ98pB8zDKFZnZVuzs+e3XPuqx8e3zmkme2zfHTmz23W8/lXFFR1PcLna/Gbx9mTrnSzHDikeYYk3Gh8eXxmXYdTESEh3NjCKf+euA8BAfJMQC3RDZXpHpR4zIIr5rS1pUQI2ae86q8PT5RnJLna06U82zC0AM7r1kOv71UntXIGHNb+RkDjk4JMjOyChllQdl7QUQwFUrusesheFrLjEPvS9fvKe3+wZ7UOhumnSntonCz3/CjV694fnrL8/rEpXat3X6/xdHIq1JruxqGlKrC3BrNerKpXtPSdoOjZeV1TGTfKOhV99VobcGuBpEI7DzEccBnGJ2jNEPpso5lXlBzzLMyy8JSlJMZhxh4KpXZGqMTphDYpMRy3RR2Y2KqlSjwAQUfiK2xS5FtCiDgFiWFSCn9maZID5yIYlyWzKuYSM4RAvhPhrWPVu76y3thiJHPd7e8un9BeIbt4wOna+z8i5s9TmCel74Gr+FBPaK7odZDOLRxde0LJRuf+YHV94TmcNUit5pp1iidhcfWOWIMRBmITnosuHRY2flUkOI4iXIqmaVWFmsMbuCpzQxVO74rRtI0MFzX082YCc6gGc+ua7WbGskLQ3B4DxKUSRIiAZAuISmNrXiedeV1ioyhEzD8p+CZj1LOXz0fZijC4bDjs1evePaOD+dnjj2NjxeHffcdLZla23V90HGstVGlcjHDqbBRYZFCyY0fxwkdoNm10caobe0TNRVEhUmMYeNZzwPJ+t7YDJZVOZ9m1goriuTCWpWnuXDvB37djow+cieeffDE6PGtT+K3gwPzuKp8o4FSOqd6mzzBeaoJXE6EEFhzvT51C2PoL6zH9cyNS8ylh9O0Tw3Xxymv4LtOPzrP5/sbXr98zfOj50N65OROGI394Razyrr210cAu1JDVjWI/UXamhItcC4z2TV+L22RodOenBPEOWpr+OaQq8FyEiNMkXMz1FwPwapGrZUpzJg5LnPmsiilVY45sx8iay1YC8TgGGJgHBJSMwJMUbjTgFbhG6s9mKsJk0uE1NPudW2MIeBrxyzjhEo3Wb5fLowCqwqX1jjXT+vvY5U2uhTn6pnbDInXN7dcwhOX9UypoF7Zb0ZMV0optKodruEcpXmCc3jnqNXA+ovjc1EuKDcu4j39QitgFGr116BDxZuyDUaIiUPX5bAq1AZ2MRbNrKYsdelnvhmXXNkMkZN06fkgjuT79zHQ4QSDOHZ4KnC55p9MHqbgGF0gmvHtufs+w9X/lzFm1xg8LKWyWCGoJxuc6/d75fzBNvylGk6Em/3IT7+45xc/+Rm3d3eMo6N5OOwGKAuTh+W4gFa8l272WRq1wVwqFGVQ97uma/VKQHBmOLrhMAbHwzkz+oXJewwjJs8+9MnBqThKNbwPxNCVjJdSKVXI1UCM1SqnktnF0BePgVTDxJiCkDYTpRS2MbBqfxaXrMyxcJFGoGGtm01MhOzp+FE1nL+GRxhMaegGPtMe0ySfQj8+VsXkCclzs93y05ev+ePPf8ph/4IYA7XCbZqgXJhSYD6dEWsED9qM+dp8nZaCrUqwfrC1VjnnjlYNuG5xM8Pj+HBaGb0wSaevjDGC7yYzSqYoRB8ZowfxzMUoJuSlHzjZlOPaGJNhrmPt3NVIl6Ijxb4GB++o9LAZb8q3a5ehxeCp2tN2JQgWPHql/AhGDAF1ntvUQ5sWFcz6hflT/f3XOPaf+XEIvN7v+OUXf8jd3Su2MVJMuZkS1Atj8Jyez0AlBIcq/bUJuGTFihCau8bSC5dSyFVJJtTrYTeI42EuTBdPVDAPTjwpBEQMZe2QAefZx0Apfa1lg1r7MKWYctTKPiWsWT+omiHBmGLEDYGyZibvMO/QBsEcXy4rp1rZOs8YoEmfaIXosAyihlhvCEU9h9EzSeDUlCQQP62/j1JX+DUvDlt++Xuf8y/+8Ofc3N4zpkBDud2MkE8M3rEeZ2i5M+/VWJZMwzHnilXw2s2UVYW1KjoI0nqwl9Axnce1MISZUQxr4JxjHHynmq1GphG8Y49jyZXzWihmoN3AmVvj1CqTRbQ1BueJpmDGGLshuJRCCMLQ+ourE+Gr+cRSjBufmJonX191B9/hG164DtgCZp2qN17xnZGOCP1UH6c6/BV248AX9zf86M0Lbm9u2QwRE9idPKoryRnzecVa6WvQhDJX1tbJY61BEvc367PV7ss0R6Gvn+QCH86VKIVEXzfeO5yPZANzQhZw4tiqUKpyyo0ZI3lwGGtrnGtjSpFRAulqAEeEcQik0Negu+JGHRBFeJ/LFejRzcliMHhHwFO0oWKIOCbvOQTPNniSxi6jM2Pr/pFr+JsaPnlubkb+8Kd3/OJn9wzTjnEzkIaRV4c9+fwO3wp5WRFneN/Na5dzwZpyyRUpxii+UyhaY7Guoa9Nf8cFBuN5VsRWPt8nhugJKaAysSwLS1OCCpvgiCFQayVfDW25XhseAdPv6EAQS6e8LFYxbWzS1KPC6fpZrUorjYsoqzOOVsnZ8AriPdUJo+/Ul+/wZwa82EzkZaZYN+19N0n5VH//FVJgGCP3hx0//9ELfu+LO9K4Y5xGhrDh892eev4abY1lXXCh06CWVjmdMq01nuaMZCX5Lq9ZqFxKn1igShXrZlgVni4V6pkf3U5sYyD5gLqBY144tUZQz2HwjCGxasfEFYHz2jo1QARr4J0wSmCj1zAR17DWCONAbY3arB+6rROD3tWMmiMJJJO+MbqIuEBohlO9ohL7tOSz3cSSV1qpXebLp0vnx6joHVZhGxM/ebHnD35yxzTdsB1HQhr47GZDOX+N1ca6rv0F2nvmRXk8ZUSEU25QHKM4nHOoGDXDqTakNghCCp5JHB8uheQ996PHB4+TCBZ4vqzMpWDqOAwDGx+oeWWtUKQyl55R0TnXCgGGIozVMG0sUtlvjJhGalVQoTZQE6LBl8vS16Qok1O872tt9BEJykC/rIgKUTxvdjuWXElNwblr4/ip/t7LusHwfr/hn//BG/7ol18wXs/gYRh4c9iSj19Czax5RVyXX5W1cTzPNBc5rQUrEMV3aUwzmvX0+VYrdn1dCiZcaDyIcZMcyQXEB9RHjvPK81JpHm7TwDZGtDZKVVartGadn29GQ3Hi8U0ZgiK1I2FRu+5/vUEq2uWNToSv5xNGwKqRSwQ6rW9wkeYbk3fdrOk7yvvNbqKsrZ/tImz+oT+nf+JlArvtyB9+8ZLf++IV42bLZhxJIXC3ieTLB6QU8lqBTlKqxbhceuDpeTVqNbbB4QWeW+uBhsBsRkU7rlNhyQ105fXWM3iHk0AhcZoXFjOq9MTb0XtEK0tTViB0cQZqdjWbGzvnieh1vRmH6HDBo7XQpHP4C/1C+ZALNyle4RwNJ8I+BDyetRjeGdF1ROdNSBzGQK6OD1dEbvDfT9r9g234Y/QMY4QgPCxH/sOv/4R/8ZP/NdNmz+4wMAbPwpmn9w+YdzQnlAqXufB4LrgKZypeBOcFpR+GO+DX9dRZra477y9r40e7Pe9PhTe7CecTFcexVE7zylMu3A8DrSnLNRfXOQcRllZIwMY5vpi23E5bjpeFVTNLaVCM90+Zl9tAbpX3a+ExN4J1fe7gPIcUu/RDlYGAZ2BLY7sJbFOPLH88r4zRczsG3lYHRWgFSv7UbH2sisEzhIQT4Xl55v/5V/+OP/7RH7PZ7tndeDaxsLoH3r59jwLVe2oznhfl26OSWmXRbrwWZ6gThhgQ4LfzGQuO0XVKzjk3DruJh+OZN7db1EeaOU5a+LBkHnLj4IXFNYwCAjH0p75VGgFl6x2/t9vwZrfl/bzgK6wls14yzmWkCFUrH+bCw1rxQC0VC8aUXA+5UyM4jw+JPcJuMLaH79bgwmie7ei51I4R06bopzX4UaqceyZD9pmvL++Y/+rf8kef/THj5sD+PrIZGsu7B7759plGwgWh1MbTKfPlQ2aXAoVG8J1X3UHnlY13/IWVTvExz2COtSoiwvuTcjtGko8Uuvnsq9OJp0tjOyizQfMNcUK8Sg3X2uPsJwu8ipE340ieLzg15lI4X3Geh9rJPw9r4WktJBOic5xr4SZGauuDmGiBSQYOMnDYwW6I5No4Xlb20bPfTCw2Qy5IA2efJvwfo/qEPSFBeHd54N/+1b/jn734I+K0Y7pxpLCy8J6Hb58p3mEuQGmc5sK7p0pMcCkV77uXo3M6C8F7vlyPJBcZQp/uX0rhPgXWFRgiLgYKwvs8837OnFtmWz3ZKj718DXvG1rh1CqB3oS98AOvxy3r8UyrxmqNJsrj+YJc5b3PS+Y0Z6J18t7a7P/D3p/E7JZtZ7ngM6tVfMVf7L2jPLXtc46LxECavMYSSCkEF9GggzNTciMbKZpAA4sO2QG3nD169BC0aEB26UEjdYWwdJMk86avq1PgcyJO7PKvvmqtNeccY2RjfhG+FFbGuZwdPnbsIW0pYkf8xd5r/mvOOcb7Pi/vjolFhIM5RtexZmATeoZeuRpiI1ktlb5LXIwDd3LEF0jqcPbmwvm6SkPbh10XWJLx8nTPF8q7dEPP+uKaISqL7Xl5OiFEavQNnjJn7o9N5hI/bpg6d8ZvCiEE7uqBTepwrol3Z1FMlRe7yvVqxRDbpOBhUV7OhRiUTfAEa4jqGD1WCyHArlbSmYQ2REcKgS5AKI6lKEtZWCVw0Si1BWGeTNsUVtphPvrIXFtWzsp5tiSi91hyXPSNarVbGtd/3SUqQqieaO4chPf/v35sD/wxBXzw5AyvboXD7o6XNz/gC/2X8cs9zE+J3OFDIAP7qaC1sJTGKj1oQVDGNKDBcAhr7wjA7U2mC4FriaydByLbLuKrZ1hFzMP9YeIHt3s6i+w14wu8O/ZcbyKGcbdbqCJEs8YoToEvX12gElht1uxT5LgIuRrHacEQnueJXV6gNhrABGypbEukch6h+x4NjuACj8fAtk/kLjKmSNcniJ5Nt0bFMZE5ypvN7nVVFwZMHcdj5fnLmZtwyw+e/oCvffWnCHmHTi9wumuXPwLH43zutra7+61mMjCkvqXr+qaT33rP7xzvCSXQmSe4QMCzShEJHWNKqHO8OmU+eDjgRXlomdA82Qx85arHDJ7dL2Sg8xAM+hh572oNVL7UbVkK7OaMThMPh0JYCh/oift5xooBnh3G28ClRMS1sWTvhM5HcI5HQ2JcR2ZpP4/bVU8IPZejx8tEITKHT0cIeFM/XOVFWbQyB/BR+HB6xUcvPuRLX/wmcb7DH5/RSZMh7qNws5/RIuRSGYJnoVJ95HKbKGYUETqannQ+VjoC+jGzugpPLlbsSsb3Ixocrx4m/sPTVwT1ZMCK452rga88WZ3X34ksf5CG2UfHF6+uESo/+eQJSxGmRRrCblLqcuCjcqIslcvgiQ5+r8ysgDWeHFqiZufhchhZ4bneJC7GrqFih47LrifGjqtR8SJIqOTyZsr5OqqPkX6MaGe8XA58+/e/z//+S8949wtfIMw7OL3E647Ud/SLcDsVpGbmKvjgEVfpusgm9FSMKoVgLSCzTBCsdeOTGk4qne8RbfQ9c8bNYeZ/fn7HKvgz1hAejY4nj1o3c79rE/ZIa3wMMfH29hoV5UtvvU0phayNl1arcDye+CBPTFVZhUSP8YPTkbG1Ps5fQYhO2I4DwXne3iQuVz2LGK5rcrUQPBfjFrMZqUINbzxMr6siDo9jqZnnh3s+mjNfGt7hnS+8g5UHZHkBesIHT43C8ZQxbaGVALMYGoSrVaSaUSpsUyIgfKBKFqMLikcxjTwZE4vA2HdUHM+Pmd+9O9Kdzdoudby3gatVkxu9PAUQgQwFx5A6fuZqhReIIbIkxUomVuGUjVonbnLhYW45KYkGw5Ki5FBYpE2UfGo5wGvgekyshsSikEJl1QVCgLEbqDVTXGH51H+fP6Z1vbnkz3zjq/zZn/4GP/vVn+Dh1be5efqUl7//+0zHE1IXumT0Q6DUSp8CZomqSpYF8fDNq2vEKk93M/enBZUKRL7WjTQ8dMB8IMXI3Uk5hoV/92FmEcHEuJaeSkYCPJUDLlYux0u+8PiCu91LeppxpwLHajzbZU6TEEILffDOs+oiq9jxMC3cT8t5VGlobabe704T73aObQhcemMdhL1rMoxFOjpzhM6zilAr9GHF+jHIg7C7r7yUNy+b11VXfuTP/dz/hj/99W/w1bff4uGj3+Pp8w/4f33wXaaHPXVZiN6xXQfmInTBI86dXfyV6B1ff3SFmfFiv3BzzGStdER+9uod1sFTi1BF8INyXyaWDv6HD+9YVBl84GvrNXvJdHgOIjybCtv1wE++dcmHN89JtMZtxTjWyrO7hd28MHSOqA7V9uJ56zpxc5y5nwq9dhBc0y6K8t2aeQxcucSVd/TBWjIlypFA0EgKju3aU8vCMKzYbq8Q73l2v+ej46d93bypH6Y2ZcNf+Jmv86e+/lP85Hvv8PDRt3j2wYc8+9bvcjgcqGWmi3AxdJTSkibFtRRbUouA/6mrDajj1X7icCxUrSCen19dNl+QCGB0feTZofIQMt//vZcoxip5vn6x5eXdgWdqPJjj5Zx5nBNfebThw5sDqbbQrgwcxXi2r5xyITDRn8MRfYhcXa54/nDPs+nIKKGF3gThInk+XDImhXUIjA7MKTUo97qwqR0DgdRFrlygFmG16ri8TgQfeH534tl0+KN9UH9C60tPHvMLf+qn+d/+7M/ws1/5GrfPf5cXH3yHZ9/+LebjEakTXRK2w5ZahdEb4iIaoBsrpShfu95iErndTxyPwlJac+Abw4Y+BERaYmgcAs8OmVNQvvu9EzjHKkS+cXHJ090DkzgWX+jmhXVOfO3RBS9vX5KAOXiKwUkyL08T00kIQenP+RPBR1bDwF4Kr6YjEU91jkWMbRp4XjI+QzwPwYoqPhbCGKhuaNDsznMdE7WciHFgXHVocNw+zLw6vXn/va7q+4733rni5772Rf67n/oqu6f/kefPP+Cj73+H6TghNdMlZZXWLAYr51sX3wyCEVHe2Y6gjpvjwjy3s6Ej8BPrLdchIaZkMyxG7nJl7xduXi6oOCKOr607vn88MuHJItQo+HHgvYuBZ/sjUptsB6cUrRzmyP4wsx0beTEaqGvZKK9y4Wk+gXkUx4wxAEcPs7SU80XhQZQuKhKVMTQ5XIqea+dYVGHoeORbw+Zmb9zNnw4N+2N74H90OfL4eiAxc//0+xwedkz7O8yM3elILpmLIeFjYs5QawZxZHHNcVYETULvO64MxCkPJ0VVCX1LLhvO4QdCYJMC0cE8eyozE5kdhbX3dAaTcxxF2JXMe1VIPrDysAoBVUdR2B8L+2XmahVwLgAOscqDVl7NczNu4BhSIAfHB8uJvQgrFVYhsRjknHExIAJD7wnBUatymAovpoXVOLKNkRRaImaUN3KK11Xb1cA2euz4wM0P9uxf3XG43wGVl4c985y5Gju6rueYYclCQKlnw3kRCKkFFF0ZqDP2s1KyEFKg+DNHWANmkcF7Vt6RpwVDKU64l4wCowaKCdNSOJwWSjZSagFGa9cQeFmMhznzUDMxJkzPoTnquJuNl/NElEAfA130zCg/OJ04VmHA87jrUQcPtXySnrtZRbpkLEuT9Dw/nlhfbLm6yIypTSWCvVmDr6OutyuerEe6PPHw/e+xu3nF6f4BM2W325Nz5nrdUZxnl41amkyrNHlyW2fO0Q2BKxsx53iYJ8pipE0PzpGKb/hXH7mIyhBGXuSZkwjZNfN5FzwXRO4t8zAv3B4j711sWpjRYIxnqooo7OaF/bKwTQ5HIDiHo3BzEF7ME06UzhJjCJyC53emIydRbn3mOq0bltiEoA5IXGw6VslTRDjmhY/2E9fXa7ZxRT8khiES3Jsp5+uot59c8f7jLSMztz/4Fru7V5z2e6LB8XhgKRMX68QYhVmE5SSYKbkKpcBuFr5wXn+bkigl4aNSCvSrrslqazPo4qFPsAmB+1pYzKgIk2RGn4izsKfwMC0c5kQ578Gxg42LeHPUatwdC7u8sBk9KXYEAzHhKJVXxwlfW/DlEAKTr3x7ObIXJTnHu6knOMdkQpQOORndRSIl12ALc+H5YWZcbQlR6UM4AxTeTDhfVz1ad3zxasUW4eWHH7K/27PfHQG4P03UUrgYEh3CsQhSm+G1ilHVcdKmh+9SYtUJizSSnVfH5dA1/2V1RG0T7ysf8JbAAienqBpaHSsSeGFR5ZiF/Ul4q3d471klx7aLBBwicHeamWoFsXMWACiKqHKaBUdgdIHoHTPC05yZ1fAOVudzY1ZlJaAzrFeRLnqKKicpvKqFceoY1yND51n3gf3xjzmW8931isGEZf/A3f7EYX8AWZgFdvOMSmXbe1QrDmW3XyhiBOdZDSOwsFTBdalhxUJgjJGpCutuwDka+VSNXRWm6uiHjsm1uPjgoDil2jmuXpVShP2x8CotDKFjyYUhNQ7qvCj7KtQs6OARZ5jTTxbfXrXpsRoZiuQcyZoJzfnmRM/nw/vmzFSN0eNdQzDdHGfu5kwulSU7ko9s+p5NN//RPaQ/4fXW2BOWE8ebF9To2N8fyMtMFeFhWqhFuBqagVYd3BwmpFZScFyOKw5L5VQVOsA3w3efIkUK69TwXMF7RIxdKfiiXI4DITQTmzM4lErCYwhqShE4zJWX98d2aJozq3j+MTahSiVnRTvXmCzn4I+lCrsqLSa8ecyBhijrXfveLHiqOcyMlW8H/hRb2NFUCs+PE89PmWmpdKdM8I71ENkMP7avkT/W9XiVCPnE4VbIIuxvHyjlRK5wf1wQEa7HrnXpDV7tJkSMLgY2/UApxlIMHwznPV2KDBJRqay7hHMQfAsMfChNMrZOIynlNjVS4y4XOgN1iogwFcf9qfDsfmaIkftcuewS3oypKGrte3E41AGmeGnBhw+l4qxx/RVHsIgJrHwgeU9wjoCjOkPPh6i+93jvmObK88OJF9PMaVmIp4hzjrGPjOmNhvp11PtXG0arLA+33Ipx2O2ROrEUx27KiCjblUdUweDmMFNUiN6xSh2nbOQKKTlCDHRdbMFcqoxD8zK54KhF2eWCr8LFesAHQbWQVbhfhM4ChlBVmItjfyzc3c0MoeOQM+u+I+CYtYJmWvaqQ1CcGVYNUeUgBdShbYl+IkXbnptnyf0BOc0w0D/Yg6dSuT1OvJwXfqIo81xxeLrYGihv6vXU41Vi7aCeTtwdj+z2B6QUSnUcpgUzYdsHRJWA48U8I2r03p9pZsaihvOGD4GhSzh1TS2R2r5lOFwR5lpb6J8F5jMUwwyOuU2KTNtZbqrCbi7c7hai99QsDF3An7vv1mjdiDny/4KUp6ZkExyKnEEE4bwTr2Kgd2dgxhnk4duHEULAOxBR9lnaObMWlqWt1i56Uvh078Af2536SZdwx5lZhNiNTNNEcpndSZnnQgpGcEYtja17OGWOpbAaOr5wtUJNWBajuspUhFqV5B3FOx6lEUdjBZ+scKpNO/WkW7dwIpTOeSQ0lvqiRlBDi7I/Zj7SE+9erDlpwblAG84IzgSnjmNpScDRtYWiGAvGgGdGQJXe4Nr3EDOjay/NhRay9THmsCg4E06lcD+1C4ypMmej6yLbsedyM/4RPqU/2fUoRmS/55gX/HrF6VSosrCfhHmpRFpy6HxmT99PE4e5cDUO/ORmi+jCfhYKjSQhRqOKxMBF6ppiVGAvhYe64Is7H8TOXP7zaNI54WRNm1gE7ueFD28f+NJ2zYMovk80uqe014cYh/OIPahBbUSCYkYXPJMaixgBuPI9IcBF1yE4ZjU61zZAgKzN5LTPmbtlYZKKVGGalXEVWA2Ri/FN8tHrqEtnLPd37FNiNXQcDjPKzP2kHOZCCg5PYClCAB6OEw9L5Wo18o23tpyWhoVdtCLmKWZ43/j+l6EduCwIe6ns64KZpx9GXGoXThFj4rzpiaBWydJoPr0d+Mr1trHVQ8SZQmkTqy5ETlbpMKIarlp7B4qwIjCheG1GtUe+IwRHFzvUmpI6Ov/JgT8jIMb9svD8NLEvTbN/mjL90DF0gW3/5sD1OupJ16GHA6cp0Kee0ykDE/cH47gUuvP6y6WZIx+OM/tauBw73rpYM2XjlJUYQV1LK6d4vDfWsV3YxBtZlF2pWK0M44AGGsJYrR2eVJkpTTJRlftj5lk98vb1JSIFzmxzwxFdo1tlaSQ0Xw2yNtmZb/tzxvCm4ByPY48LjsGnZv7WhuAktuZbMcEX2M+Zm2nmoJWqyrwIXfLEGBj6N+GXr6suo0NOE3PO+BiY5gVU2E/GlCt9NIKHIoUI7ErmVITrvuOdzcAixixCMX8GXURQR7HS9ljncGrMZuxqJtD2soNW1Br9aZKWaj6LUdVYvPKQKy9k5vHlwKwNHPAxQrT3nmqexcCJ0TnOZ7q23hFlQdDzx40EVjESnPExPNnzB76kxQxXhSlXHrIwqyIK81IJKTSq2ae8dP7YHviDCPO+EHVgO/ZUVfbLnruTJ4ixiQEvgX1uGvZjVfaieBWSZdDMJJFMYZkW6rzg1fBdZPTNtX3KhdMycz8tPBp6yrLgVOm08U8tGtUpx+PCZfTgjNsyk3PhvXXP1ToSvaMUh+AQVVIX+P15x3UY2PiOSHsQIWgL9XJGNgPzXMQeicqqRCQ6KoYA0znI49VuYfSOfS5MyMdtWSqQCPTJcbF+87J5XWVTYXea8ZsVV6uRJVf205GHWYlqbFLCDA7HudEeKkwKvQhWKxRhssKDFpI5rCiHnOlwjL4hwvZl5rSc2B8zl13P4XSEBN05eyGFwFIKd3PlMkDOlWelaRHfX488WfXE2NBdap5Aoxp8b9rzpOsZ8XA2dqfg8cEhVIo5egtc+56ug1XoOOVMNsV803Yb8PRhT2/CacmYV3qv4EDxmHp637EZhz/Kx/QntmQ/cV9P2HbN5dhTtfDqcGR3UiLKZeyIajzMMwoctbLXSqcFZ5Ugwn2eOO6VFBLRO0QLVM9wbiycSmZaFvZLYUiO29Oe4FvHiQCdjyxZeDjtWCdPUXgxLdiifPXRBW9ddAwusNSGogsiqBnfPhx53EVGjbhyDjOMkIgcVHBa2VrkndUWlYz3iWOtTM5YpcDmrJJ4cX9iMMf9aWKfF6oYKp4ikLTJKjabN+vvdZRNU5PBrkZW1wO5VE6nI3ezknBcpI5oyv3piBrMIhxLJQaH00qqmcMB8IHgW+PrOLfLweA6gvcc8ompzOw1E4PjLs/4c9q3+cTKOpY8c1cq2wTZhKfTjCzG48sNF+smyjVt77iPxYXfOe25jIm+es5gPXRo3Hy1dsCL3vF2vyUHoQOOWai0kM2PKYfPj3t6M3ZzbvJKNT6OOEpAlwKrdffZPJDPYem0cDzMuLHn4noLZuynE7u57XWjj6CefZkwa/lNWaBIg9lXFSwbBUd/xlzmYtTqSdouC6JKlsJOMuGcowNGMkeHI8TWfN1LJQbPYsZ9EbpaeEdGrvvUcOvSJEDetcnQR2VmbYGrvuci9ecwrwznxHs1h7PAOgS2QA4FPdN2nHdYbf98c5zoPeyqcKOlIeVJLARGbfkCY//pjvI/tgf+6+s1v3V7y/3TB956dsttmRmJbIceNcez+5mbH9wy58Khwk88XuGDMi3Ki4eeruu5nRY2NhDdwBI9uyWjk/KDuvD4sudehPsqLYWtGB+UI4k26vHBIyIsgHWw80bvI8kFjijdKrFer3h2c6SUlsB7pI2qffV8sJwQd6QLketu5ArPjTtRRam1dXaJnssEJQijnbWovmlXcync5wntAiiMlqh+pm/BpyQqYmDuzcvmddXm0Ybfu7nlt5894+LFS+6OldEblzGRneMHpwP3P3hBFuVY4avbEQJMxfhoN9GlyG6GjTWy01KUJTsWhO/dFN5aR24X4WZpl1bvHc/U6BfogmFeWeZCxhAp3Bt0PhCc594LeM/VReL5w0yRJqM4LYWgxso7Pjjuyab44FnTsaXjrsxUKqJwNA8Y2+TYz0cGIpGWKL1bWodtsczjFAnWM5qDNNF3iT4qIUI1Wsv4Tf3I6/p6y394/pLbD2559IOP+GhZeGdY8agbOJbCB68O/A//8SWdwks1vnoxEKORc+GjmwPilUUcYxgwVZZamVQAx28/2/OFyzU3ufLhsR34V77nVTmRqmOIbRPpgKULxOTQEOlcmwzcB6XvI+t14On9zCJGFs/z/YFJPc4b3ztMAAwhMBK59AO3unArE0sRYgmsiGxiwKmyoulXT6KMPhKysvcZuogTx2AR84U+ytlg2ShoJb/RUL+O2j5a8TsvX/Hw9JZHNy85LJVOPW+vR05V+N1XJw7fu2E9OL6zm/jq4y0hGFM1fu/uwOgDSwY3CSk5ljOzXMTz2x/e8u7jNbuy8Oy0sJ8zX1gP3M+ZFdAlR4gOpOXcrEKgT4ngHKLGKyqr1ch6HXh5P7GIUGjp0ivvGTGeTQcUxxAS29BxTeRZyDyUmXqm+4whcpUiD66y8Qnn4ahCzD0B2NcJUsAJDBooVNYxEKOSYqVqwORN0+111epiw/ceDvze3QPd/R13JfM2I9sBijieHoUf7HZcpsgzraxxDM44lczvvjzQd5ElwyaAmpBV2C2ZXIT/+dnCO5ueA8JtrpTicJLpNBK8EmPLVHIIczBWJDrzeFon/xmVn+87+j5wcywUU8QrE5mV9zjguU68OhvNLy0SijIl2OVCsYXgYaAn49BsdN5hroVdrgl0CveHwmpoU8/ehFmMPgg94IKnquE/ZRbOj+2B/wf7HVQhASeEkUjvB1YhMJfatEudZyawCkqylqZWaEimDuiInMpCdQJOWAVF6VFd+L3bAwXBO2MbI+8PibsMPvgWyGEwdCs4nthBu7mZMfpACAO/8+KOL21mHk6Cnsc5jqZHvYoNrbjXyqSViYVV6OnpUBW6YKTQuv1f364JwLRUdlI4AYkCFHKO7Io0iccATkZ+8/k933z3kiF1BAeb9MYw+brqoxd31CVjRZk8TSITUxuhmbKKDh07Xh0WvAf1TbbjpWlGP65DrTgEnDIOjpwTkyz8zv2OYu0AdtX1vNOP9HkmnqdJwRzDkLiZTk3+o4B3jDGxCoFvPbvlS3ngbhLUmiI1Bmt8dY0QYSeFYxUmXxm0jeAj524/HrHKT2629MA+Fx4kc0DJCFkqIQfu1eOdo08Ok47feXHLz77zmJVEonNswhss4uuoD+8fCCYkDwcVehxBPdEbl8kRhoSrwsupjbnD+Tk4Aw2ePnlOU+UUKzUaJkoAPn5cv39/ABW2BIbkeG/V8WryrPpA8J7oPV0I7O8XZmecbOHtEHgSV5iD776458lm5Pa0gDqQFn444jANDNGxp3KyCngu+8g6C/0w4KyNs4vB1y+29B3M2djVysGUhcosmSRrTgUqntXQ4cXx289e8c33rhhKJOAZuzcXztdRz2+PRLG2/s6T9HYlq1x2gY4eU+V2WTACXmkGyBi42CS248DT3YldPjEvgpiQUKAjes+zhxm1tre/Ozq+sN5wv8ykdHYYqaf3gbsysQRhksqTuOFxN4KrfOvVC56cem5PrcOfgKoCRDaMJO/Z1XpGMwZi37HOxuBbo6PJIB1f315AFI7Hwq5UxBmLr+RcuAyRmUY7S95zScdvP7/hK29tuHRNKbDp3pjGX1e9etjjRehQRJRw1s1I9VyPkbSG01L56H7iRpRHq4SrIM4zbBLbLvFyv3CwigRBOWvoK4zB8epYMAcDnghsOk8utU04XQQX6Tyc5gUR5YRyGRIXLlIFvnt/5MnoeVhaOKV3DbIiEa5IjMkxa/NgPdAklVEjW2dkmtTsKkTeWTW1wEMWshkutgvDw1JYR8FyxJzhzqnP33q+5yuPRrY+0TnHGP6Ym3Y/ePVAn5qWuPOefc5QF14uDu9gSI51N7AZjZcPR+5qJavReWP0GXFNIrNOAe8j3kHq4W7K7BfFmTsju2AVPVfjmu1Q2WdlkqbTm2rlINIePkZvjZeOCTcPmXkpTGo484wu8CgFiipbC6g1H4APqVF1MGZxXPpECgExuC0n3h57HHBKkSiRoJVSKg+SuVKP856iwqSVzgVGDRwWIfkWaLK84fC/tvr9m3u62NbgGAL3ueJK65SuXZPl9GOPj4mnuxMPRcmq9N5Y+4Kd6SGbFBlCaJpXH3l5mDlNGQTwDh9gHQNXKXDRrdjVwiyC4JjMmIBNFzGDwUUGC1Dh+bLwoAVTw5tn9IHrPnKqSsgtzr5zHgKMsVEBpArr2CZVWY17UZ6MHZ4WCtZZJGmhZuNeZlasOOVC0cpileQ8l9qxWwrBW1uDb9KeX0t99PBAFx2XMUB1vEKZSuGjU2HtHIOD9zcdMUU+OBy5WSpFjXWEi5hZmUNS4LLvSLH5iaJ6bo5LC1zDKNYMjtd9x6Nh5LIPHPNCsSYv3FfhQQoXLmEYo3mCtsTJjw5HfjCfWLKRzLMJgau+TR+sOLJBRyCFxLoPbIeOu1K5jp7ubGi7qQtf3Ix455ljZdTKoJXTItz5hTEHliVw1Mqdzng1nvQdh1MlaTP0yhsO/2upVw8PdJ1n4yN2ljGYMz48Va5SZB0Cb1/0sLRDzcOSKQqjGts5N+O2OcYUWbtI8I4uRvanBZkFFGYU541HKfF46LheJx7mhVMRKsbJCotXtqGtvyE4mlzZ8/Qw8XI6USok86x9ZNMlijZPizfP4BpSeOMd3eDpFoi+TamKGiczHo8dOGPjezalNT12Zuwkt7T7EjnWyqs643Gs+47jLAxOSAGyvJkwva56eTzRdefUWzxVHBNCrtBXx+AjmxgZ+oSfFx6sUkRxLjCWimvwHdbRE6Mj+BbitaOynJ+b0ZLCL1LkURexmDhVRc66/0WheIgWMFo6sz9f9l4uEw/VUxUSnpX3rGLgKILD4bQFdfU0SEwNUGulxxGdpwAex1XXpkTrGFnMyKYcVJhcJUkg0QAMN0Wo3rgYHYelI7lACp76Kfu+P7YH/pULOBzJObYhMQyeh6k07WZ0hNh0qKqg25GlVnKuFFWmmvHZ03tHkZamO8TAemgosEUMK8KMoWqYBqYs+GjNFKaKmTJLQb2yOR+8mu7KEBXOEm22XcdSWze0iz1SKt5H1k4ZXMB5x7ZvUOxVkU+6CgW4iok+RLwZFj0LcKzSgktcMyBF71FrxACvDhPl4ZDbmHyIfMpJzpv6X1GbEDDfSDbbmOjGwM1czuYcB3hScKx84O2LFacs5FKo1pL0Yq4QWpz8bEbwnsu+J3jH02KIgFjFzBAzpiyk3nEqwiLN6JitIr6ZLCeD0LaycwyXR9Wz6SOlVpYqxDQSrOEZV75p7H1wXPSRouCzUNS1YD4HVzHQeY9zDnVGqh5fHfX8/UbfiFUCaFVQj4qxP2WG6BlwSHmz4b2O6muzb3nahTDg2C1CzkaKniF5+pRYI3zBb9s0s1YKxkPJLfnUe6waBcMF2HRtQnk4Feac2VmDEsxqoJEQmh+qaDvw72pGg3KN56SGijFpoXijwwgWuOg6Sq2cpHA59ERtE9dRmx56TIHLMeHU6F1sGlQ1HMajLjKGhlUUr6BGKUJWa/LGs7nSnKJmrAgsi/DqYaEPkXUX4A2a+LXUQGimWXMM3mPBsTehFGVB6V2gi41+985mzVIq4oTqlPucz3tTZDHBYQwpMgyRfmOcgnBcKrV6shq1OpQ2KT8UYa5NDz1LJTt4HDqOKng1RGojOZUW3HXZB0pR5lq5DAPVKsE5+q6hjrvQ0uxV4UmKCI6ihnNKnzxdckTzmAmHamQxsrY8iOQ8MdBoZ07pXUOCnqaZi+SJwTfD+pt6LdWfpysezzoEgkvcLqUZbWvl6BvoJMbIkwHEVWjndCYVfG3eyiJN7hUC9N7YjJEkjrkoRWkucc5Tb2Au52lAUGbXEnFH81SnmH3cnQ8tnd4F1p2nVmNWZdt32Pky0fnA4NpUfeUcBxHMe6o6FoOEYxscowttNEv7c52qsKgRnacnkpxn8RV1yuAdsyi3S6aPgbX3n/oV+GN74H889Oy13dA2LjKsBvbzPVhof+Fnc4NVuFgNnKaFXJUiylEy1MAQIru6YLRD9/XYczl27BcDXSgiFJRc4dV+Rgfldi7tsXuYdMF7T2++OaNNKSaYCkNIXMTIW+sVd8vM3bRACHhpl4h1DHRn9/Sqj8zLwuA8N0vT0QbneBR7pqoNe2eNB+sKaGmkijG2zXIxh6L44lE1TlMhr0dW5vD65mXzuuqt1Yp7bRvX4COPVx0Pyx0utKj1o7QNwXnP1WrEuYVqhqg1k7V4LoPnsAiCUoAnG8/j7cBpqlQ1Sm1TgaUYr3IhmXGbK2YOB8yacdEz+kjRxvUVPOaNiziwToHH256HZeZhyphPxOAIzKTQbv9jDFwMPQeprHzl6alwUm2dr9gxqRBxZBNyUeoMC5BcYgieVYj06tFF8RlybZSiWg0Lrjma3tSPvLau464K4ozHQ+C66zjMR2IDPXA8Y+IU49E4Er1iHhY1bmXBquMyBPa1kL2wGjzXXeDROpG8425XmSWwKBxyYSrGXDJ3c0GtXQB3NdNHx9qaWS2LUM2o0dj6nus08OSi49VpagFEwZNi67KugqePnssucdV1vDoeeewDT2dpxt3YSFiHIqxwHLWwmwv7qbDgie7cMesiQR2yKKN6prkiZebxxcimd+dj4pv6UddF6rmVZpTexsR6cOxPJzqaafpQjE4VE7hcDZzmjNfCospdWXBqbKNjN81UjO3Qc73qW35OSFQmsoGoZy7CsRjLMnMzF7SxATjVivOeR6FjMUVFWSSTg+PSRZ50I1fbxM1x4u6UiSmgZnhf6bvEKkW2oWOdAi8ORx6lyEGgmrTOagjMIozmmEpmlzMPSyFbgyqsfWQVHYTQTJJEilSmWaibpvOPb3JIXlutY2SnSjXousg6Be6zEk1YqnJvGec9QuCiT+yqkaJrZDFraeIilWM1alBSgkfJsekSI547KpabFDdrO1dO1djXirnWfc9BsE/4PYaiZGvUnQ2Byxi5HCIPubJfhBA8/XlddaFlPgzeMXrDJmEIgXtA1eG94zJ6qkDwylIbevM+VxRHDJGNCyTvqN6xco6BQK7GnsKjsWc0w/SPuYZ/L5mdSDMRArh2kKqxSV7qJDg1BiI50w5UJixWORa4jHAdtky54ryji4HjWYe4HgLHCp35pmc14UE802mhJ6C+IQx7CxyqMXWeRGwR3QgDkcdjzxgDzoxgnj4kYvL4ECmntvGqax3YZRGOeQYSJ20Hv+Q9J3F8+/bI41WPWrtkdqFDYmVXlC/3nk0MdOqpTjhQuYhDC9wKDjM9pwe/qddRd6XyIJWEo0TP0Vr3EWuTmCpK7xwXfeKhLFgK+BCoVG4ls/WexyQmydQA2QcmVaYZrlaeYxYMj1ggG9znSnVKDLF1u8zoxLOvwuw7+mjUc5LgqJ7rvidGRzSjwzGc/QUdkS5FqgN1AdHAaRZuZCYLzE6w6MAFTuL4zvHEo+Co1SEGfTx38rKRYmLTdfQqZIwHm/De0cXGsEYV482B/3XUXV14UKELjkJHCDBbxTvHfqmUU2sc9H1kf5hYdYEirSu6C1A1sUY51oJERyepsZxPC8E7ildS9FzSEHKY8GpaGkPaGcWU3sOpKHNI9Od05qJGwHOxHth0ESeGN0cfAl2C4DuOpwWXIPlIJHHMxo0sxNCz0DZwJ577k3Ff7vjiJvFqqpyK4XGIF0SF7ZC4HvpmPsd4Ok08ionuTE50+jFV4039qGtXFu6lce2vwsA6ReRQGVLklAu384JzMIyJfGq5DKqwiHCsFbqWizOfD+3BNQN3KbTNzowxNrlGrUqVwi5nwFNce6/4s6T1FMB7T60tmRznuN6sueoSyZoGexMSKXhC1/Ow5AZDcVBR9qrcW6GXnqVwpqEY+1nIr45sx8DDLMy1TZEyBdU2oV/HJguqZtzmmat+hbhP/ghtAv+mXkvdSOEoTY64tUAgINrCSVFjyspimdQlThXWvsUlL9YukBXHIw9SQbR10q+HRvUqIkTapLKg7XxXHZMKORrF2qUzWPMISXRobXIe59sEaAwdm+gIZiQcQ4h47xlDQmkBnKptiiAI97VwQTj3yAzvPGqBj44z2w72uQXRXRA5IDyIQjLGEIghUR3czZVV8mwIRBzODOqnm7L/2B74KXAsmWztxV9ESRWidSTf4eL5kKHNGe1x+HTWx7vKyntu5oUQm9ZqDI4nq6aT2p8KU13AAivfYVRmKZxyJYXErIJo5dEZ9TWJsE6RoNYkQyginsttj9RKEWGSdit762JFzDNqRqnGUQpFhA/LxEUqjMETzTOrMFNYqed5nrlKHX1o+DKnxqMSebrL3Ebhou+46kZq3vPVJysCgW5IaAhk/+P7CP/4V2GvC1kMVcdRCgllVMd1H/He4XCE6rgMnhLaC0aCR4IyhMBtnhlDpA+Bq5B467wGd6fCrIqLTa7RVc+UC6UISSLVCdWEjbaRcgmQukCshhflFIwTyvtdzyKFh1LYl0I/GU+uNuznDqdGNeO+FooUnpaZTYqM2pBmmYoEz7w4Fld50vWsYtPk51K47Ho+mgt3ufIoBd5OPbUoP/n2FX1IhK7NTuVN7tFrKYtwv2SWWVrsuja05UBgTAPqIDjHdRf4KC+YGTF4Oo0UbVkgD5q5jongA49TxxevNwC83J04LIXgHWPvCR7u8okDlVgDxZSiSieOEFqTIviWppuRxjH3ju2YyEWZa5NSTlPi3asr7ndHRJSclZdlYZozv68Tu6QEr6iBiGMfYJwT32HhUUo8Gdsk4a7MXHQD33s4cXesXI0D12nFYa78mXeuibEjDB3ZjEN90/R4HZWpPNSJuVSsyllECKhnDB29U7x3bLueOyqpGN47fG+sEgQP+2nm0bAGB2MXuVi1w9NuN7GfF5xrU/DqPXd54mEpIKkdlHxDXxaEB1kY1DfpI/JJYNG4GphqZfKFoy/YtPDe1QVxGlq2jcBSKporT8uRZSjtwGbnLjDCNkd2VC5Tx6MuMavy7JjZ+Miz3YmpG7gYe67GLYvCn3rrCoCuGzEXKFb+a399b+pHUsaJShHDTQY2I4CpEGihZ4OLdCkRKKTapIjROcYUSMBB4e3Oo6qsnOPJqm1Yd3vhRaktcTwlRISdVnYIomDWAtjCGa2uHkL0FFNmrXggdD2rMbFUWBAml3nIypPVBaeDNIyrWqMzqvIS4+QrwplwJ7DLlWsSryZHHwOrzlEwdiJciuemFOaibH3iSeioofLN7ZYYIaXmK/i08as/tqfFl8eJt4YOvGOnlY9hSHvJjOYZfLtpXQwbKCde5RNDl/jyZsNPrFcQ4f/zgwcAjlKYj5Vqha8/ueLVtBBwHKmcTFn7wHbseThkjix0eDoX2J1xFi3CA0ygFqOGwkd5x/NXR0YXqO48WXi5cLs78ud/7suk6Hlxd+Tpqz3r6Hh/vOJuVk61YDT80hAij8aBTfBcb0f6FFlKxV4I0/kQNRfhhDAEz5c2FywZZpkYanN4H5Y3Sbuvq5bF+JIfKV7Za2UICdWFkxb6uZLM4Z1ns7ok54lTUVLwvLtZ8dXNGifwP768YaGw1IWHfWauwjffvuajhyPBYCfCfREGEpux42GeEF8ZXWCwyIwQ8AhGBASjIIjATZ64LxkXBFVBRXn+MPFynvmL3/waKQae3e74wct7Qkx8abPhbs7sTDAcgwukLrJJkT4qb29GxhTJVenvJm4Xo9OJZRF21Qgrz1curxEJvCwzqYYWXnfMf9SP6k9k7U6FL6YeNzgm17qlh+NM9pVNiPS+pTsiiS4Hbm2hT4EvbkZ+YrPFAf/Tq3t2vnKqmee7mYNVfvbtR3y0O+FN2S+VO4MhRKwIr5aJ5ByjT4wh4nrPFkdGWBPpW+YzxYzvHx94Ok/nXIcKasSHEy+OC3/xT32DLkSevrrjg2evuFh5/qxdcCjCqQoJR98HUhe46Du2MfD4emTsEsus8NEdRZR7PXFTJ8oivMeKr16sycBdXkjSuNXHNwf+11IPp4X344jr4eRat313mKlBWQdH7xweT09izJVX84yPnnc3a376egvA//v5DUcmjlW5OQbKS+Objx7z/LBQpHBQQc+Bg6E6XkyZ5AtrHxkJ4BJrPLNWgj8bFHGYOL5z3PGszBzrQjYhOM+jSThMmf/dz/wEMQRe3d7z4uUNYaX86fSE05LZF0FpIYRj6LjuEpsucr0d6LvIXBTEmDUgLOx0oczCO27ga1drTqLMkxBjc1IdpzceptdV0yJchATO4Wld8loNkoOgVOfxGLE0MuNCS9R9nHrePwei/ebDkQcyJxP85Cgvla9dbnl+WDiVhdkMXKD3TWt/nxeSdwzOk3yAFCil4BEGlzhqCxEkeD7MC7uHyk3NLNokviV69nrDn37/PaL33O5OvLw/4FG+Qc9DFlxo0VpVFSeO1WZgRLhaDfQxcKqF+5tMJ5HZL9xK5uSEJ9bzfrcmayNnxWKYOo7Lp3sH/tge+I3GFjVVllxJMRC84ZRmQMOTzHOvmZNWgnlWFti6yJgiYpVtDNxpYV9a0EEKnstD5mFeWPeRqEIWo/OQXGDsE3OpLNqkRB2RFLQh56ojqzKZUsXofesSnAAcOAKqylIKv/mD57y7GenwvLsdqFIYtZmRPo5NTjiqwlvrFVkqzjf2vxNYpMUzR2/0zgjWwkKGvhmEcjGqzOAglzeb3euqSrtUmijHkumi4s/ygUwz7rYu6sxRC5gRg6NzMHpHrpVHPrCzyqFWxISOwGa/535a2PaJi+qYayWieALrrknHShsIMroEvq3BUKFUZS6V6qDziQicSgVnJOcoYpS58v/8/ke8t97QO8e7FytMlWjKoUCU1qnrcJgFnlz0zPPSbMjO4bw/R4C3uHkXGg6sOqOLjRa0FCGXZjie36zB11IOf35GRhEB35Js1TUCjojiDbK0hNMYYQiOMXg23qOLsAFuirDP7a25Sh33s3B/qmzGSIieXNvhp5hnK0JFUG9oMFYhkBg41oxTR9E28Tw6JVRPF1oSOA4GFxBzlFL5D7//fd7ZXpAw3rkaMVNSqSw6E6uj87CODjHPu5drypyJFkgEqjdUpY22nScbBDWyU667HlFrXzMLai3w7k396Mu5hgdWa2m4fWyHLu8b9nAxcMW4s4WJjA8wRM8qetbes6iydpGbWtnnipmwSQv7PHE3Z9ZdJGggC4wEog8t4wSleqN42MZIFEdUR/KBRYSTtAvnlW90oEVbls4qdgRpndz/7/c/5J3NmtHDu9crigquKIez4yM5xyp4cJG3LjZIKWf6Spt2OQstAOyMj8WMRYUnccCJsRNlKooYTG+gBa+tuhCIrkEqZoTkI5VMsoCKIU7BefYiFN/M2h4l+EZ0ElV6HFMR9rWFSa5S4iiVuzmzipHOteDUwTeT+hgrFSP7xg1Yqz+TnYzORSZ3lpCr4qgsNIlYh2PtAmsfKFX4neeveDQOdMD1KqHi6dQ4CVQ13Pn7RByPxkBZWhMX3zycnQQiRihGo24aVZU+NFjLXA1D8HjUPt2Y/cf2wO+9OxsgG381RlDffvCdgZhi/uPo48IYW6dyjB7nwKpxkRL7IgTXtHw+eKq1m+AmJYI41CrFFLO2azjXNHnmoPcBvCfSbpHmDPHnWcP5kpncedyDsqSGU3qxO+HNeG+14mroWBR2h0L1SjCHN8CMopCcUYLHMFQVw8A1CpFJbammXqmuktLAcqot6Ms1rnuub/TTr6sUZVHI53VoohhtXOjwTR/qFKeVk1TWPrL2bfpk2igTVyky5ULEEYIj9Q41JZpr4UIBRFogCA68a3pFod0zP16DQV0jPPmARmMyoarQ+/OlwGnblIKyiPL04QACX9iueDR2iBoPxxM1QBAI1uaJS6kkPOJbrLyow3DgHEOMSM1471BvVIwU4LAIy/JxzA3nGPs39aMu5/jkHdgO/L6tveBRmt9CDLRWTla48j3bENmEgMdQU666xGlSkhMsQIyNUJIwVjESXaOTtJTvxtFX86gH8YbzHvD0Z72oeE8KAWeKmiJaG3LxTBWrwTiJMN09ULPw/sWax5sBEeVhd6L6dmD0rjV1aj2HzYQWHSMNSIZHSSlSiqfD471HvTH0gduHiVOpzTtiUN+giV9LBeeBtg/XKueJZqN3mXdUbfukN+FoQk9gExPrEFsujSoXKXKQSO9qk0Scg4KcCWMccKIoQkHgbGLUMyHK00TU3rfDWKB58RKRuWTkfAC6ih39OTeioBxz5eEhY1L5wsWGJ+uRLJUXNzsWUUTbxRkDoV0+F98OCQ3G5868cygGQQN4UGd0MbA7LuQqlNpoU2+wnK+vWgOtYeJMW+MJDGf2ifICU5QmX00WWmiga8/QzLiIAa0QnaIeCK6R6hA63+EdZGt2XDFH9C3PSc5yVXPt8hsMonftPGjtLKmmLKqsXCA56H2bQsxi7I8zTo0nQ3emREWOpwaRKSYYegbzNB+BuAbq0PM7MAUjusBcPJ1vPwcalC46HnJlqoqezwz2KX0kP5T69h/+w3+Ic+4/+fXTP/3Tn/z3eZ75W3/rb/H48WM2mw2//Mu/zPPnz3+YL/FJxeApdv6B880gWIGII1k79FcnJIyswhgD6y7QJwcYop4hnWOL+8jVGLlcdXSdZ5sivWtBRYsqu1y4ywtTqRg0HGF0dL2nS4HroeeyS1ymxDYlVs6TtW02V6njOnasYmBYeUiuOburImZ00TOmxF21JtNpPkcWbQczqZnoaBvo+ZA4BM/QRyqe6hzFGRkB75iKUqqylMpUKvPnqLvwWa4/oKFZTclmROdItB/I5ELLWDgbwgKQrdKHwCZGxtBQqmpnSpOPXJ4504/WjRyxCZHkWtz8YsJOCw9WWKSeWb/NmB279tLbpsimi1x0iYuu+T1KragJT7qBJ2lsXoAhYLEZ3AoVReliZEiRh2Isrpl8zITFClOekSz0rgV9qDZiVO8jqxTbRucNdUY1BW8clsycC1MpzFLI8vnRsH6Wa9AcTGos2u5zaPt6YwisUiBFj/nWrawoKUQuQmLjw7k54VilxFXqeDz0PF71XK9TQwV3DReHgwXlXgp7ycxWzxtpu/h9fNm76DouutB+pcQqtItCqcLbw8B7w8hFivgBsm/v6lMpiCljlxiHjjsxZt8mRRnjUIWTtM+RYvteqinV2sRhPUSq97gQ8ec/U4jG7jQzL4U5N2/DXN+sv4/rR7n+Ag6z9ssb+GrE0IATyZ/XRoQuukZRIbL2iSEExLUGwpgiF7Hj8dDx1rrjauhw1qYAsY3GWUy414W7snDUSjajakMVq7UG2KYPrFNk2ye2Q6TrGqoVUd4d1rw/rLiIHpeMyTVd9lLreQ9uQZi3pX6SsZNN28VUKlKbl8W5hgZVg+CNMTpmHGLNq+WcgffcLgtzKSylUmqlfo4mnJ/1HoyDFiXjWu6GNnVEpHlEoO1LjhbKlcyzOXfZwaHq2HaRqy7xqE9cD5FNH8A8QzzneGAsWjlI4aAFsfqfGLHFt4vtEDx9DHTRk5IjBg+uNV6uU8ejrmtgA6vM1gg/Ii3zqQ+RPkb2Z0TyQkMhZ21TCitK9B5vbVpQMVI0huSJPtARiA7MGz449tKULbMqkwmH+ulktT90h//nfu7n+Nf/+l//wSeIf/Ap/u7f/bv8q3/1r/iX//Jfcnl5yd/+23+bv/E3/gb/9t/+2x/2y+BjoDjDmWMdE50GZleJzrXOg7czLcIhZ4d+xCHSDloWPLd6bB97RjpsuohVj6TE0So3y8yL08xJlQHPSSqDb0aQLjj6c4rtF7cJsY6bqTBNylJz4+JXx+O3GhlgyR7VxLOlbT7X/UDvArUKYoaIUHAsaiymLE7pvSJV6YMCjloNye3gaKGlZToM1FNneJgWdrmgpswqFNPPHaHis1p/cKZCoOBhExNDSBxLxrmWiVAFMvrJT9GqdwTfbtvee3yCV6eZvkskAiHCmkDJQIKTCq+WmRfTRHHQ+8SkyqCRPhqdA3eePL23GfAx8eq0cFgyUhVvHl+VdzaJlDzHGqgi/ODQ1sTbw8gqJKoYOONQC8s58rtg5xwKASmkruVeiAj1/EfSIEg48/EU6qzczwu5TIhUZieINqrA56k+szXo23OKznEREkEbvWTjAykGjmLclIw/SwpXqckQqinVNxP5w2Ssxkh0EX9GZNaqpNSfsZuFl3lm1katqFJZ+Z50DvbanBMcv361pgIv5pnTSRktgVW26nn/ckXqIqdSuC5C9DtEPG+vVy2DpBrqjUMxZiCfO7MA0UkLg+t6gjq0KFIrY/B0PnHsF+w83dKs7E+ZkxacORanlM/X6w/47NZfdsqMEr3jcuhA3SdSmBA8ixr7XInesQqRq+TbXuYUvGcJkYNktkNHFzwE5TJ5lqUQQkd1xkOp3MylAQR0oVRYhUbuWf0v9uCvXV2i5vjwdODuODHiWbvE4D1vXWzoomOqC5uqeA1k4MmqZxM9UtoBbp6NySsuVhYDFSG6gtQtXd8uuaUaJVci4LwnxSYt5hz69DDN3FeBWqnapmGftwHnZ7kHLy2ZiqCekTOVK0bGdtZmxjiYsSVwQOnPZvF2UfX40PJuLkdHJ61rv+09cppZp4HoIWdhV/U8rzYmKtEnOowBZWVtz/zKdqACeVGSOAIBRbjG8962J0TPXFrwV9wXcihsU0fvA2oVNThIayJWFMHIQO/bvtv3HeoaerZWIxBJwNh5zJr80RU4ZTicZXbOGU6bouDT1A994I8x8u677/4Xv//w8MA/+Sf/hH/+z/85f+kv/SUA/uk//af8zM/8DL/xG7/Bn//zf/6H+jrHsjCcWakrday6xJe+8ISXd3vuc+W+VOYCd7IAsB46FOPllHl1LGg0KhErlYeSOWjFu4VHm4G3fc/DPrOvGfXGdUxkUa5C4ipFshq7pfB0WgjR84Wup+8DiyucTLhKA3/u/QsAQkiAg9RhwNBNCLBNiUPO/NbtzCxKFIXgybSFlRz4DgTPkgs6L3QpEFNgDI7f30+IF3pLzVwZ4cVx5vuHiXdTR0ieHt8wkZ+j+qzWH8BUK0PfOLqpOrZ95M997R2+/+qeQ8loUXSB+3km4LgYerAWiLFblExlBjotPOTMQ6lgnreGyDvdiv1c2C/KbM0g5Jxj4zu2QyBL5X4pPFMlBM8Xu44RI1uhOni3H/hTb28QaU5952AdAkK7VJxE2faJUy18b7/jWCsdHvLC8XwJxUEa2gZcq2K2EFIidh2dGd+7P7CwtM3VN4Pl7VJ4IRNrCYQQCQaaPz8dLvjs1uBhaZfF7jxRCp3nz3/pPb799JZXJXNUoXhjEU8fE4+GjoBxkwsv50IksfNCWip3c2EvQkyOd8eRt3zHq7uFlyVzcMoqBtZ9xyoMDNpQsPsi7MsJgK8MIy41uthixttp4BfevwYUuiYNehQTsoHLLpGBy6FjlzP//sWOUowgynjG1iaaVDL6RrCY80KejRQDXQiMqee7hz1LbpKyIQSSCzw9LHyQM499T3CJaLC8WX/Aj379PSwTY4qtO+kgdo6f/+JX+d1nz3g1z0zaZBU3JSMI47CmOuPZaeHpodDR8MVQ2dXKpEp0J94ZN1zj2R2VXREWVYYQGYfIRZ+gwC5n7uaZF/OJHvjiqmeVOkwMXwNf7Vf8uXcuW15I1xGjA9+z1Na5XUS57DsOS+Y/3j6g6uk7yHhyDQQxemvytIpAVuZpIQRPjJFtF/n2/sQiC14dK58Yibw4zrw6ZDY4QmhNEv18Lb/PdA/e1wkbRrrgcWfpzM9fPeLb90ceJFMxBu/JwEY9Q3IUhBeL8GwqxBBYBccHx9yMtgYvT55t6LhA2Z+Ek7Wjfhcaee8xI6WjMfGr8EpOrAg8qZ4uBqA1mi9S5E9fXaIC3rdmy9XQkYF18ER6ui5xzIWntwtVPFDwpV1KmlKgKUJmgFzQsxnYR8/WGx9qZZIZw9G5wMoHntYj91OlA8w1HHL/ujT83/rWt3j//fcZhoFf+qVf4td//df58pe/zL//9/+eUgp/+S//5U/+35/+6Z/my1/+Mv/u3/27P/RhL8vCsiyf/PtutwMgEUjnWO7t2DGEwIrA5WpL3wuruTAcJ5ZaiUPi1X6P8x4fAr2P1Oq4m/eMTeTFqO0Gv+0iS9amp3eeYMpRCiIeL0qRph+sDnxwSFV+/+7Iqu+4K5mlFDZdYFpa4m+RphmcSsEl4wdLMyQ9CSPOOQ5WmaTwZZ8w0YYZNcOrYwyRbx/an3ftE6tqpKzUujDlQk1Q3MIigbAEJtrY5runHWuLDDGcb6Wfn/pRrz/4w9cgBt5gSIHV0LHtEmsCX1iNnGrHvlQ2fiFnQbzj5X7CguGDp3fgVbk5nCg+4HEMeBaUqyEx18xBzi8k3zHJwsZHSqkcFs5YxDYWnEX57u7IOCR2RZiqsVl13OfK4HvqGWF7zAvOO57mA7fHzBPf4Z3j5JSjKV8KHaPAYq274C2wksB35iMAK98zVKUrGdQ40ORFok3Ss8FapsDs+EAWtkQG3/B9n6f6zN6BsSHX+hR5exwJOProee/qksuSOdQWFFRy2/Q+2B/x3hGjJ8bAKIXbYyFFgw4G9WDG43VHnivZG0MMbEw5lErwnttJuThrtM03k+ZpqfxPNw9c9j03JXMslUdjz31WVh1QWtDSqRZCF/jocOLVnHk7dsgZL+e84x0C4dyVqs5wpmzE8x/vdjhok7AYWodO5byhK96spW0unr2beScNPCuFQZXgHPPnLAfis1p/MSUIRt8F3ho2LUQowheuN1wuI4ci7MuCzIZ1kWfzBIDzrploxXOTF3rftMO9a4bZq8GT56a/XvuIIUyyMFM5LYU+Bqo11PZgrXnxmy8feHu14dly4ibPbPrE86yM0SNZmY6FY8moU56fZl7lia+sNxQ1XuSCw/EeHUuoFNekSLhGyvuP9wcc7cAXo8PFhajGgywYFR+a/y+YcT8tXHp4WheiFQYC7lOGHv1Jqc9yD26ceiP5wGU/EIIRY+CdVceqemZRcjWWIi3Bfsl4rwzO0ROYrPCQtYFcz+vPVLkajTIJ2cPgEr1znKgc1RqRPwOOs9zasyB86zjxKA3clsKhVFZ9YJ+1mbxp78klV5J3PJfCqVYep55FjLtS6X3kkoSmBVFQJ3jnSBrZT5UDULxDTDATosJSMxOcTbtKrcpJlHVy3JeKiUesSTo/Tf1QB/5f/MVf5J/9s3/GN7/5TZ4+fcqv/dqv8Rf/4l/kN3/zN3n27Bld13F1dfWffMw777zDs2fP/tDP+eu//uv82q/92n/x+45GERm9Z7tObNOIA7ZdoJdmoKi5sAAuOG5lJmH0QBFjXwsueE7nQILgHaPz5KVwkUY6C4wqVHVMFbZ9ZJ4KswjNh+uQ2sYl+1A5nZRdLcwoQyp862bHemisk6zCJJn5JMx6Jkdo66Bm16LrlxS4SA0cdZCKc563xzXPDgcA9q6CwMpHvhh7aoQNHVXlzFg/cdE1ioto5NK3FNSHz1Hw1utYf/CHr0EcODU653m0HrgeO0yVMXV00Ui+ohUmW/DO8XxeCLRUvWLKtBRWKTGJAIp3jnWITKJcxZ5NbySBUD1ZhYs+cVMKBUVdk+GotlCjWY15qRyrkM3opfDt+8JVNJxzFMlMdeYo0nTYAkttJqfFK5OvTD5yNQRcgUnB+cB7/cgHpx0GHN2MCQwl8NV+TUXYaGgs/5J5vlSSD4zBkwlso6dzNMPv56Q+y3cgeDpzbEPirc2GIYIpbPrI2HnGkggucrQZc47nk9ARieqwrDxYpQuwSBtxRxxrPPul8igElk6w6qEGTqpcx44XMpO9Nm2qOtRatsS9Fuas3JeWpHqQyveOR94piaKegxYOMnM8VaYqVHOczuF0B63UzrFxjou+IxSYcyU4z/sXa35vd98M6VRKhejhZ4cVFeXSB7IIDyXzzGZW3hP6cyBSiPTOE/3nR8P/ma4/g0hgFTuuNmtWXcLwbMc1Q1KGJeOPRk5N+vdwalPqdYgkgUkKyTdDJOZILrRkb6msu4HsZrpi9NUxa+AyDtwsS5s+nkOtFjWqGPeqxEXYL9KIK0vhe3c73hlXFJ+ZSuWYF+4tM0tr5i3qWKoylcLkhCE4rmNPci3Xp/Oe9zYjv3N3DwZOCrkYzsNPjQ3/+igO54An4Xba0wXoU6Krnq2Prbv8OdI0fuZ7MKBSSTHyaN2xOksMt0NHp4FjVXZTozC6YJSizWvnAqaeuRbUPN1Zr+/U8GKcKmdoQW0QGNo+e3mW8Xpv7VBujcgDcKzGyhWWUshVWFLie6eJ69RRVTlJ5SRt/16smdE758kKszRCUOcim5Sa6duaX/Rxn3iY2jtsTo5TETQb7/ueDIw+NJmPtZTz4DyxD6zE6H2g8wH5lGjiH+rA/9f+2l/75J9//ud/nl/8xV/kK1/5Cv/iX/wLxnH8YT7VJ/X3//7f51d/9Vc/+ffdbseXvvQlZhFWITZiTWiBBFBJniaFmDNZlX3NjD5h3qPeoa6ZLSsKIqhrCWg9Du+NYxHWvnWGkvMEPNEZ65AgKo52gTCgiuA87KWZg+VMDJhVqZKZxVF9bQhFE8YQWLvAiZZS6YGAEWhd1TEFhjBwZYacb65ZoaMl+Jq0w5Mmz3ubHpngJIA1gg8SeZw6rArdOXo+/nC+6z/W9TrWH/zhazCLMuLwCp139L7tXhHHYcnscmExY3emRJl3GB79mCTlHAFrmK3zgcsb7GtlTSJ4j1fFO+h8Q9nto8e84vAE5zhqxQEHkU84/C448hkpG3RpQVlSUKt03rNykck3CpRzZ+oTbfPsYmKMCXMecZ6aFdFGHsomiFgjB3Xw3mqAWTlW4SRtxBnNc7GJyNKIUw4+CSb5PNRn+Q6sogw+4K0FbPUhYNZM3MdZ2C2FYxX2InQ+4Hx7p9Qzxm22Zig3bThjh0O84+a0sB57KvLJZpacZxsCu+DOJrlmINurIsBBKsXaew3fQmZkNpIaB4OTFqqVZrb1kfl8ScVBdzaxZ6dcDpGrFJHRWmdKlCxtnZZayTTksQ2er27W5GPBStt5xZToYjMBixK0deC6TznO/pNQn+X6c0DnGhbReaOPjWCXnOdQM/slc6pC1opUbemjZogY0Roy06z500wNA9Qpt3MhdZ5iQnWNNBJCYAyR4PIZDexQMY5aMQ/7Ukm2kKV1/lWN3ZRJ3nFEmUpt+3V0DL7tvPulNBysb5AN8cZ2SFySPknJnUvLL1FrRJZCI/+ZOb68XhFEKUWp1syRGzq2fc9UhN61w5Z9jhoen/UeHKzh14M1ClgXPKiRgmN3xg1P2ghjjoaz9Odn21hfriHetVEW1RTDcVvq2aNnKIJq+/9671sT+fwL3Dn1HmYVDjSkZgBUKze1gVZUPZNVJqsffyDRN58LCqNrnz+b8jgktr4Z28U5SlFO2gAgRZphN+Dw0fN+13N/KjQbXjO5X7hAChENba3G1i35VPXfhOW8urriG9/4Bt/+9rf5K3/lr5Bz5v7+/j+54T1//vy/qvf6uPq+p+/7/+L3T7kyhKanVzHUGrbQMF4dJ54fZtTBTZ7ZOiOldjkoZiRnhOCZ54kUA1sf6IETykGNVc504Yw/ssYOHvDQBXo8znuKGrNXzDuORVlFR0ye5JrEwQdYsnGIhWLKiOcLw0D0judZWGptJHXfuOylCj7A9TAQfOAgwu/dPSC0jXhQT8CxcoHFmkHk+9MJZ43vunEBL56rEDn6RgFqXbvPz2b3n9ePYv3BH74G51oZaWz7WoQShf78Q/fyeOLZNEMMvFpmNjbQx4jiqGJ0eFIKTHmh844tnijGXpSpGCtZSPGcuKy1ZUGoY5UcRiC6QBVjqpVKMxVtnCMkTwrng3ZwqBV2NTPVSo/j7VVPCp4XWViktMNb8AwSKQLOBa6HRJfaqPy39/c04ZAj6jkeXD2zGl/erHguRyZxROfpfaAvzaB3dIWlKuo90X1+Dvz/eb3Od+BSlSF5sghTyQy+J4SGm7s5znx0mJjNmGphmxxDiky5JZNfpIgzzykXege9Gt5gCsZRhA1GVWFSZZZ2ie1oDH/nPIOLiDP2KlSUeqZNRO8JwdEwaXBfM/cIWYSV87y/XuGA50tlL5noYRUDrghmsOoCFyHhfGBXhd/6wSsCgeCaWXcwYxUDszp++uKC3zzeAtA5z8bB1rePP5EpVQgfQxw+p/U61587M+hVlFwWJDkiEXPw6nDko8Ox7c/WLo1jShQR5lpxvkPNkaWhg5MqqHIw5VAzgxjFeU7aJuDB+8ZOj75J0qz9etCKeMhzJlrDuY4x0HmoRbkrMzutLKL03vOVfoUHbjMc5pkQWuIqpTU1hi5wlSLeeR6y8FvPb4l4qirVGck7ViFQRPnG1YYPHh4ajjN4ti5xFTsuYscuLpiAmf8k9ffzWK97D3bqCT7izFGqkL0nATi4mSaeHxdwgRgCXhrquphQxOh9Q8tWE9DWlBUMXORU8znzoxn/RR3eAb7JKJ19jEA2sjSvylQrXu2T5os74zfvbMG75s8UlM2ZOBYsgDSK2hhaZpOo0vkGYfDBc1Dh93czi/MtGExa828VWqjiV1YD/+GU8bTPk3zgKiSci0yugVsavfY1YDn/8zocDnznO9/hvffe4xd+4RdIKfFv/s2/+eS//+7v/i7f//73+aVf+qUf+nMvZ13pVBqf1wyEhPlACY7ZNy7/l7oVfXFchZ6gsCyVNt1obOfkAsk80Vr34aSFnRaKwKlWjrrgqUAlELmMiScxcR0SKbYOgGHMWiha4cx+ZlbmIiyLEoqnL4H9XglErugZq28dCoQKzDiWltfM3fHEd1/dYqpsksfH9ijUHIu1YJun+5lDLg0XReGVK5Sucp8nTufwkUUbwePzWq9z/UG7ce9NOGhlEaGKULyjRMfkjZO2ELZ36Ymz8Ch4egSR8olr/pOXhzWecO8ckyjlHAIy18oxZ6RUqMqayDZErmPiuuvok2e2ig/KrIUsFRXDFKoop0WZi+GrJyyel/v8yRpcaUewZuSttIRKUSM65WGa+M7djpocKUUm5xDnMRcQ7ynqebFbuJ0Kp1o4SOFWM8eoTLMyV6UKYJ4upP/mZ/nHtV7nGpSgHJ0wiVJnacQvIs5HBI+Ko1fPe6HniQs89pF18nTJMfjEKgbwLdtjcI6N9/TWfET7RUE8uRiHUqkq1AodHdddzzvjwLvjyGWKSDBIDSXsaAeiEYeEJu1ZirIi8iT1BDOS91wBlxqx2rSmJynMi7FksAK39ye+9eyGfaishkZ9UW0yIjNPzZWnuyO3y8LRhL0Tbp1g0THNmVOpFIAU6Mf/8qDweanXuf6OS+G+NglqzSA1UPGYt0bnKrT1FwfeTyOPXKI/ZyaMXWTrI4SWI9EOPY06dirCQxUcAVMl10wtQhDPk77nUZd4ZzXw9mZk6CIiFby17AUz1qnJM6oI+1I5zhUnxujantsBlxLYWESl+UsmVcqs5GxYNW52E996eY90DjcmdPCNHmWGGUyqvDjM3ObKvRTuauZVrZwwpmnhVJrBMlq76Hxe63XvwcdaONEmf1I9oTakb/UeJOBqa34N5ojVGM7NK3HtcDuoI+CpXnAogzrW5uhoh+2kASostX4SpHVF4NInHqeOxykRvWPWigBHFTKKP5+cFZhFOeSKZmMlkVWJrEPAqdBJk2Ge+Pj9WaG2NbafK893CyVAlxzpTL9Sf/bZiXC7n6lmLN6YXSPrnWjUR2h5EkOMrLpP9w78oTr8f+/v/T3++l//63zlK1/ho48+4h/8g39ACIFf+ZVf4fLykr/5N/8mv/qrv8qjR4+4uLjg7/ydv8Mv/dIv/a9yZ69jZOwT5uD+ODMVJQKLCM+OJ+7z3OQyXU8Vz21eOEhBpN2yko/sFkWT0oeAd4GoylVwvDduUFVcKWABrR7XRZ4kT+jSmZYCb18O/M7NA1MWfGhjyaKOlByHrkIOOGuCBnOOEjynXPE4TB0b1/E2zUF+0bUgkt/bH9jnSlZjDI63gucuV4YQUA/FWTNmZM9UW/Ka1YaOWnzLDOidQ6On955N+vx0Vz/L9Qcwho5VakbHh/1EWQohBLIUnh+PvFpmzOAL3QYU7k+ZvTWU3eQrPif2WaF3FJearEcy1xp48ugSU+Wh1DPd35PVeNR5lhRR1/wrv7B+zO++eOBeK330KGc2dYBTMbJWoCVNWvB0PnKXKxsfW1IkgQs6XIRtByF6vnU/cxClAGvgugvczIp3EQmOHD2TwZQry5mDbc61ToiDneSmG5RmhB+7z0+H9bNcgwMtL6So8fK0MFshTAUh88HxwMuaSXjeTT0XnecoxiTtMlZ0IYyBU1Gqdy3AjRaidEHiy9cbnMBpf6CUcp4aCV9KPaFrQUPBe/7s5jFX9w88nTP96FGDkxrqlYXW5ceBmHAqRlAjBmFFx5HMxhtXoUNdx3UHUiq/dTw1nSpwHXq+OAY+2i2oebJ3aPAcF+M4nTjSzMSqxkEqt1qJCpchka0hcMf43zSo/mNVn+X6O8dwkJfKjZ6ajCVG9nXiB6eJu1rwBl1Y82jsWoMOYRahYcFb06N6jxDwQJHCNnZ8+eoaL0adCofa3kvrrh2cQ9em9X0H/93qmu/dJV6UGTVr3Xjz7EU5BMPndi5AYJ5bGOGug2sfKMETQsd1ao2WlXdUzfzO7Yk5K+aMdfC8FTw3Zxm+8HEgnPCytsmVcw4xY5czr1KkSmTtOowzzCB9fppun/UeHEPLVlKrvNwfmboOiZ7KiVurnDrDLLNxbWotnRIFisCDVsAQFFNPMN8ykGqFCF/d9KgE6rxwUiWGQOcdojAGR3BN0vbN1YbvLUceSsWf+fwKzDSZeRE9y4NgrsoKj58cW99z8ko5B4VddYFVHcjqeHrKZGlZTWsC1yGyJzCbUGjS8irG7Rmy4T+RFcELCpchEUKEDFEd46d8Bf5Qb8oPP/yQX/mVX+Hm5oa33nqLv/AX/gK/8Ru/wVtvvQXAP/pH/wjvPb/8y7/Msiz81b/6V/nH//gf/zBf4pMag6c733hSCFx1kafTkRfzwsmELiYG55lUEd/SHtchMqHsa2VLZetTI1MAOSjmlZ7I9py4+ySmM8WnKbYq8M5mxZBS+6HXyk9dCs93C1dDz74UbvOCA0QcghBTQHxLRg3es5PKigidsSdzK9CHRJKOnqZ9nb3gMB53EVGYVVn7QHQOc63LcMuecPYEBA8hKasQkNAO+F6NMTm2/5Ux2J/U+izXH9CU6eZw5hhi4PF64MXxxAenibkIa9cCgSZthuvQw2geBI5SGYERRyq04DRrBIsuNb2+mvA4RFKDQBN8YsZ4bzPSp9gCslT58vWGdJx5axzZl8pN/phm0GRjKaS2Jq2RVQ6mdAqaGlN4r5VViPQ50AUlR5i94sy49J5FhWy0MJ3gGaLD+cqLaeGCQOcizntiNAYidLFJimrDOV6k4b/twf4xqs96DQ4xcpFacNHVOvKd/cRH84HjUonq6UNkJ0rMQgGieZwpL+rExZJYS/wkDTyb4QV8dGxDREx41CWia9rVj6fCTy5X9F0EM2qp1M0G0T2Ph4F9Fu7mQtIW/hJcS7qdtbXUnLbQohQ9JSmHWiEb6+iZsieGzNG1jn004+tDQtQoyePVGJwRQvNgfVQm1hq4cIkBTwwgUphSE1GYQPKw/hw1WD/L9afm8CEwpMTF0LPZjHz39panp2OTwp7TbR+kkLInizJYpCo8zxOXIdDXnpQc3reJJNmRoJGgnHHRRZREtHOIEfBou6ZLCVTRUijbQD7Ak25gVuFYG/v/dsqEAL4YHpDQJJOdOZYY2cuJoyiBwKX35BgYc2FPYfLNj/SVEFGghkAIDXIQQsDj+ShPXBG4CJHOe5xXoKC0Cwk0JPLnqcP/Wb//FtcIO95H+tCxGSPfPU48lBP1TLHriCweelVEtHl6zLiX3KRi56Ra51ooa8QTgBWBgyq9MzbBMCoXcc1dVrZjT598k7WJYqz4lh65cpFqRrFKD0zn79PTloQPHiMy+4YgdmfpZBXFDNQvlJAo2ky73gLv9JEYjIhQsjCbEaPHzLjV0mRB569RUNJZmONc85CqM4L7dEd5Z582k/czqt1ux+XlJf/nv/5nziZI11J0YyQ441AWHnJl0WZeVG3j5GEVUXNMRTiUhc638d6ljy3y3SnFOS67EQ2Vvij1LGOIQHSRLnjeudgwdoFchWfHidvDCZc8j1LPpLVNEnLDFa5SZK6VRdvD3IbERXQ4jcxSMFoUd58S72/WuCj87v2eQ6mMIXBFIItRJFOshXIVU4YQWExIzpNoJJQxeB6vBsQcr+aJqxS5Hnq8C/xf/+n/g4eHBy4uLv6oH9+fiPp4Df6f/vtvUF0zPfbmGFeRLQ2xtSst5bMamLWO5mpMBB9aII00Nn/OcOkdCY/gmnFx7KjJscktOK3SSDvBe7oQeWc7MnaRbMrT05HdPiPe8XjoWVS5zZmdCJiwij1LEWapiDWe9arvGLJjonU4eucYkueLqzU+BL5zPHCUyhA8KzEWg8OZZmDOYcHRu8BJCuuQ8AqIksx4Mo7g4WHJDF3ksu/ogP/b//1/fLMGf0T18fr7P/73XwfncdoOV+tz3sI+L9zkykmNQKCPns45uhgIDqYivFoyQ3LoEdYpknzrXIoam7HDOmOdrSVJOxrFQoxNN/Lu9Yp1F1mq8OH+wFKN/bLwZByYRLmZF3al4JPjUTewW4RTKZgKGx+5HBKRwFEqps2DNA6Or6w2SKj83vHIqSobH3nkAtngRZ2ptaVmqoPBRTIVy8Z4Biyk2N6ByXueTwvXfc+TsScB//Bf/Ps36+9HVB+vv//L/+HPNiY4gXVIdDGQl4V9npmqNSMhDs7pzz65ZtatlVeS2fpAKbBJkeg5Bwp5tkNAe2OoxiItyTwF1+hnPvHu1QXjEJhL4cP/H3t/Fmt5lqV1gr89/ocz3clGN/PwyBiIjAQyC5JIkqZ4aVR0Sw0lQUsp0S0QQlmoyVRLhNQJvBDQLyn1A+IFCV5SPCFQPvCAkGipUxRZdFGdTEVBxhwe7mbmZnbtTmf8D3vsh33cIQkSPCLMfIrzSVdudq9dv/979jp7r73Wt77vakVQgrVz3DI1PkVu3FAkslPmdj1h5xxb54kpcaQNc1thtWHnR6BIz1ojuTebE3Pizc2KMaTiebKXvr1wQ6m4kslS0KIY8Kggisu6EjRacqdtkBiebzrmteWkqVAC/h9/+/9ziL+XiHdj8P/8R38aYYorcys0VglCyuyCo99TDGspGXNGEqmUKaZ8sVBxtZR4l5iqUlB9t6hhjSoGbD4WE1UBQkkmQhLQ3J/WNEbjY+K6dzgEL/zAbWNIGVYhsI4DUhjaStHv8wGyYCEVjVBIMt1ebECRaazkVluRkuZ87HEZrNQ0UmAzXEeHT+V9hYSJ0DgyvQ/kVKQ5a624Y2u0TCx9pFHlXJAR/l9/93/8r8bgR7YX2krFQBkwG2IixkJJ0EJSoQg54lO57dj99UohMbIkT1KUiqSgWNQnBI6MF4EYEyonpFSgSkInZcbnTOdHpChGXDfdSOciQiQURQFICImhtPgmVpNzqcgX17SIRxOSL/bwSFSSpBhZVJogBXOti+qLKEMZ3hepzyEl+lgGRNir/CghSPvBk6nWnNYVLma2wVFpg9Xl5x/wajBVhkFENtHT+UQaBNYWS+0qF4MPF8I+GSkW3UoWNQEV303gIZGIorSLhwzNXsnCZ5CiDAtFQCrwObNzHiGKYsRqKAO5QYARmbzftFQuyVujFTFGZIaYwYlMlRJ9TriUqERR+3EhMrUalOLIGSohkUKQKP1PlxMxJTzFjhwJEYGSGimK4lSdBYvKkHJkiJJaGyqtEPFHR5bug8RCW7oUWafAxntCMMwaTY2hkeBywKdYukpkMmX4tlKCWkmslDgVESq/ZwE/AlVOxAAmJYQUaF3UeyTQEdmOIyqDS4nrYURkwdYHtHJARomiUqEQTLRmCAkXwANjjnReknMg7ikYWcAYE8dNzShGTryhkZlK6jL4GItzeKL8TJcSWeW9BnbZ36SERhU/gpxh5QOzSjOzhhAO8fcqcFZbdjmz86VrXkcwWdDqwr3vYsLniE2SoAQSiZECqyUNmlpovPYkCVHk8l+VSRpcTKiYyyC4kCRR6IkxSbpxREuDC46LvqeqNDvnMXlv+p1ARLBKMDWaPvi9oEeh/A4+FA50gkpISNAFz4m1jDlzZCyjiNTSIBGQi3pKpMSei4Ao0ozk4lxtpKLVhlvthJhhOY60VtFYSfpRs9r9AHFqDDuZGWKiSwEXirBAI0sJLVCoWTInkkhFUGUfJ0ZITBaMIpevCUlir3SXBSqnvfJXUTwMQJcTkOl93KsrZq59QEjJGAMbJVBZlmq9kFRCMjOaISZELCZaMWdizmWINxc6jxDlbD/WFhdgJUv3wCqJEhBDZshFyap4BWRGuVdQI+NFcX6upGRhFJkiJlNLSa32g8nvAx/ZhD/EjFdlSCGkzCQLVm4EFEGIvU50ZiIVec+806rYD2eKckMlM2NKe/agRIjELo7cURO0LlYFLia6GEkmE7wkE4ipJmXBzjl8Smx2ns56lCjOehpJ7x0+JhJl+v9dJv06JXwsvOyEIPhEH0a+mCO1kLzWVKyFYggZaTLaZ3YhFUkEUaSjykxwpM3FYtxKhVCFbmFypKkMLmY6HzHykPC/KriY91JtiYHISZbc+ESQuYiACVmcbaUpF0eZkXut9JQyVpbK+jZEtMxIJCIJtj5yTzZoDSEFxhToQqJWEH0k7gUThSjViSATF4NnDB4pFYmiVND7iDOekCLkjBQSsmA3eASRnIqiSyKzHT0xJyqtuNtYti6w8QlnwLpQhvAAciam4pTjAZMVjdxzNdib6sSMrRQhJcZQJGsPePlIPjOKxC4VudSZENy4iIyCRLmw+RxwQaKVQApdKJAUtRGbJZhMkJEkBCkVWs/SO17XU4QpssVJZPocSUIy+gHRRVIChKAPERkzL0bHkENxhkySidD0seiZhxj2B6wi5shl79GqXBK1UIxCMPYeJFRa86Bt2LhEH0oSWAvIo6AwY/czKikx5sxx1rRSIqVC7CmeMUJjbeHRpkj+ETM++qDwbvIyxIjMGSM1fQoowXuJU09AJo0SRftcmSKhWCeo9kZXI7Ek1iITCKwD3K/qIsWaEkNO9KnEXMgO1UsQcS+FmcFFLvuRITi0VGgUM2lY5cCQAkP0kAuVJ8XMKjl0kqAUIUv6GFlnR86BWhru1TVbHxgjSCnROSFdJpHI+4tCloIYigSiEhktZFGDEhpypKkUIQf6IJD5R4fD/0HDqpIIx5yIqcTVNqUy4JrLRbInMsmCURZJYU1JylMEE0FIiLJYlEYEQw4QMw+MYSslOZWCW6GKK2JMrPYsjijL53Uus2ujK4VcjWAiTZH69AkXEzkVSmUCNnstf62KyMuQBEOIpXCmYKEVu1i+1grJKBMmy32Ffy+zub8AzMgEJclSoqVAqOL1W5mS+bqYStLxPvCRTfivBo+0Aq2grhQdnt4HCB5rDWovoSmjwAE/cWtOay2rnUM8L7bDY4osc0ZQLganxhJUolWmLPBYnCq3RFQQtMrSB4kbHCrDNjpuvENYzZFWBB/ZuIDWRb91O7ii65r3/C0hinILRbrpXQ3sjY8sx5H7qqURkpscOR8HtmPkVFnmqSKqTCUTrUgkMg5ZHE5JCGswpiYrg8yZWa550W/w3jPTPzr86Q8am2EkGEDAwmh2eWSMCT9IGqPRStJWhuwgxsR/8/CMtqm52Y7EPmCTAjwrISAJWiRTo8k50BhNItCPkY33haITMzNZ4YgkUVwGV9GzHEeyFmA0LkQG70pVLGc67/ChDC9qIbBGsU4eKUuiL3MZIB9SYOl23KkWBDI33vGs7xlJLJykTYZoi9fEu3MvHojRIaQuG6wUCCWJWdMQuBg8Q0hMzUd2G/lY46ob6A2QYZY1O1/MVaIrFy6rNRWJMWQMkt/92hGNUaw2I/n5jugDGljFkpRUSM50kdW0VqNSZuUcSx9YE9GCMhQpEzkIdFasfSCmiNKSaWVxPrLxEa0FSmauB4/bxx97u/it85QCTImjmIu85zp0nNkpyMgyjLyzGxnJ3NOGuaxx2aNFopagYmaVHVYppkZjrUZXpsSijJzmmmdjxzJ6ZupHR7jgg8TNxtErILOXJx7ZEZAuY42kUgo/ZkYSKcJPv3bGpKnZdQ5zvkYB3ifWORc1ryyZKEtDhTVAUuxc5NqPrIKjoswLhDAQ+4RMMPiAywJtFE2t8CGy8Y5RKLyILAdHTAJkobtNouSagKIYJsVSfSEk6NzAWavZqL1CSudJInLHGibR7jXUI1aClgrvA42RNMagjcJqQwKkVJyYmqfrHZveMbGH/e9VYTl6nAIRMzZJMkXifEBihcQIyRxwCSKBz9+dUGnJpgs8v3bEHJk5SdblLFT7fHAuNRJJKyXXyXPjPWNOHMkMSbNNoXD+ZZnHszEhpWWiFWNMbGJghsQYzXVKuPguHTGxkJouRiZU7K+RRCIuJbromdkaExUhRNZ+4FoK5hjmaHpZ1MdyFhgpGWOilRYlCiU4I8lZI3DMjOZiHOlzYvI+mR4f2Uj1JrALmTAmpnI/dCaLjundqDApcxk8TpdD5VP3b3E8mfD0YsXTqyWXvrwAwmcQEaGhzpon/ciSkS4WQ5mUUjFS0EU2zPvAUx+KvjUJLzMzJAtVcdxahhz5+mZJUoIHp6fYMBb5JaU4rmq+ernhq/01rdDUErTSHDU1by1HvrrcIvcSUJsY2KZIXZXESrvSOZBScRFHZgiyBdsYRhJfX17z768zUwwxFKt6rSRXcfMhrdAnHyvpS8ITM3NZBrOiBC8DMyEwUbLyJbnxCV5/eJvFtOXx+Yq3X9xw5Yp0lncBlz1Kaxaq5rnLLLc3/4HCEDM+ZjCRhSpyq6thYMyRMQZGkYrhi9Ic15aYM9/abukiPKgqJm1RijJKsrCWt686/rftkonWSKVQUjIzNc+3kW9vr/eXhsAueoaUMKbCU6Q9jSgb4VoFWim4SJ4kBDlElrsBR+KYimDerY5FVpv+v/AqHvCDYjCJZfKlyBBLFfHMVKxl5A1RUWfJKhRptpsU+fQbdzhrZzx5tuSdi2+xipmQwOWiXpKkYmEqnkfHi9UASPqYcCkiRaZuivpNDpmnY08fEyOJHZ67puVIGuazlm6a+M3lGoXkM8rSThqUhEpKzrTm3z1b8dW8YZEVOpU292tVzXdedPxb1jhKMaaLnp0DVXtAYqNkLgxJCL6bNhwnyTkBjCXkyPn1lnh1wW1qlBBYoTBS0gv3YS7TJxbX0bF1sVw09wXEs0XLVRx5o65ZaF0q8DGyTZ77D+9y2jS88+Kab55fElMGKRkHT8yOiVYcm5oXsefRixGUYExlZmNiDElGYnLsBsdqGIqMsMx4FzhWhjNqFpOKPif+3fKauRGcJUkzr1FaUivF3ari2xcbfnO35lhaalFou0lkvnMz8rXzkUDAiURHZBnK+6tB0krNQlgC8NxvOUXzzDtOW41LjucXN6SLzEJpFrFC75XQdpvxv/g6HvCD48lY5tdyzrw7Gj21ms0wctdWICTP3nWZTfCp+ydM6prHLzY8unwCQnM81TzuBhKRRipaLFcp8Paqx0pJFBkhBUe2JkkBMbMksPUgkWQk2xQ4kpo5gnndkITk0dhjgNsYPrWf5dBSMDOSt9YD16kwPYo+mkBLw7NN4AlbBhkZc2ZIRdLTq0RjNBWaGsGYMxeuo0maFxKOm9LNfNYNfGPcYoE7ssKIMr/Vv09a2Uc24d/5QFYSFKxzwCKZWsOYEl4mYi4HyUxaNsnx/GLN5c2Oq01P3FdWaylJprjdZgHnsUgh1VFwZBU9GScEtRBsQ+S5G+lThH0yrSWQBJYyId15xzZ4hIeJkYjB7VubZVBz9Du2g6MVlrkqPOlMMSYJThct9ZDofMDFgCFCNrRCMBCJOSODwCTwstCaYt8jZGmrDmOiNwkT4chUCC3oORx2rwqbFItAloAdASM0UyMZXWAnSkySMkfacpEcj54uqfWW601HChkVEzKCRyFEIuXMCzcyuOIibeS70/YJoxV9TLxIjm1KJFk2jwaNVtAoVeIplVhIKTMRYELZkJwoQ99j6LlKnlpLKq2Q+w0t5cDoFFJlvC8XibSfgcEUxYIhJBwRrTNaJiyKtfdc5ULZcCKxcR6nBbVTLLQo8qDywGF9FXjhx1I9leBVRvmigtkHz3Uu5i+BzImy3CTP+TtLbsyWq02HUsXF2QIRiU6JlCLviJFuzyVVUiJywOTCh+6847kb2VIO0MKBldT74lECdvtiRdobKUmbyQG8SHgCu25kHRwLbVkIUzoGIuNyUTiTGUZRlMlczKQYydkwS5Ke0mnICKwstCVH5nIciymOKL4TF8ojExxbjRbysAO+Ijzvh5JsCZBGAJEhOZwPrAbPYDJDiNzRlovkubi4YqMUy01PrRS7oWi2VlGQUOQkOPfFJKtVhmT+w9lqculCbmJxjpZCUSn9ns+MUoogEpswsouhxJqX3DaS2BWapTeJ7APXo2OuLUem2budBnwIbIZikLQRkSFFfIzgE3VdhjXHFOhFIAtQMkGCgcRVNyAyqFRkF3uZ2dKx2O/hnsMMyavCGCJ5L4pUXI4KgoyscKhU3LoXRrJ0iccv1li95WbrMNKSUi5qZihSKHMaF7J0049l6dLnXBTKTBQMKrOJnowiioySsTjPJ8FIIiRFHyJDHlm5oqE/oeSLTgIyF3nhlNCydFUFkiCgx5cZE8r8y5hLsVkDUhZPlZGyx8c9TVbJTEiO5aiIoqiSJcpF5DIlGlnc1EP6mHP4B1EOIZslOULKCSmKs10fE/t5msJ2jolH5yuCyGycoxs9IieE0rQCfC7Jlk1FEkwpOLIanQIrFwkpY/Y8vJgjIr1rqiyRFF5VnxJ9TEXNRJRh4BRikY3KpQXT5cQyempd2o3F4Y3iJCgEY/S4nIujn5DUQmG0ZqEV2Qd8BJNhISW9KK31RCbESB8CUWR8LgG0zRGR8mFg7RXCU+yxjRSIXGhyIoERGpeLq3MUAl1pVO95fLUues39yHocIGUWKBoBXgBkhJdoIjEnFsagEmxDJpGLNB2UNnQoFXShyzClT0VlSgCOkowpJIFUKBWUC/BIoU9YKfEpkbIv358TUnpCTow5lp8nJZXQVFJzbC1LHwgJjFQ0RuJCcayOQNg7aCYgUJSFdntubjpQWF8JxlykfmuxHwZT+b2B/yEVj47aSBCZlATffLEk5MRmdPSDh5RohUAnwSgEQgjarNEiIUmc1JatgI0LSA1qb2LjYxEMULI468qkCSnRxdJp8LEoieWUiSmyGSNKlmfcdiMrIpVU7HJE5HI57YNnohQhZ9x+gNNkSZUVE6mZTSzejeRYZq6Oot4PUmZcKtx+54setRIZlGBL4ZbLH2Gn01eJsBcVaKQq3OYUUKlQKXwuicq0MpALN/rR8xWJxNY5uj4gYkJridIwxhK7Z1miRUYqwaK2jDHR7zuhORdH5URApKJsUmmF0cW06GZ01LLQaa2QgMClTIdHZkmFZu0zu1wGHFfJQYQYiiNqYwQCwUA5sy1lRm6hDZPKsHQjKUWkECy0QToIoXSjxN6Uq7wvSsXWi1zmtvKBUvaqYKQEJd57j0t4z48hFTsaJlpitUaEwOOLNQjBzkd6F5A50QdNiIVqLaVgIvVeQlMw04Zy7yszlMO+WzCSqHLGZoFCEITc5wIKvx9YlxR1n4HAmAQqKbQoCo+7FBBSMYhEKfsWPX1KdDOmMtBr9ipDE6lptManSE4lv52LoiAVk0DGsmcKAYoS6xHKsLrY/+F94COb8LeyvKHZz7NKKfApo94dkBHsecUSKxTXux5HYoxxX7ksUpwKCLlU2Y1USAF9TMxyUbSoEQyp8EwB5koVJZT9Iav3OuXr4EgpvZd4Q6EXCSVQ+ypEBBqpCDnt2VZF319niDkQ9heFSpaNJyc4aStO6wY1jKxHj/cRtbfrdqnosJMzjVBkVRQDMuW/Yn/ROODVoBXlHSbyXsNXlY2h6OAKkBkrFUoqWmO42Q64FPcdnNKCjEXOnEgiZUFFmdjvQyAms3egVMi9SgnsYzCWuFe5KJV0JJbeY0SxgU8SKlF0fkv1s8SryIoWyZjLNqP2igVKCMYUiftpfi32MZgzx3XF7bZBjZGNe3cIuMyf5L2iUMq5DMzt5dozibRX+lE/Or5bHyiOlCHLTEoZUrl8ppxZaA37w6vaX/wqlblcd7gUGdO+Sq4SUer9LNBeek6UA6wLgcU+sbdKkGSGXC6Xx1LvlaBEkTfOmT5FVmG/l8WiSlaolpmcU5EyEAIhioxwikWZyohSxQ1ZkPbKP1mVeFRZkAPcbhuO5zVip9j0nuAL61XJ/F6yprLAZFUqXPs9UO6f97AHvhocG0NW+3QlZ2qpSDkz0wYti6NpJWSp0CNZbgttwuWIzwKjBdkIspBFqaSEMQLoUmCWNDKDksVRhFRi51hZcixFOCskQhRX1KJClijzv4La6PdmmbSUxccmFk3+kCI+lv1PIhCyFCli3qtZiSK3mUTizqRhMqnQnWLZO1zwKKlIe0fhmCJ6f/nV757BGVDlYpHjYWj8VWGhDUkVsYGUMrWUxFwUvpQoe5oSAiOKOtlq68iinNMxlmTbSV+6VKLEmhaCDPQZWpFJqnQoE+VnKMrMiqbMPsksmJRbHpGMTxkXQaai2CjlXjmKohQZc7lcpFiSVy3evbBkPMUULPMf7YFJsLCWaaXACXauqOZlRCnykvcuwAK590uJueS1RpZCDu+zyf6RTfgX+0S8S6nwt5QmxUyj9lNEAozWVLlw9PpUqqYCsHrP+VcRkeR+yjvvZbYE69FhhGBmNQttqWPhyroUuVVZPNDvLba1FGyiZxWGUi1IGSkls6ZCRUGlNVIWk4QUM6aqebPbMpGKSiqyFHgy0UeMLFUzISGIzDYHHswnzJspRvdEdpzHHTGUakIYEyEHGqVZmAopBC/GHZmEyhKdFVEcsq1XhakoVcYxle6S0ooQEzUKIXIZfpSaFDKNMYyuyCRKoNlz/vt9gjLEotyDKtKa3b4tvmgsR8bifeSSER8jt6wlyNJVypSuQo9HjLkoTglASu62NVVM5WCVEoTEREFymnd8pBVFPSOJTJKZPhbFFaHKRSblooN9b1JzNJkgZSTkjhfjjjCWrlgICecDRpWhTYlg40ZSLg3WShajpwNePu4YzS5nlingKVrSmcSZrXAkfE6FI58lE5sJg0eITK3KcDVIRiHwocgaRzI7FSEK1j5iB8dEaSa6tK9HUWgOd419Tz1FCYFAcp2GMhieS9z4BJ87mmFzhqz2+5pEiYq887xwHqskU6uolUIj6MNezjODELn8TDKvL1rm0waVDE99ib9RAEqRgmf0kVoqJtqiEFy7gZiKTnWNwr3f0+6A7wu3qgqn4MYXnfsjY8mixJ8XmZRBuJKxt0giZZ6klYawd9/OMpFTxogiHLukVDDXoQyUT6zBGll0TwK4GLljTOlExlIc0VkUt1SKtGzpLMHt4ynzJEmhOJ0qIfA+UPlc1MOSoFYKYxRWRvoQCXg0xVgrkQlJ8NpiwnRqMdKQwpYL5xiBpDJZRIaUqIRmrhVKCG66nhAzrS7u6f27HPIDXjrmSuKlIMaiJNdIxYZAqzWlK5QhCUSERkAMIEXGAu+mt4MqCovvJrvjPhnfpUKn1UYhdFExm1C6ma3UxH0XX+RS3NgQ38szY06QJXNT0YgMscxgKglDVuSQGX0okvFSkkVRTxNAH0vuoPZSsi5mjirDtJZoJATBmIuggRICL4uSpM6CiTAoAV0MRdpWKmSWxPd56fzIJfzv6so/7gaOKlMUGBK82A58fr5AJ8kq9QwEQoisfGKgtBcTRdf0rKnIORdzINQ+gS4utzkXI6I0lor/UVOhDNwi893Vkj5FRhJjLO28WorSYkGgkySkDCT+wOfe4PHjZwQf8EGQk6RCcu1HfAhEXToDQ44sCcylwebMygUcpZVzu7JYFGO/Yxg9637kctfTZMXGe6bGMCS4CCNXbuRYW7LPDFFAiGidyHtKz0GP/+XhvRjcDCxqTaOK1vJVv+Nz7QydJesQcSmTZOJq3BJKs7HEoJAcmVI93w2JSgpSknjAqqKyUilNDsURd1FppKxY2Ia31zdFJnbvuNz5RJUFMhfZWbsfYBJC8L//wqf46tvPcIMn+FKFF1KwCY4IRFGqAF2I7KKnkaXKsRt9oSsJwa3KoCPs1jv6ENn2Azf9iM2KXXBUosT/KgVW0TMXlpQjwUFOnsEHdEi/5XU74IfDu6/jm5sNrbFYBCJndsnz2aphmg0Xvi8dGySXrisGD0mQpKDSkpN3489HSGV2KALTXHSd56ZCJZhUikVtkUlyp4m8ebNiS6EjxgRpCNRGkvqEsu92XjNOC/7g73qdr735gth5XMqECIhYpImDQKdiBd+JxEUcmWhZzBP3rsBGCO5UNRWCzW6k956VG3gx7phpzdqF0rons0uBbYjcFlWhMeZiwONixAX3W163A344vPs6fnu3YV5VGDINiZtx4MfrGSpJhuTwZEDzYrdFSoWKgpwTRilm+zPYDZHRe3YhkjJMUulOTY1FxUSDYqFrpFJkm3nz5pqNKLKsIUaGbaY2Fp/Kpc+IUkARIvMzn3mdtx4/Iwyi6KKnhE+Jaz8y2XecQsr0g+MmeWpZuvG7GAiAQXC3atBSMPaB7TBy43oux5GpNqy9QxARGbbes82eU60IwSOjphs9IQXSXj3rEH8vD+++lo/6ntZYRAZi5lJ6blGcZ7tI4cBneD6M71W7E6kYdVEcd7s+UgTXS/FiisAhqYHgilngkbVoWSiU59uu5IoeUgRnM1EmdilQy1Jd96kwRH73wyOePd3hvSNnj4+ZLidu+pGZ1Oh9/uhSkVeeSAEp45KCvbz2mQJBYtwFtrEMy1/5kUbCzmdETKgYcUBIiSOtcWMiSUnnIl5GeJ954EfOaffJkyc8fPjww36Mjx0eP37MgwcPPuzH+ETgzTff5DOf+cyH/RgfOxxi8OXgsAf+YDjE38vBIf5+MBzi7+XhcAb/YPivxeBHLuFPKfGNb3yDL37xizx+/PgTb1W9Xq95+PDhD/y75pzZbDbcv3+/8LsO+KGxXC45Pj7m0aNHLBaLD/txXjkOMfjRwmEP/P5wiL+Xi0P8fX84xN/Lx+EM/v7wfmPwI0fpkVLy2muvATCfzz/xm827+GF+1x+FN8QHiXffMIvF4kcm/uAQgx8VHPbA7x+H+Ht5OMTf949D/L1cHM7g7x/vJwYP19EDDjjggAMOOOCAAw74BOOQ8B9wwAEHHHDAAQcccMAnGB/JhL+qKr7yla9QVdWH/SivHD9Kv+vHBT9qa/Kj9vt+HPCjtCY/Sr/rxwU/Smvyo/S7flzwo7YmH9Tv+5Eb2j3ggAMOOOCAAw444IADXh4+khX+Aw444IADDjjggAMOOODl4JDwH3DAAQcccMABBxxwwCcYh4T/gAMOOOCAAw444IADPsE4JPwHHHDAAQcccMABBxzwCcZHLuH/m3/zb/LGG29Q1zU/8zM/w2/8xm982I/0UvBX/+pfRQjxWz6+8IUvvPf1YRj4hV/4BU5PT5lOp/yJP/EnOD8//xCf+EcXn8QYPMTfxweH+DvE34eJT2L8wSEGP074JMbgRyH+XlnC/4Ms2N//+3+fL3/5y3zlK1/hX//rf81P/uRP8kf+yB/hxYsXr+oxP1D8xE/8BM+ePXvv45/9s3/23tf+wl/4C/zDf/gP+dVf/VX+6T/9pzx9+pQ//sf/+If4tB9v/KAbxic5Bg/x98HhEH/fi0P8fbA4nMHfi0MMfnA47IHfiw89/vIrwN/7e38vW2vzr/zKr+Tf/M3fzD//8z+fj46O8vn5+X/x+770pS/lX/iFX3jv7zHGfP/+/fzLv/zLr+IxP1B85StfyT/5kz/5n/3acrnMxpj8q7/6q+997mtf+1oG8j//5//8A3rCTw5+0PjL+ZMbg4f4++BwiL/vxSH+PlgczuDvxSEGPzgc9sDvxUch/vTLvT4U/PW//tf5+Z//ef7Mn/kzAPytv/W3+Ef/6B/xK7/yK/ylv/SX/rPf45zjX/2rf8Vf/It/kSdPnjCbzRBC8If+0B/i13/91/nzf/7Pv4pH/cAwjiPf/OY3uXv3LnVd86UvfYmvfOUrPHz4kF//9V/He8+XvvQl1us1APfv3+fBgwf8k3/yT/jiF7/42/5/c85sNhvu37+PlB85htaHgh8k/uCTHYOvKv7gEIP/KQ7x9704xN8Hi8MZ/L04nMEfHA574PfiI7EHvrSrwx7jOGalVP4H/+Af/JbP/6k/9afyH/tjf+x7/v0wDHm1WuWvf/3rGch/9+/+3QwcPr7Pj8ePH7/spfxY4vuNv5wPMXiIwZeHQ/wd4u/DxuEMPsTfh4nDHvjRjcGXXuG/vLwkxsidO3d+y+fv3LnD17/+9e/597/8y7/MX/trf+29v//JP/knAfi//w//HT5GhBC0bY0bI14LBuc4mkyZNjVCSdp2QsqO5fKG4AMpgHfgkuNi3KF2a6yWVFpiU6StNKe1IfhMlII+Jl7sRppaIcdEzpmLcURaxe9/4x6ndYOPETLcdI6bXUceA4vGoIg459iMgasx8mIcyVry+WlLYzRKS5IQ7MbA3AgIkvN+x0BAaEmIibuy4ai2zCtDkLCOnm2KnBnN8bQhZoWQgsYqJpMpxyca72C7Gwkh4Tz8qb/6j5jNZi97KT+W+H7jD377GPzFX/zvyREEgsparncdu25FP0bunp1yspijVUWzqDEILpeX9N7hh8C4dQzB8bXzR9ypaua1Zlpp5q1FK8G9Sc0YElkIdi7wZLVj3kimqmKMicvRIYziv3lwyq12TogZIWC1cyx3HT6MzJXFqoTzI1sfWfvEi24kSfjMfMLMKqRSBCSbfuTYSMhwOfaMOZOkYO0dn6tmzGtDYzWOzDZFlBLMlKTWFS4CMlNXisV0znSuyR763hNioveRP/mXfvUQg7zc+Pu//Q9/GJ1BSNB1xXK7phsGhDacLY6YtVOUUjSTGpXhanPJOIwMO89mtSMR+c7NBUdaMzWS1iqmVqErxf3W4hwkIdn6yOPlmrOmYWINq95xOTqs1fy+1045nbbEDCJnrnY9l9sOHxOnUqHJjG5kGwLLELkaAl2MfHY+YVFbKqtIQrDpIzMVIGnOh44xBUKEZ33HT86nnNiGutEMIrMJiUllaLWktZKEJgFawq3FguNbE4IP7DYj3ieGkPnTf+3/fYi/PV7WGfzn/9z/ASlAAEIKnl5fMQbou8Brt4+5dTLHWktdt2gpud5c4qJnHCLbmwFE4mtP3+HYSiaVpqk0rRXURnOvtuUMFrD0gTfXWx62Na027JznfHRIo/n9r93lqDEkQGRYdiM3u57sPXNdkbOnHzy7EFilyIvBIaXk9aOGGoXRAqkkfReZ1hKZ4XI7ECj73+Ou4yenc84qg7WGUWR2OTKzhhwSttIl8IBKCm7NpyxOGmKIbHce5xNDiPzZ/+c/PsTfHi91D/xzf5SmrrFao5Tk2eqGfgiMPnA0a5lOWozVtHZKVQt26w0xBEYX2G5HYvD8r48f8enTKYu2xlqJkIlGae61mhQlKSeW48h3b3a8Nm+ZassQ/P4M1vzk7RMmxiCVAmA3BjZuxAfPBIsgsBsGhpTYpszV4IHMg1mFjxkjJFZrfEhMlEQLyU3wCEAieexGPlfVHNUWY2Ek0qfMRFkEiWgkVilsFhghOJpPmM0bUoqMLhMC9OPI/+Uv/b3/agy+EkrP94O//Jf/Ml/+8pdxznHnzh3+9t/+2/z8z/88OgVeO50zmzRUdcvVpmfpRrZS0NqKSldIJWnriqFLKAxCSnah5/nVDUJnUi1wQpC0QhqJ9pExB+4en0KATYg83Y2s48j9uqbWmed9h9KSaV1x1LZYa5mb8jI1tWdiK9a7jonMSFNRK4k1CVVH+m1mkxIRyaKpOZk2VJVh3Y+M0RM7T58MRBhJVNYw1ZZZbVEyMfpAPwxchBFZVeA8fRbYWnM2r6lHzaxdkEwmuoBLHqkEAEKID3MZP9b47WJQJM9n7t3ldL7AVJZHL6558gLOr3ZoDFpYKqvRWpC6TN9HfEisVj1vP3nOrLHYVrMePAORoOFIWToCZ7MJZMHKeZbjlut+4O5iyp12wpO+oxKWSW2ZNw1Sa46mLUJAax1za1n2HRUCYwX1KKljxobEmsRFPzLGzLGSnE4bJnVN5zyDH0k+0RHKpkhCWcW0MbRWk3PGB88YPFIppMyM3cjGJbTVnKoWgmc6qRBBINOIcwFyBg4x+IPit4u/5Dtev3Obk9kCVde8fX3O1eWaXcxUqqJSFqUVlayIY0/wmRwF213Pt568w/GkxlaS0Qtk1uXQsAIvIncXc0SS3Aye1WrLZki8vjCctpZt9rRSMbOGxhpCjJweHSGEoKkb5nXDcuipxkRdK8ZOUceADp5l6ljtHFufmNeZ40nN0aRlHCOrcQ2jYpUcziVyjlitmNY1TaUJOdI7zxATUkLygm7jGZFoqzlqK7LzzCeKFCENHSI4OOyBPxR+u/iLbuBTd29xPJuCVjRGsFw7HvdrcpQkL8gSyIm+H+g2I4HEarvj7afnTCuNkLB0kaAVUgimUuFF5P5ijkiZq8Fx4zv8CNOZZtHUrGKgMpqjtmYxqQE4bluEENSVY2Irun5AxURTGXZ6pA4REwNXKXE5eFofODaCh03L3UnDtvJso8Nk2FrFLkWCAKMlk7ok+13yrJxnSBEZE6vNgLaKqCW11Zw1luQ888mUFCGOIzJ6hE7AIf5+GPy2eSCJT58dcWuxQGvN/MLy4mbLi6stNldYLFoqrNSMrmO97ckxsel6Hp1fMasNttLsEgxupBGSe60lmsyDkzkyCq66nuXgiAFOqoqJtby9CWijWTQV89bifOJ0NkFIwcxHFmPFZhiRXmJsRimoY8KkxDJlLtzAJCdSztyta+5PWvrgIWaU1AyjwKVIIFNhaI3EWMk2OTbB41PCGhh9ZjVErJRMlea4spAis1aRk2CHx4sIJQT/qzH40hP+s7MzlFLfIyd0fn7O3bt3v+ffV1VFVVUA/PRP/zT/4l/8CwBicBAceEEg0I8dV5dLrl3g2+M5MSWMBltrZIJlnxAZaiFplEblQOcCPZKEYio1d1uN04mkFDNrudp0XLrANgiqbHBxwPmIRTBRkjEGlquOz9y9jVGqSCnlhBCBODjqScMQMkSHkomJNXTOM7GaDERASklrDJ0L+JCwaFoJMgdigMoIssisvGf0ESUUt9oabTVjH+lIbLvA2HvCJPOpTx+hjUBJEFkg4stewY83vt/4g98+Bn1wiBDIfmRMA367Znm95NGza7721pOSLM8qhIyopHjr+QpSptGGeWWplUYK6Hxk4wK10dyuGrY6kJRhri3vbK9483rF42XHF25PGEMg5EylYCIFyWXe2Sz5/GstRmtME9FohGjox5G6buliIGcPUmC0ZIgJg2R0idFFWpvRUpKzIIWEFpJKlWp/zKUX2KeSbPkYsUIyMxWeRO87Oh9IPhCTpIqS2/dbtBRoIYgoyOmVrunHCS8z/oIbGYeOXilM8ISuZ9huuOgc71xeI7XEGAUCFJHz656UM8QIWSLRhOQhG5xQSFVxp7GIRmJ1RaU1b2173rzZctEHMpmdH0kiMrGKuTU4F3i63XB0dIpVisYKRMoIkRijo20bYsiMYwIpqIwhC4cUks5F+iEyqzIpJXLWpJwQWZR4FDBPFoWmI3DTO3zI1NqwsOX1WA+OnQhoBzpLlmLEuYjWEpRESImKh/j7j/GyzuDQe3w3MkiFMAoVIturFc8vl3z7+TnKCCat3lf3gwABAABJREFUwViJUoLn1wNaClqtqFAoBDEFhggiJE5RPKxnuKokU5XSfGfd862rDY/XPb/raMraRVzINFKyMJqUPdergdPJHKs0phIYIgrPdog0Tc0QIiIlZBJMK8Oz3uGSYOUjpz4RI3QxklMm+gxSEDOEmJhoDQjWOfKo6xmCZyolISuGwRNVIiYYYkSGTCs1D1MqXTchSChifuVL+rHCy9wD4xgZtx1bBNpo/LZneX3Ftx/f0LmI1IK6NUgFxsCjFxsk0GhFrTSLygKZISe8iyhleK2dYicSZTS1getrx9cvNjxdD3zp/glr7xhixAiYyMLEON+suXc6wyqFQaKSJsdIFxJVZRmcIySPAhqt9yyTTIyCmAUZwWYMzLUmRQEIPIkxJyohkcAmeB71PWNOHBlLIwUIgQuekYgnknyitop7YYZUEiUgiRKL7wcvfcLEWsvv/b2/l1/7tV9773MpJX7t136Nn/3Zn/0vfu+Xv/xl/s7f+TsAPL/Y8ujJFc+fL3H9gAoBtj07l8lGomqNl5JN73AKQo5IItZK7LTFNjUTa6i0whqNMZbGtvy+Nx7yYDbn7KjGa8kygWkNG+e4cD19zjRKspASHwL//vySJy8u2W074ugRKVFLyZgTtSptHhcTu8ETY6IBblLgyThw3g1cb0bevNgSY+JqcGxSwkuB1opTJYkp0RP4+mbLv1yt+Ha/49TWNGg8oBO0QmC1ZNPt+O6bl2zWDkJGxEQMh4z/P8YPE3/wW2Pw/GLDm4+f8/T5C+LQAw4bPZt+pE+hvGFDxPnMLiasMUwaQ1UrkpEkCxPTMKlqZraiVYasDL/n4UPuHjcsjhq2OXE+DEgrAcM7w8AuBVAZYyDmzNeuL3ny7Dn9ZksYPexjMOaINhkrYPSBlfNY3XJsLVci8jQELnxg6TyPVjtiiFy4SE8mC2iU4ndM5/goiMDbQ8dvbjd8p98hFIw50yWJNIZprZmZTIyRJ49WrLcdMUekSKgUXslafhzxMuPv7fMNX/3uM95++hznNlSAcwPrbY/WhmnbgsgsdxvWbmT0jjh6iAldlRb4fD6ndyPRjygJsp7yUw9f59a85XhWk4yks4LqyOLIvNM7NiERySglEEryrT7z5tWGTT/gRkdygSpLNtGTyQQZWAbHTe9olebYWjqd2QrogT4kniw7YpRc9z2RhFGKha34nWdHbONIJvN0cHxt2/GtXUfOpeMUUJgomQrJzChCGPn2dy5ZXe0QIaMFpHTIuP5jvKwz+O2rDd949IJ3nl2Rhx5pwfuBdT8SAaE0LgpSLgVGKyVTrZhYjak01ApRK2SWqCTQSJrW8vsevsat2YTj2YQuCV4MHmkVUWmWw4APCSEkSkpizHxnu+Htq0s2fUfwHpkSrSrxl3KmkuByYBU9ra243VRIAUYqkpBsUuKFC1hlWPtMVpLaaE4ry+85OyaKjFWSF6Pja9uer217nAtYqxlSqYhMpeDEaGJIfPc7KzbLSEqQRMYf4u+34GXuge9cr/nGkwsev7jBOQdA3EXWO49PmSwEY4y4EOl9QApBrRS11kgpibIUTTsXECPU0VLblt959w6325aj6ZQuw4UfEC2MwCo5tn54j1IulOSxc3znxQ2rrSO4csGspKQbt6SckRL6WM7gWhvOdEWN5o6pWWhDJLMFrKrZxRGhBK2xnJqK39FUJCGolWSV4K0h8N3eARZjLUKAyZlGClotCSHy5NmS9dYRU8l73+8Z/EooPV/+8pf503/6T/PTP/3TfOlLX+Jv/I2/wW63e29i+7fDz/3cz/Ho0SN+6Zd+iRuVebZc0e62fCp5bjUT9PGUyW7L0+uOdecxWvJjd4/xy57btcWaclt32w2NVbSdJJua3GemKvGZ+xVp3OKqKd4r+jETXIKcEEJwfDzh08ZikVipmUnLvah5dr3hqt/iXGLsI5HMW2PH/c2Ke9JCzDRSMa0rbrUN5wQSmcvdwFuXS6xRUE15GhNvLCbcWTRUVjIseyZtjQaWY6SSmkzm2zcrHrQTvr7csQ2eT00afuqkYkPkX37zMfEtyWfvnvHwZMG0Vq9iCT/W+EHjD/6TGAye50/POV1t+WK8w63pnMnZli8IwXcv1lzvRkY/8PBkglWGT70+J4VANzp67zEITtKUJ+6GEBPtQvH5Oy24HmgIJIbRMw4BmQWV1cxriyVRSc3UNiyqhi/YGZ1zPF4uGUdH349EBI9Cx931mntGUSE4k6UL9eMPb3EVIgnYDI7z5zsm1hCU4bvLDfdvtdw/OmJmLOOu5/akQQFjSizsSEyZf/fimruTCU93I7sQeTBt+NTc0jvH2y96Hr2As8WUk3mLasyrXtKPFV5W/OXa8o31jhchMlaWE9syv7XgmCXPlms25xmjJZ99fcHq2RVvzBtCSnSjZ/ARZeF0q5gdHaOM5bSqeG2SuLp+wWyyIEUYR1BB0CpLKxuO5w22TpgsaamY25afsB27zZLHXaIbErsxo0zm0dhzPvbcV4YTYZlUmqQUP76Y8WjsiTnzeL3l2xdLbhvLSM3XrjpeO214cDrhuLGknef2YoLCsPaaRg9k4DdvLnmjnfA0RlwIPDSS141i5QZeXIw8uVhx63jK2XyCbQ574H+Kl3EGB6v42nLN09GxJHOraTl7eMxPTDTffbHmelsq+nPbUiM5e+2InDJu9Lgx0KqKz+tTujNQSnBnWvFgrul3W0LVIIAxFTqCRaCU4GQ+5b4JtFIzUzWt1DyQFavYk7eZrnNs+xGlNU+6kZsucFcK6iy5Z2qauuL3zo94FEcSmVU38nS5ZWI0a234Zt/xY2czPnc656iquDhfcvtkQoiJz85mnFhLJvNceM5aQ3eT6JNHAw/ahtW44+pix3eeX3PnZMGto5ZJc+gw/ad4WXtgbwxfX6059yNbFbjbzJnfmfEFHXm03LAcRpQTnNmahTW89voMArjR0/sRpRS/oznlfLUlpEg9SdyfZFY3S6btEUInhjERuvKzhRDcmrfcn8+ohGZqLDNt+YJtWfU7RudwQ2L0UM0sF85zfXHNbSWZS0VTKRpr+alFy2WIZGA1eJ682FGjWOueb212fOp4woPFhKnVbDYbbtuGGBWf9oGjPUXx292aE2XwXrCKkWwER0bwYjfydByZXW85mdccTRukfH+p/CtJ+H/u536Oi4sL/spf+Ss8f/6cn/qpn+If/+N//D1DHP85/Lk/9+f4pV/6JT5z7x6ISKsVdxclkUpj5qobUUKhZUKJ0qDYxYgYeoJTpCyIKTPGmkpqCKUierMV/Mt3yi3owSLQC8WzrqOLAZ0yp42hn2qEjKQugId6NuHeyZxUJ0bnCUkwRsHKDdyuKubSEENGI9ACnrmeXkSOmwYhJH0ubZ250jgHO+f4xjJw7gfuTmo+1bRM24bgImfTGdOmJuTAs+UOcmY9BBa2YmFroixBkDOMY+D5xZY0ZNr6Qx/D+Mjhh4k/+A8xeDw95mhqub2Y8cbt24icmfmGdL1FCImRCqMkk9qy2XhqKfAx4WNGCsXNzjE1gZPWEDEMOfM/vfkcgM+fnrEJI2/frNn4iFWSWVWzo/ABU8oQE3UlOT2ag4E+RAYp8Cqzc56zpuFM1UTviRliSly5nmuROG5apICBQIwZkwXORdYuEm46Bh+5N224axua1hCd5qjOaNMwxkBKK3SMbHxgUWnmVuFTwpGJIbHzHh8EXR+p9SHh+o/xsuLvqJ3y2skRd+ZTPnP7jMFHUj/yvKrQKmCExwjQLnMzDoViFTM+JBSC9RCws5pKF/rW9a7nf35UJN/eOI2sc+DxbscICJE5ahVrnTASkkskkahqxe2jKchE50cGmUkyshxG7rQ1d5sa1wVUigTgcd8xT5pbsxopBC/EUA6+Grp+ZOk9cZ0ZROT+fMJn6hlTKxiT4t58xqKpcMlz0XfknFkNgXml0Eqx9oFthBBgnUaGq8R255iY6tUt5scUL+MMvnt0ysmnGha15qQ2DM5zJKc8klvQZa7CKMls1nC57tFiJAfwviTAN93IUaUQMZKT4GKb+Z/fKR3pH1sErqLnreWWXQjUWnHUNtwwYPZxnMjUpub+0RHKRsYUi9hAhJswcNJYzmxFt+0hJaIUvLPecVQHbs0rpBRE71l3eU9x9Gxc4K1VR8jwcNJw3FgmFoakeTCbctTUpVLb72hRbFJPqzVaadYhkaJkw8j1rmcboXOB6eEM/h68rD3w7tExbaU5mda8cXZU5j78knglyEIjZKGrns1abvyI9QEfIi5FhIRN5ziqNEcTTRKaHvif3r4A4DNngaVzvLna0OdEg2bRGm4YkbKwJ6KAylacHjVMYo1zjixhEInrXUfTNsyVots5RM5EkXm+3TGzhjuLKVIIxphYyVzmqVxm7QIv+h6t4KxuOLEtdSVxUfEgTTmuGoaU6LoepSRdGDHKYKXGx0SWGTcGnnhP7xOuj1Tq/VF6Xlmk/uIv/iK/+Iu/+AN/f5IRLRXTdsKd42OW2y0jDqUkVmlqndFSoIJjEx2NqiCV1mKWGpQiikgM4FNkGDPdDWQlWY5begQ3YyREgZKFC9onSEOm8VBbidSKxWKKMpmL1RaRR0KKrMZAJQXLFCEKKgqHUSnJvK6YNdV+eEJQKYWMmWfrjlXvsEmRyKiU+XTV4LY7fJbUUlBXFUgLfcQgGDLUORNyJgJjykgEE6XpnOPZKlJtDsnWfw4/bPwBPL9YQppx9+iYs+MTur6jUYacAhBRMqMVtNbwPO+YCo1QAplkGaAEooDBR0LOdD5wvRlIwHqXuBp6nqx3jD4ihYAsWPodjVBILfeDs5qjWQUC4rZHpEwImeXomCvJVegZXEBm0LIoUpy2LdNKIQBFw0RrREw8XQ/0ITERGp8ymzFw30K/HQCFFplZZZhKg0kOETJDjlRREhJkJJlMTAKRFKvBsfORShxi8D/Fy4i/y+tr8vGMB7dOuHV2xs1mSxeXKAlWCWot0UpAdDgBSQkUkFFEoaitRmpJVBLnI27neXo9kmTCy4YuBHZZYGxFDpEcoc+J6CITFJNaIqVg1jZIE/GbROoT/ei4Gka8ENgEm9EjcsaIwl+9NZ8yrRVCwB2pmBhLDIEXbsCnjNKKkAXbISIawc16RCiFyTCvLFlpbBLILIgpMQQYYyRlg5QSSWKmLCvn2fotjexfzqJ9wvDDxuDzqyua+g6vnRxx/9aCm3VHXl4jMihZONNWwdQoHqdAlhZtBBmJSwlbSZCCkDKDiyzHyFVfqJA3G8d1HHm+60o/PMuiwjMGopdoI8laIjXMZhar4KrviCLT58h1NzBg0TFz4xw5JawqZ/a0tsybCikEKWZMApElT3cjXU7MclFaucgDp4sJ3dYRlKRSAlNVHElLkyIqQsjl3I05owCkRAfFVGZWo8MtM3Nz2P/+c3gZe+AmjqisqWzN2eKIoR9oZFGvkTmhMxhg1mjOXUeSBr1XBnM+okQGLehdJqTMLjgutwMZyWobWTrH+a4rQ7I6kWPmenTUSrKQlqmWSKmZt1NmInG1Koo4MUfWzqMRtLVlGQqlW0oQSlDXhsZKpBCcTSwGiDHyoo9sY+R2EvQ+ck3P6WTCrvNkkaiUwFaGLCS7nHFE+pgICKIGtc8rcy78/Y1zjDnQiPfHzv/IXk199kghyEKQlUa3E46Mor7eUZmRGBNKlsUwxuJz4dInQBuJzhmfAwhFVpqQEoNLRJHwY6ZLkTEmMoKgJM92npsuY0JioSXGgtKKiVE8X295uvTsRseYPQGIMSGkpDKKnAUuZ3KGSmkmxpJJpEqTsiX0kaOJ5DRahJI0StEgcc6x8w6ta9CSnCDuOwIxZ+40NYZS7d2FTBICoxTGKMaYiCHRhUM78VXhYnlDwnN6tGBIGVU1nC1uUVfPqIzABYEUAp8ytrLsXCClRIiZmKAxmiQoVfGUiDHjXGQIkdYqrrqB3gV0FqgseOtmy+W4wwjF2CRqWXNPKJpK8+R6w5vPlrgYiCrjc8Y5j9IKlCSnTKBUO9q9DGNMiaglwWhi8pzMGm7nyLRStFpjpWJwATd66koTpCTtx3qmWhNy5lZTU6OQSdGHcomRQmJlJsRIjGUDO+DlY9vvSCJx6/iIPgnqdsExnvr8GqsEXgpkOfq4dXwCIeBjIEqQ1tBWlpAigcQYY+G6+kwQklUX2DlHVAIhBSJJnnWBmzBiJUSrmFYCrRS6Vlz7jpWT9FGAFEil6V1gQIEQRJkLjxuotaE2ihgiRmas1vQ+cbaY0hOYWM1EahqhGL3nfNNx1DRkIYg5kxNMpSHkyK26QlIKHT2QpUTLTKU0q+DpU2B0/kNeqU8mzlc3WGs4mrQ8vHPKZHEEAmYvLpiYooZidDl/752dIHzhUkcFUhnaWpOGRJKCoARjyAwxFkpOyCzDyBhTGYTUmreXPReDY6PAN9DIIg+stOZi2/POamAzjgw54GKE0TFkidSSlMogrkZgpMKqMlRZK8Wsrhhc4njacIfARJf8QKTE4D03257WGlRT+NKkxExqQsrcbWpkztRCsqfz0wpFbSUXLtA7R3IHdZ5XhU3uwUuWY83GO5QynC3OaKtLaj3gfUILGHNiNqmLwETKRfLVRSaNJAJBgAdcjPQukHymEYJ1cIwxoaVASPjWiy0v/ICSgrM6UYmK14Sm1orn3Ya3r3eM3pc8Miay8wSjkUrgc7lUWKWwSmIU5JyplGJW232HLHPX11RCIlKRmnUh8KIbOTINqhYlBsk0WkOCk3d5/EKQKLHWSMVESi79SOcDLn3IFf4fFlKB0ok+Od7Z9cxmM147ucfbFyuW2x0uBrQ0yGbGbRpWmy3bwZNzZiokOiXG7KmqGmMtMid6N5J8wGhDcp4QAilBFpJ/nwS+84hacDzRqErxBSWQEn7z2TXffLKlsoHFQjBtNSoJjnXLnVmDS5GLvmc19Ky9504WuBAZg8eRqIzlf/fGEXdXhqv1QJM1J0bTu551SBzJXKa0O8e2GzmTEq0lv+f4iK4fGVLicozMa4UyGqkFU6kRSbDLh4HJVwWXHZebNd89P+fuO894eP8+r7/+eU6fPGLZ9aQIIQhuBse9+SnfffaMdd8TRaZuDI1sSTljrEAlQ0oZrTN+62h1zWjKsFdIpcL/vzw+R/cgTOaqHRBJ8eP3b5Gl5DffueI3vvacxUzz8MGUttZID3NVc9rW+87TyI13bIaBk2aGc5HtUKTm2qz40o/d4c71hot1Ty3hyCo2Xc9uTCyUIOZEFwM+e+7oCgP81NEROcCQMtdjYGpBaUAIpu/pEh8SrlcBVWlWuy1vPn3O6ckZn3vwOR7c+zzfevqUm1XHMDhSlATV8LvvnPHvH7/NjXcIKTm2BqEMq2FJzqmoKWlJO7OQDTpngh8ZhoiQispUfG0zELYDTWsZ6khTJb5gFFnD08uRJ8uIloLJtOJ+U7Pebpgow1FrCSpz4x0Xm6LTv6gWDN3IchxZxUiVBD/7mbvcWxleXOyoheTMWnZ9x3V0TKhwPrPejbgUuGMbtM588WRO9pkuR65TojGSWiscCaMFMQrcoejxSjAGx6Pz52QS1bTijYcPePDgDe68uGCz65EJtKlItub3vX6Xf/uNt7nxa7IQHFcVtVJcj2tUq6kai5IQRWS99VSmoUqKnDJCQmUsv/Fsg/WeoBM3tccKxY8/PCFL+MbFkm+f76hNYtHC3Gpyglpr7lfFp2HlAhfDwHZ0ZF8x9CN9iDgEWUh+9tOnPLioeGu1pBZwZhS7fuDJOPIgC9rK0nWeTddzgkJq+L1HC2JM9DmxjhlDplUSpWCeMmNMOH8oeLwqeBnYhI5Hy0hWkYe37vO5h29w6/lT1r0j5ZEQI+e7gc8+vMO//dZj1v1AihmbBJVtyL3HVqqUsqIg6IRfehprcCqTPaQYAcE/ffOSqVZ4kbisB2RS/MSD2yDg68+v+f9955yjVvPwbEKrBFYKtNa8Zg3eOdajY50zzhdJzmFIjDHjhUBXlt9zVHO3Mby92qGRnKiK0SWejgMT1SCFohsD225kqhQKyU8cTYmxFG36XKjslQGbFW3UECLOf4hDuy8DLmaQmSH0bP0Fs7Hns/c+xWxSURmFVYJKyr30paCaNTgRCd4RZaQnshlG9G6HrQy2qpnomiQM1mqUiEgHORa6DCYWg63R83RMWBH5bz97RsrwM5++U3TWh4EJUE8s4SazUgONF0yMYV5bLoaePjpWrudqO1AZzd3JBOESLsD9eoZfBnrn2eXEcW0YARBIKTEITEg4DURwLoEQJAU76XCj5mZwNFKQUybljDuo9LwyCCXBCs7XS379X/9bXru64M/+d3+U2ydnXG86/LhkzJ6JbZhMJ5ycHBNWgt04EGPat/zKMLZSGoVAisTMVIwKgpEMPjGkQG01jaxY+Z7jiWXjAs82HWgPGf7A5+4StiN98ExRzJqGXYoMKTG4jsYY5m3Fqg9sxMh1V3G96qis5tPHC2QsG8K9aYXb9vSjp0+R48oQ4ohzHpSBlMn7GGwVxBGSTDhRJMjSqLlOfVFQ8ZEYE84dYvBVoLUtKUmuNxv+l3/3b3jr4in/1z/8f+Jkccz5akUfPDnuZ3uUZNbW9KMj5UStBTQSv4a+H0EqjNVYo1g0U1IrSXFEeAlZ4oHaagZp2PQ9O++wlSxyr8DvvDcFt2aMhqYxaKX4xnLLphqoA7TKcmwrNtYRdWbtA882PW1l+MKtBWmvKPawPmKlepZjR+g9b0wa7lBDzOScURl0ykSdmKiKGBNRZKQo1bJx9DxzkZwjbgyEEN/jjB/wcpGzJJJ5dn3N//iv/zdeO3/Cn/3Df5TTo4YX6wqXQ6GPpcR6s2MytWTd4vb0sFFKVqOnlgmtNVZqlFCMUnLV9wzAGAKkDCiOFy3XNxlrAldx5K1hBySImZ957RZaGno/MNUwnVR852JDnwISyay2VI1mJxxRe9bDwOVupKk0d2YVwQViiNyZtzxebVkNI1YIHk5q7gTQSiJEJhMIOJxumCsJQuIFEMDHyDZ73uwdMgtSyqWzerhwvjLEXUBqybLvWK86vvH8kh//I/9Hzo4XXG97xpDpvSOpzMr1yKlCS0kcIjhBHwP0MJd1UdHThmOl2M4MV9uBXS5d0XeVvqTUdAnaVnHjAk/WPVKV8+33Pzhh7Ed8yizqmrbVvHjW46wja0WjJKqtSAScEPQucbkZaSrD6aIh7c/J40XFo23HenDUOfNw2vJa1ZJ16W7mkAkhEoFWKaKKxX1RCEIM5AiXSHADaxcYUpEcfT/46Cb8zmO1Ku0RIVivNzxbXmCsZtJaxjASU+LF8oZu02NqRXB7qayUSUagYqHv9M5RjYH7U8/njo94MyYmogIE3eBw3nN5PtJoSSUTWQqs1kgMCLg1b/j9P3bEo+WGa+eplOXfbJ8jI2QVOA41Gs39yZTXb51wd36ElCu2vmOXRm5XLTE6xtFBSlwPI0+HxE/bY24pyeO+p8kSlaE2gmAAEqP2rH2gFprXRcuLrmcZAk8GjxbQKIE5KIK9Oshy4Qp55GYMbN/s+Nqb3yALCTLjcAzJ0y1veHxxw7Qpjrs1ihwE0mbU/nLWJ4fRktfmFQ/v3+KrqxuUTlRaQcpIIbjZdFRS0hiF0ZL5xACFC302m/HffvE+T1YdN2OhAf3mzQusNTycVxylilpqzuqa1+YLbs9baq3Z+RGfHKd1TYoJP3q0hG2OvOhHWtVwq614uhmpdKQ1gkZV2LZ4SgTtGYei3X/PaC58JCJ5tNpByrRa0MpDS/uVQGQmjSWnREyRy6sL/s03vkrMiVuLGVrCchhZDh3X33iTbCIx+cLzFIKqMggRSQJiSMgcaJXgizN4rg1UM3abkW7j6EeHHwPSBaQOVBJqkUmpULwaK/ncmeH5buTKDaRR8o1hTeUVnz8WnJhMJSUP65a7x0fcOT6i1pptGBhwnOqKGCPj2DE1go1XXDvPfdMyVxUv+uJ2fmQs2VdIa7l2RTpjGzy11DzQFc92PZ2KPF8OiBipJdTypatLHwAImUhC0YeA2+zYfKfju597ivKWad2y9YHeJdzo+ffLJ2gNORcPCK0V7USilSTHTOc9lYi8Vlt+14N7/H+fX7ELHpmL7KEXMPaOmVGgir30RBf1LyEEi7nkdznLW1eOi84TlONrqyVzZxB5wnHM1Mrw6ckRR/OGs0mN0Rt6F/E+c1wZonN0o2NuoPeZ573jTlNzUhmW44geBTbDTNbYtmLdjSibuOk9GsXdyvD2OgCKb6131FJwZBVze+Dwvyp03tGohJUKvGK36Xh8c02rplilAAdEDDWxi7RohKkIOZJkRlqJRJJkJnhPYxQPjxru3a759Scv2G6LlKetNEorxj7SWoO1mWklOJ7KffUfFrMZf/D1wNvrngufGIPi37o1RxvJ54/nnAhDheT1asbRfMqibTFyzeAcbnAcNYqYIt1u4Fgrkk5cx8idGGmrQjeSQpZZulqhlKIbI6DYjA4rBHdNzTM3sI6R55sOgaCxkup96hZ8ZBN+7xLBJpQKRJXIEd589DaVSjSmwoiRbnTUypBsYhgGJkajtGA3erSxpBRACjRFy/5ESKromAyeu0axazTPleCdtcdLOK4MSgYmteLIClbrLUfzYlW8WDSI3Zbz654Qes79yNwqctaEqMgITmeWo8rSh2JglAOkBDdi4Lit8S5wMmuoGsuyH3j7eskbx0ec1gahytBS1WhGo9isV3QkjBTMlKZRil2OmAhGCu5NK2ZW0+0OdIpXhRzLEE8UAmIip8S/+PrX+LG7JxxPWrbtlNB33Gw7+q1nPBo5m7WcTqalypU9cV99VKLc1k+N5biGT8spNZkXpuedXc91ihBhNqmwWrNoK46aiuW242Q+AWC+mKBGx/VmS9cVlYszJTBqAhSFoJNomWrLehdYdY4QI7WGpd9xphV9iMzbCVXdsB5H3llv+dR0ymndIFRCKYnUmqAMfRjoY3hvQLQ2Cud6+sGjcuZWVTOzqpg7HfDS4WJG6oy2Aqs0QkS+9s7bfPbkmMYY1koxDJHW1AyjxwOn0wmVkoTkGXZbcoxU2pAVTLTipLII79Fj5HUjcFXFJYq3Viuih0lrcaOnJTNVkcF1tHVNiobJZILfeR7frNiOI9fOc6sFkQTSKaRUzIxigubF1YrL645Eoq0UN7HneDEBLGdzzaSdsOwHvn2z4rOLBQut0RK0Ugir6YQghMQOmGBYCI0WglEFht6jU+JWa2i1ZBwPHaZXAwUIcizKO+OY+Dff/CoP7t5iMZvSR0fvOo7mc6RQCKWotSCFwKobGXZgNaAEIgkaKZlUAqMTv+POnFpmloPnfPAsfcKRmAqIInM8sdyaWTbOs6grUoRJ0xBkx+NNx+Azq+ixUrEMnpxgriKv2ZaKokh1042klJHZsIvQNBLnAkeyoqoN2xB5tBr49Lxmbi1CFtZAU1VslWATCsVRR0mjJFJAkIGrwXF/0nBsFJUUxW38gFeCFBMpJrIAQZFP/8bbj3g4azmaNNx0LS4NtFJgFey2pds9rSwbRlplSCZRieJ9NLWahTJYAV+8O6fmlItu4FnXc5MjM9lgRaStFafTmteOp2ycY9E0AExnLXHX8+RyxdpFts5TIVkPEWOK2MYRZZZpveu42TlyisWlOiWOJpoYA/Pa0piawQXe2XY8XEyxSqAEKGXAGDYpscWxdiM2wUQZJOBy5to5Fk3F1AiUzAzjx5zS4z2ElDE5kLPASsn51QVGCSSJSW3YjUVr12iNlg0Pj+dIMt985xnDdmCOLC5sUtJoSWs1Wipu+g39KDiZT/idJy2fP2757nXPTArOtxtGF+nHSIwgZBnIMFWNNBYpYaIEf+C1W+QsmGsJOeHJOB94cb1mFSJ+DLgQkALuzqe0bY2xmpv1hjGMrP3At3YdbVUjgHlTU1tDluBTom1akvOMwbNygVVMyJAxQnCqDNOskPvX6IBXBUGM+46RikSV+daTt7leXXLv5IhbiznL1RaZKTEi4fWTI2ZVxbefnZOi5MQomsoWnrQWVHVRc+qGwrW+N5/y4NYRo0w8er5lZipWoSOmyBgCMSWEsEgZMZSLIUArDT977w5GSOZS4nNgTIneK57drFg6RwqRmDI7Jbk3a2nqGqEU212PGwZWvufr/Y6JkYDgyFQYa0BrfITWVgivGLzjOowQJDkUM7hTZZhoiZIwug93lT6pmLQVUQQqIzmeNkBkt73mcRy4dbzgqG1ZrnaEnLG1xQrJa8dHGODN5+f4wbFAUVcaIQRagbJFYuVmt6X2ktvzGXdnMz590vL8qqfSkjevOvrgWQ8O7zO6MaBBSksWkpwjMyP4g6/dQmc40YqcC+VLJcfzZeR8DJAiMWe6pHgwnzGdtoQY2W5XZN+zG3u+Puw4seUwPTE1lalAq+JYXtfkmEghcBlG3FgcfU2EY10uFjoJ+nSgVLwKVFIjtMTlwOgdKcF3nl1wue15486cs8mMTe8ZxhGXIidNxZ3plGEYeXG5IjqYG0mrFZLizG00KCnYhZEs4XRieXAyAal5MWRkCDxZ3+CjZzM6Rh8RjSrOtsaUyonMHNeae4tTFJKJBh8KjWwxBtyqY+ldkWeMia3zvD6f0zQ1WmtuNlt2nWPrHW+NPUdDSYOmtd4nbQoZAqeTBu0cg/dcO8dzl8qwJ4KJkCiKFPJ4OINfGaygsBhyEarICL7z/B2ulhUnVcVZ23K13LAOnnU/IiO8fuuIymq+8fQFOmamRrKwNWY/GylyRkrF1geizJxODPeOKrKRXG8UCs+Lfstu9Nx0DudBtAbIKK1BSoQQ3K4tnz6ekkJkrjRk2MbE1AfCZsd1iMT9IPvWw/1FS9s0oDTLTc/Ojyyj49k4MhtroKiUGSNAC8SQmNUN0nu8CyxD4Nw7chBUQlCLUlBOWRDyx1ylJ+VMEdmU5FzkD3fDQM6Zk0mDrRTGwhgzViiU1FRNBcFjVGnzzgFTK4SSWClRWrEMsbQiBdwSmYezmpPZjON2RxgjN8OO9eDpXUCIwq3PORGToDGGW5OGJkuOZw2Xm4AVI54inXnTj9z0I8/7Hi0VMSYqWXwEbGWoasswbpmmxJZMv050vuiYG2NompoIrNc7rLEcK8MmjVwNA6txYIrAKsEUTZX3A0+Hs+6VQUhRhrpTJsWMNJGL5Q0XyyUnsxmLtkGpjFSCpjVYvZ+wTxmDYNLUHGmorUFIiZRlQG3lA5vBE43kdN7y+tmC6cRyp52SPfy785Gt84zvDYNJUi4D5rXSnDQ1FsXJrGK5cWgCORc1oBs3cOMGzvuBRilyllhlubfQ5WJsFDH0+BSpQywV05yolMRWlqqpiUIQNgNWapqm5kZ0XA0d23GkzRorijqV2V8+eJ+bzQHfH6rK4HOmqjTzeYvMmXG4ZNmvOD2e01QV1kicz9i6cFfrSu8lNiMLq6ltcekWoiRKQmaWIbDzjjFJbpO4M7UczaY8qTZ4H3i6VqzGQB8iaS+PGSgSxpWUnLWWRkrmteVq7bBEnEj0MdG7AMPA43FkajUxZYzUPDxdlFmqrEm+8J9nKYNK+FQMxKytqOuGKCEMDq00p0ax9QMvOs/l0DPJhloIamOoUaRE8ZY/4KWjNhptSyLT9wM5Zi7XHZebnrtHU26dtExry+ASQgoyAR89PgRyDMyMZqYUlVZFdliUrWIdApvR4ZXgZFLxqaOWs9mU552g63su+xWrvXkcqSjj5FQqvY1S3JlUzLVlXhlutoGKRCciXUw870boRi7GgUpJxhiRQvPafI41msoaQh5IGgaTCGOg8wmryvBlVVmQkjh4FpXFKs0y9zztOs77kbNsmClJjaDKkkSGfDiEXxUqUZLUnDIxQyZzs1lys4Hp/fulmJYj6zEQfKa15XKohGCqFbeaipkEaxVClDmNEBObEMoZKwOLesKnj6eczBueLiUujlw/6ViOA9tBI1IGBCnFor6nDXcnLQujmdWWi/WIFRlHpo+BZ32ZGzh3iUZJXAgIBPcXLVprZsbgnMOnRC8icdhT3rRCaYmxuuyBaaDRltZo1srxbLfjvBu4JRsmSmKBnETZ/t5nCH5kE34pEkoW5e+UIOoynAtF51cIUFYivMYISBrOuw2MjqPa8JmzY7aXN6xkGcMRKFLWvNXtMEpQaYFREqU0k7bmi7XhauP56sULtm5ASkBkXHAQE9vO0UrFGycLCHA5DDxejzyYQV1JfMo83xXO6eNNTxZgkJzahhBLoKYMd44qHpxmHnjNxicmueJWW7FYTKnrGhcC3eWGRgruTSe0tmJcZy6XPd4YaiQNxRpcSskYDtWFVwWBghTLZpPKGua9LFaI5c/aaNCOibF4FfjOxTlzZTmbtHz27Ih+2NGFQEihDCQGyVu7HUIKUJmQAzkn5k3Nj9+dcLPZ8o0rifACKQU5QwwDLiXGcWSiFG8cLYgJrtyOb1+veTA3tFpRJclTtwPgeT8WSTA0txtRDsyUQMLJ1HBrOuHWqOlCZCEnHNea+WyCrSp8jFyGLVHAa9MJlbW4LLjpl0QFKksqramURglBVIcD71UgAkJKlJLlIIjQNBaAJCRjKsO6UGSEjdHcuB1hGJi0kp84O2F5vWblIj4ljBBMsuStzabo2QuBi8Wkpq41n7o1Y7XdofcyibXRCKB3Pc4nui5QC/ixozk5w5OrDd98seHTxxVNrUEJnm0LveudYYBOYLLgdl3jXCR4j5SKk6OWOyeaO2NN5yMnuWY+MUznE6qqKmoUPmJS4vWTGdNc0cfE+bpD1gKbBC2GSqoiWcyB0vMq0FSWqtKkGFllyDITMoic8UKStaGuLVVdo8eOy+2Gy/UKFTOLieF3ni7YrnescmbIZfDaCni822KQ6L33SEZSVZaHRrGSJTkyUjLTpbjgvSd4X/j3SvK5RYm/55uBt1cj91pNrSVWwpP9GfysG0ECGY4qi4+pSHkrxe1pxf0FPAwG76EOhuNasJg01LVlTJk+gU2Ck7bBGk1H5nJwSCGplWKKZm4sQghSGD7chfoE4129/XdPmCQzZt9RCTkiZbnEiTGjdWCUgW9fv2BhLLemNT9x55Sh67hMnpGIylAlwZPtSCX/gweTkJK2rvnUseWml2QpUELQaoGWCZcd0QfGMTHXms8cTUsM7kYeLXtOWk2zl8J+sy8xeNFllBblfDca7zNh3408mxhuTybc9xbSliZIjquK2aSithYXMkNYo4jcWdQYK9nEwIt+QFhoyFg0NZoMXLxPWu1HNuGPKeFdmUgmw6KxgCdnGJxBS8XCTHBjIDUgteSuMRyrKUpEbtsJz9yIcIkuuv2AjaQOArnXGpc5I0LEO48KkpkpJiJMG44nNesh8Hz1nKOq4p2rFaIRTGc1Nhv6PnGx8Swqw9xoTEq8NUTIGasEwSVmSnHLGCQROQ4MQpFky2qn2PWKn354i7juYfR4B6hEIEEFs6ZBK81RVbEMHrHaoJWkVZYqAkbhsiBiP8RV+lFBBjI5i31FJ9P1PcfTilunc55uenocISU+c3zKZ4+OmTY1Z7Mp67VhudpwHUcScGQ0135AVYXaY6XCZIEPxSRuUlmM0SxE5nhi6H3iq88uObaS58stQgtmTU0jajaXW77z1jWT10+YnWpaDZs9n7nKGg8sjOVe1SCBGAJJJIK0uFEyDIqfvH9M6nrCOOJ9BhEJsWwes8aShGBWG+ajAQRCCGZVxUQVfwsXMz4fhtZeBSoFQmhUFgz9iJcarSU5gw+eRlc8PD1mDDU39MQ0cmItJ9MW7RKzRuKGCVH03ISBIBOVtNRZ4ISgloJWCHTM9J2DwWEFKAWnleVOVdENjq9fLHmtrXi83JEtTFtDlQ1x6Di/7jhtLfNGMyfzyEdyztgg2cXI7bbhs7M5xDKA6b3HRcu2j3S95Kde/zz9uiOEHjdGUgpEIhOhOJ61ZJFojGVWNRipESnSyAYtQEhDVJmyIR7wsqG1Iv3/2fuzJkuz9b4P+63xHfaQO6eq6ul09xmAA4ggSFEgKTJkS7RF07KtUIjhD+ErfzhfORwOX0i2LNPmAOAAOMBBzzXmuKd3WMOzdLF2NxgOhqMpn4rTgOofURGd2ZW1M/Nde61nPc9/QIhyKsJN9SNXSqEApzVPVmsGNF++/oaXu6rH+PHFit4aNl2LJEUej9ynQC6woaVo2JuEOxUsTiCEQM4a7wEN597zrGsIMfL5F1vOveLVdiRbRdM6XDGEkHiznehcy3tN7by/nqqbk8ZwkFid74omSQZy1QbqhukAw6z43fcvyLuZeR4JCUoQcsksjKFramNx1TVs5o5WHVFe6Ghp0bjGEymU8d2E820hFyEXhQBJVxf6jEZRmEOh6xwfPrlkuZz48s0No8p8sjnnp+fn9N6z6luc0ahx5GaeSGTW3pC0ZhCDz7DE0GpFzAkoLJpqPX1hGp4uFhwjfPn1a859x5v9AYyi9Q6dIOwjL26P+Iue9bKl1Y7brE9rMDOkhFEao1tS1qesFCEVzzEoDgF+evUBzDPzHAnzKY+JRG89G+8QybTGsfYtSztijeBpaGgwWjOmREx/zSk9+zEQM1ilMFrYbQO6qYEaUSus8XR9i14+IknwIpx5xYe+Ye0ajDX892HElIJSiqQUtzmRpfCzsw1Pz9asWkvjDGEGELSB/9nHHyG5hgod9hPaKzbnZ3wzDHzx8MD+9R0r4/ndyw3/9Gdn/NnNA589RBrnmLXmq+2Oc2N5Yh1PF57rlauJpxbWBv709g6tDO+vlvTTBCYSrjyvHne8fkzMJSNz5P/y6hUXXceH/ZKLvuM/+fGP0Mnxx7dfEwyM04zB0rt3Bf/bQhHQum76OQtQQIFk+OXXr7jfHzlftcx6RETxpG24Xjd88OSMJ+sLvIL/z4vPcGiiySgKD0ERpPDp5owPLzasG09rDBIADUYb/smnHyMixJzZDxON1azWS14PI99s9xzutqyM5ZP1kv/67/+ULx7ueX2csdaQsvDmELhsDc+c5Uln2Cz0d6FIYjSf3z5gtebpcoGbEoZM3nS83B94sU2MGWJM/IubGza+4f2+52LR848//RRtEv/65UuGkhjHAVsMS/9uDb4NaKXRRpFy5HG3w5sO3y+ZxoG7xy2t8RjreWHf0GqN09XgZGkdl5szjM38918+B62YyahUuC+ROwn83vU1P77csHAWC+RhJJDxaP7ZB+/V9VcK23FmbTTn52e8SZmvtnt+9XCgV4rfvlzyX27O+OXNlm+2R/rGgVJ89njksm34SdfytK/C7pZAhxA9/PLNDUYpPlz1rOYDKybCyvJi/8j9ITEUYZoi/+LVzEXneNL2XPY9/+lPPmYC/uU3X7IHDuOBRnuuXP8bflJ/M2G0YpwTaYal71h2DX3X07SWv/jiBV989ZyzteZf372mKOG69zxZOz7YLLhsqy7jv/3i60o7QHBG8TrPvIgTP7tY89PNOWvf4IwmzgVsROP4rz7+uFoDi/DmYaQxltX1kpsoPN/t2e33LJTjo03LP/2tJ3yx23MIwsJ5nG95cRgwKD7tOi5az0XboIAGAeN4cZgoFDa9p00jhsC8Mdzs97zZFQ5FMYXI//PVkQ+Wnutmwapp+Ec/fh+dDH98+4J9gS92AwbLVdP+Zh/U32CMSggqVMpKoqbPe0NnErfHOw7HPaoU/vD1SxSF667jvHc8WXc8Xa3JRvg/ffkljTKVnqgUtwivxpmfXp7x07MLVp3DWpAAWoPXhv/qpx9TRIi58DhEVsZzuV7xECe+2O3ZPmSWxvF+7/lf/c41zw8zg8r01tD5hjfjSM6aD7qeq95z3rdUR6G63m/2A1oZnvQr3BQwKTKtNHfHA6/3mVEyMSX+X8OBD1drLn3DsjH8vQ8uMEnzR/sHhjJyGDOuWC7677cH/mAL/hKr/7cYhdW1x5pzISE4pzDO4RuH0Q2azMPrLfs3d7zB8fPNBVEltmHGodHKsNSGlbV0qwXvrdcsuxZvDUYragYbSC5YIxRdEIRZIruHQIg37MaJMQqPY+auDPx0s8aKIqSCKYKzwlmrsbOiREhW4TvH1arnfL0i0bDbj6hZExDeyJFzIzQhMmjL63niYZqZc+YhBKZU6AyUAkMShmni5vGO//fjI5TCE9vzXlOFKO/wllDd4Si1zoeswNZxYoyJFDNaKyJCorCLmj9/eQsTuI8UMUSmOVZP3lytxa5ay/uu5+Ozde3mWwMaMgGDBdFYVRNFJdc3/eMhcJwnHkNgHzN348xtCpy1ns4o9iHhtWZjNFcLy6ME5lKYFLjWcXm2YNH0JGuZjhEtnpCrR/BKFRYBBiU8jIm7aeIokeOUmOZI33RkKYwxIYzcDAd+8bADYKMd1747Ue3e4dcNbQzGKKQkclYkk+koQGI/JiaVOVtbluue3hoebh/47OaRA56fX1wxzQNzniFXdyanDAvb8NMLxSerDb2xNWGSQpSMySAI2lkUlesaj4ndEBjnV9yFwH6ceZwCu1y4WLScacUc69rWVrHsHKvZk0ohKGgbw9OzhkXXM6M57mdMtgwp8XkYeWo0y5QZlOd2jNweJ4aQGUtiKIWPTYOowk4Sx6nwfLvnzx4PUArP2iVr3+K+Z6z8O/z7IaaMLqW6PpVSgyu1QauO3X7AaaFtFgxxRhmYkuGLN4+oQ+G3Ly44xomoalc2nAIur5Tlk37Bj1dr1t7jjfmr/SNpDIJ1BrEaFRN5KtwdJqZvAocYGXPhcc5sc8K1hidUWmu2BUNNdlZakak14qZzfHq+oG0aIpZhSByOM6NkDpPmPaPwAY4KbsbM/RwYJfIQElMqmKJIOTPFxJQz3+yP/GJXaZNnxvPEOxzvJpxvC8obigIKGK3rWvFglEYmISuhdY6QBaVhComvXj9iA9hnihAjqMwMJMCrarn+8aLl09WGZVedHdVpCarTfxh1MlDJkZj2PB5mHseZxzxzCJnHKbErEWeFy+KJJZNFUVIhI4xkitYUBevW8tGmmrIImnkShjESSuAYIxe64MiEALu5BmUec+Z+nohJoZKQiBxLZhcVb46BXz3sKcDSNlw2DqX+mrv0UHRVIOvKlVYayDW+vaDQSmOMqZVYgRQDhMAkmfvtjkGElXcnrjVEyWynmfO2YdFW7rEClKphC87ruiKINRHVaBrjmPLA85sHhlI3nHCyahxSZptGsGBQRJWRXGi1IVMYRUgKMIpDDMx7wRTBGst2nngzDhyco48ZlSNzqLfJKKVujkCnLEhmmGemIDwfBlKuASBdY2mMYh/e8QffFgo1S72Uqh2ptJ76/zIFbTXrxYLWasaYaZWiUxqdIvuHLccYWBtHUlKpQMAohZUydL52VhWAqhxC1xhSVKhSaUNGazpj2BbhV3c7jpI4pkTMCi31vfBiPIJVOOtQ1mCpAV9ZC1PJNbRIK6YUSftMo2r40n6ceXOcuXCOtdLkkpljJkgh5Ponl0KrNUWEYwgcUuCb/RHJilgSi3ZBqx2H9M6m521AlW8vUuq7dQcCIqSY0NrgrKHTgveWPM74XFBkHu4fGVJkZRtiqamPWhRzyhij6JzGSKZkjTIaZ2q6eEoZl+vrFZXoXGSH4pf3Ow4kBsmEIviiyaXwzXhEDGiryLoWSNZoYslMkkilCt52c+AQhF5DYx0Pc+TVfs9gNZfakHMkzJmUhLkUEvXyYbRCl8IYIkOYeHU8IlJIFBprsBp28/gbeT5/05Gq+AwRiEmYU2IOByRmhmli1Tka59n0jkkyrTIsjcVm4fFxx0EST1zLXkWK1P0sn9b00vkTsbagVC3knNeUVAkbiMIWTWMMcxp49TAzlcI2J+YiONGoDK/LjBiN0ooo9QxWSihaCKUe6QXFEIQpTXQYFIr9FHl9iLD0nJ2KsHza8yYpZKlqrUYrNDCkxEEyr8cj4cQhX3hLoxWP787gtwh1ItRSizWlsKZQtKoURRR907FuNLOq4uvOWrTAdncgZuGJa9mmhNIFC0iqETuLxpxMn2oOjj4Zu4gIWhtKAasz3mimInz9sONYMseUCblgqO+NNyGSFTijcdawMgY/jSQlhFIDtDSaEIX7w0yrWkCxm2amYUKWLQulSLMQRcgI6WQUA2BUQSQzRmEf4W6aQdVGy4UDq6oI+fvgB1vw17eZQko5/cKAUguuUk5x3NayiJlBBKdh0Ti6CNM0MxVol5ZUMgVFETjMmU4LuSRUVihl0MaglMG3jjRmJOQqzTzZ34yS+WZ/+I4/pgUQOMTE82lg5RpyKexzteFcacfRRGKpkcpjyjzEAznDs36B0YZS6oYjsWBEWIhCcjlxveDMKSbJaGMxWnFIgefTzJtppimG7pTKO6XIY3h32L1NlO92G6g2E/USgCq4xnGxXvPesufmMNIpzaZ1LL1lHidmqeFx9nSzzKKIqRAVxCxoElYptK5r0FhDSEI+vUZR9dIRpPDyOBBPPsTmJFoXBTfzxNJWweRYChlVhW4qk0QISZhiYsyBmIUP12uMVuRS2IUZU2B2Bl2EXKRajKJZOleDcXQt4I45cTvMvBonbNF45bEYQs7s3h14bwVF/soARGtdr5wlf5daqxvN0rcM8RF1eoarxrMQwzRMRBTeGlCFzmgKmpgKs2SmGOpacra6V1iL6xxpmCm5FulVMleYEV6OM5PJtUFyOoRzgTfzRKMMSQlDiWSpB2G0hZCEOQrHObHPgSkWPj5bgNFVbDsHTNEk7dEyIVmwqq63RmlCETK1s3dMiefjkbuxTm07V8VquzhznN+tv7eBWvArYhKmk800Usgpk4uwWbacLXt+pBfcTiMrbbjoGpbaMo0TSSmW3jCVTFIFgyYJTDmTJKNzpdt+ewY7rxklIuVbkwshSuYQA8+HiUxBTkLcUhRGKx5Sqlk81LM25LpytYG51MbcMWamLEwp8mHf1xmZCIc5cOgs2pjvEuu1rsnTK+sgJ4wyeGt5jJnnx2r3aZVicUpOP8bIrnKC3+EtolBIRU5GFIas6kJwznK+XvLRuucuTVX707esGs8cAkJtnA6qPl+LpuSqL0qSsLmglQEsKI02hihCUQUptbEQSmGfhdfDzEwN41QFBIVC85gSvalfX1Q1hPFaE1UiZGFOhTkWJskkCbzXO0rRhCzs58DRO5SzTDEBdf+zpXBmHdt8OoO1ZpeE19PMfkpYpVlojZLCMYTqaPU98IMt+GtVZb570Pb085SSKWSs0Zx1LR/O8DwXVO9ZaEs/CnoUvIZdjPQYNJaCIivF/SzcHSbOWqHRLWRTj7UCY545hoBQCDlyMxy4nWaGFFFG0WmDVZqByGOMHIOwtJWusZ8iVgsX3iEqQ1TMIfN4DOxK4uZwxJxpzvueJZZzbdmXan03m9pJbZXGKM3T1hKMYLsaBX2/O/L5bk8QYa0annYd2zlwIxn1zqTn7UMBRaHMt7W/wmrDom15enHOfzhe84tyS46ZtnXVNSCB0Y69jDRa4XXdEFSC+5i4PxzZdC3dqbuPKmRRTDERpgAUppR5PUw8H2eOOWGtojUaLTBI4ZAyKVf62ZBnkgJlqnWnLoJOMM2Jh2HiIJnbw0hrFJ1rcRhW3mN0YSin4k+BN1CM4qrtyQg0lkXTsj0MfLata3CpWq7bjl2cuZsT+p0P9VtBEYVIPVass7WjlGqMukihdZ7rxRn3wy3T4cCic3TZ4oNCmWqFeBcmiitopXFKo1E8zoE3uwOXXUunFWhDUTW1O6ZcE5ZLpXG93M28nAZmEZTVuKJRWTGVzCEkRBRJhKMESqQWSLqQNSCKIWTuhpldydweBxqjWPnaBV4ZS9saxhBBwGnw1rAuinPf0rQGjKVtPXfHI1/tDsypcG48z9oVj/PEmxzx79bfW0GcE5nCdKImltPveZxmrNO0refp+YZzN/CX3KOVqYJaLBIyjdbcSSCWjC4aLYqUC4eceBiPbFoPWlULPhQpC3PIzEFIJbOfJ77cHXgxTYy5Tnu81E7HIEI4TQKMUUSpFtdFVRcxYxUhw3EWHobAqA1344At1dq6MYqzxtMqQ9SGoyooAx5hqQ0XznMjE8Y2LJuO+3Dgm91AVoW1sbznF9yMI8cUcN9N4t7h142cBGUUUqrLUkGRsyVlcFnTLRueXp1h5yd8/niHFFi1nt47JCWkwKs0kSpPBFUMpRiOJfF4GNl0TZ0cmDpVT1kYYqTERJTCwzzzxeHIi+PELAJW0eq6lven5lzKdYoekzDnhHE1aK41lpCFY0js5sikFPfjhC6gRNMoy5kvqJxJFoaYaJ2lMx6F1MltUTTW0vmGu8PAN7sDiGVl4ZlreDPPjEVo+X5r8Adb8OtSO6CmgK0hpJUjFcB76LTno/UlHzcTzecvef0gMMw02tP1Gx7HA+M0ERuARBQIoumN5uZx4OKDFUZBSjM5Zt4cH7laLxly5LP7LV/t9uzmCckw6UIoGUz9+r0U/vJ+xyd9RzMWWjStankIgRG4Nh2iC7fHwJsp88n5hr94uOXzh6/4B5tzzl3DnGGKwnublkXTUkTIJ9vEVd/z82cfslwbHh4PvNmPrJznSbfi3Fu2ITAWRWMMa/OOv/rWcGp0KqVQplJ6FAYsbNZL3j+/4uPzD/jtTcOq+SVpO6GywhSN7hzDMDEHSBpEpbohzBER4epRcb7oKaUQ5hkVNTfbA5frJZNkPn945JvdgWMuHELlcE8lYY2hd4YUheePI2faceYqtWFKwtf31Y7zsl+i2szdGLiZH/ng4oxf3m/58v7A37k857zx6FSt5i56y3q9QLWKtWSMLiz9gp99eE3bNjwejtxNIwvr+Nh2vNev2DMSRyArevWOw/o2kAGHwhiHa2w9kIYDwzFRlGa17Pjo2QUfT4k/+suvafaWHDNZadq25yFEsrGkOCMihBgZ54xShodD4mphKMCcIioGXm5nnp6fM0ji84cd3+wPDDEzSKR4CCnTOUPvLLep8Oo4sSyKy9bjtWZIwmfbgVFnPup7dAcPMXJ3v+X9zYa/3B75cjvwn1xfcd13lKbjdjtw7i1tb6pJu4AzhotVx2/1z1j2nt3+wHaauXQNV+uOa79gmwcOoXbbevuDPcb+WuPhcKScEo9z/qsOohJoW8+T8wW//d41i7yAzz/HDRkzSXWlcx37ENjnv6IaTCQec8QGxe3jzPkHa5SyxBSYY+Cb7cjT9Rn7OPCrh0e+2O44DJlRItnDnCFjMAWmEvnsYaCZhc2lZt1Yeqt5vpsZQ2bTGTqreJgD+5R5tl7x2cOOLx6O/L3LDU/ahg7Lwz7Q97BsHNoJq1IpP0vf8Tt9x7JtuNs+IDnQO8N7i55r03AXJtRpctbx7gx+W9htM75XaAUlVCrtbGZkBmyDc55n63N+ujKYXxkWSWO+LX6NZ5wSIWSa1iKlMIfMLgZUVtw+jmzaJWRLmAuoiS9v7ni6XrKbZr45HPlmP3B/nDjkxNJZZiW0zuIwbOPEZw9HvGieLB29tUyi+GY/sw2F864mpN/PgePtIx8tVvzFw46/uN/xe+sN122LN5ZhGJnnQN93eGspFDprWHUtP2tW+CZwuxvRu8JKO84XCy6MZiTiMSAaV75f0+OHu1MqvhsbqxOXKeeC1rBqeq6WK1a95bObLSZP+CwMRTEqaKywMJqGJXel3u5izuymmaZzvB7h4mHP1WrBctHQ9Y4VKySPGIRCRuvC066twohJcRsijsqnWmqNiGIXhEHVcXI55QPcjoEnixZr4dp3XHYLnpyvmMKOc91z2bV4Z2gAP4483+8Z9wfOXPWVXjSOn647piEyJ9jFTCyKpXMsteJ2GPniuOfTszPebzvi8P38V9/h3x9SKn3h3+L0UK0p4frsjA+eXLJaNnz91QN9KtAuaosdTZHCwhjWq2u+nm7rhY7CtiSedJabEDnbH7lcdCw6T987VmcNkqu+xChF6zSrRnO0QG+5nWaUVFFQ62sOQxZ4GAVUtbLVWjHGTCq1eXa56LherblerLF55tw0XHZLnDOEkvCHgZsw8NXtPWvtWBjNurV8eOUJoSGazBgyJVf3l8ZbbuZHXodAbwzXbUfzrsP19qA1yoAxlWLzOEekFC6XK55dXtIv1/zly7/Al4h2hmI9pagqYkPxcb/iy31mLomEcCiRJ73lcRp42HecLTzL3nG5XrJmhWRBSUCrRO8UG9cxJI+xwt0wo6lOF63ReGfIU+YxpCqUzHVSGaNBigYlXHY9TxdrnmxWEEaedmuumuZkRysYpXjxuOf+ELn2npVz9C2s+g4ZhMkE7seZOQkb37DyHV/tH9ghLLTmWdPg3wW/vR0YRcn/7lypq7MVHz55wro/5+svX7Iig7cY5UFpUhJa4GPg5TRWPr3ALgiQeUgt2/3ApvO0jWO1cKwXF3X9USm6K2doe8UuwEXnuZ0DYhRFK9wsNFpxtmyRZJmzIqNZekfOQocjkrloG54t1jxZLVEhsukanjSOVlcNCkrxZw8HlBXe73vW1tJZzWVvOAZhNCP7nEFprqynL5bXw4HBwNNFz5l2TNM7DdPbQpkDoizGG5yvjaV5qjTvq77j6WbDou159eVzNqZO1QvVlU4VsAme2Z77HFAJdM4ccqVgvcpwPVZKdNM4ll3Lom2RnDmqmU5rLhvHwjsedpGmgbt5qpQeo1lqi1Gw9JCyYpBKNbvCYTT0wIzm3He8v1xytWrIKbPqNBfdit46EOFRwZ/uH2He82HfsPKOzjsueksMwjjDIQqiNGeupc+aHZFg4Gm/oFeKw/T9qN0/2IJfKCfefi30/22cdQ0Xyx5nHXMonK8XqDmx1ROpKAqFqAqL1hNCZJ8EU2DR1JF2bxVfHrc8SuQ9VnzSr8l5JoXAFAKtVTzrW3wyQKJbLrk5ziRdmMlspz3owjRnGlMDbCrq93yQwNpZLpY9H19e0FvD2nuuFi0L16CKwuSM6zq00ryaR5KGxho606BiFSrJPvJiu2OcI09syxBnbqcZ5zTeQdKZ/fdUZ7/D/xj8fxey9WOlFRerBU/P1nRtw5gm3nt6wbSdGEMi5EzWmqgUvVes5pY9Aa0ivdGorGm85vlhZCuJJ3R83LaoWP3VpzniteKibTBFszaG87bnLkRmqVSKz7eH6l9dBHdag6oUHJC05pAia++4WCz40fmazlpudo7rRU/f+moVmwp+ucDPlufHAZQmmxqoI2KIaSIdC68PA0NMbJwn5cDdlHBOs/YN3nmm+C54621AA0af/qiTdiRmvFJcdiuu+w2d9cxz5L2nTxjv94xjqJxRAyB47VhqRxawWrFpapGtveYvxy2r7HifJctVR8kQA4QktEpz5VtaHMll1gvPQ5eIJbPNM988DIjyLLKirUMvvpW2W624nyc2reVq2fPTq3Ocg7VvuGgMrTUUAZWFTdOj14LsJoJWHDU0SiMZtvMRpQxv9kfmJCybhn0cOWTBN5rWWLLRHPK79fc2oFDkkhHkuzBjVZm2XG7WPLvc0LaaeZ742Yfv83i3ZZqqoDGhyCJ0raMXIceMlcTGaYw2HCXyx/f3XLQNH2xWfNp3lCxInshxZqHhWddQjCI3hYtVz1WcCEXYx8SfDDOTZM6cZyrplMhb7bQlFx5ipPWK60XDTy56sELfGZ40js7a+nOUwqZv+FSEmzkwpFSpI3hmMczpyDxpXo0To8CqbTmmyEOsGRhRwbZExvKu6fa2kEtlezitsM4AhXGfaLThol/x9GzDsnF8kSc+/vAjhscd4/G0ByrFpCK9qZ3/KQuq6NoMdpaQM39898hVP/LBZkHfb0AyIpmYE1bBmXecA+szzVnfcD81pFI4xMQ3zPjsOXMNQ8kUqbVYoZCU8CCFzmuuVo5Pz1u0dvRLz8Y1LJyj9vKFTd/xMx25mWb2IoSQuVCOIpppDkQV2B4DEgtrb5lJHGNi4RzFwEhh+p5OeT/Ygr8eHurkYlI/zqUAwnq5YLNaoZQmJ2G5WVLmQMqZ3ZQYYu04/eW05bpY1uJw2TDmKoowreGQE6bMbJXhhYaFM0jOpJTxohFliEoIpfBe62uSKsIoic5Ynh+PvN8uWDUeinCYIq+GmXVr+PBijTMGZxWH8UBWBlVMTRo0Bqs1pShSqvZSoQhDTsxReBEGbocZpROjFHYh0hrLk7ajy9WiamEUOcNDCkz53Wbz9lCqMrYoiqpCcQBtNJdnG67PNxgNSRLr9QU6QsgHUkoMQTGlzMuHGy61Z4XByCklUDTOOqY5M6M4qMgLtWflXA2cyxGyIKkwSsAYzco5Fk3DLMIhxkqrOB45bxvWvoECxxi5GUfWaJ6ulzRF4VVhNx6JylQxpqqBX0aDMQYRizKKSQpzrkLf28PEm+NLlBJSKmxTwGrNufNE0aiiWLSVnzjG+F164Dv8eqEtaKMoJTOO1Ys6nXJFrjbnPLk4x5pKQT1fn6GmVDUgMTLHwiyJP7u/41xpNsXSFsWQhJLAdZopSt0zzcSXd48sjCVnmEIkppMrhCoYo3lm6mEVEc5StVO8HSaetg2b3qNKYT9FRhnwGD64WGDRGApv9o+0RjFKIorUiYVTKFv3wXXfclVgSJkQM6/mkfvxJVkyoRQOIeCt47ztsEqjOjjrDMe5Xq7fLb+3BKXJkk4iWqpNsSkoo7jenPHs/BxjDKUIq82G6RgY5gNDrI5MQwh8NQeudMOZaBoxjKm65rWNpmQIKvOwH9Fqy9pAKYn9FNnPiWPKlFJTdxde0/sFsRQOMdNox/1x5Gnf0DlNzMIhZGQuLDvD++slmoIq8HJ3YOE05SQC17Zq8Uqp38uTvtp4TjExjcL+OPBqnFBkZqmv1xnHVdPRKgM5c954DilzEEH+XSOQd/i1QFPptNoprNekkJAMyiiu1iuenK2xVoEUlus1eQiMY2BMgV3IRMl8NQTOjWNlLB6FjgWVFE4rSlKEOfNwHFEaeq0REXbDxGNIjFnqVF3B+3bBYmkJIhxjxGnF3THyrG9w1hBzZoiJY8wsBZ6erQAoUu2E166hFEGjqjmBVhRd0FiudEtIsE81zffVNPH6NNEfcmQKQqMNZ43HU8/vc2fZpswg5XvvgT/cgl+pSqdQ1QtdnRx6lIK+b1n2LZQJVQrGWhbLBSkVYhm5HxJWK16NR67dmgUeD1gxzCVjisFLQUc4HmfmHHh/VYMLhjkynFT9c0lMRRhj4qJvUdqQCzzrl2hV+HCzwjtDiglrFLucaXXhk7M1GRjmwN3ugCmwnSLOKlrX4Fz92Yoo+tbSTIohFPYhsp0Du3Fm2WkOqWCM4b2+xyrF0no0mQtr+WaY2af8b1n3vcOvHYVvrXJO1g910mStZrNasVmuUCqhBLT1NE1Dd/KKzlPCKPhqu+Xi7JJeWSwKpwyxFKxyNAI2aaZJeJ73POlrgMsYA4c5sJtjtRrznpAS54uepVas24aniyV/rgoXy5bWWmIqqFExSKTRmh+dr5GQGEPgdn9Ai+J+mnFuwHnPwluUrnzHxnu8nRlT5DhHHsaZl4cjTWNI6XTAdy1X1mO0oWlh5R2vh4mY5a84k+/wa4XWlcqTkjBNVWuUSkFJYbVasjlbolTEaoNRmqZpaLvEmOo+ZrTi9XDgvFmz0AaPQhVFzBmfDbpoXFZMY+TLtOOqrQFqx5h4nAKPKTEbQ9d4QhLOe4cyhnXjedb3/Lm642nXYZwhhEySwrqxWGP46fmaGOFhHPnm8REH3IQZJwrnLUvr0EohseC9x4eZIRSOY+RunLifZ3xnySGDUTxdLHjWaLz2tF648JYXcybmgn/HoX5rEOE7sS5UxqKxiov1kovVElS1B05F4bzHeQffOvqUwqtx4KpxrJSt1D9RSM4svEMDOsMwRIa45bqrz/F2jNxOgWNOGGfpnSUV4dy3oDRnHt5b9PyZvue9hQdTxeE5F5I19E7z47MlKSVeHkb+cjdw3lj2kjBF451lcaKHKCm0jcfPI+MEh6lmkdykkaYxzLGgtebDxYK+M3TKgI+cW8ucKt22Ne438GT+pwGl6h5orAajSLEKZK0ybBYLNsu+kqlFk3PGWIfzDjXPTOFUlM8zl71nYQ2N0uikCKWw0Lb675e67xxTYHXSA+3nyF2IHFI9x52xRMlcNA0oOGscT/uOX5kdz7oGjGYK9e8qU9M5f3y2YoiJN8eBLw4DZ3Zi0BmdFI3R9E09g3VRNLrBEOGU+bCbZr55mOhd1U5pVevAZ9bSFoMyhZU17EJCSaHT36+U/8EW/HU3OFmvwqkzeVIsO423iRxnvILpOLNsO9pLhzeeed4CcKV85dYrcFaztJ5WCq3XLEtLKoqQM4cwc54aAG6GiTfTxChCZw1KwWfbHc5orvolTdOitOK3JaB95VUPIZIl817nKSKISjXwqxSGIDxOE8+PR55PhsY7tOmq60sGs7Ds48RdCDxOicMUiTEhSmONY0rCLgT2J+eWJInB1AP+TGvsu9CPtwaVoJy4CvrU5dJK07eeZdvQWlvXIJpxHPDOcr5eY6wnxj0LbznXvmpQNDhrMNaRRPDO0ilNQRFyYSDTn/zsH44DN+PEIWd661AKbuaRxjvWXUvvPFIsP10HtDe8mgaOU6SkwjPXnr53AaspUTHOmdsw8WocuRmP9KbDLhxKaVCJ7Cz388DNMPI4RPZjYp4zcym0Rp+cWwKTcfXN2Cq6JDgMxlr8O9HuW4FW4HTdAEvODMMRsORcMF7jvSHFGY/jYb9j4S3PLs7ofENKOxY0fCwREyxSaorzsnMkibTGkXXtcAYRjinhTu6CD3PkfgoMOdN0jiKWuzjSpxr00rnqOPXpeoX1lq/2Bx6GkRILT1yHmMIwJrStb5xJMi/HwOvjxGs90nqHKgsU4MTgbcPD4ZYXw8jDGDhMM2MWdiWxNoaYIMSEyhkFzDExaIMqmqU2tLwruN4KpMDJCvFbKKVovWXZOfpGk/NEBB7ublk4w/VmhTWeNO/AwTNibZpo8F6zUNV8w5t6Ac0IsxTmLLwOtU15O83cjTNTFjYaTGPZRaEzhaXX9MaAVny8WtB5wxf7gf0QIRWWRqNtTco1ZKJE7sLEmyCMQfHqMNAYw7WU+v5SCtU2PMbATZh5DDPbMDGmxLEIHZapJKaSUGRQhblkjtnitWbpDJ1+t/7eFoqpE0aNIichzkLXGFrlWTYdnfekOKKA+/t7FqbjfL1CacU0ZwpwWTqs1lilarNVO4JUu1+jpIaslsIuZvYnemrKmYc5MuTEpqtNjEOY6bVh2TZ0toqAP1wkvHe82h85TokisGwsOhamVK1kC4Uh18tvIPHSDDRe8cS0qJN7WlSWfYw8ptrI3eXEMUcmVNUClEwoGX/qrd2mzHjKT+mtZvU9dUw/3II/Q7Hlr5qrAErx7PKcde+xKqOVsOoMcwiEpKvloDEsTB3XfdwtmcfCXASvSxXLGo2xNWrbKfDW4foFm77+KsLcMYnwMA+8SoG/tTxjt594frvDXiqeOE3Jjk2/IOfMQ5yQCCHV8K+rZsEfPb+jdYAoxlC4OQkqHo8RWywr0xFy4vlwzyIveYyJr8eB7RSQVLDJMIrwtFckKays40eXCwrwL169JgaIqqCd+QE/wL/+yPrb2I9qIKKpB8RHF08461u0ioiKrFtPDtVz152CWr7FpxcXEGqgmqFgDfhGAxl1+tcbY1gtDFd9jaO3qZAE5nniJgZ+a7NgTIk3+wNKKc6tRRHY9C051/CRiVNuHNCblj99c0PrNHOsyZRzyfRo7kMEo2vXNidebh9pGs80Fb45jtwOMzkUHIoyZkrr0Fqx8i0fX20owL+5vyUZRVaCVoUi388D+B3+PWEMVhlQFq00eQQxmevNhuWiwVpBp0DnIYQMKdQALklInqvbQ+dgqvZxRoM3BW80WVeHmyKKVnmerpc8XdWmx5vHAws78TrMPMTEB5uGSRIv9wfeF+Fq0RNN4arvkSxstCOYxCCRTGHtO/7k9hZtFYJiijWZsm8shyGyNi1PmwVjTPz5/T3vrWtI3KswcDPPpCR4ZcgJZmooTmst56uGAnz2akdMAsairWLknY7pbSBlQaQWLNV+XKG14sOrSy5WKxrryDJx0cI4ZjBgdEFKYJa6/trGoo+l2roahbVgMZiq6Qagc4ZnZy3nvhbOn+VHKHAXA/fHwHnbcggzxEhZLDjve3IuXPmWDCwxRB2ZjRAQrun4k5s7rIIhZEJIBAqt9exjoDWG88Yzp8TXD4+s+57HIfHyOPAwTcwp18CuWbAWHJZeG1a9oqD4s10iZcHqGsMe5N36e1uwjaLpDcboahMbC+vect61dI1BK0GpQN9AnmFSE0ZrYtEMtl5WjYGchblU/R0KGqOoWcwAhtY6zhYNK2OBwuvdES3CNmuiKNZ9wzhG3oQRLZqr3hL4qzN7bwxB1Uyo4xh51jv+7K42npGqQ5CcaSzsQ6IxlZ4zpcRn9zesmyW7GHk9R7ZTZD5ZL4ecscbitaG3lr7X1czmXrgLEYWmKOEufT9q9w+4XiyVY3dqLgjwv//H/5Cf/fRTGhNI05Z5v62eqwR8YwghkYxiuerYzwPrYBkWEa0NGkOMGSg0J5W2dxZrLUJhGGY+f9yxMZaf9h0fL1ruY+b9puF50Vz0Hbcx8dnz1xhV+NuXTzDG8ZOLJ4w5sZsCY5i5C4EPmyWHkmrypBOKLvyoW7Jj4vPtHc93W6Qo/mS7ZTy85KPzBcOYmKaER3O2cAQyU8mcdQ1Dzvw337xh7eCpb09jJ42UwjC9C515qzgtwFIKRcH/4b/8X/J7f+v36V0mhz1hOHDR+9OltCWmjLGFs+WCcZi47lsemiO2gBVNijVBVKPxgHEW7auILMw1YOaqcXy6WfJ+atjOmQvd8DzN9H3Dm8PIn91uEa34D682aK35eL1h7gu7KfE4zuxC5IlpmFFYLzROM2TDB3bF6zTz5/eveb6/RxfFv7q9ZTxknm6WbA+ROGecUiyWDSZXnv/CNRyj8N++eMnSW551CzbeMebInDJjfBc88zbQOYgSGMaRcIxk4L/+x/+I3/udv03jEnneEccjT8+WhLlqPWIQ2ig83SwIIbEOkRebCS0aK5qYwSIs0CAF02is16iS2e8GvjocuVz0fLDueZIbjlPEibCfM5vVgjfjzB/dP5IL/EdPrvBG88HZmot+xeMxsB8mbsPMle44pIAUwVNtat8zjseF8Nn+nueHHSEW/vj+nuPXmafLBY/Huv4shmbhgUyLZ9k4Dinxf/vmBQtdeH+x5tx7djkypMgU3umY3gbmKSDp2+S3WvD/H/+3/5S/87d+h64ppDgQhoHL9RmkjDGGEAuN8by/WXDIiesEv5IDjRJ6ZYhRMFisNZgstMahXXX1GdLMZ9st76+WPOk6Jsk85ojLhUMWznrP/Tjxy4c9Rgl/a7NBe8ePL86ZUqWhPYwzN1Pg3DkOklm0mmXnGLPwo6bndQ58sd/zcjwSk/AnN3tGueHj5bLSaUPEorloO4REZxxd0/CYMv/nb96w1JpPlks2vuHVMHA/BXJ6x+F/WzjbdMRZOOxG8iT0neaf//2/x2//5G/RWpBwIIeJJxcbIGBwxJQRZfnk7Ir7ccuzZsnnuy0TiYU2dS80BgOYXNkfyhpSgjkVng97nvQNm7ZjzoWjzJQQyUnTNJ4X08Qvhz2tUvx0tcF7xYfnl1wsM9tpZjtM7IaJS9MQRUgI1ihkpfnANjymwBf7gddDIEThX98+EvM9P1p03A0z2xixStWcCsBZWGvPYU78N8/f4I3hw2XHBs9NmNlPgTD/NS/4v6Py8Fexyk8uLui9R3IkF03WFgV4JZXHpTV94/AXhk1q+IvxDXMBR0aJMClYOIcz1dYpI5RYb+cHThzT1hJzYSyJQ4qMulIa7o8jiUJWQtto8qn7MQFzTkxh5GYcUGL4Jo5IgYWyNCgKhl8djxSdaYwFDYUaDrYn8XIeCCI0xtIozaSEiJC0ZlGqIGUsASmaJQ1JKb4cjuxSwrxzqHi7UN/actZZ05Ora9rGoEoglxo9X3LtuBtfA7QWytDajrhwfPH6lkkyRhQORTTQGYep2wAFQcWEQTFK5G48YtWiUtVS5ZPqAjlHbofa+ZdcaDGUUhARjnMN/JjixDEGrNM8H2vfc6Uta2PJaD4bjswFGqvQpaYEtsbxaGbuxiMJwXmDoyahFqUQpA4lpQbZSCmce+EQE18cDuxD+C4U7x1+vUiScbamN44xVg7p+aJ2TUuuT0YK45TwMmNcjxhN13o6Zwml8OVXr0mlnCIMC1MpnDUtkHFFUUohpYwymgOKmzCjrMfF6s+/jYHL0HCUyNeHY90DgaWxlKyJAkOJhJwJaeYxHmmc4et0ZBZhrS1nxpILfDYMuNZV26EixCx03rMNR26nI1IK3lmc1nQKKilDULomW8YkHI1iLxEVCi+GiX2KSHoXvPU2kFJ970M10MDA0ydrur7BEEixhhWVLLgsGG9RojCto2uWnCfFi9tbnFGI1GlNsRq0orOgi0ZSNSdQRrHNwssww1HTaEMowgOJVVEEEb5KmVjqbPTM2br/xcReDHOu6dFDmumd5ZvDyCyZlTWsrGVG+NVwAK1YZoeJGimVnjQNmTdpJCjBGF1DOCXSVM4PXiuKQBSYdeFmmtGp0n8fY6hWMu/wVjAdIqWoGnAvhdZYztdntI1CS0RIdQ+LEaMz2jd4pdHa0Daei6Xl1e0j1mpKSQQy3liM1UQi2lR9SMk1mOtA4vU0kwVam8iqMGShKYVAIc4DokCpgnMOravRwRhmxpiYQuBQAotW83ycmVOmt4ZlU6mYn08DTTFoKQSTSSWz9I59CNzFgCqFViuSqlTIFkOrNc5UPkCSQtCFu6FSJo85s5fMFP+aF/xCpVB8+1bSSuEs1fqoVD9+o2CeIz3ldDkoKAXeGYyCSSvGVGu21ii80sSS+Nax9BgikVoUdcphlAKtCVReK6kwmcxdDEiA1tTQGaTalQEcp8QYa3dfo7lsHVklDimhCzil6bRlGCa8ru46kwhSqoNAYyzEgtcaraolXW8s+wwKjVbfZolXt5jHHIlRGEvGWEPzLnTmraGcnhGqriula+KpklQdK6iuSWOYqkUWmlIymioyMqowKiFKpe4YXTBFEaUuSq2FMWZygYUxOCXYk6g3CwxROIbIY9ZsS2SbAo31dNahNMynOPiDJOacCTliVGHdeubQskuxevobTW/hbhK88ehSUKcLiEWzcB4thc4YQGFRLJwjSL3ofCeep6b63oeJKRumnFFKo7+nJdg7/Pvh2wTHfErATanmLIgkNAWtLEVbpmmicVVkUkrdC7Uz+FI4nJxuDAWvFY3VzJIQIFthNwtzhjPjaZyhM54shSzCkBK7KZPLxGAyWnL9O6epaDqFKh1jYUqRMQa0gqu2YY6JbawppEZrNsbxZpw4M47OehoUmozRcNm0JMmIqdcSo2BpDMOpl2HUifym6rnwGAJBJ0IRvLIU9a7p8TYgUi9b357CNZRZg2SUErRSFKMYwszaOEqpDQEUeKsxCo5ZUMpQdM0KabXhmBMURwb2uV4WF8qhrcIbzZyEaGCUzP00E4D59NqtNSycA62YT826UVX3vClFnLFsmoZBEvsY8CgchjNreYgHNrbBYXDUsMLWKnpjkSh0yqANRBEM4DB1L1caFJiTW9t9mLClIBQW1qHexd2/NQwPgVIqRVtTNU1aO8iVrVEdXTRTiCybynyo57bCabCuTnes0eRc13BrdbV9LxBLZh8TsRRWjQOl8dYQJVNCpYPfxsgKEG84SKI91WiiYD9WhsUkVWw7n2g7Z03HsQj7WM9ZXzSNNbwZR5bOYorCSt3bVtbgVMMxBBpdLTDmImihdr1L1ZsoVR3ySins5hlHTTRvrCa776ej+8FWi9/2VOHE4dcKoSCSURSsUmStCEno7LcmnqdU1FM6Ks4QIlXooBUOTciJEY3kzM08M4hwbVt+1Hmu+xYLjKUGF3k0h5R4zJWfvVENvsAUCunU3T1OkX2YiUVYtx2XfUPrLW/miRgyZIW3dXzutCFlmLKQslAEWmNRWU5G1nURtihCqRvNt+FjRQCjuM8zY9H0znPW9t9RTt7hLaCcrp2nQ0ypeulCpCb/KY1SmikFFr6pPdRSvlu4SgHaIAUiNQvCl7r2im2YS2KbI6MUUrRct57LriWXeuGcpVAEtjGy05mMcKYMznomKQynW/0hZEYRioKVNWy8o1uvuQ8zIVUh0bdGEo3RKCno0yWkCCyMJ5eEPaU2l1LwqordKQo5TRKSEhoF9/PMZCuncOE8+V2H9a0gZ0XSNYdEpJws6RRFBKVAV39LYorgqj3wtzbGdREKYjUpQC3xFZ0yzCmhjWcqgdscGWJBkuLDzvFs2TOExFyql3rIQkiJ1FR3lTOtaMzJKu7bgj9kjjGSSqb3lo33uLXlfh45zoGcC42tI/RGWxpr0aVQcq4Hnvc1vEjXiZIU4XTPxmpDkUJCTpMKxT5mosmsbcvKtieq5jv82vHtXnZaT4o6XZScUaZqK9CaOUXEVWtWKdW1p5YfNfW5nOytiyp0puYvKE4FfQocY+JcwbO25f1Fxzhngqod1cOYyIC09SxURtOpwjEntqf9b5bIIJlM4bztOPMOa1c8ThPTycaxURaRuv5cqd+dUBtt3ipSBKcM+hT+820GkBZFPukY8ikobhRhmyML71m7hvQuh+StYdydzi+raDuD0Yr83R6o0ao63QQRlKr8+3oG1/2vAAmFAQJV52ZsObl7KXYlcZcCYxayLjzpljxddgzDTE7ClAqPU0CAxrWQCs5olIIhCQ/jcAq9rG46VcNkWfmGD0zl609TokTBW12zcozG5PotCrWRbJRhnAPu1PgtqTYbRQsi1S2v6EKk4IxiyomDKFbWs7YN7fcU7f5g/cwM1RlFl5NhTymErIkpISlTpFBQaO9JxlUHFWMw1qCNQhvDdddVBTSFsRSmLPS6xbmGQykcRRhT5mHKnDWWn1+d41UhxEyWuknczhFRimI1omvQ0WOsDiZTKUxJGKUgCla+hkNcrc745OyMTdMyi5Cp8eAxFyiVDjSlgJJTqA6w0IZeV5rGy3FCcsZozZwSh1MoSCww5MyYheum46NuyUJ3v9kH9TcaQjltGoVKK0gJRAoiiVJqroPWDcVkChFlqs84FLQWrvoWZyCJMEchBOiMp/eWgGJWwlwi25hYNZ5PLnp6XS8VSil6Z5myYE3d2EQKIWUOofLnp5RJCWIqSKl2mZ3WnJ+t+dH5hsu2r1qPIEwJpjihqZaz93GuGydSp03K0ChDKfBmnAgxUnTdXHYhsp9rYRWSZhbhqmv50XLFxr9bg28DJSokKCSqumeEmRgtKQspJ1JKJ3MDS8GhKTinaLzGmXoJe7pZ4rUm5sIQa15IUxRd60hSc6SVrgX8pmn49GrJwteuvLEW7xRaa6zWmBPvP0nmGBLHXDimwjFk5lzQ2rDpPAU4X674eH3Ged8y68JdrGm5+zmyD4HbaeJmmui0ZRIhlYxVdSJaCrwcJ4YwU4BjSGzHwBAyWitKqWm/V23HB6slF8v+N/mY/ubi27rpVPQrDTFCTHXtSc4oAaXtdz792oAxf9Wqu1w0FCUcJbJLkWNKnHuPc5ajEqYizEXYlsRF7/jtqzWrXuOdqoGCulCs5aJtWDqPN5okiZthYqsLj0rYSp1S6aLprcICT7qeHy9XbNqGUWX2TIQEUykEKWxj4M000ihL1lXcqU/rz2Lq+Z4igmIfInfTxC5FNNCqhlwU503D08WCZfdu/b0tpDmRU6ZkwQK2aEKKZFGICCVXJx6tNcVoFAljBG0LmIwGNp1FA0MubLMwSASlaJwlaYMoTSqwjZmz3vLjsxVLbzHOYLyuxgnW0OFptadxFuUrtXDQwlFljrlmNmgFvTU0OnO1XPDp6ozLpmWmcBtnYqkOQKkIDznxIka0qlOvREJrsEafGtxC0pGcFbsp8jBMHKeApoa05pJZGsdTv+DCfr8z+Afb4YfKm1MFNIWM8PWXv+K5nigxYCk0VhNCIBvNoteoYhDRgJCz5pOn55iimXKqN72UGQ6ZISV+cnXJT88LIdbO5vXFiutnTzjv3jAeDxyHgbv7I0vfculrV6pB4VQdoZyfXzJnQeuBH3nFunMoCq92R1b46mjgNM5bzoqBRnhMEzHXB7a0NexjHGEis2k6nNXsUkD2kQ2a6cQNdKVgsmIeI//x5XuELLzebfny8YEpvOuuvk3Ug6ygckGVwt3t5xy3X6NSwpQq0D0MI9Y6OlOL5VIEChg0V5uWNG3qRaEU5pQwRjNk4cnqjOvSk07BVs/WSy4uzjlvHpnGiXGc2e0H5oXi1X6kXyywja9BXEqzWV8wEGinzEdOs2ocBcur3T3npk4mMiBoLsWyOtd8Mxy4m6faPTUa7xVeNUxmxmmN0zUgR6aJ6+LZ5doN06Vaws5j4R89+4hA4OvjPX/5+Mg0vetwvQ1oI7gCOtVArWEOPH/+p9y8+RO0CE5pvLWMw0izBm885NoMQUPJ8GTVI0lQokm58DBMeGsRhA+ur/kgCxITVms+OF9zcX1G5yzjfiQNkTFp5nPLZ8OR87YWNoKwXjk+vn7CkIXrcaLx0LWGNGe+eNiyonJuo1Sf/Gvb8v6Tnl8dHvjs/gACjTYkI1x4j/iemOrEoGla0n7kqnVkFEUrkCrsTEHxD5/W130xbvnz7QPzO9+Ct4QTUfZEZ9RK8fz1N9zfv8IT8EZwRrE/Rlqg8wtyOU1oCiCa9zZLSiwIS0pRDEOlPIac+PHZGR+vV8SUMFrxbL1gc75hbTuGaeQYZn5uNMFotqZh4W1d21lYrSzX1xvmLIRxojO60ipL4YuHR67xBBFSLjRiODOaJ5eePzns+foYKFLwGrKBFQppDTEJXim8dTwMiZVz34UV1kZLYiiKP7i8YhThxWHLLx7uOI7vzuC3BckF7RRNq9ksDWTh9uYFh8fXKBLOQGtrd9xaQ2cs5cS+0Lp2/N87P6sNKlngUOQcSNkT08iPzy54r4sM0/TdGXy2XlUXp7mKYXeNZ8BwpNC2LbWPL3zQtZyvl8xZyHmid5V5UUrh+cMjKzxFAqOKiIWNs7zvzvnFbsvnYQBRtCju5yMdll65Wu8qWHrDbioscoOc5mWJ6nbVDsI/vr5iwPD18ZE/u3vkOH6/KecPuOCvbyIBMlCy8PTZUw6HO1483rIbD3RG8duXV1z2nvE4IyUhpdTkz5J58fqBcY7ffS7EyNq37GXmF3cHVCrYXDsJT1eWbreHkNECXmuuvOdAw15mFsowlMxtTnhl+TALedhx3loa78i58NnNI1/Oe84ZWDiLUZoL17J2Lde+Wsr94v6BhzAzlcLraeQj17DPwo5Mz7f0JeGVZLpsKo0EhbWKTWtpeoNMgSuzwKbAFA+/sSf0PwV8y44oKPCGJ+8/Y9jtebHb8nh4xOnC73/whNX6nHTcU3JGCqQMGc+rh3umFCiljhHnLDzpzxiGHS93D4gIWirH8HLR4Y4DKgu+viwpgzXQd45V40hacZTEUQkbAjYEVr6j8YZYIs9vb/lmGljPR1rj0WjO2oYz37M0hZ+cn/Ov3txyN83kUngYR552lpwN3lTrRqgiqVcSqpeQUihVWHjDutUkkyljrEnTzvI6H3+Tj+hvLHQWMookp1GsM/z8d/4uD/ev+Pz1NzwcHuiN4e+995TNRcu4S2TqiVEvqpnXj3vKnMiq0sScEi56w/P5yKv7AzqBlZr6eH4yebaSaYxCG42zmtTAebB0vtIZxlRpEh/OATNMuKYWSXPI/PLFG17FmWZ/ZNl4GmO5bhecOU/nHR9uVvx3L95wPw5oVdiLEEPmmAO9t6fOVZWK3sRI63S1r9X1ELxuNDOZOUSufc/CeG7z8Jt7SH/ToSp1xyiFNZoff/wRu3HLN2/2PN7vabTm7z294PxiyXicURl0UZWGVuD56x1TClhjKj1Q1Q7/7RD5izcHjFZ4Xaka515jjKUQcQKLoGmUhr5hPiS80oylVPqOFZ7NAYaJ3joa4wgifPbmni+ngefzzNI4Ou142i9ZGUPnNR9uzvi/f/OG23HCGthLJFI4ToHeeDqrKbqgdOEggcY0KOplZ2ks596TbCaNgSeupVGWF+Hd+ntb0FrjvKbxVb8hufD+h59yPOx5df+a3XGH0/B3PnjGxbphPB6RLBQMWTQQeHFzYB9HSlFY0aikWHbwEDJ3D7cUpVBaYYri9riveruc0SIoEdZA32uGYcJkR0x1Dyx25Lz1MEdWp70uifD89sAX80g/TLTa46zjWb9kaQwLa3iyWvJv7rfsQkCVzMuhqkoHiZx5gzOaSdTpc4mm5g2jVWGhFevGcWwy4TBx6R1OaV6m73cG/2AL/m/1Cv82rq+ucE44pgPChDWGi/UCJZmYAvkkYixFIzicUtwlIeR0oi0UtvPMlCMXrqVxCu0KRmvGJMQwkVU9ZCmGvvO4piXODgzkEGljjeWexjoinImMuY607+fAojiiTuRiK8fZO1pv+TYb5iq0tJMipMhhcjjfcKkV161j7RtCFl4dJ2Yt2JRR1cSVbIT9LHyxvSelTOs9k2SO6R1/9W1CAeiqIem84+n5+9zrlzwe7jgOuXY7zzY4hCi5eqAL5KSACSWFMeaq2aDazO6OI3cxcmY9zlgw9d/PZHKeKFQrr6IzfadZdB0yF8TCmIVGNJ01EAsOWyPhc2SWyDZnOt8gQRBvaJ1n4Wz9+9TuwXXf0WlFiIkpC95oWtew7g0Lbwm58GI6MmvBl7rZGMAUzRjhm+0DZKFvqyDqEN75UL8N5FjIJpPJteDwDddXT1FMPGxvSfORbunYnG/qHhjH0x5Y/cJRBV8UN6GOkAVhzoLaw6tx4sI1VSR2Wt8TgpREkSoM0yZj24LvGq7EUKypDRGlWVhLSDOpFOIcMTkRRdhLxhmDzkCpbisrWwMH/Ulv9KNFz5VRxBgJE1hnuNSO865h2XpmCi+PI7PKkGpehTVgbU0zV4c9IQqLpu6Buxh+o8/pbzK+1YQYo+id4+nVE+yj8PB4z57qdHd+saouSjGRc66FfVYEHWmt4TBpYhREVT3I41D4y2Hk0jqu2oZl40FV3/+cEqkUkhIwQusseMtVbygGiIIuioV2TGMkhswsmakkQikcJLFwpibqKsfCGnqr8EZV8SPwyXLBM+8IOfKnU6HT1SzjvPWsvSdSeD6NZECLoJF6MTGWY8ncTSPDHGitq+5A6d3+97ag9CkgC03JtZHx7PKarVMcj1umYQ86szpbUCQgsZAzlRNSZiJ1atOIZ5ZElIxKcJwOvBwnlsZx3rX0jUdRKKlQvl2DUjVu1mpM49lIqbqpUuljnbWEOSIpcSAxZ0suikMIdFhKErqFo/cebwzOGFQRnFJ82LVMWjOFwC2RVduwSJqz3rKwjhgLt8MjSZ+MalD4k0B3FOH2OHKcIwttmbMwyvebsv9gC36oosfLsyU/+fB91ptzLi6f0HQOpTKrxiJ5orGGebfHSI2Sz0XVoI2cGObMNBeM0lhdrb3GlKBoSlKIr3zXtfPcb2caa+gEilboxqOaDpRGxZlBZ3zjeeY1SlWXnUNINKZyBqNUl5SlcyDVY90WwVDDR/CWGGN9YLoKcUUKjzGwthYShJKIQO8djVLkUB0DrKquKSutue4appTqpUYKl+4H/Qj/WuNbl4oPri/5u7/1E55eP+V8c41rNEqEVVMTdRtriccdJafvJgIxRnKGECJzEKwxOK2JqXCY03da4GLqhKnTlsfHCSeFRpmacmkcdtESrUKnyITgrGXpLK3RKK04zAGrq5uEFBhzYdlVLn6jDU1RuFKDi5S1hHnGUKlySYSQhUOJLJUjpAJkkgitNbQ0zCmTRbAn+shCW646T4z1Sp6xnJ3Sfd/h14s5ZSjC5dmK3//xpzTLDevzS6wTihQuHpaoMuCdYnw8ovJc90BRTFMmSWaeIttxpvUGbwxjKtxOc3VeKpqkwOpqV7zdB5yqY2aNQjkPviOiEVWYRHBOs/KOxmrQwkOc8L7ud7NkhpxZNx6LolMKXyr3tvEOrzVznGiMYtaaI4UQhT2FJ74liHAIkVQEbQwXzjOHuk6lKjbx1lRhZ8qUolCxcGbfJZ2+Fagqkn3/6oy/81s/4r0nT7m4fILvDArFxWKBpCPeGabtAZMDSimSaEIUIok5ZYaU6Zym1ZYYYTvn2tW3lqgNQSl6o3k8TFgdcEooqkBjKW3LrOpkICjBe8vKG3prgMIsCaMqRztnYciJpXeIKNoi+FJdxxpv0LohzhNeV4vQWYQYM4NWXDWeWODhtP7U6XNzqBcRJQrRGoPiyjsOVEquKOHCvzuD3xaMqkXqZtHz8x8/5Xx1xsXFNW3nKj9/0dQ1qGEeJiQnlFKIKEKIZHJtbIWMtwZra4PsGARbNLookghJMp22HIaAI2JVrnQubaDzhKLQyjLlXKdRbUPjFEYXxpioSU+ZmAv7HOmsI6PxReGl4HQ1LnDaEeYZshBzqtMqyYScufCOMWaGMJNToRhhYxrmVIMTizppCVFc+JYGUAly0Zx9zzX4g12pitpVeHp5xj/8vd/m/Y8+pW8XtF2H15ZN1zAfnqMkEeYBrUFrg4TCOAViyuynRIpC4w1OKcYUSaJQyjDkzJShFMuZNmz3A84pnnYNzhqKM8zKszuOTCJMSjjzlo31ILVgG1KqJECtyKV2eBvXYmZLh6BSJBTQqwXa10CIXIQhZ7YpMZdMjoUL13CcE/sSEa1YOkdjPQc1k8RgThvilW/48fkZuymwGyKuRJrmnWDybaHqRxQfXl/xX/zHf8AHH35M063wrae1DZerJdP+OVoS8zQgUkCZk8AykyOMIROl0DpDYxwpZJIkjIZQqtuTAE2B7XaCnLlednhbHViCaXiIB0JJhAIr51hah1ZCNoVDDrTa0qoqnPv2tRbW0WQFkpFYUH2LPRX8KVfLxYeYOKZIUQrnDPP0bRA4dMayoGPHDFQBsdeaM+/55PyMwxDZzRFLwr+r998KYooYCs8uzvknf/8PuPrgR/hmSdu2tE3PcH/G/PAVKgfmaQAlaG2JWTiOEzll9tPMECOtMzhlUDkzRsE4xZCr61ljFcsCh2MkpsyzdUtvDcpYJtuyPR6ZsjCpxNo7em/Q1DnCIUd6sVAUsRSiCAvnsMqw0ILJglDFc9pZclZEEQ45c58zx5wIRXHuq9VcHjO6FKzWPGkW7FVEpF5CJStWneMn5xt2c2A3zDgB37xbgG8D2iis1Xz09IL//A9+jw9/9BH9akO3aFn4JR9szoiHF6QQiGFCq4JSmlgK0xQppYq0R0n0uqExlgE4SqG3lqQ0jykxSuHCWvaDUGTiemGwzlC8YbIND8eJOVeHkpWzLJzDA0klZiVY1MnCuxBE6E8mHh0FnRKpgO411jtSmEk5s42RmzkwxUTSBjrDw+ljoeCs5VnT8VASYjIxC0kKS+f50WrFbgo8xIBNindH8NuDUwqrFOfrnt/92Yd8cHlFu1zT9i190/J0s2TevULiSAqBoqsNrOTCNGc0iUMI7FPk0rW02jHpap7hdc0H2YWZWTLKdgyjkCWwbqDRGm0t0bbspoGUNXMKLJyldQZrql13pJq2KAqRmmp/blrEgKOgUqr9u4bvzuAxRO7nwDZXd7PjHDkzhrspcAgJkYJuFRfWM5EQDbEIWQp9Y/houeI4a/ZjxqSM/s7T8v83frAFP1rhvMV7h9KKOYy0bolzZ5xdNnStYry5Z/vykRlQtkESHKeZ3b7GzSNQjCDGVi5sznix7F2A0/gmjNRMZuD2MXC56PGuIYvmLgRe7o40QOsLKiaOIigUCwc4uDtONEZTdPX9X/kOcqRTMM2RIc90XUPTd8SUOEbhEDPHVDeWlTV0KN6kyCiCN5beG1a24cwZLrxnPydeHQcWvWXRLkhJMTuQfxfv6R1+bTCnrnbbeFzjCWXEyxrnepYbQ+cLR3Xg8fUbBhGUcZRQGMbMYRI6o8lZo1z1y405k3OiM4aHmGhbDQLTmJklokW4281slh2NNQQ0tzHwYn/kTCl6Yygps88BBbRaQ4HbeaSNBleqm8rGtJANzkRCiowBrHc0IsSYmKVwzMIhZaKBRldnjW1IxFyt5xpnWVjFZbNgs7BsY+Sbw4hvNJt2SUoDU6kOL453I+23gTxHlm1P3/eoxpPyiJE1zp2x3LR0Fka54f7lnmQ0UVsIMI6JYYj03jJIxllDQnFMgpTMyhu+nEeMLmhdsFERJ9gYx/1u5smqQzlLKIqb48DLw561EpbOoqVwmCMKWGhNbw0P44ydAkZpWutYeYvF0CshzIlpiuzdQIjV3vgYMvuQGXJBOUMDDPPMoyRCLlipLkKddpz3jovOcjcFPns40ONofcccCkYnWiu48k40/jagtKr7X9fQrFqiOhKLoXHnrDYNnU1M5Q1vjluScYhW1RhjDhyHSO8rzUcbQ8iKo9TOfeMtL+eAPdlzWjSBxEIpXu0mVv2alfFEpbgNkTe7wNpqGqohx17q/rdwELXhcZ5oo65ZPU6z8R6TDW1JTCFyCDO6MbQ5k7OQRDEkYRcTIrX7/xBm9jGTcsFoxdJ4Wmn4sHNcto6Heeazw5GLtme96MhJMYUaXtjYd4fw24LTCmcN1lvwipv5hiSCdz2LM4O3iWO64fE2UrShWEcOwhQSx5DojeaYC8Up5lJt9gKCMcKbOaPJqAiNymijaI3ibsismgXWG7JSPMyZN4eBM9vRGYVGOMb6dUtfC8H7cTo1nTWNM2x8TcltEFLMjDGiTSCfpkopK6ZUXRe10cSQ+foUFhcEQLOiwWvLRWu46BseYuLLw8izxrFpqw14loRSCS1/zQt+Ywpd55nUxB+++gX5xb/in/7df87Kt5T5FoZvsDJA4zDHhvtDTT6NsTryzCmDgY8XF4SSGeaZhXcYo/lqHLHU0IMomd088aNVx24QXOMQB68f9/zLb24xwMoZnuiGp6uOq3VXBY23ezyGQ5w4TJnetfyDpx+wNhr6utFFN5LHiW92By6myMM48/IwsptrcFPnLFPMPFCLfa0UvbYYHDprfrZZ82Tdc0yZi13HZb/EWEPXrzgGQblCp3+wzqp/7eEaTdNZBhn5sze/or+z/MHv/M/xbkme7oj7r2C+QWvwGHbHSEhCioLOhWMZmIFn67ManhQia1UwRvP1A8xB0BqUCEjhg9WSmzyje0i6cLs78kev7jBGwPc0nWa51Ky7al346kFIOaOCYi5gWsPvP7ukN5qcLTk3BDUwjgPbYctFcoSgeD1O3M+RLHCG5SCCTUI4efm32tDRYrTmx2cd52c9Ryls+sBV32Gs5axviTnXUl/9YLeRv9aYpsCTJ1cEnfmjl3/M6r7h737yn+E3DXl4Rd79Ch3f4BqHmQ3bfUTFTJgTKSmOJVJw/PhyyZwLY4q0TmG04vmbk9CwgBQh2ch5v+SI0C4NYuDF/cC/en6DNzB1PddF+OCi5WrT1PX3agAsjRTy6WLxB0+u0Dhsb4gxMeqZIzMP+wMXc0POwt00cz8H5pRZnxyDglRzBqXAG82V7fHAT9ZLLpeOD7LwXr9k0zcYa1j2DdtpwhnNwvrf4FP6mwtrNY03BAKfH17RTIZl8yPc2SUy3ZCHr9HxkdY49sB+HAkpE+ZMSoVZF0rj+KhdECSRUuRCw6Q19+mUMSNCLJlRCdeLFbs80yw1xWpudzN/9PoBAyTtuV44rtcNF0t3OoMnPKbSICTTWcMfXD6p4WCAxDp9jyHwejdw5TOiDDcxcJ8iKReWJypEzDXJR2nwxvKJP0Nr4ednC86WLWNOvLdYfHcGr1cd+1g90Oz3yzx6h/8xsArjDFkVbqeB6Tjze/dv2Jw/QU2vSPuvUOkB5zU5GYYhEEMmhExKiWPJ9Lbl2XJFSokQImtrSNZwnyNaa3IppCwccuBitWI3jLSdAqO5PQR+cfNA0wDZsPFwsXScLetE/W4X0TbhpkIUsK3hP7i8wFMbsqUIohNhjjwMBy6SRwVhG2PNExHN0jnEn/RVKKwGpzXv+SW9En52seCsbxmz8HQV2DSunsFdxxz2ZFPQrvl+v863+az+/0HONW3s6fXH/O/+4X/G3Ys/5ss/+u84HnZM+y0lTrQNNG1PSomlU8SgONbaiSEoPtqs0NayGyeGqTCd0kivnePSWbxWKKVBOV7dTzzamZvPXqBE0SvD316v+FcPN3w5wuvDzEEyv+MVH16tOL6q3rBG19TJiLDbD+yx9LralSlRNFhKFl4eDnwejuxjZM6ZfApg6JcdMRdSgpRqyMiV9+wZmUzLWBTeOd4/68klYxvP9cpTRLh93PHquP9NP6q/sdicLbm8OuNv/9bv8k/+zn/O4fWv+OKP/x8cDwfG4xFCoDHQtpoYM95ojNIMJA5lZg6Kn12do7XiECKPUoXdAJuujqWNBm8drXHcbGd2duIPvwpYZeis4T+4WPOn9/d8vT1wN0zch5aPz5d8cnlGfrin15piEkkKMRVuHhIqBYxVNRG1ZBqlWWvPYTjyp+ORYa6jwQw4FMuuo2QBqbzvSRV6o7kl8h4ZK5rOen581tbAOZvZdGsimsf9gdvhnVPU28DDfEAfbvik+wn/i9//Zzy8/EN++Yf/V6bDlsN+S5pnOmNYrztiynTWUlDkkJCSGILw6cUK7xp288xhTrwZZhRwte5OKeDVys4azauHkVln/s2LbQ0MFMV/dHnFv3l4w5fbHTfGsI2Rn8qaT59dckxbSoY514h4EXgzZMI44j2snEekYLVh3XhGCfxqHDjmiDYKowzK1EBEAJsKUQlJQ9DCmzjwJFlcdrS24cnaMUz1/XN+cU4SuH/ccbd955LyNrBcNFx8cMbv/O7v8r/+/X/G/as/5cWf/kt+edwy7XYQA94a+q7lWGZarfDackRxKImbcebTyzXaag6z4X6KfHEcCMCiVXgMDVVr5KxFVIHG8cuXe3RWGBS/ve75o9s77vLETfIcyPzELPngYsExDSdqWUUU4c1xwgbIRui0qcGDObNpPHtJ/MXhgW2IZFVwzmJQLKxloCZSlyJMOvE6zzQ5cp8sLrc0puHpQpNiADzrsw25GG62e15s353Bbw1eYdaGTz/5hH/+D/437O6+4vVf/ILPp39BmAYkzRgjrNuWlBJeG5wGrWruzH7OvH/usVY4FsWhwO04EbSw9AprLK2CThla1yG5TgtfHRMxBnLI/PxsyS/ut2zZs0qeQQkf0vL0bMVxipAhKk3UlTXysD+ZCJRIZ+oajDGycpYQAp8NB+5DIkpNsVdKcdH37MKMBFUb1wb2MjNoeC9kGl9oneN9a0kpIkC/9Kxyy7yFh/332wN/sAW/d5ofP7vg6UJx882fsH3zDfc3D5giHHd7UpopxYOyTLkKNLRkUsqEAkNIaFvwtnqjBi/EnJGQ2PRdjZlXVdADFrsqLLVhnxLTKIgUSlM4ty2vxwNDFFZHxcPR8eFqTasd2RYWvobXxFR4PGaiHNh7xYVv0OVkaeY9h+2EKoqNd2jvmKXwJk4McaKjJvwZVTsb9hQxv3QObzVRErsw8mYa0Y3n/aslTQPOaOSdD/9bw9Vmyc8/fsazteXmxV8w3D9nv92TUmIej5UP6i3Kd4xZE8aIKlU8ljIcQ0TrhHcdLglWgVd17P3h5gytVE1ZFkGU4tlCc25ajseJXMBgIVnWuuN1PpALLMbA2EVyUvS6QYywbPx3oWD7KbILR1SxXBaPLkIpgnGGbUhIgrWzaKsJqQYiTXPEWlUD65Spo3wjFDRn7YLeaqQkHsfIwzjxzGiebhoaq3C6UuXe4deP68slP//0fZ4uFK8/+0P2b57zePcGWzLhcCCEgG47YvI1/CrMmAIpFpJWHGJCO4PzCp80vXFIW8P83lu3aAWIokg9dJ4uNdEXslimOVHIZGDjOl4POxyaOSSmISBTxjlH52DVVO/pJIXjDFOKHLRgtcFIobrpW3Yhk0umd4qlt4RSeDNHRApeGwo13blYTWccUDjvl6ycZ86ZN8PA/XTENJq2szivUcZwiO8oZW8DHzzd8PMff8BHy4abL/+cx/tX3N/ukDITpoESI6Vx+EYzTpndXBOgUxYCcAC0qu42rbcsEsSQ2KWZHy02GKVQkimlILo2yjbnH7Lf7hnGCURoiuHc9tyFI03OjFPkcAyERYtzBgf0tj2tPzjOwmFOTFa4cjUskdMZvw0DWQqdNSyNQhK8mQPFfZs8Xl3UrFa0uqAxnPcNndOEGLk9Hnkz/w/s/UnMrll21wv+dvs0b/M1p4+IjHA603YaG1MFCDsluFVCIERJSCU88oARQ2AAYsIIGHnIyDBCMEIIZlVCQioYVEkIF7q+GAMGOzOdTTSn+9q3eZ5nt6sG+82Ae8GXyLo+4bTjrNSRQudkfOc78a6z99pr/dfvP/MTneHZMNB1it43YMLbeDPx5GLNj3/5XT64WHPz/Nscbq847O4QqaQwNw8bawheOMZEDE1aWErhUBL3MfGuAqc9nauMnXCWPLMU3lmt0Uq1BXEBMIxG+NHtmu32nKvre25vbnFZOHOG7y0zPkMMEBZHGjJOa9COJ33X/KKqMGchpczeLFzoVgdapRmM5VWKFFGMTrMyIFWxR5ATZUdpUFVhRDNohQLORk/vNKkW7ubA7Rz5wBge+hFrDNYq8meU1f7QFvzvno086Rx2mbj65Hvc31yTl4mlKPbzgtTEanTUWlBoru8nSi14axm6niULS6poC6DxxrAaHLk0+22FglIopbCkiJbKqAx+s+KOmeUws5sig3IggkhhSZm7Q+DV9UTvHPcxcOEtFsUihUkLSy5IMUw5o6VSS0FL6+hzGlsb3bRiNQhaYGU12jb30owC1dxdu5MEaZ8Kr5bA62nh/ZhY5owxhn7wOP92nvim4kcfX/DedqQvgduXH3Pc3VJiJaTMMURqLljnyCKg4H4KlFpx2uC9oxPFFJvzbhXBKlj1lrtjZbD+hOLMxJqYU8LWwsqP2E3PcVmIKXIsmVFbqghJCqFUDkvm6n7GGcsxR8ah5WCSwqISBkhFOErCUFEIxIUscqISCFYJSisyYEWarbxRJNX+LKimr+29xxnNfgm8Pk7chsDDvCGEhNbgXLMCfxu/8/HVhw/40jjQLxO3Lz7k7uaaEiZCEQ5TpJbM4CslV1SFm/2MEqG3lvU4ElFMMWO0JRcwRnPhNDdHWLkOrWBJzW085ISqmc72DN2WG47c7XdUqaxU676GWphykya+vNkzWMN8cinXCpZcSUkoJ6v7Y8o4EZBKSZFY2kJ4lJZbhSYF0qIxwKA0RkCJAtUekV3n0VozLQuvjgeu48KXNmvmecEazTh4ureUlDcSX31yzgfbFWMO3Lz8iN3tLSUubQ9jiVAzzhtKbS7JL/YzlZZ/q75jiTAlAds49oOz5NEzHxMb16GUIqTIlBJzTCibef8rTxiM4/nra3bHIybBmfOgDsRSOKTE3XHh+sbTG8McMmtvMKo13QLtXItVOOSWfwphTomcWkFf5PuGYg1/nKXiFYxKY1X7Xu2JRzp0HqsV9znzalp4lQI/kjPLHNBK03mPNW9ltW8qfuydS778cMtGFe5ev+CwO6BqIBY4hkQtmbXR1AJGLLfHNm3ujGbwliCaKWbQhiqC05p135GXwGg9WilCycy1sORI1IV3331Gbzu02RFrAdFslEFJAw5MubKfI72dcVqz5MK673Cq7enF2iS5pTaCjxcw0ozbSmr0vxNAHqFSKsRUsFoxGNMczWmPZQBvLVZr9jHwapnZx8J7uTItGa00vXN489nqwB/ak/LZaqALkXR3z+wc+92MqQv3U+UYIt62uiTXgqJwf5zYp8z5asXDdc8cC/dzohpPzc35b/COvW2jb60US60cUuJqmugAvOXZ46cUUUzTkWMSet9mAKKEpVSuDpEx3fPuo3Mkg3aglKARBq85ZEilsqM9IlRtv7eiLViGIlQtOA09hgHLhbVti7sUgtDY+9DMckphFyIvp4XdUqBW5jnTD55x7Fit3upX31S8d7ZiLYJMM0FnpkPAKjhOC3PI7XKgaZUB9iEwp8ym7zhfDVQst8uCmEjOGaVg8JbbOaFVy98iwlwKt8sEtbAxlsvLJ0RgPx8pujKcKup8IjzdLhF/s+ediy01N98JFI2kYxSddsy5sCNiFVgUU5qbPhDFMTfZjtLNTKdTik5rpILTlaKFetr6zwipVPYh8mqaOJSCAkIsWK/wnWX0b7GIbyLeW68ZlkQte6If2E0HfM3cT4kp5JMkUZFCRgP300Kqhctx5L31hlLg5nikFE3MFURYOYuoeHJWUOQaOaTEzbIgJbJ2iq9ejuglMMWENYqVNqBgKZldUlzNAVvv+ZGHW3ZFkKqaVwXQa6EYTcmKXYk4OPlEFqhtyXHOuUnDkDZlVRqvoClYdXPolQQ0WSepcrvMvJ4n7lL7s4alMIyGzeg5X7+l9LyJeG+zYp0Lcjgy28BxP9O5wDQVjkvC69MdnAtOwd0yseTKg9XIo/MNqcJdSGTjGLTGa2HoNGrS6JNzbyzC/ZK4C4F7k7hQhXGzxu72zPsdkoXBNOO/qWTuE/Qz+Gx4ejGyS0Kx8P1VNq8b8rVm4b5GBq0YlWbOEQrNcVoqUSpCxbnmsNsZzYDBiiAo6mkRvIgQcmEXEq+WwL62s35eEmPf03vH0L09/95UfPnhGZdWocPCUoRpmln7xLwUppAwqnkrlFgwKPYxkkrhvOt4Z72mSOF2DiTVptFGKXpnkSVwqqdbjbUs3OeElsSqFM7IzWOhFhKKXimsMiwV9qngSdQiPN6smvuzNISnUuBUJinBJMVCoqqmJkmp5SC1kkWRqlClYDEspTAYDRi0avdvPt3BqVZCLuxT5HVYTkaMiikWVt4xOs/mM6LyfmgLfhMTu2lGb0a2Tx6QamU3HbjdVzqtWDmPiGY3B0RgXwu7kvE1ocnoXHk5TcRqMM27iq5ookCpCaUVqS7cx4lP5gPOG46HwjvdVxqVwFtGDFIquVaSEm5LRuYFF+DZgy0P1/3JVbWSASEDmo/nI8YIK2MZdfNMtVLw0li+qTbE16P1yJBAdCUUQRnNWmu+v37x4u6eTsOLeeL58cgcINHMThTC2Dkena1/1z6j3+/hlsIcJnTfsT7z5FQI+cjdITEoxcZZDHCYF0TgUBKHXNG5oisIietlop449laByxqtNbo2V9uplFZML7Hht9I1f/zh4yZXcOA10HDsRBHuJLavlwvvbkcuVn0z+jpZ1WltKMDVNOMMdNpgMWgFozGNGkD7fSvC07Gj5oIAUz11VZVBaJf5y+OOAcvrOfAiLsTU/j+ZhhxbdY4H2+3vwqfz+z9qXNjPBVmNDA9XhJRJ4cj9sU19tr3Has1hnhHgECOHUtDW8l6J5Dnwct4xLeCUobON4rSUglRBa0g5cwiR1yFwJBHvXvL48TOEdpF6DLFkahSiquxLxkVNlzXvXwoPt54UhVIUgqbWzLEW7lKiSMaj6Wjc9k1n8UUxYDhWoVJ5d+yYS6Wc3MazgEOTawGBD+/u6Wrl9TzxagnMoZBRiDHN2Mt5Ls/fnoFvImxKHK4SjD3Dgw1zFWoI3E8ZL4rRtl7kPIe2NydwqIUuR2pNxBi4ZSbViuo8g1WYCiVrSo2gFXOauVkOXMXInsqH/8u/4X/66h+kdA5cy6lCRlXNIpn7kjERbKg82nouBkvKTUIkqrXK5pQJc2bRieotfdeBNLmEF42gmCskUbyzHvjkfk/RhqU2fKIzDeaBwPPbPU7By3nmOi2E0/lXm4CDwcPDs7cPzjcVoxjyIZI6Rb/uiClzL0d2x4LTsPK2NeHiRBVYpDBLpasVBHJcuI6BRQwPe8vaNplXkVOjVsOSEtfzzOsSiaXyvV//dX7ug6+SSpPVGqNJ0pzHpxS5k9Y8KSnzcFw3kEw5CSAFVKnMS6EUSFKoJ8Ts93NwwIJRTCpTqvDYeb43BVbQ5Om1LYLH06Pz9f5ArxWvQ+JuyeRSSap+WryP3vBw83t8affJ4wu+8eo133j5Avv6E757f+SsWlZjhzGaj++OqNsDP74ZeD0L729GltRMjX7ley/YeIdjhRSQ3KYCn8QIWP7z4Y73L0f2KbNLFW0ccyysMPzyv/u39NoyGkewiillLvqB89MIPFG4RRi3azYrw/PnR0Jul9ChzC0Bk+JuTkSr0Cee63cOO6IuTLl17rWDIVU6YLcktrp16mMGPQwMwOvlgKlws0SOsY2dNp3HKYtCkaoi8ba78KbiwcMLvnN9w7devsQ9f8n35iNPTIc1hr3RvJwTXE186cHAh7d7Hq4GznQzd/v1l1eM3Yhng8ZQa+IQIy+nRM6V/3j3inceb5kksauRCpiieegt3/jON9FaYXUjWSwRLp1l6zqM0xQN+yKM257NasVHrw7MUYDKEiNd5/BRczUHkNKKQ6u5KYmJwFIhS+t2SQwMaO5DYLSOoir7FNn6kQvg5jBjjOYmBO5DJBdF10EHOC0UUYh5m4NvIh5cPuDbr6/4zY9fIh9+wneOR554i/eetVbchxm5vuedzYrnNfNk7LlImWlJ/MqH1zwYBs79I7wxpBS4Pcy8uDvQ+4HfeL7j4XnHMSWOuRnGbbRjoOPXv/Eb6AqdMYy95XjIrJzmy92K3juqbvpsP3Zsthuev94xh0w+cfVHr+li4fkUKFXRa8doLK/mTDALKE2hGYR9fEisPRxjaTMH1R4CWvfUlLibD/Ras4+J/ZIIUjjvRpxSGFOpYlDy2S67t/GDxcPLh3zr6pZvvrqhe33FJ8cZSHRu4HHniYtwfYw8HDwf7jPnWnNmHSlU/t3H12y8YzAtZ0QquyVxPWUkCv/huzvevxwbHUcZvHY8ALpj5X/+9/+WzmrW1jHQSDsPvOPMrtE0o6RFgR97tquRT66PzDGRc+EYZ1ZecUiaKStuY+VYIq4qZoT7MiEYFBaN4XZZ6L3mNiYaL0oIBZzzxFS4Pkx4q7kPkX3MzHK6g23FWkuqipjfymrfVFxcbPje7R33r17Tv77mw8PUEK7O8rAfmEtB7xMPh57ferHDDa2TH2Pi16+vWXWeC79lMOClEaRulwpF842rIw9XHQlF5z0XRTGFij8kfv03f4POGlba4fGAY2ThnXGLKMUiLRfG1cBma3h5nTgsBaFwjIWugxgK+yjMS8HPFamF4IWpFCgarQxWWw7AWefZl0aWVBqi0Cq7WrkLCd8p7qWRfULJbLxHrMFZQ62Q5LPJyn5oC/6Xt7eUmDAi5FyZU+GpGxmN452znnNv0blwPQWuDhPvrTZ4KShVGcaei3XP7aFwlyP3YSHlyOgUm2LJVfHxbUSbSq8MxSoeri3zHNkMPUprlGoasKu446NSeV1mHvY9D/2AiPDdl9c8Oe94fZyRotBKswuFEXgoFlybCuxyhNqIBBvfs7KJubYe/bnx/OTZGSFnXi0LtUJvDZNVvDzseFdGjlJZRNh2liFa/sW3vsPPvvOUd/SGzjq2bxU9byye391TloTJzUl5jgmGDm00T1cD551DSW1/CXNh45pur1MGZUfGwXA3V44pcUgzSw5oCmvb0xnN7pAJkiFXhqJ4fLFCRcVmHMi1Ukqhc5ar6UACrlLgUndcmA7l4HtXtzycKneHI6VWtNbscsHnwmPtwdP8HiRzyBpXLGfG0yMEVSlKWBvHT50/YF9mrqelmYA5y7EKH833PC4rJENIlY21FFv5f33zQ/7wkwe8q9d0rmNwbznobyK+9/IVc5xRtaCLIsYC3mK04sl2xaOuQ9fE1XHh7m7mnc2KWoReKUo/cDF0fDwHYs0EEtkUjBK8dkDh/j4x10QqFSXw1fXAHCuXwwgValVYaziapv+/yoFHWvPQDyhl+N7LW56ExM19gKpxSiNFmEJlLZZz5zikQi6JYylc+A7vRvZSOEohq7a8+0cvH7BI4vlhplZhdI6jqvyntEctbXFtyYW1sayw/D++9S3+6OOHfOn8nNELvYu/2x/V78v4+Po1JWTcCVm5C4nzwbBy8Gjd86jz6FK4nSPXaeantiNSK3NWZNsx9o7rpbJfMjsisSZSqqz9mkzl6pgJNRNLI+t9dTOyj4nLzdD0y7UtO94dGqt8L4mtdpx5RwE+uZqIMbE/RkptHf6cm0yoV5rOGKoSHO37P3OOrRZuaiVII7kMxvLjZ2eUUvh4P7GLGdEt3/dzYN9laqzsc6YzGo/m//mt7/DHHj/indVA797ewW8yPrq6I8eKqwbRwpwrg4G10Twdex72HdTM7liZgB8fHaoKoSjEOsbR83KqxAT3IVJqw1Gv3QZK4XAszJIINVOU4se2K2KIjH2bCtUqiIa7eUGj2aXE2jkubY9S8HJ/Ty4DhzlTakWpSpCECRpdDEYXShUQhdKGDQZKYFGFpBWI4cJ6fmQzEEvk43nhLmayCM5q7mNgwnIfFHOGlTWMyvDPv/0RP/NoxZOxZzCeUf8e5/B/eH1PoaBEODeOC+1YKJQUeZA6rDd4r1l2kUUJN1Mm1soiMGjFYY4kNCvrGI1g8aysZzdVlqVpk7PKiK6sjeXZekUZBqpALJUsEHNhNq2IKwIUwYgQSuW7t/c8XzTToaCrYuUc533Pq7Cn6GYeY06vtN4YXlmFNbAyFlMUWYRz43lnGIlSOOs7qiiqaF4sR76rMy9jwCnNnAvXIaC1Zlssz+eJTd+xRVHK22LrTcWLqzuUAW1hqzou58y+VHSYOfcO5Tu0MSxToTjNPjRHxiQarwo5ZsDivebSdlgcXmuOUybFSK6ZqCLFFsbO8aX1BgSWLNRaySLMITLVJrkRTgdQFapW/Nbtno8PgRAzRmB0nvOx4/oYAKFDo03TX3vt2KdEpU0OKgotwlo5Ho6eC2l23aW2BeMX08zHpXIzBQZjWXLhfkkYDU4nrncL5943Q/G3OfhG4qO7O5RtexlnxnJhHXOCKImjX7i0Bms0S2360dcxUkqhYPBWcRUCAqyd5dxbDANGaea5cghNPlN0wVrhDMuDfoRBMadAkCY7JFQmMqoqECGXwlwSYgovbheex4UlVkxRbIzj4crxYYhUhME4LBoxtVF3OjiEglCxpz7rJY6LziM41q6jCFSEq6l5pdyHxGDaYtxdajsFZlFcHQMXw4JWHTG9JZW9ifjG1TXaaAZlWBvHFkutimNshlbFWpQxHEtFG819KtScP3WzD3Nzwe28wyqHxqIGzRIrJWRSEQLNyfbMOB4NPRd9RxJFypVSmhP5XQqUmhERoigCiqIU/2l/xzpoalGY2r7PrTN8sgSqhQ6FoFAK1p1mUcKhns4/aVtK59rxqOsQKitrmLOwVLgrgb3L3C4ZrYRjLuxjpteaSQovjoFz73Hakt/m3xuL77y+xnaWwRguTjmYa+QQKlOsJC94ZVhywveKOQu1VGKzviVMCY2mtxaPxymHNYZjrCxFUWohUUHDRhkeDD2qs6dfF0pVzbU3CuW0ZJsKRCpKK37rPvMqBGICUHRGszWK25iJOmOUxp6MLUdr2alKjBWtQNMwsENVXHYeAVbOcEyVY6rcp0J0kftUANX28mKiUxqdKi/nxNoOOK+R+tlIeT+0Bb8+aZb1CZP12Pfc5ULIlWMoHGxlcFCU5nxccZMzvWmmMjdhYVsNexQXNBpAUsJ9SlQF29GyS5FYNRSFRmEwYBR300w5OdjOtTRTopO9c66VfUworTmmyIXxrIeOJWammnhoVxAUItAZi1OK0Vi23nMIC30pYJt7q0bzwDmc0biT9vA2JK6XwD5mOrF0StNrQ9IFaXtx7Ermk+ORp6sNg+uo5e1h86bC1bY4U0TACA+6nlcloGqbOB1TxitLFc15P3ITA71q5i13MdAViCWw9a49FCnMCqqqDL1nSYUOh9OOzhi0MqAKN8tMzkAVDjVyXzKqVrTSpFLYhYAzhl1MnCnN9vS15pJ5pFcoHckIltaR8laz9h11X8ilokzrxmoUl97jjUIpR62ZmyVyvQQOMdFjGZWlN4Z84vZbFKEUXofAs1xZC21h6W38jocTTSyVBFQjPB46PpoDXsEUE4cQqd6jjOVsHLheZkalMEZzmxZ6UUy14qQjqxPyUoEyivVomXMFcWixuJPMQRm4OzTHZQSOOXFbmjZVowi5slcRr5uL75gt265jCYlDiTzRQ9NSF6E3lpU1OAWX/cDLeGTOBWPAa40zhnPn2gKngFNwnyJXSyDkyqg8nVYM2pC1kE9whLkWXi4z7+SRlXg+4133Nn7A0BUylaRBjOXdsePbYUZpQ0yVECvFQRXNuh+4joHhpFOeckRrTaJyqdridpZC1q3bvu41Uyz42qQ1ThoAwZnK1RQoud39kxQOpd37qgoHlcgWeme4yxGnHNu+J6Umpby0Hm00RVd6bXHm5L7beT6eF2oWeqMbDUUpLm1rwigFyRoOJXGXEnOBUTuojZ4StJBJlCLMqvJymXkvD6y9f9vweIMRSyZEASucKcOj0fLdQwSjyLmSUkWMQpRi7Ttep0gnbf3/EAPWKIooTOkoVCZVwRSSVEbXIZGWJxhUal4iWmtuYySXtskWamWqlVAKGjhqoUhlNJbbWDBGsfUdc65MufDAdShdEYReW7zWeAvbzrAcAlUKvdbNZFUZ1rrJkJTSpCocYuGQM6EIg7ZQwBpFBALNaMoUw80SeLYSNmhEfo8X/INuXcVcKlUrHgwj97sDiLDEzC2Bo1VkhI3veTXvGExboryOC0559lLoKlQNQZq+6sJ2bIeOSRI1WCQrRAoxt6XLF9OMUe0yus+RYy4Mp+3rVCt3ObHyHqM0l27kwXbk1XTk5jiB0ay141gzzjbjpI2znPWOl3cGkxPZKjpjGYxjsJpjaQughxx5Pk98fJioYhm042Hf0RmLyoqDJMjCoWbulpmp1Kaf/oyWym/jB4/RWPY5NvdIbzgfOl7tZwyakAr3c8SV0ri6tuNmmum8xSjFIUWMGG7mAyaNoCBKJunKee9Zr1bIccFWh1IGEA6xUiXy4njEisVrw1UOHGv5lHYScyaRGbTFG82DzvNss+V6Xng9zSilmySiBqy29NqwcpazvuNwnEmlGRtpbeiUYfSWmFvHYZ8iL+YjHx1npEJvHI9ch3MaZZqZDrURq441k070KfsZD5u38YPFynhiCSy1MGt4OA58a5rp0MTTxGUuiqoMg9e8XGZG28ysdsuC0R23y4xOBVGaosA4xcXQcTGMqDmioyXnVvDELMRSuA4RXRsW7nVcmEvzjxCBUCs1C9pqVt7zyI88Wg+8MkeupwWUY3SOqcS2A+AMK9s6ZzfzxFAga7DGsLIWbw3HnLG1cpsWPjoc+fA401lPrx0PvaF3Gp0VO0lIqmCEQw6E02KeevvgfCOxdp5DyeQCyVSerHv+83FP5ywpw2FJqCjUqumt42ZesKYVL1MprIzi9Tyhk0YQFgpZCRdDx7P1QFUFkxy5NG56zBBV4fWyYKvG6SYji7WSi4JSSaqQTjtwXlnObftad0vidoooZ1n3nmOOeGvZOMu6t6y959W8YHMzvByMZTSaTiuWnDGnhuDzZeL5FLB0DFqzcYrOWrTW7EtBUkaMMKXAUmub/PO24H9T4ZRhPpmwRlO4XDl+c9/oXrVU5iVRtKJIy4fneWGr20LrPmX6TnMIBaXblDxRwcLYGS76nlJgMB6FYh8mplQoFF6HiBaF05q7HCk0aU6VRm6qNOKPRrM2jndXAzdz5GoKGGsYvVBTpjOGlXOMXrPpFK/uY/MmsZqVsfTGYgzMOWN1ZZ8SL8PCizlgtKMXxVobOtMwsrdVQ2p+FykXilRE8Zmbbj+0Bf99iBxzwihQvaVzA4l7Ns6BJO6mwJwqylvu88zaKHZLIamKsYqjBYnCUiJKDBvveW8cARARdDFYLSjXdFQ5V24PE0tpoxqR0lxRrebCG5ZY0FphjCLUwgf9lnPfY2rFZqHD4B2s+xV1PuBtz9obRqdah64TjDakRkUnK3heItN95twbPllmppw56w37DMcqjN6xdg6dFaFmXsrCQ+c4dw6v25JmfVvwv7G4j4GdZETBmVF0TlNrwtJTc2ZXEuEgKDx7CqMRDikhWtN7jdWGcqzMKWCcZj1Y3llvADCm5ZPUQi2FXCHGxjIPuZJJxNpwcBjYWEtKDaWptCJI5aurLY+6HkdlAM6NQ2s463rilOlNz8Y5RtdMZbJpD4epFJSA1opX8wKlMljDi7CwVOGi77gPmQD4TnHmPJ1zVKN5tcw8sp5z7+i10HqAb3PwTcR9CuxqQimF1g5lXSNLGEWpwt00M5UjwzAQY2WwcFsTtSgGY8FpOBaiEzzwoPN8cN7yL9uKnLwWDIVahJQ79qXJebTSqCrMpaKUYeUMU8qIKFCaKRe+st7yoO+wuskhqu8oWrhcrYgpY3RHpy1ewX3IDenqmqupkYIWRcyJcBMYrOY6JxDh3bFnXxQRYew8a2fpO4d3hg93Rx72PWtn6JVF5LN3t97GDxY3MRGpJ2SqZxFDrmC0ZskNEbikQud7ItCjOeaKtsKm93hvMccD+zKjjGbTOb48rgDwOKyOYFojIylDyoW5FHIRCpWQKru4YKxm7Q0hFrTWWKM51MQ7bs2F73CiGEVRtcNozeVqYLkraKWxyqCrZo4FEei95Uhp96bW3BXY3U6MzvEiBZaSOXeWiCJI4T3vGY1nsB5jNc/jgce6Y6UVPRqRtn/wNt5MhJMppYhCxFGlp3KNpjCnhRwDU64Y0xb3NwpygVCgF4PPQimVO2aMtpx3PR9sBoBPb63BKTqrKWJJotmFiVgzTllqrRxiwitYO4gVrLZoo7mrkfeHFQ+7RktbGUP1Du00Z9oyZwfScqRUYQ5C0IXRWhaBKqXJdnNhd7vwcOh5ERcWaXVgLu2uftj3rCw4FMYq7pbAo75noCGTDa2m/SzxQ1vwo4VbIlPKxFkw09LwSAluLWAUxjqeup4VlkM+kioYZbg0hpuYqbFwttmwcobtyvPuwzMAXr+6JUjE2Tbai6lwEyeOpbLkStTtxT6icdo0cYQXcmljxjNv2nKZN8yyEFUhaeFqmXnv4owpJXKpHCOkYkil8HouPBw6aoUpV3ZpIhtAO17HyOPB83QYmEvlP+wmejSfLAtDiqyN5b1hzTELf/rZM6w1jP0A6CZLehtvJKoI+7Qw54wU4ZMloulYToxco0BbxQOv6YplijPJgDeKtbZchYVYAmM3sPKG82Hg6fYBANN0x10tGK2xRlFTYjclFuCYC1EqRhtG0zN4BQiV0ORmYui9pWjNOA7MeeG+Ru5qJET4ke0FY+gRgTkl0mmL/7ZU1oCpzeTtSEAZ6HTlJlbOu4En3cCcC/9x2oERXs+Z+yysvONJNzKnzP/1vcfA6RGAZpbwu/ch/T4OpSr7GplyBgrMlsu+p5bKjpOTrbVsfeO3Xi17LIbOWEZtuAuJQyk8VY61N1yue969bGfg7fGeu6owWjCuGcR8NC8NjxkT5ftyymq4HBzF6GYsk9vz7vt+f75zHHLiJmbuU+CwRL5y/oitGahFONbIrGsr5mrjpI/VUGkYxzktfMn1vIqRB6uBZ84yl8p/ujvgge8ed4zWsrWerfZs7ML/5Z13AXB9h9Aco9/G73x4rdjHzH2q5KgQmRmNpaTCtWku8razXA49W635cNo3yUw1eGAJiTlXznvNSmkej56vPG0I39tp5maqWAxKQyiRj2ahlMJtjISTpEyhWVuD0RrlDaVoKNAZGLXifOw45sBdyewln86/c867gSrCMQlLSmgtTBG8hXW1lArHKBwp4GFaIg8Gxzu2Iwk8j5XrufDhEhl0ZmUM59qwq5b/6ekTAFw/INqQ5a3T85uKldJcl8x1anfwyzBz5geKJG4XhRWLVpqHnQHveTEXFIruRLkrJJZSOXeeTikunObptmF8p+nArIRDzBySsEuR6Rg5srBLBVHta9UK49DRVZq8WjcZeIdh1J7z0XPMmZsSuZfItM+8d3HGxdRqiCU1UEsnmhgzTnl6U9uvxcwE4BUSE6P2rI0nC1zHwlQKr2LAF2E0lgsGIpWvP30MgNYOQRE/4xH4Q1vwf3Q4kmth1AYtilISu5jQuuIEjAKrNdGtCWkhohALZ0PHT6zX1FD4f7+4Zp8Wni+JeIAn04E/9uQdXh123C8LShnWnWPTOXLUPI93GAWmgtetqJ5yoBDYeMdtDLwKkSlXktYspvKfDzfc5YDXmg/CmuNh4Wf/0Ndw1vDxyxs+/OQVo6789NmWuxBPRaJB4TgqGAfHe8by5GLL0Hvul8g37j5iyJpbZm5S5bHv+dFxyx++fEAtwutlxi2JLMJuekuoeFPx3XlHKW25sOSEi4X70mg4DjCmjRx7eo4UknGIqqyd5SfO13w5D/x/5kBShedL5LvLxLenPT/77Amf3C28mI6AZrCOlXcYA9+4vyeTsUoYlOLcWXYlE0vCO8chBfZxYRU9LjqWdMNvTjfcpIA3lq8I6PSan/rKB1ijeX614+OXN6xM5cf8wOs4o3Sl1wajDFMVrNVc+o7HZ1vGbuAQCt85Hllbx+u4sJsD1J5Hm47/8/kl+xC5XQ540yFVsZuX3+2P6vdlfHg8kEtrPGglFJ25SQmjNN6ArdIutWKZSiSpnqILZ4PnJ7bnLDEyzwkpmY+OC9+cDvzW8cDPvfOIb77acx0CheZKubGOTR74jcNVYzyrJmnbDiP7GpmXSO8tM4VjiiTp6GrmqA78xv6W27TQac2PyIqPX13z01/7KtYaPnl9w0cvXrPShq+uem6WTJCCRmExDEazGjueGM/l2ZrOe+7nzDfujmx1x0cxcJ0nng7wk6sVf7h/zG2YuTpGRu9Bwy68PQPfRLw6ThQUK2s5X3nmUtkfC6U0PT2AVZqtFmpNiDKIF8be8+PbNRW4OQRG3bGTxMvjno8/jnz96TO+fb3jNgWq0njj6LxhiJ7/fLhGK6FXTXqztj1TjdwtCyvvTx4PmS2e50Smmz3fDkf2JeG15h0RdLrmp7/yXjv/bvd8cn3Huiq+vB54nWYkZhwaowy2KradYz1oHm/WDM6yi4FvfviKp67nO9M9L2rm2TDwB1ZnvNuP7Evmdon0oZkqvc2/NxfXS6RoxUorRiMcc+BlCoy6TYiUiljRjLkjxCNFVaqCs8HytfN1MwB8dY1Tlr0UbqaZ6xev+SOXl3x4F7kNM5XmZjsaj3j46P5AEUGpNil9MKyZSNznDAYOMbEUYe0cL+vM8TryvXlil5vR5eOup17f8gd/5H2s0by62/Hy9g5n4MubTZNJpiajXDkwCc57z0YbHm1W9M6yj4nnH73mchi4Ok5chcQD1/Fj645njx+wD4mrZaE3FqmK/fTZmm4/tAW/VRptmvylcaLbP3ttaGoWQaRpWScEozS5VtTJTXKqwuDgUAK3KRFEMMZwXCLPp8C27xCl2ha10ohxrHzPlCNKgVIaUypbPJGEF9UWiwSmGtmJoqYKVdHV1sE4c44qwq9867d4b3uGqcLTzYiuFacroVhSykSpaANrDO+fb6lLxCh1Gq9DrzQKuCiGq1o46sJRMs9sQ4IeayaHBKLejhPfYPRYqm527EsRoklI0XRaMMqgq8KLZqmZiUJvFVE0aI13BmqlV5pjLtylyCyFohW7ufA6Lqx7R6ltEdGbZpg1esPdohBlTou0lQGFs21xZzIGpZtb5KEuMDcG/soYBmNwxhCBX/veJzzbjBjg2fnYcjdHjmLZx0oUsFrojOG980timtHKoE5885WxOGM4U4brkplSYYqJZ6uRIo3dfp9aF478VsP6JqJXDqsrIsJSCub0+QxotGhQCiWKUoR42usINBv3wWjKKQ+nmtjlxJGKWhS7JXMTAmtnSLUtpnkNxQhD75nCAlUjyiK1sjIGLYI3imQ1oRrQMEkmLUJVlV5rBqXRGiYyv/ad7/BgtaJD8f75tjlL58BcKvNciFSsFXpleLZdsywTmrYYbLTGWXBKs6mapSjmlNnHwHvDhiLCoSbu54hBod+m3xuJwTmUanLAm2Xm+3yIThuMaffmoA1WCneqsLKWIAUjNDRsrRjTzJCm3FCsqMxxydyExNr3JFVBCSurqQIX3nOVF4xSDNpiteah6fGm7dVVgVgFtCKJYo7Nyd5rzWAN1hqyVnzj+WvO+wGF4ul6jSvCCuGQLHvJRMk4JayU4d3NSF4iRoM2Cq01RVWcsajSZCWHkphK4tyPFFHscuQmpTZlQ/3uflC/j6OzCm01oDiWyqFktDR3eGsMThtGZel0u6O3zhMpeKtYu0ZmGjBEMksthAJaRXYx8TovrH1HkWZk2pmTJt8brpf2gHRakyj01VBtBqWJ2mJqI/tMKWN8RSnBa4U97ccJim9/8pKzcYXRiqfbDV4EWyuHojkumYBgXHtUvLNaU0LCnnYDzGnh/awqRIRZKpMUiqpsXJtQHXLiLkaMqE8f4P+j+KEt+J1WiNbkIoRU8FZjtWoXh4BSDbe1pEg0la2xDNqw1hYlrXi+7D23ceZT03ajiLU5im6sbo8IgVAqiYgzipqbw2hVEKU0e47TxapV2wYP1HawpcRoLB6FUXJKqALXbTno2WrNw9VIrsLuuEdo7mmBiq2CM4qVMUxat8WzclJDG6HDY2phX5tDW5LK0Bmu94G7EIm1/ZnMW0nPGwurLKKb03IsFavbqLAt67QfIpU5RYIWzpzFK3UqkNrXuBx6djmAAq3AGEWsikPO9K5HG5AqpFJYaESIKoKicaWDNMdTqzWO0za/0ac8KjhRrI2n0/pTU5qblFHHgK+Vx9s1D7cbVBaudwtGGTLSHp0idKqhwFTVaDRIMz5KWuiAzhpcUVRVWaTivOFwXDjEwlxTo7e8nWi/kbDanPT6lVSlXUpaYzkhu1RDz80pEExlY2Gt25JsYyrB5Tiwi9NpBK0ZvKYgzFJYa4uRtg+QSm0mNrqdJwJUJWQtWK3wSmOlOVOKg4WMOzmRb4xtCFgRqlRucsEvCYmFp5t2BhYFt3eRolRDHkttfGrV8IlZGURUw85SCFJQDkZrWIlBVZhqxjvF62Ngl2KjZojC17cF15sIrRVat88klVaY98ZgdJuwGw1KC0UXJNdGG0OxNc2BN1XhsvfMuVJVa8p1zhCrMIuwVgpDO+9KFibJeG9OIAr9aS5qFKNzpFORZawiiVClkGiOv/5UKAHMtZKOCyULD4aey75vZLWpOaKnKixSyQqcEUZtWIzBtLU4KkKUglLt/BuyhgpTLviV5vUxcJ8aRcVojVdv7+A3FUq34le+/9ATxaibvFCd/icKgsoUVdjqjtFots60hoiqbHrLMRW0amdZ51rDbK6VtWv49HoCEiwUnGm1pVatZiy6YpTCV32SzigwiigVW0vbX7EN7CJIq0tLReaFUuHBeuRy7KEKx2lu5zZQpVJpf5bRWIKtp5pUURAiBS1tAtuj0bphbI2F+31gFzOhVDTgPuMa0w9twa+VbguKp8PAigYjKFVPHfh22S01I6ahO8+dO3XZQdcTV5zSmNJKcTE0l0hr9akxKcRSmaksJFLNSOMynQquttV93jmc1uylgIkUgVxqO1DGgaKEpSamWrhPgQfKscRMHYXRexLw0e09c2nfS6JSRXOsmZoS9lTwS20XZtGVzlt0tKx1peq2lGG84vUyczUv5NraWp/Rb+Ft/P8RAqDbQ09XsFiMEer3/8JSiaoSaqIojRLNxmm21rQHnNJcjj0SatvzwHDWOdDtoCpVUZSQaiXFhSOJWBtr3+iKooJueudt1+FQHKtgTCZQyQiihAf9QKQQS0KLcBsiD3VPzhWlNKt+oJbC/lYIWUhSiQgqV7KulBLx2nx6YZYKRymMWLRTDLTpQ1YVscLdlLhfIpPUNmF6i4Z9I1FpF57VupFxaA2PqqT9xVeCiDDlQDq5Mm+sZessmTaSftD3VJVJBkQrHq97jG7TIlG65UJu5J3b2gry1mkXlBasa2L9rdVoXZm0IAgh5wYqwPCoG0i1spSM18J9rqx0h6BAKZw1WKU5FGEqDa8p0naiFp2oMeG0BdHUKuSamUqhaMF7y0YLCSHWgljh5XLgdllaAQDotzu7byRSKRilcKfl12pBiaLSsISltsLYaIuq7Y7aWsu5se1+BZ70PS9CICjDaODR2LU7WBtEQS5CLpUDldcE9GnSrdpuOFY3z5yVs0wpYYwCFClVqspU0xjmGSFVwSrFEgtbb8m0R8pgNYLm1bEVdSKgKhRd2Uuh5IozunXqa/OfiFIpVDbeoJUFpZmLIFbxcpm4C21SjwLz9vx7Y1EqqCoY1ZptSixGNVeaXAqpNnpP1vrESqrNYM05mn+44mz01GNt545VXIwWpcEZAzTSTSyt6XYnC1LBKN3ufQWdaffitnYcSyZQWCqEWhq9rBi23hNrJZZCZ9vkaXCWLAVFZXCOIsLVIRClobutKIo0zCsl46xGnc7xcmq8FQUrazG6nceLNNLVy2nibkkk+f4Z+Nly8Ad6mv6tv/W3Tp31//Lja1/72qe/viwLf+kv/SUePHjAer3m53/+53n58uUP8lv8l2/sZDE8GM3jzrMyDqsVzgjGNjbIIWdwBo2hGmnPF6OJWkhGo6rm3A28u1nzwfmKp+uenBeedivOfc9UCs+nmdsp8HyauFtaB8BqzWAtj7ueJ13PH370iK89vOTReqTTlrFqtChGbfnKxYavPTrnKxdnfHW14YGzDN5yPnR4owklobQQTrIOkYoDtEj7/kNmNIZSFXMqxJPFNy5jnOZsdKy8IeXKNBVexYmbZeYmLNwsCzfhi6Of/jzzD04mVwK9NjxwPb1rUgZDQdE6CrOC6CxOW6pqpkIFxaItoi06VtbecbnqebwaedgNkAvv9CMX3hNC5vnuyMfTxM0UOKYMVAzgNVz2hsve8H96+pCffPKEp5sNK23Z4LCqstGOrz7Y8geePuAnnjzipx+e8aX1inXnOV/19BZKmak6sxTNzWn3w1fwqXW7Smjja5QiZchJsEWYySitOO971tYRYmQ/LbyMrcO1C4n7JXyhNKyfZw7GWkkVrFge6A5fm1yh0s6/IJlFCrjWiYXWNSpFqGLQRpNLYfSOB0PH077joe2IEb68WfOsHygivAqBXUjcpkxVgkbjtWFtDBenH3/oySU/9fgRz4YNQ3WMpRV562r5ie0ZP/PoIT/16AFfu7jg/e3Aauh4cjawHRwigs0n4yRqk+1UjSRFroqSodMaqhBjIS7NsOkYM9o4tkPH4A1zzFzNCzcxcl/aj7sSua9v8+/78TuZfykLobSO5dZbetu3SplCLIUpZY4pc0iZbNUJWyifFiwCmGK4NJZnQ8ezceCBteS88P645lk/koFXIbalybAQckEVjSoKi3DWac46zdcutvzMw3PeG0d6ZehN67oPVfHjmy0/dXHJj52f8ZXt2NzEleXh0LF2hlxKmyKIMJtKpzVrY+m0JldNyYUOTS6VJWbKkvAojixsjeNx3zE4za4ErufIbWkwkUNO7HJkl9PvxEf7eyI+7zt4yZVQmonkE+fovadIU1nMkphK5BgDyyLEJCySqbWiqqKII6HZiGawHRdu4LH1rE9Y4/d6z8OhJyrNVczMMbFbMuH7H6eAFc2l7rnUPT/1+Jw//OQBX16vWKvWdVdVGKvwo2drfvLBOT9xccaPbzc88BanHA9WK1Z9d3LbFYpoStE4o+i0bg7CrZ2GMxaNopRmYLe2mp0urJ3hgfP0qnnvHA6J2xjZp8whZvanH58lfuAO/0/91E/xL/7Fv/gvX8D+ly/xV//qX+Wf/bN/xj/9p/+Us7Mz/vJf/sv8+T//5/lX/+pf/aC/DTPC2jblfq6VrfL8zLtf4tc/ec1dTjirOXeGpSa0Vly6kUErXk8H/t3rwDPfczSVZY7EJChRTL7ycD1w4UaWXBmLY0slqMofXF1QqrDowu0SeXmc+DZ7PIb3z9d4ozEi9Naw9Y4/98577fIyFq0Vahgp68I7m5FqhbXrOMyJb728IyahkjFGIUXaGBrDY9ezADknco44bdhYw9eGM37zMPNROKARNtZy0Wm+NR2YYsWJwSDEXNgvX5zLDj6//ANIprByHqWa38NWOX7ivcd88+Pb5niH5lw7llrIJAa3QqN4uT/wH6+vedgN3JMou0CuDcuqnYEOBu9Ylowvlks7on3hkR8wxnBVI1fzwot54aPjBMCX1xsGX6E2csDaef7cj74LGLw3pymhomTD2loiTYN7XALfuNmRiwYy1jRNoqAYnOHMOzIamyvLvEOb5kr40xcP+NbVLb+Zj9Ta9LkPh4HXu0iIGS2GQcEilf38xaL0fF45WKmMxuCMULTw0Hj+0Lvv8qufvOQQF7zSjLrjk2UGU3iwtZSq+XB/5N/f3/LMrHnNTEwZiqJThtRrHo4GkzuulwmXFM/siJjKH3AD1hpe2cDNEvjutPDN44FahSf9wHrwDYEp7e/F//1L7xIBbQwWeHjaH+mBCKx9z7RkPpkOSBFCyeQ5k6gopeid47FrXiS5QAgzSik67fj6+SN+bb/jPx1uCaqwNY5nfsWLKXGYK2MxdFVYUmFavliass8r/wZv6b0DhINkLpXhq196xr9/+Zo5CYOyrJXle8uEofDg3JBU4reOC1e3mUd+4IZESZl6gh/cmMzT9ciIYlkKXXJsFWATP6HPsNZw7SM3YeHFsvDtaSaawpNhYHD2tMsnjE7xZ955h1Iq2nXNROvUv1xdwL4IZ9YQQuHlHBARQkzsS6OWDdqwMY4zpcg5MQG5NrOw0Vh+bv2Qf3848BvzLUvJnFnPl8Y1r0NkmhM2w6g0IRcOXzBwxud5B297Q997RITrHDjrHH/svXf5tReviHNspla+kQ4NQmcG5hS5miauc+VxN3CTJzIaqkJlwRXh6QYu/MAyV3zQbGvzL/mSH1lbwxWZXYq8CDO/NR3JNfNwNPTOUlUz+1q5jv/bew8oxWCcwZ7M3HIpWGuYQuLMG5Y58vz6SDGZUirHEyLWGsvaGrRS5KyBhaWCNpa19fyR8YJf2x34d+HAVAsX1vHlceB1CBxj25VBhJAyx89YB/7ABb+1lqdPn/43P39/f8/f//t/n3/0j/4Rf/JP/kkA/sE/+Af85E/+JL/8y7/Mz/3cz/13v14IgRD+S8Gw2+3aP2TIVjN6y7l1bLRj5Qe+9OCC8yUQUiaXwm2C3hh+63aHtW2z3xvNXoT9EqlRoLbRoFKwGTriYWFOjYRy6T0J4eMl4oCiM1XawpwWRdXwb19d8cB3fBxn7mLg3X7VqABGs6TKnBJLDoimdT3LwiM3cDsHPj4e2XY9P+o69ikwI2jdljAXD5/c34FSBFFkq9BOMRbNTWn29EmD5EJYjswHQVfFpCuhZJQSBvdDq8p6I/E7nX/w2+egM5YgbYH1cb9iYwwXfs0HD+EwB+aYmHOholjbjk92O5QCa9rC+U4SpRQoGlObFj+rxGbomOdKFoU3BnVaQLuaA9YYoq6NnNJ3zKnpFf6/L694NK54Mc/slsDTceAwVbw3pFKZcuCYAkEghMhNTDwZOnYx8nya2LieD4Y1k5+QIE2WBmhdeX530+RxSpFOXZszDdfMlFP/YY6Vqxj4RE8UEZZSyblAFQZrfsc+398L8XmdgWtvKYDTjnfXKzrjWHWerzy85BgWUs7kktkmg/eWj3YzVrdFN2M018wAODwoRVXCri686wdCqMwCq95igatp4c4IKmZiLXij2XSeJRmsgf/l+pZH3vPxMnGbEk8Gz/Uc6J1FSuUQI8eTC/lUFl7HwLNuzS4kns9HLl3Hl1cdh6iZS6ZoQXQlaccnhyMcIdkmNUMUD7QllozXBqmKFIQX88R8aHtOUtsis1Jw5v3v6Of7wx6fV/551XZ6emM58yMrI1z4gZ8+f8QuLoScyVVY4RmN4uNpwmrT5DFO2m5cSailniQ0wqHLeD8wz4UlZVbOsPa+TatjxBjNHYFcwOEQMl2p/MrVLeeu52Ve2JXIIzswh4rr4BACS67kUtu5Gxa+N0+8N6yZc+FqCTx0Pe/2nn1MHEjMkkii6azhw/sICopX1JM0s6/CTMChKMqQs/D6buLlfiYo0FRSKSjg3Lvf+Q/5hzg+zzt4wONPHXE/eLytXPiBn7i4YBoDIWeWmhgwjBg+nI84pbBKgRF2EriPhf60e5dUYTGJ9/3IXBYORRg6zeg9+zmyWwKLMex0BaXYWsdoKkvR/OrNPWfe8jpm7lLmYd9xPVXW3rCfIrFkshSK1hxD5MMp8MHYMeXCqznywDierR2TSRwkM5OwYvDW8Mm+jRWS0VSlMICrwr4kNjTWvopwHTOvTORQK+okaTIozu1nOwN/4GrxG9/4Bu+88w593/P1r3+dX/zFX+T999/nV37lV0gp8af+1J/69P/7ta99jffff59//a//9W/7Yf/iL/4if/tv/+3/9hekEmPGWM+z1ZZNb1BKeLDq2XjPMURujxNKG6oS9lPEK83KND38zTLhtWrEG90WJlMpvDge2kjHCLU2HWIQ4dJb7mtmoz0ThVjzp4XaVUiAYR8TITes3K++uuFi9OjqOKbEriwcVDsATYVSNLsU2NWMS5nsLJdDR4qRWAoazbNhzXeON41EBBxKRRX4A3ZLprLWto1Ja9O9UmHlLTUKF65n6Jq294sUv9P5B799DjoFSylY53i4Htn27TV+uRpZOcdhXridFiyC1ZVDilijGbRDCeznI041hrg56a+9KF4cZ7bKU3VGO7BFWJKw8Y5jqazQUCtBFE5ZsmTucnNF3edIkEwQ4d+8fMW7qzXWOI45cZsWdjl8asZWVaMIHFJlLJXcJS5cR6rCXDJYxTvjlm/d3gDNtvuoKkrDtl+TSyNJpdp2DlCNGLD2Fr1E+t7RaUP5rBDg3yfxeZ2BSulTUaF4MI6sxgGVhQfOszaGQ4zcHia2XUfRmVgaRcJhqVVxHxtp4lLb9ghVDeP5/G7monMMaAxQSsUaxcobdjnh8kk7CxijcbSfVwp2OZNyK3b+zavXPFz3dHTMObErgUDTPudaqTKzpExIhUIlYbhcdRCbnNFqzdP1hm/f3YJALIqDKogWLswZCXA07rqSRlBxtbJZ9eyOC5fOMxhD/mI1+D+3/FtqpkSF7y2PVys2vQMRNr2j94YpJm6PgUdekyUTU0GswmoDynCdAkkqD5xplDCj8Z3h4+PCQ2MQ18T0tTbn0rPeMZfKWrkGxqCgsgYc1zmTZGGXI6FWkqn86t01D/qOnA1zru37NZVUC4dcuI6BkCtzLgQytfc86AZqrBxPEIb3h4GP4x4EcjTM0owEP3AdqYIXjWTBK03vDaFkLnpPjplBGzpjyOHt+fem7uCDFGyuXBjPw3HFdnRoJTxcDaTOcoiB60lxIa35lEPzxrFKI1W4DwtZKms8HoMYjVjLq7Dw2K9RkhAFVRSJNnXMIvRVURSIPp1BRrPLhVSEXc7EUojO8h+u77kYLVUUS64stXH6S63c58DLqEi5ElMmFYNUuBg66ixMJaO18M448uqmPXCK1QTV9qTeMZ4CGBQ2CQZB2UrIiYerjhAUvVJ0SpPSZzsEfyAN/8/+7M/yD//hP+Sf//N/zt/7e3+Pb3/72/yJP/En2O/3vHjxAu895+fn/6t/58mTJ7x48eK3/Zp/42/8De7v7z/98eGHHwJNN+1VI1I4remtQaTgtCLkph2+z4k5Z+aS0VqRihBOqMD5pBnNUolSWGom5MzVPBNzbYsatWkRSxW8bvbf9bSdbbXG2Wa8dayF2xQpVU7mCYUXy8SL48RtmLmJMy/DzMs0c10WisA+NtfIC+swCqZaGbqOd9cr3t9ueTiumFPhIJWdVO5z5hATMTbDpZ+8OG/drSJIadSWlWjeHVZsnKMzTWc76i9Oh/9N5B/89jloBTwKC3gt9NaCFDqtSCWzT5FDSaRamVJGKUUolTlnqLW9+HMlSmWWzCyJKJnrZSaVSlItN2OtSG3b+JlKgRMyVrWRpXHMtXKfIrkWnNKEXHkeJl4tR27Dwm2M3ITITQztcaA1c66IUmy7riE9S2ZwhmebkQ/O1zzaDIScOVbhWIVdyhxCYokZEc2Pnm/x+qQLr02724vi3dWKrW+L7FYpOvXFoaR8nmegw2DRje6koNOKUgtGK6YUuZ5mbkJikcpUClopUmlLuN/HdeZcCaVyzA0rWKVyPc8cciCROObmb5KKMDrIktG6UdKcahMoYxTz6dFZa6VHU0rlZZh4vQRuw8xtDNzEwFVZuC0NFTen3ApEZ1FKcciFsbM8W438yHbDs9WaQ8lMUploO0672MyaqlZ8ebtCcQIkSHMFHtC8Nwysu4ZsNKqRq74o8Xnmn5G2V4EITisGY6giWKOZc+Z6XrgOASlCrA1mEEplyQWpjXInaLLSzEoIp7XKmxCYSybXyj4n7lIi0xCesRasUicMZ8MiOm2adCYnSpVPtdOfhJnXy8IhJg4pcZMCr/LMbY0MyhJLy5m1sYiqHEtm5Q1PhoEvrTY8GUeWLOxrZarCXUjchcCcEmjFj21WaEDK98mATZb0pWFgdBZlNKJO+LUvSHzedzAnQlSuBX+S0YDQWUvIhds5chcLtUCgFe5zrky5ffaxtJ2kAiz1ZGhpNPtUmHIm1cIx5XYGirQclHbHOqPRJ0qQM5pUYS4Nk9xrjRZ4HRZezwuHkDjEpq2/CjO3KTAqQ8qCElhZQ9GVKRUG53gyDry3XvFoGJhi4lCFqZaWg0vgEBNZwY9uR0otZKltWZ4KIvzodsO278Ao0qdMtv9x/EDV4p/9s3/203/+mZ/5GX72Z3+WDz74gH/yT/4JwzD8IF/q0+i6jq7r/pufH7RBmUbLWVIg5fYfXinN692Rj/YHFg2S2xhv4zz72LpJa2NwNDfcuRRCrU0LbywpVg41UTSEVEm5YrSlnv5DBmn4sLVRLKoQFUxxpqTCoAxb7YghQw+7GBEPc82EWhAjVASnIOfmzrf2nn0tHEvl3Fre7zq8sdylxK+9fI1gCLSHia2KQRlA80cfPeC7d7v2vQv0VbMSzTM3cucW7pdGCxq/QFjON5F/8NvnoJZW9GiplBQh91RT0MDV8cBHuwNBpBEsijBay31KhFQ4MxanDFJglwKhJoyCs94TYmZPJBsIuZATaGmUgUQBpbHWstKaKIKqEIJQYzN4G7UjxAq9sK8REdW6XjWjdFuWWzlPzpnBaobOUnLlWIQHRnh/vcIbw31I/IcXV013KEItnPZLNLkofurpGR/vdgRJGFH0xdJjeNKN7EPgdg7kk4PgFyU+zzPQoOmMbXKrnBhDJJuGX32xP/Dhbk+kNScyld5YjimypMzGOnprKKlyVxJLTRgtPMQz18L11NwLQ66kKDjRDYdZEmvb4VH4IkxVEWpkJpNSpsewsZZUKmIhlorRkeV0zhbTRgOjMuTaMKKD1yTRHFLkgel43A94bdilzP/8+hUVQyFzLJlUKx2eVIWffLDmP7+8ZqkZpzS9MhjRPDAdV27mPkRSEfq3Z+Abyb9eGhKaIqSUqV6hlEEreHmY+O79nlkKF2YguUY9mXJFcmEwBq9ARHEUYU4JrSpFC6nk5pKqVXMVr5XBaEJRHEvkzPlTAw6kQqptYjTXijeGQVtUFaIWjjmxotGmArmBBoBnZmjNEa3pfZuSHnLkwjje6UasMRxS4d+9viGIwqDZpaX9O67tNf3M+Yp//+qGcuq41ixIVTyyPdc6cZMDSgRfvjgF/+d9B3dZEVRpi9dkai1k1dCwL/cz37k7MCk4w5J8e3tNqVJUZewdTlkQxVEqc8moKlyU5mR7E44YdDNSrcKgDA7FnDPj4PFOkaikIpQqlNown97oRvE57ZPEIngqVSpJCjOp5aA9I9WC19B5w0TlWCIXeuByMzTyYyj86qur078h7E+SytFpYhX+wMWa//DqmqxqM1mURmt7Nqy4ConXIZBzofuMXiT/h9rD5+fn/PiP/zjf/OY3+dN/+k8TY+Tu7u5/9cJ7+fLlf1fv9T+K+yoYEr6AKpV02vr32mKco3ONUhJFqEXYOod4RZKKVnBuLNclQK7UUjFGob3GZsVHcWLT9yw5E3Kh94pHJ9fHc+cZtSNV4XvxwG0JHMnMFaxrl84SM3WpZA2HOKNoesceQ6CiTEMsRSqvaiJWofMGQ0EXxf0U+GQ6MGjLBsuLEnC9bV2sKtwvkdd3e4oqDF7jlcVpR9xnbpcjOSZ0aV0XY784l93/Nt5k/gFNn29bQVuLpoqwz40cRdV0aLyFtLSR7jA0rXQqgsNyoTRXdWp695JxWrEg+Gr5OB8YtSdIY447ZVlni9aax33H2jmCCB/NM3fTgUUXlgLnaLyCfQmYZNjXymFpWm2UoteOqCCVjJY28Qon9KuvJ4JmEe6OgRe7mXPrGVBc5wUzdCRJlFrZxczN/shSKt4oRjyDdBzrwvX9nv0SGEQzWo9WXywN/38dbzIHjzVRlOCKZV4KyRYCiUF3Lf+UoXcQU+M/nzuHPmEMrdFssE1WkSO5tFHzcqLkXMWAc445t12oje+4m9tk6MJ1rH1HQvjkuHB7mGh+4wpnmtfEFCI4xS4E7hIICmWaN0X1jRc9aE2phbtYsM4Dpe20+ML9FHhxP3OpHNHAXVGMtlKp9BqmJfLxTZuWGQUrbVgpy00KfHScOC6Jzhi2zjPWL86U838bbzT/JBNqxefmrpulkBJ0HoR2z3qlWCRjquax7TmYQhZhwCJWWE70EJHSpISpMGbDJzVwPvYcc2GJieI9Zx44MdRXzhKr8EIWPjwsBF3ItaEMpSquU6brPYeQ2ZVCBpKqTY6hNLd6xitFqq0ZsjGe2Hp6GITjFLiaIg+NY4XljoRXBqOb8dZxqXzv/kBV0FvFVjm2dLxm5qM4cx8WOm1YO4/7gu0w/dfxpu/gJScWLXTVIcWScuE+R9ado5SGiTWqshDRRfPIOqYGtGZEMzrN65iotVJLQRQssWLQfBwObHTPUkqrL53CFQvGsO09a9/8bl7Gwm4OJDIiBkuDZFyHwNo7ppSZJLGIcASy0/Sm8jotiBQsil4beqfJJwNZQThOC/f7wCPTcyyVPSem/mlyOc2RF+qIotJpxVpp1lj2ZL57d+TmMGOqsLUdq8/oBfF/6KQ8HA5861vf4i/8hb/AH/kjfwTnHP/yX/5Lfv7nfx6A3/iN3+B73/seX//613/gr11oPNOlZH7zasf5sbCQGDS8nBduUqJquEDjvWE0nqTgWCIxFkxRzZJeG7RpzOo5l/ZqerClJOFVKRQFm8ETAVM03ejQRtMBX+m3WHPHsKwxWZrLn4L12rPLibuUMRkcis5otsawMZq177Eno465ZvAWoxUxKr5x2JFTk21UC5fGkqh0nSFSOaZG83k9H0i5bXNXGuv9YBIfl4pyijPl2FjPWf/fvoq/KPEm8w9at8ApR47Ct1/fcXeYOdJ0cHcxsc+FmgqXtKUtXTQ9FiFzLIEz02GMwcfKqJr+v9TCjOFHH5wRlsqrsEARzpxrjs5V45qokF4pvrLZUnJbDnPlZFKD8Gjoua2ZfW0u1I7WnbAIj72nswaTIAksQFAV4zUhwX9+cUfOzScAn3k8dujZUIwQpSMUhdZwnAJRpK0MKUVQzWviu2GiSfoFaytb+8VaWvuv403moKoV7xsb/OXtkf2SOJaEd5arFNlJhVk4rwbnDQpDp4FaOKS2qGZPiE3rKlWd5GYYfuLBQw4hcFVmktZceMdUC0NpzqGlFKyGr1x0KAbGRaN941orpRh7z8t5bkaDJx8wIwobDRdWs3btDIw0/fRCQqE4xso3p2PrlirQHr7qO17MwoulXYijdfTOEmLGa01RAgYWEtWd/s4ogyqCUsLYvc2/N5F/VimqUygj7EMkSGQXEoPRXIdIEIXUhifEN4KOBZIUbmOmKxpfOEEqDFEKx5ipRvPVR2eoXJCSUdZz7jtua2SlLb0xWKWwVvPB+Zq5FM6qR0tz2FVKs6HnviaOpRUxGnBVwyxcDA6DYNCnZfXKNYmNrxyTZT83yZFGGKzwZLS8PICyCdGGjWsTriW2x2ZRUICEQhvH8zmirENXwQicfcGWdv/reNN3sHLglAIpXM0Td8k0WARwFQKL+q/2J4xD49qkqWSuYmL0hs7SDNKcJmThEBOg+cpmywrH8xDYpcTWWPYqM3hwtjRXc6X5oDOEEBmHvpnCNSMoHqmOoGBXEoY2DPNAFxVnXUfNAYuhMxqlKrcxUbzjJgZuF0EXMIC1lS91jk9mCLailXCmHcbqBiY4SbtLhUJFG83H0755VNQmaXzkP1sd+AMV/H/9r/91/tyf+3N88MEHfPLJJ/zNv/k3McbwC7/wC5ydnfEX/+Jf5K/9tb/G5eUl2+2Wv/JX/gpf//rX/3eXNX67uMuBJJonfuDJ2YpHfc+v7ia+szsylwJKMShHqYplESadMFXRiSGZSELjokNTsNJeghZYac2jfuCgE1PNSE5AJltLTLBZD6y7drjoUlFas6Rrtt5xLIVjzgwoQlVkLXReY9F0xrDqLSHDI79mv8woCp1pqXBIgSsrKDFkmnHYe13PaIS72RJrZpGK0obzoeP17kjO0paCauUYQ2Oln16XVQvaqNZt/oLE55l/ANdxwVbDZefYrjouV56r+wMfHyZqrRjdLN21DMQaGC2fGmolYDaVoXi8ASW5ST21wRvPRTc0yRhNmx+NUMjEbOjGnk3n0QgeIW03zNeRy9Ey58IhZHxVTCgCggOMavrDlbNUhKd+4Kgjh5TRpbX2A3CXG76r6IrRlXf9gEcopflaNPdJywM7cDtFyM1NMpbMEjO9M59OlcrJpK7zX5wO6+eZg6/qQpccj23H5dry9GzNr93ctqZBPXWDlMZqx7EEno5deywmRSkVSlu47Vxb2C1SUbrQW8+lt9haSUNmXyMHndCiUbpwth7YeN9czYG8MezSNY+8Z5ciN0ugr5rROfYUtGp7BlZDrzUxw+Xo2aeFmiumKpRUojEcJLKyri2PlfrpRbUrGSPtN6wKznzHi/uIFeh0I1HdpcLKGlq6KaQ2a/ruCwTp+Tzz7zYnjFWsTUWTuXADH06B3zxMLb+kGSJd9j1zzYzWorJGiqaWk9Y/CoMChcaezLRGDO/YjlkKi6tUFVh0REpl0ZnzzZat70AqOQXqWeE37/ZsvCMJTKVQa3sMBtMaJIrG/rdViMAz407GmkKi0cgOsbaCDkupFaHytOuQkjmkBa2h6HZ2Px07Xt5nBjRRGZZaWcpE59okH9UWM43AaL44kp7P+w4+FnBWIQIlZR53jv8UJl4vkZwLUgQjigdacx9nno4GJYoobQrfngOOHgDBq9bIcFXz0PcYpdhIJKrKrGPrwlrNejWy9g5VBR0rX96e8d15x0Y5QqkcSsYohdE0T4giKKPpNEhpe6TP/ECtQlSKfOryTyUTQmLEUKT9/EPvkFo50iasijatOtO2kdB026eJRbiukY3zbStBgUXorML3ny0Hf6Cb+qOPPuIXfuEXuL6+5tGjR/zxP/7H+eVf/mUePXoEwN/5O38HrTU///M/TwiBP/Nn/gx/9+/+3R/kt/g0vtSPbXlMaeZceDnPuKp45HruJZJEWBlDrzUZwWuaZXyq7FKhN1CqsHEGTWPfd8ayGSwfhyN3x9ReT0YQLYxYxBZsEVxtLrxXh5lS2qLwxjlG5zAp8DoEzrznse95PS9EEbRpr60za0kpNlKFCLVUzoznR863GOAbaU9A2GrPzZK4c8LHaaZHY7RCtPB8mtjFiD392RVw2XV89WyDQvFqXni4Gng09tgvECDg88w/gPf6kaSb615K8Hq30GH5UjdylxKxti4qum0MZWld1ErhmCOCIlEYO40R32yyrWE19LyKgdvjwpQjqEpvFBemJ3TtETcYTS6Z6+OC5ILXbWFptBWjIq+mBW8t573mbg5kqbiT7KGzhhCbpjrkTMmVs67nRy82KAy/dbcjSqNAXeWILsLHcaETg7OGquDqsHBVGvkqlYpWiofrkR87P0MpxYv5yLnvuOx7vkgD7c8zB9/3K6pS9MYixvJyigwo3usH7mLTzTsF2EqHI4ki10Kqjcy0toopC513IGAqrJXlQTfwIi9czRNLKWijWBnDgKNqhddtaTLVyuv9kWMpaCpeac59RxW4mmaolnfWK67jQhWhM5oz63EoQm4whKlk5lS43PR87eIBVsN390dSrmy05ToUEolXIdIrg1MGqnC1HLhJS3MxLxmjFY9WHT9+doFS8Mly5LzredQP7ZHzBYnPM//e7TxiVFuaFc3LKWG14plz7MiE2mSlU45oFIstBNV8bbIpDNpz1IVONaygVYYH1rDpPd+bJm7mQKgZa5oU0WnQRmOlYmm0nevjfBJBwGjNaZJUeZUSguXROHC/zFQRvFIYYxuvXxtyyRxyk2s8XfW8f7ahQ/HhcSZVYW0dd6EwSeZFjvTa0mEQVXmxzK0RU2BSBWc1D63nK5sVScPzaeFi7Hk09Pi3+ffG7uBnvaUqhVaaiuVqygjCpbYcTkZ+TmtmmhNvQlhOU8VCwVbNMRWsN6iT+/il7RmM5rvHiUNpTrtONZWI8RqNxhWFk3YGvpgCVTc0a9eZ5virKve1UnPmcnDcLbkttIvCKMO5aXjaSRKHkkko3uk7vrRdozB8fJhJWVhZx31u8rnXKbNSll4ptAj7WJlEE5I0V1+jebLyfO3inFLho92ed7Yjj1Yj7k1Iev7xP/7H/7u/3vc9v/RLv8Qv/dIv/SBf9r8bT4aBIIVUKkvOHHMbn227DhFhnxNVCtbpE42nfCozqEUhqj0Aim4jGAH0yRY+1cpUC+3F115UTTulKCFRlCbUyvPDEWcUx5K5Swl3sv22WmFFcdn1jd5TKlYpcqpUXdnrgChA2ob5XAqPhxU5Zzp7pKqTlXfVHEokVEEjOBQilSVHjrXRYGJtSbr2lnfGkVSEY86sO8vaO0r+jNsavw/i88w/gI01zKo9/kKqHHLBO8uZdeQKu5N7o7YCRXGoGaQhLFUBOdmzZ3Wi7oii0HTKtSrmkk97KRqlBKd1W/zObewdS+HVPGOAYy7cxYjVqtlm6WYFf2Y9Ox1BaKzh2hyC9yUiqlJKw9I5V3g6DkxZ6DtFjboZgRnNMUcyGk/TuOYMu9wOKi3Sli+tZtN7nm021NpcJtfese5s6/Z9QeLzzMG1MmTduuxTqgRZ0LWwNZZqGiIxS0VUpVOOYy6IkoZQ/b6ro7QpkjmdjSKKJIkoilkKwgk7J83ZuSpFDImomn719XykKsWSMzcqNlmatDPJVeHMOm5rAAGnGzpZKsw5oZSiCBxKxkvm6Wok58JzOxOl7UApbTiEgIhCNFQl1Ar3MTLl0jpkpS0kbwbPk/WAFJhq5qzzbLxDPiui4vdBfJ75t9EasZosiilVlKlUEdbGIAKqFgrN/GzrPFNtElllFCqdimAtJN2oS99vhCclHEtmVxMGoVe2Tcl146fnU/7NJfNinhhsW2A85AZMCKXhtK1q5lp7AyVXlLQ9qxAzuWsLlbnWNpmXwrv9QKwFExZCEaoBg+UYA0W3olIBuVaWGIm1MKVC0ILrNGNneTwOJCqHlNn2jm3nkLd38KfxO30H90YjWlNEEYuwSLtBN8ogxqC1OtHJhDNjmUslq3beGRSq6oZ4l1Zj2VMtmHSTeB9OTZPBGBytQ49AyZmSTaPhzTNj54ilcsxNhR9ro/Xo2ihQO1PIuSIFKhBSxmjTcJ9FONTCZC3vjAOHBMYuBKltIVwbDrmitcZJWwauUgmn3YI5CEstuKF5ozwde3KF+yWw8Y61N01q9Bnih3YWP2hzWsitp13oihLBWc9gLUstTFLYGmn6eg3OtcXbVWzGGBhFVkKDiAizJGpwvNevCb7JGBRQCiy2XS77JTQyEMLrsDBYzU0sHOKEPyEIz4whnh4gWoOriq4qcircVaEbaLhMaYfTIQa0Bm8VjwfPfcooga3rCCGz1Y4qQhaotZnKVGDQiqotyii8M2ht6TSs+44omUMOOPmh/Qh/z0eiLYNVOBVPzWStP3VBndHMtRU2ymqyaiY1azEQThcQzWHUGIXSMIuQkuY9t2HpPKXWk5t0abbgVPbT3JxJEa5jwImwi5GpJLRqErLRNPKEzxYtGqsrnZJmRFKE3mlWSqEUTFI5xhk0KCs8GD1WJ2pSbF3HUjOXbqBKpEglV1AGyAKlYgFnNNZojFEY03TWS07skuB/MLrv2/iMcYwR3WkUhn0IrXlBw292WjEay31tvh7eOLIWRu/orUPnQC2K3ghR1YauVK1QyanwbLzgzHtyqYAiVCGqguTCzXGmlHYZ3aeA05opF45lQqqgBUbj6GgEMaFhg5W0Qj/nylnn6JXDKEOStuAG4KzhydijwkzMha0buFs0l64jqUKmkmubyCo0Opvmp2IMzlqUASWa825gKZFdWhj44mqo32RMKbe8qhBSoBtMW+IVjdeaQQu7kklSMU6B0XirGTPElNCiWBtDtRWl2/7RJAGXKhedJ+NQRXCnKaJXmpor91OkFpjJvA6BbTUsRXgZAlXag9CJxlXBlnqipdDwjUUoJbE1ujXmlCJL5UVcsEC1hgdDh4oNMbvqHaYIF655pRQRgrS8VgIxF4zReDTWapS2DBQuuo5ahSkl7BeIUvZ5xyEXvG90mmMIzcY7C0UKvdVoZQjl/8fen8XatqX3fdhvtLNZ/W5Of25XDYtVIosK6aJUMmQ7UIwECdRASOTAkBQhESyIkgMQkBDmQSU/BMqTIwTQq14tQA8CYiRQEhMyGYuMaFIkxaaae+s2p9tnt6ufzWjzMPcti6EIVhXvqbq3av2AjYt7zlkba835X2OM+TX/L0MK1Ch6Kai0YayG0hqXYSwjMWcQQxZ+mXtE0MwKg5WD9awWkAjkNNi/771DCtjHzE1weBFwOXHt+sGxJ2dKJTEJbFRoAZ6hrCyIROMip8pQJI3OipgT5/1g92ql5Lg0CJnwYfgcyguOrUZFOZSiAYah1yTGIYgis0ArNQRbFEyrgt5H1l2H/TaTTB/b0+LFvsGpoUxhetuYerXbs3YBIxWnVYVTGecCeMGnXjthWhv2e8f7bkPvPFFHosqILOh8ZuUD1UhTK8WJNlzGnpUPxJzJKqH6IQXTpITUkiwFq85TICmMonOerQ9MrOWuKuhiIPhBlD2JqZDsCExkSciZNid6gCjwwTOvS+apYNMHXu5bVsIxMYpTaWhypMmJYYaHpGRoOh7LDFpSFgXitl5/VhR8sF2zcj2nRfn9ukU/8KxcJJhMIRWlNpTWsHMNe++pjaE2BfusaGKi8PDZ+ydMKkvTOF6cQ+/AENjloTQtkrjxHUZnSqu5kzTLxrFxCScSiB7VKnZ5z7T0KCVonCf5zMJass40IdGFhEVQWj04W0fY9JFGDmUcCTiRI4RSEIda75SgD56xHdOrwC57blxH7wO1hYWx9EmwDx7PMJSmQFBLg9UaXRpsYQaXHxTTouDdzZ6lazmx370d24E/mHPnqLWl1hIrh0mMIUo2eOa64LQwFFny7HoLRvHlT7/GorZs1j1v90ta1zM1hq0M2KxwAS59pNYFZRac6JJV7NmGMET2VaLpEzfBM+89Rkt23jOSBSNjiTLRu0AMw6AkqTRRgWoEe++JMjHVliYlTtDD+HghqJVBhkTvhjVwUho2vmfb9XzQbVEqMZOGDsEmeTyZCQppBCkqRkZSFJpSFgg1lCeNs+GD9ZaztuWBOejvVfCN3Z4jUWGlpnEO4QR3xgXXznFaF5yaAuM1T/o9qYt88bMn1Naw3TleXGwgw0hFljmhs6SPmSvvuFdqjktDnSTr6Nh5P1gKV5beB272MC0j0kBMkv1ttqCQ+jZrDxaNzJFNSsNBP2eyEoyspA8SIUBKybgwICW9S7TBU9Xl8J1wnivX8yTvMVlzXAwmG9sQ8DkyQZGj4NgUlFIy1nbwgFfD48WsqHh3u+LG9RzrH17jjFfNN9cbpqMKLRR7HxAdPC4t18lzrAoWUrKKgZvk6X3B5x8tKK2kaz2Xy4ZtD5MkuMlueLDMiRvvOCosd4xllxI774ceyiKhgxki6zHQ+UQSGZMVzmU6B7YYzDwyYijBVnKY9xAFCoHSglpJ9kFig6E0IJVCpaFaow9QF5ppVGw6wbKPvAwdUzRJKbrU0+bAPiUKEjlLTquhSWlammEY6+3spWlZ8PXdmusucWK+vaDHx/fAH3qE0DjX887tmOU7pmSza3g0rpmUhjYnXrY9JfAjn3rM6XzCs7NrnrxY4YhIBDfO3477yAgNOxf5v33wlJNihI+Dv2tlLNfrYUONMrJr0lDPpYeI5gzJqSo4Op6Ahve2LTsfOYqSPz6fY6TEKsWisPzW+TU3KVJKzZHVzHWmE5FvXrU0cUXWmV0KbKNnGR1PenhoS+ZKM0ezI3OpdqBgmRQPJiP20fOb11f868srWiJ3ZYERkqmU5NuRzAc+egKQsWxc5Gq/BGBmLNvQciQiI2XpsuRit6eSkv/pG3c5mc54fr7m3fM1LQEJNOnWLodMiJFd2/NfX7/H3bomhkgKQ0p85TwRcBLaHia6oNCGqBNEmEvLvXmNVZK3r1fsYiTEhi8eTSi0ojCak/GIf/PsnFUCraCUmodW4nXmmzcty7giMUSmNr0nJnBNZEHFPWsYiyFFfZW37ACD5rgq2BH5zfNL/vXZBS2OOQWlVMyVBtrv2z36QWZkLUFIrp3Hu+F7vjCaZp/o60RVGlwSGGNxRN544yF3j2Y8fXHJ159eMBmXNCmw37fs5bAOZjJr1/Hzz7fcqUfkOGRRR0az3Sm20Q+zIJxklAwSCURi77lTlNybzzFW8+52yU0bcW3L5+dzaq2/tQb++tX5EKWXidIK7qqCqCLfvFqyigGkYJ+GQV4uDpGxqRO8NhmxMCM0gbP9DVc+8JqsOaknbEXgN7cv+aXVGV3MTOPgxz6SkpDc9/M2/cByOqpRSuFior81E9z2iU3v6XKgsholFFNr6BV8+q37LKoxT86WvHdxQyE0zhjaxhFSRyQPddbJ8y+fXXIkLX0eyoRmSnO9c2yiI8mek6bgSFnGSkOCIzR1Ybg3qqm05oPdjrO1Y7fu+dTxhJHVFEpzUlT8xvIc5c2Qmg0JlRJjm3m6bdluW3Y+sPWeJkaucmDrPK9VBXNlOcayQ3IRW26SY24sd6dj2hT4tcsLfv3ygi2RadQYqTBScp4O69+r4l49IitBFzIfFk7FqHAp87TpUSpTSs1YWRoFrz06YVbXPL9Y8/bLDdHB1kb2XSTlSCKj1JD1+aXrKxayHIabAlU0XMWeVfQ4YN5qFlIz1oJdjIyJTBE8nI4ZFQUfbBpetFtuYsNnTuZMC0OhFCeF5bfOrogp0d1mFQwZrRTfvFnTx8g+Ds3nfU70IfEkJu7bgiJlRsmQY2YTW9a+ZSQ1D6cT2pT4pfNrfu3qihUwinGwCEXyQfiEl/QEn0jJYY3i/nTCpnUoLXE9nPc9N9HTMZS99CSurq5ot3te3uxwOTIrLTFFymSIcejIF0IQouC0KFEiM7cWmxX7GEkysUqRFKBNkZQdOcdh6AiJaAU7n9h3nufbHaWWjIwiAy7lwc86JNoUqYNAkIa+AQETo7iI++FJMA+b3S4EREosbIlOipsQiLeTfl3MZJ+Y1Zqdd8MI5izofeBRXdOGgCfQJ8Em/TC1TH5v8T6QcsIaxaIesWt6tFKE3rHpHHsf8MDIZPoUuLy5oWs6zm8aOh+wMuKSxDKUbMEQgSfDvVGFFnBU1VRC06dhYFebhhpsR2SXenyMlGbYdNGwC8Ngpae+QZGpR3ZYOACZMp1bs3OBkSoIfR5KMBAUKM7bHdsQUUAXA20cmoHnUjMDOp+IUuIkRC/xzlEUBfve0+SAzYnWZR6MZoQ4pDgvg2f9bc/5O/CdEFMk+ohVivl40J/SlhwcKxdY++EQP7aWLgbOzi9oNlteXm1pfMSaoWzRSDOURuZhcyRmTosaLTJjY7Fa4Yg03uGJqNt5IikPZQ/DqN+hmWDVO/Z9y/tdi46CuixofI8LAYlk27R0nee4qNnHSM6DoYLKlg/adth0M/Q54UmMpUIqzaxUtP0QVQtaENHQB6qpYesc+xypgqbxgfvS4GQmkFnnwOaHyLjge4nKgxNSJRWzyrJsO5QGlYZy2+ATQiQqCVsfOLu4YWsbXt7saGPERxClQKGHCdEMTb4hwNRYlFFMkkIGSFmSs0PLW59zBN1tyMWgwMBIajoXuGpb3t3tsUpSjxRL17FPmkJqtk1H12fmWtKmgFBQK40n87vrzaDtmAhkkIOsT6xByyFTm9MwJC7GhPeB8bhkGxzbECAO2dP7piLITJKDywrph6eG/3uNTpmcYaKHc5vzAadACEnO0OfBicnIiHOZs6slO9txvmrYRoeLgRKNUYqYhsGoCkmMkSNZUjNMEv+wtHsTh0BxFSVaKLzIJDzSaUZGUpuSfchc93uetXu0hImxXLc9bR+ppOKaPW2XKI0mJU9CgNCIDG+vm8HZT95WzGZAJkZKDvtykgwtccOi1ofI2BbcdMPabOVw3ruDJMp8e8oEJT/hB/6JNgwzECSV0AQVgaEWVZAQGQokdaHYdYGvP71CG822d2xjwOSAkAKVhrq8eDuaWEuB0oojY7BJkQI4Ejd5qET1OSKSR8VMrRVNCsSU8F2gk4F18pCGyGlKgqV3aCQqSlwINB4mSuLSMEEw5sHhJCoJUQ6/K2VsFpRas9CWsTXsfR56FoSgyrDPIMKwQOos0UJSaUPoh+ERUg7NHeGHqGHye81YW4IGKQQ6CJSQpBxvJ6kPPRyFkNRFyXnb88HZFm0bNu3tQ5qIpCwQQkMeXEtCHB4gRkqxKEsKFCkOpRrd7XC5dPsAmUUaIlwuMyk1lRqGfFy5jnA7OVpnwy4k9G3TZQiZIAUW8DnRpYhPEZkFWUrIkj56cs7UQlJIyUlZMdNmaAwdanYohWSPuG34VEghqZTBFBl1qzkpFFLKHyqnqO8lc1niVRoaw8NQ165JKNLgba4UCsnIKvo+8+T5DdYqVvuOrfPDRPFhRBKJjE+BkDJjqbFacVIZTFaEIEhRsEsd8dZZKuRElSRTbQhB3EZQDfsUuPQ9IWdOraFSkiYFdM5YoeldJN5Obu5ioomelBNSSDyDU1AfE1lkSjV4SB/Zknlh6NwwnEmRmRtJqyVdDiA1MmcKBheW7IZ9QcjhYVaIHx6XlO8lE1WSxNBTMQw4koSQkHIISiiGablWQ+sT7zy7ptCadetZ954Ye2yShKAIt8YaOQisloy05LQ0EMFLCEmy9D23uzttHpoiZ0LRhIgykGJmEx1XoSekzIkxZJVwOZJjIsbIuo+gBer2PfYh0/lAnwJCZCohiXEo0DdCIFMeyosqSwqZGEFHqIVBip6tDwQhSJnBQQrwHrLKxDw0wn9o/njgo2dsSqIcGqlFEGg02+iBYe0wDPEIrRR7Ei9ebrGyYdU7Wp9oQqTvoBBD061LESEFpZQUWnJ8e997nwgIQhx6OJXM9DmQkmASJXsREWoI426C58Y72ph4ZDVBD8PdmhzoQ6LpHYWSjPXgTOVDovWBNg09gXMlkB/a1JIJIjIRlqqQRC0JEVSIhKwR0hDVcEbNCMxtOY+PmSgGQw0Jg7PDt8HH9sBvEINrSYYUI0dGcdMHKimGL2oeMnbWSAoveb7coW5vSEoZlzJGK4waBnXIPAyyUWT6kBDG0BNpGVws+ttDTKUUGoFiaMYtkSQ5RDpcTgQShVQYIZFC0LpIITMlYvDqvfXHdoTbqC6DY0YcRJsyJIabJITkqCpZjGs2rWLrPG0IJCGRRrILgZZMFMMGp1TGtZFODinQUkhCPERXXx1D02tKQ5PQVBlWrsNKSSEEVkikkFipKXXibLVHqMGfOeVhUJvWApWH6EK49YMyCFwa7MW6HOhSxOVEygLJ4Dv+YSNkgUJKbhvThgUrpEQpFYXUKKXxccheSSGGiX0xEoW/7fJPw+/KghwH7/yYh0bhYaKf5KQecVwVLFvPth8yCF4r5snejiT3CCkQSmFUxvWBJMCqIYUpfphsUr6X5GHQVSSR09Do2CePEWCVQisFeaglrZTi2c0GeWtHLMTQxCj04MITZSYzrINWD7M9Etxa2GUCw3AhhaSUAAkFtxElRSAQM7iUblPUklIqDMNcESmHoEQjIusYIA+Bl5jT7cCkRELSp0wi3cZwJUkIjquS03HNpnNse0cbPKOsWBjLPga6MDzgCCUxCjZuaJS0YmgmFwf5vRJSHh424+2+NS8ta9eTU6LUBqsUiIyVw4ybJ1dblJS3ATbwJEwWaCXIcXDTS5LBYjEzGFUAvRgccwjDICJ7G1AZGsEFRgzzTVxIw36dElow7Om3c0+MlGgp2RNxPqJwdHlw6Ykkch4OTE0KpDw4uOQMSgoWVcF8XNG6SOMC2QdGyTC3BV3OxNsJrUkNAZng0hBcId0++Bx4VQz7lxyMM8jUVrHuPSllSqnQSpJzQiuFS4nnqx1aiGFybs5IIbDoYQ0kE77lYjYoLIqEE5mWRBYSIYb7WUlJSkPjtkgKpQIgcD7QEuljuP39UIhhdoMUGcEw98GliEli0E/68Dw+2M80KVKIjLr9U4PgqLbM64LWJ/Z9IBMo01AimZXAC0G+PU9moM0JSabPESUE8ttsHP/YHvhjDJikh+bX4LlTl1z6zNTcPuGk20EyaBbG0PYOE4dNqECBBHk7IKjImpDBp4RzPXsXuJaOdOtgIYygDIoQEyfGApkUMzIIZlITzPCEL/LgzSp0ZlIVVFLStmCTwBhBKyV9P1h5SREp1RAVzRKamNmlHiMk6najc8DJuObubEwhNSnu6DqHFJLjQvP1/ZZV21BqxUlV3GYKMm0MzITCGgHx4BDwquhDIMtbF2iReVQULLuGSmoKoUAMFnM+JibGsGk6lBQUUg8uTYApJKmXRCRRDh75JMHSd+R2cM5JYpieN8sFISXmVuPzkAkSKOaF4qrtiLbDi4xRipEQTKoCW2hMn6jkMBZ+JSPXbc9eDuVIpVaMzGDh2KTBdaXQw0LpASsEp9MRd0Y1QnbDRp09WhhOpeHdds8u+tv6bA1iWGxCBq0zyDxM7T3wkbOJDuQw6VMKwRvjindXnkIqrNDkLHAx0YXISCoumxYtBGOtmVZDI6ETAcIw5MXK4eExSdh3npfCIVRG3DpOzazF3wZXQh6i7SIL5pXm+a4HlYkkrBDkLKnLEotAoYbDv5R0JnK5crRqeJAYKcVc68FlIyVWqWcsNVoOWQCZBKd1zZ3JCCkVfU7skgOpWGjFE9ewjR2FVsyL4TM1MmLJCKlQktu8+IGPmk3oyEOHIlpI7hcjtr5HBqi0wkhFmyMyK8qUuOkdMkNlFOPKwG1xDjlTZEUQkqAzMktSTLxsHUlClgKFZGqGYVljBTkLYoLgYWY1HYMVq7styTAyoY3EiIQJg3++kpKuzJzftGz6Ifg3sYpZoUhJcNNF1qlnIg1SSiKgpWFRl9ydjFjuHS51pOApUDwox3zQN+xz+PDZGxis+QqGrAXkQ4bzFTK4hBmEhCwyY2sxXtE6j9YSK8St0YmgQnHhWowY+ntqo6iNYixLQkgoLbCowbEnJURWXDTd0NskJFoOPXo+5cGSNg+RdJ+glEMmvrs1tZBkFCCtpMrD7BrN8HAbSsOT9Y4uJkJKjLRmZi0lcNV1XAfPTGiK2/kCE2W5M6s5KWsu9x19CCQRkVJwv7Cch8HMJeZIvrVS9kTKNDxURwT229Tgx+7A/+FTTAxgBPgY2cXAOyFzquwQRcqRKIZBG9tdj0Ei4/C0ZaRkqgw5Z852DTIKvJBkCVZmYpKMs6LtEvOx5v6opEiW2iheXO7xJHyMpJCRSSJN5mU7DBzpU6K5HVTz5z79iBdnaxp6RMq3UYRA0zqk1CiRIQ81f1sfMECKibHVVGq47FIIJsrQ7hxt51m1npf7DmMyza0lk4wSFxJr31MXBU2b0EiuoudGBWT4vdftwB+dD6+lzoIiSrowTNZ73u2YG4UQij4Mg60cmdbDTNphmnNSlEpRl5acMxfNHhkTPg01e8PgZckk1TRdz3xsOB7VjCiZKMnz1ZZWRnrncS6iiNSi4qZrKIKiS5l9iigl+J9/8S1enq/pciTelkool0h9pLm1b7RCEmVi5yMGiD4Ozi/iVoNZMNWW3gW2fct1t2fZtiQyLYIUIyJkkk80PmL0EOGXUnATuqEu0sffc90O/NH48DpaCSNh6EJk6T1P045TZWhTpncM9fU5se49s7JAZYWRw6CusR3WwOc3OzTyNkOUSTKjkmSO5KbzHI1KTsqaGsF4aniy3NAIz85Hgk9oBG3yNMHhk6BNQwZJKcmXv/A6z55e4vdD7f3+dhid9Rnn05BqLzJZJNZh2KhSTBRWUgtNzhnhI3Ml2e46mt6xaXvOtw1KDrMB/O3UyhgTjXdoqREOkIldSqxl+pYP+kF/Hw0fXscqaQSZvfesQo8MmYkRdEbiY6BvA55EpyRjNPq2dHCcDXfssP79m7MVE6UodEFQgm3wTJPkzqjig3bPtDCcliWltFgluF73NHj23tO7RJUUIgo2Zjh0u5RoY0II+A/++EOenq1otp5N61k3DoyCnEnuVhNC4NXwINk6R09ibjOlGA7rPqT/YQ/uPfvOsWx6Uky35UgRI4YsGlkM04BTxhHobm2bw2EP/sj58FqWSVFnTRMCN50nd4KRlIgkcS7ShUjMAu8dRxiSF2gpb+cUDWvM+zdbtFaMjUELWAfHEZZTZXi3cUwKzZ3CUitDrSQfbDpiCuyipw0JElQoWgnqVoNdSgiR+ak33uTmakfT9mxaz6YPZJ2GKpPeIxgStTEKAgrXe4JMSKMGS1AyfXBUWdF0jn3Ts24cV70fZqNEcNGBGLJYMET6kx/8/T2ReNt7+m9ftz8IkT9mKn327BmPHz/+fr+NTxxPnz7l0aNH3++38QPBu+++y6c+9anv99v4xHHQ4EfDYQ387jjo76PhoL/vjoP+PjoOe/B3xx+mwY/dgT+lxNe//nU+//nP8/TpU6bT6ff7Lb1SNpsNjx8//q4/a86Z7XbLgwcPkPJQ3vNRsFqtWCwWPHnyhNls9v1+O6+cgwY/XhzWwO+Mg/4+Wg76+8446O+j57AHf2d8uxr82JX0SCl5+PAhANPp9Ad+sfmQP8pn/WH4Qnwv+fALM5vNfmj0BwcNflw4rIHfOQf9fXQc9Pedc9DfR8thD/7O+XY0eHgcPXDgwIEDBw4cOHDgB5jDgf/AgQMHDhw4cODAgR9gPpYH/qIo+MpXvkJxa8P2g8wP02f9pPDDdk9+2D7vJ4Efpnvyw/RZPyn8MN2TH6bP+knhh+2efK8+78euaffAgQMHDhw4cODAgQMfHR/LCP+BAwcOHDhw4MCBAwc+Gg4H/gMHDhw4cODAgQMHfoA5HPgPHDhw4MCBAwcOHPgB5nDgP3DgwIEDBw4cOHDgB5jDgf/AgQMHDhw4cODAgR9gXtmB/x/9o3/EG2+8QVmW/PRP/zS/8iu/8kpf93Hn7//9v48Q4vf8fO5zn/vW33ddx8/8zM9wfHzMeDzmL/7Fv8j5+fn38R1/svmj6OgHUYMH/X1vOejv93LQ3/eewx78ezlo8HvLYQ38vXws9JdfAf/kn/yTbK3N//gf/+P8O7/zO/mv//W/nufzeT4/P38lr/sk8JWvfCV/4QtfyGdnZ9/6uby8/Nbf/42/8Tfy48eP88///M/nX/3VX81/4k/8ifzlL3/5+/iOP7n8UXT0g6rBg/6+dxz09/s56O97y2EP/v0cNPi947AG/n4+Dvp7JQf+L33pS/lnfuZnvvX/Mcb84MGD/A/+wT94Ja/7JPCVr3wlf/GLX/x3/t1qtcrGmPxP/+k//dafffWrX81A/uVf/uXv0Tv8weGPoqMfVA0e9Pe946C/389Bf99bDnvw7+egwe8dhzXw9/Nx0J/+aPMF4Jzj137t1/i5n/u5b/2ZlJI/82f+DL/8y7/8+/593/f0fY9zjl/91V/lb//tv827777L8fExQgj+9J/+0/ziL/4if/Nv/s2P+q1+T+n7nm984xvcu3ePsiz50pe+xFe+8hUeP37ML/7iL+K950tf+hKbzQaABw8e8OjRI/7Fv/gXfP7zn/8Df2/Ome12y4MHD5Dy0JLxneoPfjg0+Kr0BwcN/tsc9Pfv5qC/7x2HPfjfzWEP/t5wWAP/3Xws1sCP7NHhlufPn2cg/9Iv/dLv+fO/83f+Tv7Sl770+/79V77ylQwcfv6IP0+fPv2ob+Unku9UfzkfNHjQ4EfHQX8H/X2/OezBB/19PzmsgR9fDX7kEf7vlJ/7uZ/jZ3/2Zzk7O+Nzn/sc/+yf/TP+wl/4C/y1v/YfMaot1hQIYTi/ucDHTNc7JkXFuC4pbUk1rpCmoG2X+OhxLtDuHF3b8dsXL7g7skwKQ6UkpYgoY3izrnEp4VNm1Qc+2O54a2KxwnDV91z2jrLQfPnRKfN6ihCQEyw7x6ppCcGzUIacEleuwcVE5+FF0+Jl4lPTKZ3vsUpTFgVtjixkRkXNsu2BTJKZd9Z7vjAuOS1rxnVJR2aTAkdWk3RmkzMTXVEKKGTk7vyIxWlJ8I7N1tH3id5F/rf/p/+GyWTy/b6Vn1j+IA3+5//Z/4J6WiOlJLnEct3QxcBqt6WuK6Z1hVWGYqLRGLQUFMbQOc/LyxtCdvzyu+/wsLCcjApqq0FmjILXRjV758lSsk+ZZ7uWO4ACNjlw6QOltfzpR3eYFAVSKXLKrDvHqnH46JiiIDmeNXu6mAlJcNFHjBY8rCs2vUNJQWUNfYpMtGGCYes8UkIS8PZ6zY+OpjyaWjASlzM+Z2ZFwbXfEbVmoQtqJSm05s58xvRIET1sd5EYEr0P/OWv/NcHDX6X/EH6+xv/2X/MYjGjMAXOJy6WNwggCY1BopVAGMm0mqCqEpMCMXRsd3suL9cgPf/q2Td5bGumlaW0kkpCkIJPTSfsnQcp6HPmfN9wlBWFUly4lmUI1IXl33t4h4m1GGNIWbBqHDf7Dh8cp0bhQ+DpbktKiZwFzxtHVvD6uGDjA0pISq3ZhYiIgSNVcd235JQBeNY3/PTJEW8uxrQh0sRMEoJZadgExyonjnTBVGlqIzk9mTOfV4TYs905vM84n/ir/8X/66C/75I/SH//h7/7v2QxmUKSNG3H9XaFkILVZsOorqjLEoWmqCp0aSm1ZFzUtE3Pu08+IAnHr794jxOpWBQFpVaE7FDacL+yND6gpMRnON91nArJyBre2e5YxcBRXfPTj+8zsgotBSFl1r1n1fak4JkLSYiR99crXIok4LwNZCn47J0xN/ueDGit6UNk1/U8Kmq2vYOUQWRe+I4vH5/w+jUCbGoAAQAASURBVHzEMni2PhIjTKTmUngwkju2ZKoNtdEcHR2xmGuS86z3gRDAh8Rf/i8O698fhT9Yg/8JldakEOhdoA+Z1954k6QMFy+fsdms0FpjhOT0wQkaKKQlZ0HrWrabJak20AdkcrhmzdXVczoleViWbJ2nNgXaaDY+MclQAl9frliFxPG44stvPMAKGFU1PmTWfc+m60kuUBeK1Dre36wJKSCUZBMySknujCrWfYdQksJYuiaw7lvuFTWZiBSZkBPv7vf8yekxj4+mLEPPzkcEgolR3ERPIxQnlWVqNJXU3J0vmB5XBN+y3QWCT/TO85e/8v/4QzX4kR/4T05OUEr9vu7i8/Nz7t279/v+fVEUFEVBWZYopWiaBoDcdzy6c8Tp/AhlC8YmcrXac+4SZAlJkoGUMvv9htVqS8qJput4ebmkyhqlJK1S+JSYkBgXCi8DD44mkDOXjWPlG3KSHNcVKUteOEepNadVSVUbOjz3J3OEEIx95HhUsWk6hPdU1hCajI+JPmReBseVC8yCo8uRx2XJa7MRy+gxMaCCpAuRJnmcTNSFpLQWVUpW0bHxni4Gxrmi6RNv77dMZMFRoTmpDSdlz6SuyUHj2w68Q5jhOgohPupb+YnkO9Uf/MEaVDHw5mLB0WxCjIlnlyvOdxu2XYfSBm0KSq3RUiEDbPYNKSXWTcMHF5eUEoSSXPuI73oWInFcGrxMPJyN6HxkEyG6RO0UD0cSHz3rfUMlBEejgroy9CFxbzFFCMGoT8xKx7ppMDFT2ZJVShQxEbLgIjVc+0gRPXsReFBXvDYZsXaemCRFVvQ54cl4kTBGUWtBUom1d+xDQGYYC8Fy2/LNvuOuKblfldyZ1JzUBbPRlBgguo4+BaROwEGD8NHqL7uWR9MH3Du+QxSad18YnPO0UdG2HSF6tJQUypJyZLneEHzH9XLF2x88Z1obZJbcBEfbJ+bCUNWWNjruTSucL9jGzFnTsuw9b85qlAERJWNhOa4q6sLSxMjrkwVSCCZVZFFXrJuGMke0rFkFT84RkJz5wMvQQ5fpU+KN6Zg3Z1Mu247rbYs1Cps0XYwEMlXSHJUGrSWrtmPdO4yEsaq52Tb8m+2WE1nw2qji9cWY3DumozEpamLb0oWA0IPuDvob+Kj2YLqGh48ecjw7oouB989f0DtPihFblRS2REVFbSvQAtc7bpoblqsVT8/PkCIghGSdEzklpllQSoGXkbeO5+w6xy5EXjY9q97zueMZ2ihG3mKS5mRUUVUFLnhOZ1OkEMx8ZNH2LPctk5yQUnDhOkwKCCG4ii0X3vGsbdn5wOPJiE8tplztOr4aPdooZFS4ODwgVFozqTVYuGl7rvYd0mWkKrnKPe93LQ+LktfHIx4txiy8YzyyYA3e9bgU0LenqIP+Bj7KNVAEx/2jCdOiJCR4sVzhmxu6bJnNjzg9uYMSYLWmqDVWaoLz7Ns9fdvjo0OimN45oVKaZnnJcvmSSOS12YQmevok2SVJIHNsNX1oqQuDNpmTusBoQeMc90Y1UkimcUTTe/b7lph6iqLk0nW4pFFasu061j6SXc/aOx7XI96aj7lSjsvYY62iD5k2hSEQZwzj2oLJ3PQ9q85RJkFVlqz6PV/bNtypCl4bj3ltOoHQMR7V5CBJXaSLHmHDcL3+EA1+5Ad+ay0/+ZM/yc///M/z5//8nwcgpcTP//zP87f+1t/6Q1/3C7/wCwAEF9gtdxQhU9SGuOvYXS55fr3npmlJIlHUGmHAIjm/3KMUFEZRSEVRSWJOOJFpU6QSmgfVBD0R2MKghWC1bvnmZs9l14NcsGp6pICZ1SyMhpR5sV1xdz6jUGrwMI0aXxiaHCnLglHw7PuensCssLxwji4mejFEqlLKbHeOh2WJywElBT5mdj4yMhprDDsReGfb4HziTlEwUhrJkFXYhI7oJdFZ5rLhfjvCaolBEYQiiPhR38JPNN+t/v7t136owa73bJY3CLcn5cz19TVPz6/4+vMVWUvq0lBrQ8wea+C98z0AVaEpCkPvE56El4LeZUqjeFCU6InCFprSas5XPS/aQCM12Wj2qQeZmSjB3EhijDxbbri7mFEYhTESXYAMga33lJXluHDsek+TI5PCcOkC2+BpSSQJRgq8h0VpESGCzOyDZ58C00IhReLaed5vHCEm7haWWhvuFSN+fbslhkhwEddmaiF5+MYEJQRKSrRUxHDY6D7ko9Sf7x27myU3IZKUYnd1ydX1mmsneLZasutb6tIwrkvq2vDV918SnKeUilJbtl1H7hL7UtDnSK0td4sxJzZRGs3IKp5fb/jazYb3t3s+MxohRUQImGjFTGsE8GK74eHxEZU2VDajs0RFw7KLjKqC03pE4xxtisyqgottYJ0SIWeCkEipSQleq0YYKWlTpHWJPiYmpUEDT5c7vr7b41PiQVVQCMlcG7zLXOYOlTNWCsa24EHokUJglCQqSciv9p5+0vio9uD9asf1+Tm5a0Bk3G7N82fnPLvZs0nudm0xGAHTacH5qiXHQKEVVVnQrhq22w41UfQeTFnxuTtz9EQxrmpqYzm7uOGr1ys+2Oz40aMxqQ8gImOtmGoJ2fNiveb+YorVmhEClSIxaPZtx3E14sFoxL537FNiagPPnOOiHfbh+1lgs8aHzBuTMfOs6Xxg5wN9SoytIYTEO8sN39w0dC5xogyLyqCE4aubPc9jS0qZnAQTVfDwUYmSCiMlWUpSPgjw3+ajXANvLi4p/Z59WSCV5fJmhVIVcnYXqyuCT6SuIZeahRwxmo1RpkILgW63FGWNzJaMQNkRkzrwsJzwemU5HY0JeH53ueWDpkeYER2RTeyQWjCTkkUhkQTOtxse3z2l1JZSCFSUCKu42ESm05qH0ylbN2hwbDJXbcON72lSJGaQCfoUeTCqmSrDlQ9sfaTNkWOtcUTe26x5e9sQQuZBUVIby32Z+N31jsumxyRJlTUTYzhyJUZItJIYJfH52+sdeSUlPT/7sz/LX/2rf5Wf+qmf4ktf+hL/8B/+Q/b7PX/tr/21P/R1f+Wv/BUAnt3s6DrP46Mxb94/Aixt6Fh1LT4FlBIknzBZ0KlIJqLRGKnASKJJ7JuAbBw2K4rKUJYjPn//GItHKYkXsPKerAVbEuvoaGNCaYGSmSIbXq47vn7xgsfVgkoZyJlCSp73PdPCInNm5z1X3lPaikfWUVjNI1vzsKwxQtOmBEjWLqCV4EgVzKXhbmnZ94Gakn3Y86zvWabEG+MJ6ESBRMvMWEhqBF3seefda+4fjyAntMool17FLfxE893q78PXfqjBd84u6HYNDxYTTk4nEBR+G2hax+R4QjUqCcGzdB16CylnykpjRgZhFKaT+H1PJS2VkBSioByP+YlHJ6gUUTLiN46rELG1oW09675HZ5hkwywN6ZtnrqN6/oI3ZjMmukBlgTaZZtexqGtGlWUVe9Zdz9wW3LOgheROqblfVkihaVPHQyTL6LFaM1MwFYrP1CNebneMdclN3/C07TjrPW9OJ2QluCMNISckESscTdPz5IMlx7MZIkYUgXzY8H4PH5X+nl2u8W3gwWLKw9MF0TnWyw1fPd9ixgWT8YhMYud27FqB7wNGSrRRCC0w1tK2LWUr0KUaSgzHNT/24H9YA9uLG853ewSJpAVNl4kiIY3A2kwpBCvX8Y2zCz51fJdSCWJKICXLsGOULZNC0/ierffMbc1CRcalYWQ1D0cVUgjaxBA9c4Ejaym1wonE66OCfdMzKg3bZeLJvuOijZzaEc7Bwuih/Edm9jnQhY73vrlkfjJCZYmWEpnCq76lnzg+ij34+cWW0D7h3vGEh4/m2Erh257N3uNNRlqBy4ltv2XfKXqfh0OwyMQkKUuDv/ZUjUJakJVgNhrz+TdOUE1CSUl3vuKs6ZBSIKxiv23QVjFSBWNTYLPkZbvnq2cv+czpKSOpUGnYg580DeNRzbwq6KKnaQf9zW3guDKUVvNgXIMU7KJgYTXRKe4UFbU1eJn5wmTC5aZlbC033ZYn+5Zja/jR+ZQQEndMgU8BHyI719P1Pe9+c82dEwspI4Uk5YP+/v/5qNbA33nynLOXBY8WY958sCCESHCO6tRSjytEDqwaR7vbIIQDYxAxEV2HMRYvt4zGR7w4f05bNkwETKczvvDgBFILssI2kW63RXpHaxLOgYwZi6BAUsqSlXN87ew5nz66R6U1IXp8iCz7nlGwzEuDi56VjyyqKef7yGmlKbXmTlWRs2YXYaoMKSbuj0fMckmbAo9Kw3K5Zzqp6OKep33HMkYeVSN2ZO4aS58zXfK86LYses0H7woW8wojMlpmVPz2Ar+v5MD/l/7SX+Ly8pK/9/f+Hi9fvuQnfuIn+Of//J9z9+7dP/R1T5484e/+3b/LaD7hvO3Ybxp6aziyE16/fw9f3LDxCZ8FKSaaqw2TWvH6m6cQMm3n2buAFoofn97j5WpJiIGizNwfwermhvF0TIqJzd7RbhwqC4RLPJxMsGWmyoqxKJAoHqmK65cdnbmkz9CmhDawJ7FfBk6i4DgpFkZTVRZ7VHMVEhm43DV8fbvkuCzYRM9X11s+c2fMp05nLKqK9fmeOyNNHxNvuYqZFoDg69st91VBCHGo57KGmYWv3awQ6w3H5yUPjsYcTyukNa/iFn6i+W719+FrP9SgKyW/uV3xge/4jEwc2ZrXHt0lTRRtkmQ0wlruqBFrueO1Y0XOgq6P9E1gNCr4yWrKTdNQl4Y35zWvjxSr5YqqrhBCsNx1LFc75q5GzQ0n05ppWSI8mCwYy4I3qNj1jsvtnud+x77zkCJv9y1Puh2fripOlWZS1Iys5nPTmm0cunhunOPJdk9tNRex59+sV3zx/oQfOZlRK8vF2ZY3TmeEmPiCm3CvsAgBX99smGCotOHGeXYpsyVxs9lw9l5DJa557XTC3cWIsvy+twJ9rPio9Me9EW83LRc7aIqS8axmcTLnjTKRdYnSFgFUTLlYXfFTnz4lx8SucWyanpHSfOHolMv1huAiVYTXR4rtZk1VjxERGp/xHkzQ1LJisajABGRQ1KJAIrhPhXSBm+0Nm7bnZtuSgMu+Z72/4PWqYmYMldKMjObNacltUQg3bcuz1QojJTdK8kvrS/70/ft84fSUwkouz2948/SEPvZ8dj7hqCgQQvCB67gnJUop9t5TIshG8CuXl5xebpm+sNw/mXI6H6OtfZW38xPJR7EH60dTvrnZcLbsWanEWFkWJ3PeGml6FFkoEKDUCWcvznjtTkVwic2uZ7XccDy2/PhrjzlbLgkhUEl4MNOsb9ZUdUlC05JAKsaypBAF9xYaW4EMCovGInhEgd92PGnOaBLsYwIR+WC1Zd33vDmqmSvDqNKUpeW1WYlGAXDjPV/fbwEPWP6fN+f8x2/c5SfvnmCU4eXZijdOF7gY+NF54KQoUELwDdcxRTOxmusukaQkKcF/++yc6cU5959WvHHnlLvHU8pSvfob+gnjo1oD/2d/9s9ytbzh+vyM3zhf0TnHa/MFb3/jlxnNjhmNpgBIJfndX/917t5dYExJSuC9B+DZ83/Ng0ePqUqDDQ0znTi7vGA8HSMEzKoFn7tzhJYw3V9wNBlTvzbFdS3CdUgEj9UI3cAyL3nXOS7bDilhve3pO8+jcclUKuqqpCwNd8pjPsx7XzUtT26WSCVBjfmFm3N+6tERnz2ZMzUF26sddx4vcNHzVtczvc2en7mW2gJWEbqASMP5878/u+Lo4oYHkzH3jqcspiOw42/rvoj8MQvPbTYbZrMZf+5/9WXmkxF3JiNeP5nR9Y7VasO/OTvjbLdnHwIawX1tOG86TqqCGIcGwpASUQiOJlOyD8QcKYzgeKQAwY8czbhyjt+6WPH+zY5KCv7TH3+DK+GoFJRRMNEFd+czVrsGd/t037rEPkSWuaeuxtytDM1NiwiRJOE6ecZjyxuLEVIKXiwbzlYN89oCgv/+4obX5jWvzWvu1iVHWOpakZ3kZdOx84EQI7tdS6Ezv369xcjMSWE4LQpiTqxSoA2RO8WIe5MR49Lwt/4v/x/W6zXT6fT7fft+IPhQg3/hf/0/ZjGuuTMueXQ8xveZi+tzfuvskrNdz94njBS8tRhzsd8x05oQE+7DGoNCMy8qQt+jpaQuNbN6WAbemo7Yp8RvXK14tut4MB3z5aMRzShTK0W3degg+PSdGefbPVJDzrBpPcu9Z+Md0Sge1BWjlIghsA+BS5+Yl5bTozlSCM42W15utpyUBQHBr9+s+Oyi5s3JmBNbUefEfFSyD56LXc/WB1wM7PYtUwO/drNDZjgqFItKE72k0YFtl3h9POX12Zhxqfnf/Z//m4MGPyK+pb//9N/naDrm3nTOm6enhOD55gff4LeevuB8P2QjrVL8yMmcJ6slc21Jt03UPkeyFkzKmth7EpmqUJxOSgA+feeIbdvxm9fXfHO9oRaa/+Rzb7DUDik8opdMZMVbd+asVg3aCPoYWTWOq6Zj6QLz2nBajNDJ4/ygv2XwTMqC145mKCl4/2bDe8sN89pAEvyrm2u+OF/wqdmE46pgLAWLuqB3iZf7jnV0uOzp1x2VNfzSyyUGOB0VnE4LXIhsW0+XE49GFfcmNaW1/O//y3950N9HxLf24L/0p3h09w4P5gvuLyZ433BxccmT5TXPlw2b1qOV4M6iZrneMFYS10e6PpDIqEozGo1w+5boI6NS8+CoBuBTiynLXcdvrla8v90xyYo/+7mHXBIoJKQ2UwvDZ+8tuF5taaNn3zqchybBTXJoq7hb1tTJ0/vA1gU23jMdFTwcTZBC8MFmy9PNhjsjS5M0//LlS3767jGfXUw4Ki11lszrgr3LnO9aVsHRp0Dee0ql+O9WS4iZY2s4rS0xBa56j5aCR9WYe5MRo7LgP/8v/9uD/j5CPtTgf/VP/q9cX1+yvjwjtUteLG8oI3zQ74nCIKRBCTipJDufUcGhMgihEEpR12OqUiNIdH2PyJFZZSDDyLWkcUUaH0ExRoRAcfFN4tGc+WjM9uKauNny5v1jblZ7hEg0rmPTB25cYOl6ZrbgqK4oibgY2PpAm+C0HnMyLpFC8GS54YObNfPa4rLkt5fXvDWb8Hgy4bgoObaacV3hQuSmadlFh8uRuPZInfiV69Xwfo1ibBSFFOx9REvJorTMRiWFtvzct7EGfmxDc/uuH+r8iop7x8fcbDY03Z4oMjkmZEgoKagLTd9E0BmtFFEIYh+xCpSGJgRcSmybzOW2JytB32eWfc9F1xFIJKHoIlyHnho40papFUgtmdQVKEhb6GNP3wdW3rPODZUuuYkeHwJaZKyUnIxr5lWNFAKmCoPCec/L1rHzAZcy6y4gYsfxxLLZdGihKRQUhUVJWOVIlzIuAhkkiloZuhwY5UyhBFvXE9aR2f4Q3XpVXFyt0VLy8GjKncWCm1XDuC4xViFEIuNBSAqbabaeidJoOTjxhJRAgTKSbRfxXeC6czzbZFStWG8dvRCcNx0+RXIasjtea/Z9QmZJYSRSK44nNVpJrvcdMXpa77lwHUoapt7wsmvxwZMTIDXj2nBkNVIK5KjE5ojPgqttQxsDrUtc73uCT3z6tgk95kRlFFVtEBJWORNyZBcjVgjAUAlD0mBEIim4vv3+zNtDlulVcH5+g8qCB7NjTuZHrNYrSm1JQMgBnxMyJ6wFpzNJgxaKJAUhSQotKErF2jt8yHRtYNntSQraNrHres77PT5EkhHkGLkRLWWQjLPCGomWmsmkwirBdbMn5kjrA5dtR5AJi6J1nsZ7XIooJXlcl0xsgZKSe6NIDpmcI0+aHpJg0/Y8TbDvHH/seMZyt4cssBpO6hKhKnYBUpYkAUEIEGATGKFAJ4yH5b6n8YmROayBr4KnT18yKUreOD3l3uldVptL9vuGcHlNTJEsEwjBWGSuVMbnRBYZZSRZCKwxFErQIehSptk7lj6QgOWqY9U5rqMjp0wSiRThKjQcqYpaKkpjkFozm42ZkXh5s8FFx955zvqWSlhkSnSNw8VIlhkrFYt6zHxUoQT4nCAnUoqsWkeMiU3jeMaOrTV8YTZjs+8ICSaFZjopyVKwzmv6nGhjxmaQQmKEoihgIQQuZC7ajm0ITGzx/b5VP7BMJ8dYXTArS2hn1HXJxdkl7AWNawlxj5aCYyxCT0gx4ZzH2pKTo2PquiYlR0iZXb+j7Tq6NKae1CSjSVhGeoI1FV1zhfeZxntsFwCBtRolFePJrZ62ieQibQhcdY4mZUypOW96uuDJQjCxlsXUMjElEsHpKBBCJKbEdduBAKRg7z0iZRZyzHa7JWVJaSTj8QghBGu/o82RiECJTKEkU2tQUgwl7Smz6R1bHzDq2zvKf2wP/L33rHZ7rrY1y86BsSwWR1TPX2KEwKcMGbqUGU9K2pwgZXwcXHNm1pC8J+aIzxmXM30IeJ+50op174YNSg4R17evdyxDhxaZvkyUyvJQK5RUXHcN5/ueXe/ooyeERE49vlAYJYhREFNGKkGlh07xGBOF1szqgs0uczo2PHaOSipkAhnBhcDz9Y7TskZWGikzKWcKLckxc7cqUTlTSUNEkKVgYgwawUvX00RPCoem3VfF1XINIjMfFTw4meIFnByfMrtZcrVrcT6gbw8kspa0ISFvE2ZZCqwQpNuDUJMSLiRCSpik0VLSZWh8AAkxZDZZs24So1xQS4OxoLXCas2LzZ6NE4Q82DFmMt4HvB7cJiKCBFgBVisqOTRKFcBIaXYxc2dcsRORQqmhCS1GXAi83Dcc2QpTW4SSpByxWiEj3KtKVIaRMSAVSmYqDLYQLENg7z0pHPpIXgWXN0syiVld8+j0hF275/TkPqPzCyrnSc4jyazajs4HtlGgGewLXcxMbIHVgiQFSQtyFsNDXOeZJMm+9/iYMVkggHevdpybjiIqTgzMVEarwXnicrPjvcsdTd/jYqCLga4TdNoTcwYhQAqEEBR66KXKMVErxUlZsO0d92eWINPQdJkipEQIkaebHcdlga4s8tboQCmBSpJ7owpyptaKlIcs10hpKiQrP1j1HfT3ari4WFHZFxxNxrx27y5ClxwdnVI8P8eoPSaCFBkXIzEIekBKRSITU8IKhc7DWhikoI+J4AIpZKxLrJ2nFwkpAKV4suy49D1mUiIlTDQYrdBW8+JmyZPlntYF2hzZuh4lIVqIGTKDhoUa9FcZQ06DMcaiLNg7z8OpJYhIKcSwFsuE854XTcvCWupJNfT2pYSUoJE8KIrBtcxohBCEJBgbTZaZtQ90KZDag/5eFVoXzBcVhdY0KzhKkRQUlz7iwgYy1IWlrCdYu0BOZqQYKMqSk+NjcnScv7xGliVJSpQpqEYTiqrCrXdsti1dXjOqPfhIkzTLmx1mUWGERhclQgrK0hKwTMpjGn2B9s/Jbcb5ACmTEUihEEIgGNZBqyQhJkqlmJcFOxd4MDNII6iUQmRQGbwPLPstY11R2QoQhDhoykjJ3apCpERtFEZpshBUIiMT7FLEx4y7LV/6Q6/nq7tVfzSiDFxsl+x8xz4H3np0nx978Can7z9hud7RdYOjyGXf8fDhCW8/uaBtenLI6ABTa9ivG1RtKLRCmYQqEu3OURiJjgobh82HmPlXT64YC0OwgSvrkGh+/A0FBj54seI3XiwpZOao0oyVpMyC0mfuFRavDEvnWcnATddwZAzbpqfLmSQltjR88e4xj8cl76zWlEJwr7C0fccHXcNEFdTVsCmudntmSWN04o8fTckxswuBpfeYEmptMGjGObMLnv6w2b0yfIq8vLwhBk+XPA/vnvAnP/t57lxecblq6NtASnAVYHxcsXyvJfiAMZJRVVImyXa7Q1iJNpBkJsVIbhPVrKbtIzJlJOBd4CyV7C7WyOMZSmeCjhRGkrPid8+ukeWcmbEcyUArhohZmeFhXZMQbHzg0vV0XcKVkX3nuOl69j5SCMOX3jrlzdWW91Y7ygR3jaF1jvd3DfWswgjFrnVcr7eolJlryZ88WpBiZpsDyxyRCEphODYaLT1NirhD4/grYb/vSCmScmTnO+q64s//qf+QBy+e0ncOFTONc3z97JrgE9vUkmRGAEVWLJSBImKNxiiFtgoIuHNHURqiFMQ+Y4KAKPnl95eMC0NUjnUZsbLkx41GKnjn4oZf+sYFs1py77hgWmgmWVAIyb2RQQnBPgZedh3bznFSRdp9QxfCEPXVkv/gzQdcXI/4nctLCiF4bVTTOc/725axKdBCse0819st2ieOy5qfOJqTQ2IXA8vkSTFR54w1kpnQhJTpD0GPV0LXBd557wwfIrJQvPXap/jMvdc5ffGMVbOl63tizDzbt8RW0xCQVpLIBOfAJAIeaSWFMog4HKZpInVp6HImBg8ItDD82tkKmSRaRDYMD3JfVIpoJb/17IJ/+bVzjseaByc1lszCZ05HFZPx0Ni99Z7z0LHtG/y4om179p0jC5jUJV9+eMqy6fiNswsIkQdlSZsc31hv+bHFHItg2bScbzYUPjItKr68WNCnyDYF1tGz6xLTSjFWAq0MgUzbH/T3qkgpUlUTvPdsvKSn4PU3fpQ9CZTExczi6Ijp7IRpMaOcTigrjZLg+p7t9XMuXr5gdLxAq4LF9Jg3Hz0ixsiLlxecX52T5Bnz+YJ79x+xshPOnj6lNDOqQoOSKAlKaXax5uj1P0Yev8vOrWhSRLWZhTQ8mJaQYe8Cz9o916uO+WnJtu1oegcZKqv59x7f42q95XfPr5AJjipLSJEXbctb45KcJTd7x8VmQ+EE85Hij82mpJjZx8A6BZLWEBwTNAujyMC+/4Qf+K+2W7xPyO2Oq+2Kt6+e8eOvfYrj+YTFdo1PkS5Egs1sUks1M0QR6LeD3/g69cTWM7aDlaFBUQpBYQTnu44uD7XKYQgPYKSmYSgFuvGBZ12PlMNF/MnXTwkusOkcpTU8KCzvXq64iA7rYKQUx5UmIxFCsPeBddNRFpaTcYHwChcix+OKry2XvOx6JInPjWp+ZDJGZIlMCdlHchforWE0qAyfEgJBjhBS5nkAnTyrztOFSPSHxeZV4UIkhcjZ1Zp11/P25TU/9ekvcn96xOVsS+8DTdtzuVxReE2QQ9TIFprRacH2sqXf9dQTTSkVRVLEJOil58Wmo8uZNnmUglGI9H3PxiXO3nmH8dTyuXszfhQLBP79N+9z1kr2fUfC8nBs+GB3xY3bc2THnFYli8rgNhknMhvfcbZsqYzm9fmIlBIxwF1T8tTvWDtHkROPxiWPqwolBJDw3tN0ngJQ2qKVwotECtDHwBjDlQVLYB0crff4gwZfCUlASHCz3tO6Dyit5c9++X/Cg/kRy92WfQj0MZNdINwOspJSILRACMkmOcQmIKxBS4XNgspYyuMpN6uOLgYaP2QsVY5YU9JJga4lF9kx9nukcgD8ic+8Rt8HmuCY1iX3jeX55YomBY7RzAvDTFqSuF0Dk+dq1zIuDA/nY7wPxBBZjGvsUrHtOy76Pa+Pax7XFpcSZQrE6Aavdw9qlCgweAH7BN5HpBR80HUYaW5zWplwCHq8EqIchqk9Pb/i//6L/1+Oj36b/+P/5md4dPyA1X6Py0P5xM2+x/cRdMDkoYE1xsQ+BdptgFJjhEAlQeEhKsmycWz6wcpVKIGWnlE14nLTsL2+IubA/njGn5EgQuQ/+pHXiU0c9GcNd6qay03PNY4JcFxbFkKTN5CUYOM7ltuWkTW8vhjT+p4+QJkV2We63tMJxcnIcmdiiRJCGiL+TevxSXK3ALRERtiGyK5PGGDdRhqjiDkP1t+HgMcrI8bhO26NprCa3/jq24ze+FFmqqRUkkjCmJoUIw6odEYo8MGzb1uqaoH3keuXl2SpaScttTE8uHuX40ePuPA9bYgoM/j/T6oFL8RLfu2dr7GYjfn8vWOkGgOOBTvS+hzRBRbFgnIs+Y3VJfs4ZI0mVlPrgq4d/n/vPOt9i7WGe0cThI+EGJlWJVpJdq1j1Tpen9XURcE+OVT0eO+JzpESVMxolUcgcAlyzlirudxDVBAJRCL999Ol5yPBZ3LOJJFxLvD0vUu+8ewFSE1hNFqCFIIjVVL3NSklqIYpo9llRAUVBikF3gcqpXk0rbl/YvmXzy9wLSgEygiUUsikMUCtBy//B+OKlAZv08pKfvLunPdXe553juvg+fpuxzhqyrkkKUkhNK9VI07uzDiuKwq9onEdzvdMVEl0ju2+55EuOPeJVetpS6jRbGPAhKFUY1JblBXcOE+h4LrvMULy+mTE2WbPUjnO9j0lDNNP7cf3Fn7SySkSyciccV3k5mzN155/HVtqJuOa8XpH10bemo0By7ld0csMIrDcbVBKUpQGkSXOJ5SEeyPN6+MFv/ziiqYPaAVKSdZ9i9qu6C732FHAisF+DoZhGrNpRfRL3tluedr0SCRf3e0QUVBY8EQqWfDWbMT8aMy8rjBiTed7kDAvKlLvWfU9M6VoMjztHPfLEoXgrGk5NQmVM7PSUFtNExOKyLJ3aCH5dDnh2a6hV5Lf3e1RIVAz1FYf+OjJCrJIxBhpu0Dwkbefv4+oR0ijydGjgeN5jSlKNvsdSQ+9IzneNo5rjVQKnzK5D0yS5ovzKb+063BJUiiNlhkh1BDR8pmJVFgruFcXpDisgeMa/sRb9/ja5ZIn2z0mRt7ZdcwJFEhiZrBBnI0YTwf9FQga59mFyNQaUu9oesepNgTnueo8j0pFjebpbs9DnSmE4NiUqNKwiQ6ING3EZMlbZc1F2wOKt7cNE6uZWUV5GAPxShBCIJRASAlRsNns+NqTdxiJhFCaKCQuKe4+OKbpI+12h1ARrQWTqSFFSSEFHRkfIyWKe+MJD8aaf/XsCpMgZ0ESkk5ldExMpAYiti65Ox4hI4BgNh3zH37hEV89X/Luege5512/Y7x11GlCiJnCaF47nnM8HTOuKwpu6FxPHxxja0m9Z9O0HEnFywxPuo7TUcUoaJ71e6LOGOCO1SyqCTF6HImbvkch+NxoxLN9QwN8bbWhkIKZGTJdB14NSimyzBR1yYP7j/mx3Yrffvc97p4cc/fu60MlRZ9Ras+zsyXnN55qXDEZz1jUC6wtcEnRxR4fIvv9JWGzZLK6S/3WT/DHfuSP8/TlBzw5e8r7L57yP/rxH+f1u3eQF1s0gRj8t9ZAUyg2Z7/B0+sNT/cdUsOZ76FZ4UY1TW8oMZwejTi9M2MxmWCNoe064m2vR+oTbd9yoi2ooTQthoIayUXbo02BRjK3I8aVZRt7esVgRSo0n64mPG86tJJ8bbMdZpNoSflteu98bE+LdVGhU8R5P9T9xcTvvvsN3jo+5nS6oPMRt2oYlSMmtuB6tWIiNWMpuaFjFCXWgJIKlGCkJVMJJnleWxT82N0pN63nRdNxkyLjokZ0jrIQPDye8ObpHBcTpYEUDcW4ot3seXe15bp37GKkRnPTJtCRhZEcCzAxcbFa83K9hZSYWM2GPdNRSRcjk6KgMIatd7yz3PP6YsRIgpIZoxRVMaFXin2z4brrUSFTa0lW4DIsW89pYTnSQ83i2h2iq6+KSVmh9DDcQiKIIvPNp2f8+GuvMR/XLCc168bx4HiYE7Hue2ppECKwbTpqqchm2Aw0UAPHSlCqxOeOR1RGcuM8Z63jJkXwnslYo61kXmjGGprWU1eDs8p4XONWW95fb9m4yCoG5tHyfOfpleCOlbxZjyhQLDctq6YjxYTKEh8jolS0nWNaagozZucDLzYd06KgkFBmMFpSjkq2AlbrPauYKWLk1BgKwOXIk2XPnVoyrStEzjT7by+deOA7Q8iE0ILE0FCrhOTr77/Npx89YlaPmZQ1PrQw0hih6VNgkg1FVuxyYFIYSiGHDKFWlEqx0GC8442jMVNVsOx7zvYtF/uh6buWAiM1dyYV96YTti4wq0pSdEwrC0LwctvSh8wqerQXfNA0NDFyN5WMbYGJcLXZ8WK3h5iZ24I2wrjUOBeYFgVGa/bO82Kz4aiuebO0VFpitWJaVGzjMLDw0ntMgCOjsFbh+siLfceJkTyuLZXRbN3BB/2VkCUkgUBijGExqfitt7/Kj3/6c0zHUybrNavljpPJHYpxZjQusT7hXcey3TIxEhkVZRKUKjNSkqNSYFTis/cWjI3m5W7Pk82eGw+UmipEopQc1yXHk4JNdIytwUTPZGSJOvO82Q+DBX2mNIkXbUPrS45LQV0FBHCxaXm5GQaBTQoFbWA0rdi7nqNRyaQu2HrHNzcrTqsx41xSK41VkmwqvC5Z37RcRYf0iYWxlFYRWnhvteXEFDwaFdRGftvlFAe+c6RMQEIIwXg84dOf+Tz/7//uF6lLSUyJdr+j7T2vv/7jPHp9RBs7utUNzc2W3WrHyWhKbUE5MwxrlXAsFc1qxflv/wpHo4KjosAdLdifX6BRHB/PeXGlMSlg8DTRMbY1KnqqcshGvlzvEEbQ4ulDwcumo9GJYyu4jwWXuFiuebHdQkxMjSG7yHRU08aeWW2pS8Pee97rNizMCKtLxkpjtWBaSoKybG961tFhU6bSgIA+B55vG46N5sGopNKCbeO+rev5sT3wl7ZA50hOieA8RiqeXVzR7DvuTEvmRcm5X+Nd5Nptid7z+PgYrST75jllloyloLYKKQRKCiIJtKbzESkCdyYlb5xOSUaxcpLUdLzY77jZtzy3itcmJZWt0RLQFqE0ViseqorPnx4hI1RAJtPkwLZ3uJsN6+BpfYCciCTujkdMRyXCWDbbDU3Xsk897wbPvBscJhbaYqxBKsPeORajGtFLut5z4yPPux0EKJXEZkgJshialQ68GqQcyhPIAik1vXN8/d0XLK/3vHnviFlV8ULcsG09kMBF7i+mGAVvX5yhraKWmZGVCMBKhrSfUbTRExDcGZe8dTrBScl1I8i959LvuNk21BI+PSmpqZBSoK2lKgpmhWGkFT92PIMEWiRyEnQ50XvHcp14tu/ogkciyE4wKoYx9acKVtsdne9YBs+1j7wmhhC9NgWFtlgryZ1nXBTIOHz/rkPg5TaQg2QmFTpAUBIpQXxsV5FPNlkOD5kiJXL0CCV559lTltsNd0YVb9w9pqrWPN837EKLQfH64g4ja3n34iVjVTCVAotECImWUAtQRrHfNXR4jkcFjxZHBGm49tBudqx8w6bpWFpDnE8RNQgpUVahlKQUkqNS85nTGQSQKpJTZtk7ql3D3gU2ObHsOlLM9D7y2nxKPa6RWnOzW+NDzzY6XvYef7uElXZEoS1IzbZtGZUlSUdCH1iHyMuNI4XMaWGxZHzKpBA5VFS8GnIa9rZbVwDWq5bfdu9xcbPlc2/c462H95jVFR+sNmitiDFwb7JAFfUwQEtJFuZ2KmmGQg0PlJVRbLc7brrEcWX58tEdojK83CWShZcu0DrHdtcQQ0BUNRKHNpZxWXJcFZRO8vjOFJ0lMXlyTDTB0/Wey+WGs71j6zog49FMx2OqquJUSdbbLfu2Zekd25wx/XBYKguNKQxCKVoXqCrLPCp8dqxD4HzrIQruqgKrJC4nQsj06SDAV0XOEZEzUiqU1kwnp/z0j/1xjmYTVrslUmZCjIBA5IxCUChNiJH19ZL9+QUTBLUEBBRKMjMSayRX6ysuNvDo+IhPTcc8eO2EIjiia5Exses8N8s9YT5FVhJERosCXRi0gUJLvvzgPjlDyh4iNC6wyR1tjOxItL0j5kxnEq/PJpTjkoURbPdr9l3DLgWufaYMw0OjLCylKUBL1r1nVFeooPHOs3Ke521HTnDKYM8ZY2KfBW38hEf4pZQYAVpKyAxR8V3Hdt8xLe9jtUUQ2XctLkcQGaEkSkpGQnFnVGLdkF4UYli4fEpsYqRxCZcd96Y1nz6ZMp+NOdt6+l3HRbfnqmkplcCHIzKKlAIuZiqjeTCpGEvNpCq4XnmMGDr125B4tt3BFpYxoI0ip8FK6Xg2wVrDvFCkvAcNzghEl3A+YpREK421BVkq+qZlZix3rGalO9abHS+7jru6YCQlRZYoIUFKDIfo1qtCCEGMeWg6lALXR56/XPH85YppXXA8rVA6c7XfQZS40JNTjZSSEsFJWVAKR2HlYJEpIKmhCbuLgV3I3JvVfPp4wqSuefcmsGsaLi82bBrHWsthiq0Y3JtiyoyN5fXpBE3mqLBcbwJCDfrrY+Rs38Ae3t+1aCuRAmoVbtOLmsLWhNDigFYlzkMk5IgSAq0HDSYpCFtHqQzz0rDRHS+ahoum544smRWCHECjkVKS1SHC9SoQSpCRpDzcf0HicrXkar1k8qlPcW8+ZuO2sEx0XY+VklIbSm0YS8WduqQIEZFvo2Q5ExPsksb5yN477owtbx6Nmc/mnHWZy0vNr581bNuerbXI27KynMDHTKUVDyc1i6JgXBdcrT3CDAGOto88jzsA1lHiRSCkyEZbHsymw4FNa1zakaTAKzhrhzpdIQRaW4qiJApBaFoKY7lfana65/l2x2XjOFaKu4UlpYyUQ/YjHSbtvhJyyuTb/8aY2e5a+o3j+ctr7h1PeO3uEVpE3ru+JmqDvG0Yl0JQZsVJUTCJkZgjOWckAh+g89D1jsuu47Q+4tMnU45mU965aNnuJDdXLY1ztK1DxMF/J+TBDW9iCt6YTfAhcn86YrkO9CLhc6QPgZe7FnYtz3cdWQES2mh5fT7DGkthNSE29GR6lfGdJvbD+1ZaURQFWUpc01Jay0gpdqLj+W7PZdNyKi13bUHSgBREMdjHHng15DysW0NMQKGV5Ys/8gUymXiWcNEhdB4i311HTA4lBCIL2tVycKkTgp5EJqMZ9vM+Z0KK3HQ9p3XB0WLE0emc1T6yDS0iJzoXaBtPDiAQRIb1szaGu5OaUikeT2dcNx7nG/rg6Z3nzAXYD8NZFQKfM4UNvHY0RxvFRI+IcUcUEDSsnUSE4TNYbSjKkiQE/a6lLizTqmTX9uzjlmXbcqwNx1Yj1bD++QghfXuB34/tgT+GiFQZyGQhKe3guYsQhDx8OW1l2PUtSI2uFC/bJTbBUV3wudMFm+WGK+fpU0IChYRnux6tFEZCypmQBVZbHs8U69vyHyUEtZCoLGi9I4bArnNUQvCp2Zgc4YPNnveuO45GUElFcJn3+w0A1yGhtCRnmBnDG3M/RKEk3JlXPFKKxnm8XzHuDeNSMR5XFFVJSJkI9CFyMqsprKYJgZt9Q1FmRFLMdMm40CAE2fXfx7v0g41SkhgC8dZfuvcB74fDxbrpKEeKotScu4bcZ3rV8/76gpHUzErLjyxqNpvMOkZcTAiR0DmwblrKQuNjJt1GKsuy4NMnE24axW9cvkQhGCmNzpI+JUTv2PeRSkhen04ROfJku+H9lWcxggKILvO1rgPguvPIThJypNaax5M5KQ2lQXcnJQ9mkn1wGLFn4UuMlMxGU8q6oEtDQ7hCcX82prCGXgiamNFIvB6cCaa2BCV46T5Ws/t+YFBCQx42vdtYK4EAWbALkeu2Z7nbo2RGBYG0cL66otaKiVK8tRixXrYsQ0OfhkiZioILFxgZTU5DOWDIUGjN41oyPZrymy9fIoWgNgopBb2PpBDY7ltqpXnrZIYWkufLHe/etBxN1GA3nDMfNMOBf9Vlohp6sBY20bpE8BEp4d58xGNpaFyPDRtGachgzeqaoirxOREAnWE+qikLQ0ti4x1GgvHD925sDT4nnvrmD7yGB757ckokIYZ98tbuOvghmt20npvdju32hqNxRUoGbQTrdkvseiaF4LNHU25uNpy7Yf6HFIIiGkKXmWhNpw0CCDFTGcNn71Wst4bfWF6jRaCSmpyh7R0pebrGUWR4PJ0gshjWv5uOxShTCYVL8PZm2IOXrSeJwS22LSMblzi91fv9acmjhaANgbdfeISWiJyZj8bUdYVPEZduPf1HI0pj6MTgkmIAJQUTUzIqB5eeF7H7Pt2hH3xEzuScyDGTySQZKaoayIQETR+x2lKVlr7pSMEhEqSYCX3L5+4cc7N0bPphD5ZJ4ESmbztGShN1QiJwOWG05mgMhSzJLxJGwshohBS0zpFST9MEqiz51HSBlJIbH9hGi0g9OQVCCFzcRusdwxkzkpkky64NJOdBKU5mNQ+UpveOKrao3pAEjKqCsrD0KdGFRF3CdFQPvQhAFwNWQ6ciM1VhlaSLifhtHgM/tgf+lNLwRVQarQJCCDxAHlJoY13w+PiEy/WOTeroSbwxG/G4qrEBalsg6xFC7Dl3HS4lKgwNAayglIISUCHi3DCQw1qQEk7LkodVTdN0fO38mnvTMZc3O5KCshrqYnWCZu+YlZbKKkoFZ8GQM1R41n3ECslIK/Tt05fzHu8s2yaxaxOfv/smrmnouh7vItCDFExKw8JWxBAptWVR1cyKPSJJKlmglUQZg88w9KYfeFUYpckxE7oARJQcOuWX25a6tixGE3ZhR0MLBl6fT3itHmEyTCc1OQho91x0LSFHjqzmJnmm0lKQqYRFJTloMAQmSqJvswN364qV95y/f849K3m6ahFWMK4sMkq0LmhSZBwyUyuxReb51g1ZgZBY3Zb0zIRBpUgIkRQTXhbs+8y+T/zo8UOaTU/TdHgfkL0gEZkUhmltSFIwrkZMQkJtG4RNTFRJEQc7sD4EXDyktF8FOQEIMtyu1ILgh7ktzb5jagxH9QSTMjbvuYkb7h7NeHNyhHaS2hp8lYht4qIfXFVOjeWm7aiVxRhFoRQqgXM9KiYqC6qAqbJMjeW6bTi/uOJRXfPe6pqsYVQUmKCJKXGx3TGuxhzVhkpIzpthCJtVnmX0ZCCZTJN6IOJ9wsWCXRtpWsFbD16n3TQ0TYvzEdF5IDPVhrquCClTl5aZKymVJgKzqsKqjCksPiakPkT4XwVJZEQe9uIchqbxHIb17/Jmw2xaUGqFUgpbKDqx5562HI9KZIzUdUnX9Sx8oIl7ehKnRvJOO/jeKy0otEILaJ1DxkhVDIqf6oJ5UXDdNrx4seT1acGL6x3c7sFBCbQS7FJiFAQnpWSuJMtekskUynATe1LKVCGxdUMDeIyJNo/Y7hTbtuX+YkGz2XHVNHQho/0QCZ6oiqNaIZNiXJTMKke53RGB2lZUCmpT0sREFocD/6vCh0DKGXIiR4cwERicoJpmS7ffMq0eMlETrq/fY3SywOz3LLJjdOc+1nqsrZjGwFXX4XJiTObK98wwdCSkGubXeNcjo8DowU//uKy4U9csu47fub7i4WjCi+sNyQjKyqKj4u7iHg8Xb3HxwW+TdjdE62h3Q9DDApdtT5sSKMGq3QGT277UgpdNYtd67izu0252LLuO9nYNjOQhi1qNBg1bzaQuKDpLGwPTYoxBoaRE5oSSn/CSnnFZkzWEPtL0iU27p6wtMUTeee85N7MR49rwQXtNZS1jo6mlYFZo7iwKwPJfffMdRqoABq/zpQxcuMAfuzPnM0enjIsCpQS+90itkMBfeP01cki4nFj5nqO6YLEYs2w97yxXXN1cs9CaT90Z8ac+veD9TcvSBUopGUnFVRtxSF6rLMeV5bguGea5eRTwwXKLVJoHiwkT1xNDQzspeL5tWG09HZH9NvFB2/BoOuJOPTTC/djDe4QQ+d3VNU2G99YNlSo4rQ9T/l4Vm9WenIboVmJIbffeEVLi3efnNK7h7lHN1W5JgeR+YXg8qnljPqdWBqUSv/D+B4wx+Nsu+mWGdYAHteJHjo6YFhajFL7PoDxSwZ/77OukmPEpstk1TG3ByemMi+6Sb67XrJZL5lryxnzOl+7VPNluaaKgloaRjJz5hhWRNyrL3GrG1iJCpNYJNLx3tUUIyWldY0PLREXaO+b/x95/9GqaZXt+2G/bx7z2uHDpq7Lq1jUqkc2+TVJNEJAggBQkDUhIA1IDDfQRNJEAfSMCDbkBQUDQQN1iN6Hru2xWVvpwx73uMdtrsE8WG9BA2cANVN5C/GeZyAxExLPO3muv9Te8Po68uM1MuYaB/NX9HeftgWeLnrOu4Z+8/5SYJL+9v2VSmW/8hEZy0XW/3w/1B4oSAZFRWmAXGqMF2ips0Nzc71DAD99/RtseyPcONTc8ahY8Xa1YGY3Sif/m09/QZUXKdbp+LyJ7H3n/0Rkfn5+xbg1WS4oD/3Ab/C8/eI+cMilnxqNjLTX9mUXtDV/vBoY0sdCSZ9uG/+jjR7w+TRymiC4C5yJ3wTOowo8WHeeNYdFYFjQolbECnh8HBIInqw0L51jh8BctLwfHq/uRMUXGeeCz306cdQ3vrdecrzr+0QfPyBR+9s1rSob93QktDeft4vf5mf5gIR7CrLyL3LlTpVA9PO5//elXDNOejz+4JI6a1arl8crw8aMnPGoXxOmIBP6bn/2KVilSAYrgOjpOPvGjiyX/+PyMTWdojHjgYSfA8p/96ANyioRcOIyeq16zPdvwaox8en/Hfjdz3rZc2IZ/9/GCm8PMYS5YCTIJrr3j6+R4v2m4aC2bvqMFOlW921/sRzJwteqxfmJF4uLRglfjzNd3E1MuHE5H/uU3M+ed4tlyyUXf8U/ee4aQir/45jm3GX57P2KE4aLtf1+f6A8eOU5Mp9co1dC155RgaFZXWJn48Y/+iOWyYxgiZ/0F6gd/yjS+pO0VWnR4GZBK81//6nPWquZDZOA6BZQUvL895/2rNWtjaKSguIzX9THxP//B++SUiTmxHxxXqmGzXnIfAq+OJ17ejGghGIcZvv6CF8OJIkBLRUyZySdeBs+7bcu7C0PftqybHktGSMk39wekFDw5X9Mmz0p5llcdr3YDL/d7JgpjdHzz4iuedkuerpds2o4/efQEXQp//fIljsjNUC2Kr1bf7Qz83jb8kYxG0eiG9SJXHqqEuSRKyXUDIKr7iM0RNyW+nu/h5DFnWya3R+uaZpsoNErQCMNHq54PNmtardGiJlMWCuohvEUbQdYSGTLMkevZcT869sEzZM+Y6pSqO2gutSClB+tGqVBWMkVPypmkMuuF5cPzNWddx5w04zAxT5Epe06z553O0EXJGOAQPLez4xQzB+9JAjoEOQhOKeFK5OV44tPDCShcdksWRqO+ox3TW/zbozzYxkEhp1LTaXOdsMYQcC7gQyanQDSKMcFnNzv8FHhv2ZNcxsfEiUJMGSUFSyn44arl482GVWOxSiAfXucSUElilCbLQgoQguA4DezDxO004nMiJnjpHFZPrI1kjomZyKQD2RZSiYhSE4BXTcOH2yVP1ysimuM44X3Gp4gPka2GLgeca9jNieupOlCdUuQYMpdNXeWffOIYEi+Pjk8PBwqwNg2PWosWb4XjbwI6S3xOteAECGXQViKUwB8iw+DwPtB1Kx4J+OrFzDc3B6QrvLvqGWOgiMwpREIEoyQLW/jxqueDTUffUGmTopKFKAWZoFeWIgVzDOzKzP4QufYTr08jpxCZU2J0haQlvUpMIeJFxlrFZms5TbnWpKz/7tl6ydOznpw1p2Hi/jgxpcy9VjxSkmWEICL3w8yti4wp8mocGUvmqYEgEofoODLzcj/xs8MOKFw0S560Ha18y6F+E2jbBh8iKcVKLUs1+UAA3gemOTK5TBomZMn80bsfsl5sid5zf7tjnj2TSMSYCRGUhN5ofrhd89G2nn+tVCghHghrAAGjLEVYSvBkN3CIhevjS27dSCwZJRTXw0RUsM6KUwggJI0tpF7iioQiSVqw7Bo+2Kx452KDy/UOfnE/MKXMwmoem8LCB9wsuZ4mdj7iUuab00ARqtJ6S+YuRnaxcOcG/vXhCMCFWfC0aWnM2/p7U7i5uWG7aFm0Syw9WQesXCGlYrW6YDvPlLLj4vIRT7pHPP9NJBxvmMPIbnfg6EaMLMyx0rSUEqwby9O2472L2kNJVa3VURLqTpJOVUeyKXpKmdmfEq/dS+7mmZgLokimOXDoEh3Ux0QuCFlNEYJPhFIYiJw3Dc+2HY+XPS5LhslzM0zMObGbHU+1pc3gZsEhJYYc8THzzTgQckYXmFIk+QkxTRxnx2/2OwqFy3bNRbPEfMc28Hvb8BcKQgqkqpw5ayyz91WsWkArxWbZstwrhMjIIlkYTQPc7Q/MMXOuO47JU2R1mcip+lovjUaJDCKBVEgp0daQYkSJGnlskFg54ULhs8OBqUSGnKqfdazijZswk2WhldXyTinJUnnuSmQumVIKpsBp8pzGQKclWiqmyXE9Tpiy4FwphikQY6EUUSchogqNjZSUnBhzZB8jO+fQUuJSphEScuHev6X0vCloVYXXtZ0thByr+ExKigCpYNla2unhwiqCRmpUKuzuD4RY2MpqvVUQSCQpZJKq4ltLtfsUQiClwjYN2We08OQCFkFrBNdj5LfDxJQi0wO3D59wKfI6JGIBKyVSCDohWCjFGANTyQgpWGjNFBNuP2MQGKW5n0e+Os1cGcPjRhJTwKfKNwxkfM40SrHSBoPAxcgxJa6nmUAhxZpPoUvhzk2/5y/1B4pSH5g5QpwLkoA2BiUrnSanXMXgeESOdG1LKxQ5RXa7PWPObIRmLypNRmRQSRBEZtFalBQPtS0oUmMaSfYRIeobQCExSjLFyOfXA6cYCGRSrg+DqwRDqOtnraprxaLtGWPC5VzdS6RiYQxDcOzuHEtpkVJxHCdeHByx6XiyaAlzYk4Rn6vmSmTBojEsjMUIUUXGc+B6nFHIKmCXBg3cTcPv9TP9YaM8nE91uFUAUUTNvSnQmYbczTRN5unlU9Zdw2F8ye3dHVNMLIxkmCI+Q4fCZolWmWWj0LL8zmlOSoGyhuQD+kH/lpEYoxjGmS9PI6OICAk5F45ztenclYyjIEVGEWlEvbuNAvdwVi+1ZvaeyUUs9W69nya+PET8ouGZMQQXmWPE51q7sRTst41fLowuEHLgdp4RD2LmldJoAbfT2/PvTSHGwDgJCgLdHaFYjG7JWdLZjk2/JpxOuGGHli0L0zBry5gS9/s9pxiwRjCmSCoCXap5RhKF1tY7k2rEB0JgrCHEgNTUPhOFlopTcjw/DkwporVCyJoxsvaJ+xTxpepNVSq0KDSCzmh8LkgkS2EYXeJ+dKyMQgrNwTmuh4nc9ZxrSYwelzJoidEKPdXfX2MNqgi8jwwxcnQOLQQhgxWKlCtd6bvge9vwk/PvxGqCgpKSVDJKVotDoyXnmwVP71tOyaORnHUNK2WYh4GExEpZX1zfTvKT4JQCIWWECMgskEqipURZg8+JkgRFQACOKXHwgRejI4lEkUARxFKgFHYx0EkDUpCFwAhBKzUSzxwzc0g4HzlGjwuRd9dLSqluF6MLTDFzsprDFChFYqSiMaBLneoLWXmKB+95MQ8MMaGlpJGGnAs753BvPajfGKoKHshVOJlyri4USoAEazTnqx4fGg4h0CrJWdeykopxPxIQGCHJVOcKjSJHOMVQN0NSIEQNRhJSoHXDFOcH7namkPA5c/SR56eZIutKMuaCyIWcE7vR0yhdD66YEQVaobAE5hTr5ZXgMDjmmHi66GtqX8nsvKfN0AhDTJEMaK2wMrMphqwknVZ0WnMfAl8PA/c+UCT02lBS5jA7Tm+F428EDwY5VXcxFwoJpQS6rQ9RKQSt1Qh/ws8DttGstKVNhXkYyA/nHqIOTVqpaNAcoifmGnQkEAipkFKjtWJMmZxjdTUjMsTALjpejDNJJGRdeFESqFzYzxEtBKUUUimstaYTkgZwMRNyJufC/Tjzapj44eYcoDqmOc9kWkYlmKZEIiN0DUQ8tw3FKBphaJXhED0vTxO3s8MIVcV0GQ7zzN69Fe2+CcSUyKU82FpLYk7121N5/EZJzldLmqWlaQzn2wtM8aQUGKcJL+r5F3Im5drUa6FwMZJyrA5QQoCSKKHQpiHMgZSrq1QsiSln7rzn+TQijMBKQcmFU0zkUDikmkJKgRirqYFKhQaBi1WomXPh7jSzmz3vLlcIUc+/u3nmSWOYrGR2CYpACYmScGYMKSWMUrRCcoqJV5Nj7wNGKHpp0AVO3rGf355/bwqlRFySFD/T+AOGJYVIzgKtDH3b0RrB/etPcceeRia0gBwjzjnKw/bZl0xBIh9ySVyqrk5SV8tiKSUg0Voz+0QhUsj4Us/AWz9zMzqELNhSKFJwyonk6xDMGPU78a8VtUetg7aHYW4U3LuZ62ngB9sV4sFdZzd7jspgkiFpjxDQmtoTXDQtMSYapemkZh8cN9PEGCJWGaxSpJTYxcBx/m6Pzu9tw598QAsQuaBUtSfMFFptEKJgjeJiveInFxu+2R8IotBahc6KJBVWSr6YRzzVWUQXicxwSpnr08R510DRdVWuK23B+Uj0mbkkbuaJXx4OPJ9GQskIBQ11u3AkMYWE85m2LYwlcYyRRilCFjQoQsocXeB2cgwS7p3D7uvUggIrrdFK4RAcc3UdaoVAJ0mnFIeSUFqx6BpeRc9nxwElJee64Vm34MU8MIXAgrfrxDeFlBMpF3yIzM4TU0ErgVC16W8aw9VmzWVzwad3t0hhWHSKFoVXGqTkMJ2IEhop0aIG2cTg2J9GytLSyQaTJQJFTIn5QUAec2Q3z3x6HPhqmphypBWS9sGebi8lIcDkCsYUTtHjSqYXiiAlCxSnnNiHyN0cmAK8iidELjSyri63rWatDUOqjwhtFK0Gmatoc9YZpTWLxvIqeD49HmvtWsN523AzDMzB07yl9LwR5G/deXIh+kwqoGTAPgjJrZJsekt0mehHTNfRKIEtgqQUVkmObiRQ6TytMbSN5egSd6eJM2voGoOUilKqn/UcMylEUgrcThO/uN/z8jQz5Yixgq5IZBbckRhj5jAFzoxlKokxV3vXU0woCj4ljt5zPztyVnx1d6ArAmEVucDSNqyWDQHBlAtSq2o5rGrQ1iwEVhiWXcvd6Pn8dGT0mQvbctW33AwjY3D1UfMWf+/IKVNyASkRsibSp5gfpqHQWMPVxYb3VhqpVhgp8MNA8BNKa4wUjLsJn2qjoYQgSokPid1pZNm3NEYhhCZKgfSFcc64yZOJ7IPjk8Oez8eBIQfWxaAyuJTwJTPPmV3wnBtDLoIhVytbl+pZOeTMwQXuZo8rkk/vdsgYwRqE0myallXbEAWcImht6FXGpsyT3nKXHcpozvqG4XTis8OBKCRrZTjXS+7dxJA88q1nwRuDcydC6ohZ0kyFVsgHSndBGIXQ1Xr6+vUv2CfNk2fvEKYT0Tm00hglmYeRkAtKUAfAWaIQ3OwHLpeArSJdqSr/3rlMjO7BtnPml4cdzw8TMcPiweQgpkwsgjklXs0z78oOEFXErWAumVZpTgGOIdXhbJFcDycWCpJQCFHojMJqifOBIjWd1RipkELS9Ct8ijTSsuos++h5uR/wMnNue9ZmwX7aM0eH+Iduy+ldQUuwRmGX9bfZJTCyoLVk3S550p/zwx98xF9/9hVlDOASKc9IaRlyRinJRitUBO8zXwePyJnXdwNX73VIlYnZEU+FT17c88HlmmOa+GJ35KvdievjxCFHNlZzItMZRScUw5QYgsCfPJ2xNUgpJz6/O7HPhctOI5Xmzkf+8v7ID9YX/Pb+hi858qPtmkdtixGWV0ePup9ZrzusBnJVoJ9vqz1Y1yruTyN6P3BWGp4t11x2lpOfaVW1DWvF24b/TWEYAzlTG6CYqi//Q9SZ0YZN3/P+xSPO7Yam/Qp5DMQ54kpktewYo6RNMxtpkAimmHkdPB81LS/2A2ebJUJoQoyklPjs9Wsuz5aMPvHN4cQXhz1fjwOTL3RWModMqxULKzllmLMghETbWjpt8Snxcpq5J3NhLRfCsJ8Cfxn3vLPa8NV+4qu95+m65ZG1rGh5Ps2cK83ZagWlMIaAzIV3z9es+pau19wej+R9YIvm2XLNmTXs/YSQ0FrN8m3D9UYQUwIpEBpkzecjuMQpTvRJsrCaq8WKy8sOJzPy4JFjQAhF1y+ZS2FtAudGQC5MMfGbw553bMNXtzu277xDEQoXIs6PvLre8c7ZGZMPfL7b89vdgefHkX0OnNsGVwqN1vRGcogFlOKQI5cPpgk+ZX5zs2efImtr6UzD3iX+6nbHu2dnHELhn7++4WLdcq4NXYKfPb9lZS3vnK1phWVR6pT/0WrJsu9YNg274ciXx4wSkj87v+BKWW79WCl2Ahr5tv7eBHIuGF0prxSBkRLTFGL02FawWhgedz3nneST199w//w3jKeJ6BN9u+CQPEbBM2UpqeBD5pvDwDvW8KvXR/6H7y9pssA5h/Oe169f83jd4ch8vRv4ZHfHL447QoB3NgtCLohS6EQVD0+T5zY4tkazNAqfCs9Hx22OnFvDxmp2PvLXtwfePVszhMS/fH1Pt9Zc2IYzY/jlbkcvBe+sz2i1ICfISvBou+KP14auabi/3/Pbw54s4YeLc55YzZ2fSbI2dUv5vW2j/sHj57/4W3KRLBYr3nn6FCGe0/10zUI0uPsd+/vXHG5fs1KRXz3/kpfffEpwsWZ7dA2HWOg6zUVqUUhCyuzGwIebhs+vD5z1PRBxMTH5ws3rwOOrJWMIfLk78Nn+wBfzwOAjT2zDcfZoY+iVYuc9MWW8LGQh6JXGyMIwO+aQUEpybiw+JH57GHmyPSdlxd/cHFg0hlWj2FjLl9Nca9A2ZCE4Ro8ShR9cPsI0hq7RnE4DX+7qluLj1QXrYnjtB5CCvmlovuMd/L2tVFkD5SmF33mwQgQUF+sl715dsF2v+fSLT1hphW8gKksuAlFA+8BHbHgRBqIoBAFjroKMaz9xvZu43PQsV5Zl17BY9AiROUwFqyVny5a1bbmdTjRKwuRppKI1mlUwbDuDlD0+Vs98gKumQ02eBk0k87jpeHe94dF2Tc4nLuyC87aj0ZpcMkZP/PXNPeHmxEfLnouuYdFaVr0lj7kKeAeHyIWrrmUlBbfHIxHBpe5pBJy+4yrnLf7t0WmNC1V8kwFKQUuFQLJZLXh8ccZmvebm7recASfAdD2lCGbncTnyfrfgxTyRqXZxnsynKbIBHh9Hzvvmd+Eai8U5OSWi8LSmcL60NFZxd5yZScRSSEKQhGJjJEvdQRcpWeIDlCI5Vy0dkU5pxgzrpuXdzZqnqw24gZXtedRZeqVIpWCc4C9uD2y856ppWCjNwlhWvcT7DNozh4xCsTEGqyQ304nWaNbC8DuS+Vv8/aOAEAUp4dueViARWbJerXh09Yj16oLnr3/OY2uZe4mUhlwkowt4H3jcLbidT4Scq/g6Zn7pRy6XhtvjwOXCsugty3XDev2InDKHnLFFcWV7Vo8ark8jIWeET5RYCLLQ1COPPmnGGWKsKZdPVU/HTG8tc4ZV0/LOcsXT8w0cZy6WHWddR6MVKWV204m/vd1zZMfjtmFhNH1jWPaW4AIHMvezoxTJk3bBtlhu/JF127Btzigxc5jeUnreBMQDbbFvW9rGUgpc392jpOJs0/Pk8QWbyzNeXX9NlxynKaHVEtkKhnEiJfhoecbr3UAUmZirIcWQIq0PPLk/8GS9ZL1oWPWaxXJDjopBHOiM5MliQVCZ29NMIhFDYaRu/U2qIYZdMoQZJl1QwIdNy4WTCKPJpbBuWp6t1zw93xDHmQvbcbnoaI0i5cL92PH/evE1dy7zqOtYWs2q1Vz0ktOYIUb2cyIXxYXt6azm4Ccu1j1b1+B84PiW0vjGkFMGWXBu4P7uNULAN19/wVIIbofnOHdiURpeHvacWc3Je5qmJWcYRkfOiY+6M+7HiVwKRcIxJv72NNAiudnPSASrVcOyX3K2qZv9MRVWaJ6onlllXFf70Vgga0FS0ChBngqbpMEXvEooBJdqwUo5kpZkJJu25+l6zaPlEnc48JPtlrNFh1GKGCMHN/DL3cBvdkd6I2ikYm1busbgXWCIiZvjxOwT66alV5Kbcc9GaZ6YFVnA/XekNX5vG/5KFRWEVIghUa01BZnCctVyfragaRTOBX74g/e4/foVx+PMHBOuFIbw4JEfNKcUIGeWRtFJw4nEX93f837yfCRWtI2hCEkMiZQSC6mwbUtpCmdGsOxanswPqZHece89epRcKFuFbLlGO0sEnoQPhUWjeLzp+fGjDUpKdnbBRktaKRA5U3Ji1Wj+ZL3h5TjiU+beRVLRXPSJk3MUD6+nCZcK57at7j4J+gacTPgCs3i7T3xTSKUaeUkhUKLadSkpa4Daes37l+dsFy0314kf/OgDXvzmBfMcmGMklsjJz5wveowIzC6RSmbRKhol2TnHv7i54f1lzw+3a/rekIIgJsHsa4N9YTqudOGRsDRWsEuZmAvH4PnZ8UAnLEYK9tH/ju8tiiDkwiQijVY8Xnb86HyFlom+a3ikDSttkUIgSuKy7/lTL9lFxxwyJWcaDTkpJjczB/jmNDDGwGVnmdOMJ9ErQ1G51v5bp6g3gpQLGoGSYB/s4nICmQUXmzVPH52zXXXc3So+/pOf8uKT3zCOEy5GtEzsU0TKjCgCUSRKCVYaOiG5C46/vL3mPbfko7Km77uqDwmBkCKNhkeLBqUMj43BGs1pisSUuA+OL+5GXIqcL1v23rObPUpAqyWnkJhLoG8UT1YNP3q0RklBYwWdEXRaoYUkCrhcbfgTYJgDMQpOJVNEIvjMaZrJAV6fRnxMbE3DmCYmH9maBmQiyEx8O+F/I7DW0rYN1miEqD/jRgt8zFxtNrx/+YRNu+EufcEPP/4hz3/9OePgmUIhy8BpChhjKAZMlpQIRsCisdxEzz9//pofTTM/eXxG168pD/qREAKazKU1LPQZk/Yses1hLoQSufcTrybHMUXeW3bcx8De18yRDonzid4IrFFcrRf86HKLMlV3tGwkvXmoPzJXqwX/OD5mnwJZgiuZLknct+efD7waB3xKPLIdKnlmSdUe2Kp5qtbfb/EmkIpitahBa6dTfVh9+fNf0rewd0f6vuHp4y13d4k/+uEP+fKzL5hOM3PKFFlwc0RYGAk0KKxQaKVYaMVLN/GL+3sOwvGeWdE0HZL6yEipYLXictnQNQJZJKvWcucSQSSOwfH8NDHLzKVuOMXMMVTDAy0DJSUWoqVpFJerBR+eb1Ay0XUKowpGCmpAsOBysebHQnB9mpmCp5jEQhS8D9xPM0bAzTwTBDzqOiAilKRIKE3dwi31d6vB723DXx6cAQBKSUyTozzEI6+6BZfbM5Sq3NPVYsFgLUcx4WOo4QUp8uXJsRWaNZJeG5KSSMDlSIiFOAd2x5lQBJ0S5JS4Hid23jPFWN3wiuLxUrJYtMQMg23QynB0I0/6Dik6xhA5usAYEloVPrzaUpDknPn85o61aRiDZ6Hs70TCspQ6qe875pQ4hcDBe3anwNfDCVIixMIxRzpleGQ6bBHQOM4bza0LTKk2o2/xZpBzdahQSgICIQv5IS77yXbLuxeXWKsRQrBenrHrbxnnCRcC5EQj4YvjgXf7Ft0a5pQ5xEIppR4iD0Lbm2Eky8JC1Hq+HyZuvWfKGSMkOgveXS85kwKfE8fgMUpzcJ6nqwVKCU4xcHCeFMDkwnsX62o7K+DF4chG119bSFBKoRR151AUT5ZQTpHjnBhCYAiR596jUiaVwj56WqW4si0tCcnMRgiSlBQDRarf96f6g4RUBW0FuhEoI751zqSkzKPzc955/AjbGEop9IslTWs5DgPOe0TKdCLz9Tjyfr+gXQrmlLlxqQq7jUKrOi29G2aiumctFDklbl0Vx/qQ6aRByMyTvufcNMSc2cYGYxVzTFytO96RPafgOTrP7BPnjeGD8y1WgSqFb+7uWVpDLAkBKC0wSqJyNUh4sux4FSX7GKpIeHZ8MQ7YDFHAGAKt0Jw3LUFISptZaMUhRkIpGG1+35/qDxLygaffNZZcMofTgBQ1BOnp1RXvPX1K21ikkKwXZ9w3rxhPnhQ8OkUWEr4ZT7y7aOmVYg4ZMxiUliyNRqSCypnrw8CYI9uHqfz1NHE7zZXCKDVFFD5qWy4bTSiZQ+gw0rIfx2q5KQt75zlMjhAy2lh+fLUFBJrCy8OOhanOVlLIqi9QEpUTpUjeXa8x45FX08w+Rk5j4is3o1OmFMEhOqxSXLYdlIzImaYkZgFJVMHwW7wZKGlobIO1BlIhj46/+8XPQWaePr3gantG33YYYWgXS9qmYRxmQk4IMgstuPOOp8uWjdGkJGhmjULQGlmdlhLcHR1DuOVcGUouvJombt3MFAO6CFoUz5Y9y6bBi8IQGxqhmZ3jsumJWnAKnsF5csp4BT+83CCKQuXMy/09FsEpOjZGo5REK4XMtYYuugXOZ2YXmH3mOs28ds+RsSBK5hgTRmnObAsl0+lEJ6stfQDyP3QO/7dWYJUykHHeEUjIAqu252y5Qj5Mt4OLaG1omgbpI370aAR3fuZcL+ilengRSUKCtVC4kmiQTD5wdxfo1EMwkve8nmaOPtAoSacavA9s+w4lNdu24+lyxa93r3i8bJFFcHABLQTGBHKWfHy+Ygrwze7Ir273rJuWMXti6uianpVWD6v5gm4kchSEKXOYPDvveZk8vRbECCjBu4sFTatokEQZ2OjKzVaF6hL0Fm8E5cGhQipJISNkta0UEi7XK642a6QEoSTBZawxaKMRc6SkQiMVN/OBn54tOe8sc85cnxInF3liDUYKXM5MLvBFCGwepri72fNychxTYmkMG9uAUKyMBpHZWsuTdsXPbl/z7rJHKsGtdxQJSVXa2g83a6Dw4jTw6d3AxhgO2dMUidWV0sOD/WLXavQoyKUwuMh98rzcBzayiitRhWddh20UVilCcbQIGimRWn9/D5F/4FBWYFqBtvIh9AhEBnLmfLPm6mxbLeZKxs0zShuMsSiXKCGzVJoxRC56y0WrcTFhh1xtfU21RQypMIXIV/czm4cEy5fZ83qccS5xZi1towk5s24tSho2NDxe9fz85pYnfQtasHNVPCezY9MYPjpfIgo835349d0ty96y94FGa5ZdU8Xvsj46e2tBOOYYOfrAwTt+446cK8u31NR3+gXvdEtaoQjSox/sgrRU9PZtBb4JWK0epvtVKzRME0rUh8DV2TmPLy9RSoASBJ8x1mKtxjhPArTRDMcDjy7WnDWGOYI1pdafymiqW9PgA69vZs6bh/qLnpfjjPN1qt42CoRgbS1CSLZtx1W/4Oe3r3i87kkyY0dByZlRRHpr+PBsSY5wfRr47O5IoxXXLmKVZtnlmqYqJUTBorXoEUJIHObIGGc+OwxspUZlBarwdNHTdAqQ+ORrLhASWQRvb+A3BwFoIVg0LY0yhHTk9e01w+x49viK8+UarTVKKkZXN0q2bbAZigvY1vL8MPF0ueai1cQE1rSElHimGhohcaVwdIlX0569qGfJ6+B47aoV9lpbFkVx9J6L1YKF0WxEy+Nuyad3r3nSd4wiI6ZMyZGkHh4I654UBLfDyBfHHaUobtJIh2HVJnSdulEoWG2RSlAKOJ/YpcBnfmQjNbJkihA86hY8aXqKkEzFUUrBp4J8MIr5LvjenpRK1q1ZjBnva/BHFtA1imVv6BtJig4BvHx9y1I3PDrTSGW4H+9Awla2yCSqz76UFECi0Lr68htb6Rkueu5dACCUzCkkplgvzEbD7ThjrWHda1qtoCieLBd0xvD5/YHjVH3Wl61BicLpNCOVQubEECJfhnvwha/lxMp2GGoqmhQQW9iFidtQLb/2zjPkwBihV4YYweXqc10APydGCq0wLI1k+bbhf3MQgiwgl1IdU1IVFFqjWS8My16CCGQFr69fY6ThYnNGKSfuDndQBNuuwShFbwydhFgCIWauegsUfMxI7zm4mdNDDbpUGx+XChfWsG7rYVNUYmkaFo0lC8EH85KzVvP14NjPkZgE1kiWWuJjojGQydw6x6djDYu5Pc4Ypbigri9NKeTGcEiZY44cc+TgE0MORBVYYPGl/nMigIApBUZlkEqxMZqVeFuDbwJNJ7CdQiuJKJIgCzJntJAsW0vfKsgzWcHNQ/1dnW3ojOHVzZECbFqL0BIlBCutyZtKk9ToavsaMzJETiHweah6oIMPnFxEPWxGF43mNniygm3TsLANvRA863r61vDZfs/N4HEhY7WkaxSzc1hdE6ZvfeDX7gRJcDNN9Fqh+g4haoy91D07P3IMgb2P3LvAHBI32bNUCl8K21S3AwgYnEeparG3MpaFfEupeBPYLBdoKWtY2uGI956mqQGT675j1TRQAuXb80/DxdkCoyWvbqrqbtk0CCmwAhorEQ/215q6rfIxIXzg4Ce+OJ0AeBU9x5CoVgfQS83eJyCwtJZlY1kIy5Opp7eCn92fuD75h3AvxcpKpuDpsMgk2M+RL8Kek89cjzPLxvzuDiYLrDZcu8CcEo7MqSQmn0iqsM4wx8TKRiiZAkypOgeKUuiFpmnfnn9vCj45RIjYUGge0myuLhao28zFasNmsao0MCLX19cstOLx2ZpF47i+HygFtD6iVHVFNErwSBlSyqAyJQl0SqToODn4fKyZHvfe43PGqDrk0knw9TgiG8OlMSxNA1py0XS0VvN3N6+5HRwyVyrZZddwnBxWKEpJHEPgs3nPFDLzVFiYBpkeMi6MJmjJLszMMTKlxCHG+t/i2CqFE5lNiXQPGRXPp8B9yvTScqkNm+/YB36PG/7qNR1CZnKR4BPtQnF5uWG1XGBUXT+vlOI4OQoRowVz9pyYKUBCErzAyUTUlWf/bYiSFRBcRhbF+5stZw8PpC+GPY2Ee6dwBT7aLBi854vTjvdZ8awXeBF4vOohCZ40HboodjFy8oEPujV//eoaK4As0EVBiLRKMfmItbDsJbOPfPrqlvP1kpOL3HjPXfSMKQCCHAUg6ZRmqQ19Xx8s00Hywk8YFPYh/Ost3gzUg2e0d5FUUrVmVYLz9YL1cok1DTFGtqpwPAx0gBSZgGPHVL8XMKbM4FPlzadMrzJaS+Y54XxBCs2zsw2Xqv44fjHsQBZOvlAQrGzD6/2Rm6PknW1PuykIoXi8agFYiMAgFF4mfI6sWPI3r65ZdxKRBIus2XlPBl6qGhxy1lhcTHx1f6B3Pcc5cB8jhxiYYkACIUMxYKVhbTsu+54CfDIeCX5moTQlSU4l/F6+zx86TGtorEIKyEliKIScWG161n1HpwyhzJwpOB5P2BRQorCPE1/4A6UUdsGTSmEogpwhBBBCYhUMHkKKWFl4f7Nl9WD49a+ub9BSYqUgkOhjywt/4m4v+PBsQ3/eUIrm8WoJwJnpcKaQkiOkwoqOv3t1y9IKcoQewckrsoJ9SGirWfYtU4j84uaep6vArgSOBE5EJjIySUIsuKbQSM3aWla9pgDjAUZmttrQFMWBtzqmNwGp4DgMHA4jznkQEEPk4nzFdtnQG4jRs5WFw/2+nn8kTtH9rv6u/cRUVkwPd29KCQVIVW01Q6wBfx+dnWHlCij8i1fXGCLdA1VQpcInt7dYJfjx2YaPzBpf4J1+AwQubYPoJae52if3quOvn9+z0QKZBCLVTVbXKHbRIbWkbyxTCPz67hVPV+fcO4fPhZALY0zIBD5kBpOwQrIxhserhgJ8+XIk4VhiEUby9vR7c2i0RYpEzp6aMZp5551zgsisznsWS0uKI2e25XAcKCiUzNy6kV+Od5Ui62diycxJUwqk5ECYhw1TIIdAi+CD9Rl/elbdCP7b1zcMsbBQmq1VvCMtn06eL+8PiAL9uh6Wz7YrcoaP+w1LRvbBI4BLOn7+8o5eCGQWpAAiwsYYdsKjG8GqV8wh8fn1LefrFadYmFPNL/EhoWOl8E6txAjNwlpWK0MBjvuMRdesKZHZpe8WwCpK+X4p7g6HA5vNhp/8o3eZg2cOnhgyQgj+j//lf86f/emfsdSR4vfM4x3722uiDwgk3heGyXM3HjlOMz2SXx/qB+rQmKLRUtBQBXHGKLRRZF3QSvLVcc+VbrBCEClMpbCfA00HT7qeQ8zcuUhfDD+52GKtoWkVY0jcjZ67eWLwA9rJKqrNERczY4JHtsOTMAi0FoxE/vJuBxme9QteHkdOziOloGsblJIstGGjGxQSXyJWBt5rV2yt4qVz7HwghcT/9f/+Cfv9nvV6/fv+fH8Q+LYG108vSACiIDRoJfjf/6//E/69n/6UZavJYWAe75juXhEfpo7TnDgMjtvTwO00cakMf7Pf00rJpW5YCUPXykoBKxApOMALEAS+2U88alu0FricOIyJQ/F0UvPD8wWHnLmeAyuh+Xi7QimFtoYpJu7GmdtxYkoeUyRRZOZYt1WJwhbDLnkMkoXWRCH4i+OBnDLv9y3PJ8cxBIQoNA/0orVu2HYdraqTCkXm2bJlqwzXs2MfAskn/qt/9q/f1uDfE76tvz/6nzyl7w1KCsiQj4X//M//Q/7Rv/PvsO4lxAF33HG4e050CaVgmj3H0XE/Ou6miS3ws/s9VinObHVhWtkeRa3XDIQCLmda4JPjng82KxopcTGzmzN3/kSrDB+drxhi4nZ29Nrw0XJRuai2Y05wN898czwgEbSxMOEZU51U+QwXqmGfZjptWGiDL/AXd7fEHPnBcsVXw8jOewQPIWGq0GHZdA3GKLLIaAIfLs9ZSsF98ux8YJoi/+z/8qu39ff3hG/r70d/8h7HcSDnTGM01mr+y//sn/Ln/4N/n7O+QcURd7xhd3xJGSYEktkFjuPM7Wnk9clxIQt/ebtjbSyPmg6rNCtrUDrRFkVE4MuDXorCp/s7HvcdrZbEDPuQeeFHllbxR9sNo8/cToHGaj5crtBKYtuGOSVup4nnpyNDmDkvlpALpxir1iNlzpXmJjgum5bOGk4l8hd3d+Qg+OHZki9PJ/YuoES9e5UCmw3b3tBZhaAgcuDjzQWdVrw4DuxmT4yR//P/7W39/X3i2xr8P/0f/nek6AjjCZs9508WPF2ds756QmdBRMc8HPGHVwTnEdR+7DQHDoNj709siuTvDnvWWnNhGqRQbGy936yqg9RUBCkLBJFPjgcuu4ZGKXKGKRSuxxPrvuWj7Zq9j7w6TbQSfnJxhW3qlH6Kkbth5ovdiVOKXBVNUInhQVealYIIPkcubUujFacU+eXugBCCp33P83ngEGvzrpSiQ7JUkm3X02oNJRFJPFv2rGg4Zs/ee04nz3/1z37x/7cGv7cTfv/gQW20RogICC7Ol3SNRBVFxFCyxjuPCh7V9hgjWKBpmjWXy57Xr3e0pgobMgm0pijNlAJNEfiUcb5g0AzJ89VxxrWFRtU03SkLdE6MM0xx5NsdgW0MphQIkfsUq4/6PDONE02jeO4HppJZKsNaNWAin5+OPFouMUWSI+Qs2eqWMUbugwMFtnngTOfCumnojaJTipwLPmVikbwKDikaxlyYCzWK+S3eCFLONXRGgJSglOTZoyuWC4sikEMkl4LLCZsTQlmMlqx7Qd9YHoUlN9c7lkpChikGgkisguWQJzZS00qNkJqC4N5lPptmHIVWSUIpHGNEpERuJF+cJgKQEKhGPkwrMqPzuJDw3uPyzMK0fH064Uv9dXqjGHPh8+PM43WPTg/JqDlic2YucOPqZqly9BMlw1nbsjZN9ZkuhTkVkhS8Gh20haFETjkxx7czrjcBISWRqrMwAoqSPLq6ZNE3KJ1IsTZKY4h0uSCUxmjDqhN0TcPlcs3169csGgulNvZDEWTvuA4DZ8awUBolJFnAS+f47XGi14ZGS04psZsjOURkL/nyeMSlQi6SrdG1hlJmdA4XIn52yFBYtZpX84k5VYF7LwyCxKf+yPv9hsUD97nkxEYbDhFuY0CI2ujHnBEi06uWrTGsbQMSxuSJCL4ej1w1liQVWSiOb7ecbwQ+1AFU21gWXUNMmQ8uLln1Fq0zOUZKKQQfaHNASkvRCrFo6VrL1Tpy+/qOZWPICQ4hYClMPnM/zlxpzUIZlFBEkbgNjp+dJqTUtEYzpsTOeeYUWVrFV7uJuRSyhK1q0alAzhyK4+g8x3FCxMxTu+Sr05GYC6pAj2SQ8Jkb2RaJjzW/IZG50JbbFDiOEYOiM4WYCi4mzovlvLWsbINSEGLAC8VX48BV29QsVlE4pbe2xG8Kyiq65ZqRxOnVHvHa8f75e3R2gZaOxEwu9Qy03qHanoU2tJ1i0xoex4ZXL25Za02msI8RIwQpFV6GgUtjWWuNUZogBHdh5jfDgEE8NOSJexcoMbE2kq/HIycf8Rm2pqcUCB5mF9g7x9HNLJTgql3x1W7H7BNaVmeyEOG5H3ksOkqEQEEIOLeGm3FmN860UqFMgyuREDMdlpVp2ZgeK8HHurF9NTu8yQhZKevxOyrHv7cNv1QFJQRSVnFhKQUhJCVFsiygJEJqRl/FhbKAzAldCkYqtKnRx0JWt5wsoDGSJCOqCELO3MeAj4UzadFWsmgMoWRSFMw5c+M9fRaYrj4IrJD0WuFzZOcq33WiHiA+erQSXLYtYVmFl5rqSHFuWr7aDegiMCgk0FJYKUOvNftpopcKLaqIUxeJygVRqFHQMiMz1TEgeBopqjOMMUzprUvPm0LhW82gQDzUoFISckKKSvmRUjG7gBECQQYSUhQao9FC8FlMGOqFViQYo5hkJPnM6+xRMtIoQ6M1qQislsQCUy6MMXIze1oKi0bjXMBKRWeqW8X9VG3Kknx4vMZIozQXTcMYIvchoqm+vkZLvskzVitW2qJyYQiOTmh6q5hCtfEUsrrA2FKTgZWs/O9UCrkUVKmWokbWhnRlLDq/DX97M/iWgFhASJQUaFUoOVKKQAiNUIrJOVrVIChAFZo3WqKBOcNSN/hSmxyhYKKegXfOsydiHxqsUiSrxjCXUj3TY+TraaSJYK1m8gnxUH8+ln+j/mpKtA8RoyTnrSWWlqNPxFSbrlYrPtudUEvBwjSoAtk7TIaVscwhYBEUpRhLfSjIAlpVG73yEHhXCtw6hyCxbjsWWuPtWw7/m4AQPAzcBN4HXIgoqZAlQZEIUUO5nPM0oqaFyxLrPacsphF8WWCpLY5IEg+e6qkOFF7MM62I9MpgrCRmwdoqfMokAvsY+GqaMMBF7LgJniSgtQoXE7e5PvQmUbUAMSWsElx0llNqGVwk54QW0GH5Zh5plMEKSYuiE5qNjhymyBgDRkt6oRiJVMP1Uqf8SqJlAQWiaO7miVISC2M5X3Ro+fb8e1MoKSGorjZCFvanI4PznMWA1AKEQSlFiBmrFELUFHlBTSLXwjAU6FXDED1TSaDrVF8Xxb33nGKiU5nGajKwbRsChZwTpxj5Zh5pheJJrPqmVApWVeOXF1PVncQkiCmRc0YpuOwso+/ZB08slcbWG80X84nWKHpZ6ThRCCatmZXG50SrNVJKUqrb10wGKVBCoiVkUXvI23lmDIGrrqUzhr75B27LqYRAapBZIh+a9hjrVKiSAEE8RCFLZRGALDWg61uSUpAAAp+r4FcKCCKykJZdTOyCZwwRaQrvdks+WC+4OY34VHCpcO8csWg2rSanjFF1tX70kdelBh3kXA+oQma1sGytxWxbNsPMwc/4kliIyh0jlTpZKJmUE51SJAmnAkZIpBBEURAZ5hTQWdbDryRCylipmHLmmD2XtmetG0bxdrrwZlEeHpyQi8DFRH54SCqhUA81mI1Ciowg/S7zTgjw8kFsnTNZwtIKJgJLZXkRHKP3KBU5axo2jeV90eNiJj7Ytu5CZCklJmV8LPRaYGThEAIp1O2OlZJSqkiubxo2jUGwoneeKURKrjzo6nhFpeuUQilV3W+txceIlVU3ErKoqYQlk3LGiVqvIWe0lMwpc4qRy65nbVom+bYG3wj+jUIS1RkWlxwpRygGISRKaWJMZCOQov4vQtQHqiSRpUSnwlggkdBSEkXismn4cho5BY8kcV4KV13DR3rJlCLxYSNw4z1dllylwhQSxkiMKuy8Z34IHDRC19h6Ue0+l43CmBVHF7ibHKfg6ZQmpYIPHnRLLoWQ6sPDKsXoZhqlyVIgZLU6dCkRKMyp/sz5lEAJfM6MMXEGbBuLTm8brjcBawxSSEIMnIYRnxNjiOSYEUohhEKoejdmoykPRSrKf1+6QUoMirlEvEhYqQgJLmzLl+ORY3Q0MrPBsm4sP1otGFzCpcSUEtfesVSKmATDw2S+ALd5ZnzQ3SUEVj64hllF30jekyv2U2DvJubo6ZUGMlpJGiSm1JO6UxoKTCQ2QmKlZC71582RcKI+UELOxJww0jDHxF54tl3HZdu/dcp7g6gZIlXc3y00u2NmN448jo5G1fpUSteUOGnqXU2hkKHUKsxKoXOl7LgS0VpU15u25Zt54BgCJhW2QrBuDB+vlhzmGZ8zrmR2MbLUUELVdSAEWcIhOU7jA/0mSzqpabUEJWiN4J3thqX33M0jo/N02oAUSC2wVB/+RL2/jVSMxYOsQYsiSxSFmfpzM+ZAKFUDI6QkxOq2dtW0rFoL/T9wl56CoBSB1pLuwW8/llTXvTFTYiCnhJVVxJAlSKshVfoLMXGxaDk5j4sJB4w+IFtFrxU7lzBFooA5Rq6ahr5dMPoZ7yJSglWKVmo6IcmSum5BcgiZ1tSHRfYBlQWdUSyVIpfCtutYN5rnh8KX+5FTmUhScMyBUBKDDww5cb5suZkdoygs//s/OHOOTKFaNY1+JqSIkInHbUcrNCLD0hjOuhYtv5tY4y3+7SEECPnweizVBnDnIz5nFIWSIiJnhDY1I6KAVKrWY6rCtKt1y9HNDDFC5mEannlvsWKiMA4Tex8oSvDxxYIPdcun93umKIlIhBqRykAopFjwRE4ik6Mg97Y6YRRoEbRK0mkFInGx6tg0hq+Hia+GCRkCqSR2s0MIgUuRuzChKHgSUVabWv3wB3dEJp9pqX7r4SEsrtV1MiKyYCUbLpqe41vZ2huBqAN7JKAK+FQ4JE/MiRgzJEemIE09A2vOgkQ9eKVLYLvQfHbj2HlPkvUXkzqzXaw4kpjzxBg8x1z4eLnkHd3x69sdvggaJaoojG/tDio98hTmSrto6k6hi5m1NqysxRpFLolVt2bRBHyJ3PiIT3XDtRtHlM+MKXEfPa02nIhECUXWKb7Iopo1ZI9JDacwEkMVzm/7jjNtaYSmFw0r3VDatw3/m0BnLUYrjkNidAFh4Hae8DFjVKKkRASUNhQESUYwEqEq1ZBYp+3H08yQE0FkKBGhBU+WPS4nXk4DxzhDLPzwYslS9/zs9pZ5zhQeMmuEQFIn9XPOHL3Hh8iqq2dtbfYNrTFobckFzpdL1k0k7wt3h4BTiSzAk/E5cYiBE5netCTzbZNYz/pS53qMZMYM8+SIKSJy4qoXWG0ftgSaTlqiflt/bwpt29F3HVklmtQjUuRuGnDRYXREloTIGa0VpFBdeYwiK0lKmZISlwvD13cjmUwRBZ8SjVWcd5ZJRK6nmTnVUNOP+jN6Y/nV62vcg4FKKzVWaBpgoSRDzgwhYkqh+TYDRGa0gaU1VRtVYL1aso6JQmHvAidSNetIkRMw+si+RLpGMeSA04kWVbebslbjTGam8HIayTkhyVy1LUut0UqwUi0L1ZL0d7uDv7cNv/MRYxVaShpV1zTfvPwtt/efIZLDPPCcp8kh+haLJeVqoQh1CfBsu8K5wDvdEi0lLnlU1ngZ+dHjS55NE4dxRCvJk6sVm/Nz1q1hHgfm2TMcWwZl+DoFzpsFIWRCTLzXG969vGJMCe8nOi1YGIMPgl/vbrjKhZIzBx9JwFPR8cMnHX+zP/KL8QS50EvBp4cdG1mDwVKMSAFLBIeSWGRD9vXSliUTU2L0gX/y+BHew+eHHX9zfcswpt/jV/rDxresuG+nVW2vYbzll7/dE7xHpkgvCtM0o62iaxbkAvnBvk0kyYcXG6aQeVbWtEJSfGRIicPk+cF2y+PVkkMItQbXC7ZnW7ZNw3EYGUbPn5QtYyPYJ8mq6asepUSulh1PztaMKeO9pzWSRVOjuj+/Hln1npIzQ/TMaebCWP6Diwt+eTryV/5IKYVWSoKGdxIoZYgIsii0RuCnQpchqAKyVAF6juhZ8k8vrhhT4fPDnr++u2ae30743wRyEZgisdRm3s0Of9jxN7/4/0AIyFJorCRNicZ6rFakKMi5gMooIXi63XIMmacsWSiNEAklBa+PEz/Ybrhqeg6TR0nJk7MV5+fnrBctYXT4OfBTpRgQ3KTCR5uOWCKxBC76hidnj3B4ptnR6uoiEVzh1/fXXCYouTC6ACnTW83/7Mm7/GJ/z8+HIzkXeqkZmXmsLMEaXAFkoVeaOQV6BORMFgIvYYqJznv+/PH7TD7y+e6Gv3j5gqN7q2N6E/ji+Su61lJEpuiMaTTRHfn1J39JSQGRC42UJD8grMU0BhKUBKVkclK8+/icySeesKKxBkmkw3A9Hvnps8c8OY28Op7QUvHkbM3V1TlnXcP+ODDMnv9g1TMiKErT2QbnaxL0dtnw5OyCMWWmaaY3sGw0MSg+vz+wShMlZ6aYSEAjBP/Tiyf8zX7Hr6cDuUCrDIXAD7qWnAvHlBlKQStNSpk2C3LKFClwZObsEFPmP754H58jX+wO/OvXN5zmtwOPN4V1Y1m2DVH2jGHLcVQoN/Pbz36NlAVVap6DyJ4kFbapjX5+0DYq4HK1YpwLT/WK1mhccjTAmCN//OQR58PAq2FAS8mT8zM263POmoZhHBic58/7HpThVDIXzRmD9/gUeLJZcHa2xSVI3tFqSWcMISS+uDnQuwMQGX2lPioh+I+3T/nVccdfzztizrRUKuXTzpIxDBScEAglycqxSgpS1RJmCiFH7qeJ/9HF+/js+XI48PP7G3bjdxv8fm8b/hwz0mrMA4d4CIk/+sGfMfo7vr5+zovDHUZG/uzyKReLjmmYENRGKyNJHr6537GbHEoIjJDkmOlbyegn7l6MlWYjQEnB9f0BmYAYkLmgUmEhJH2vOR4TlkwoGZcSOyd56k7o0WEag1UWlzKfvL7n6zBwcI6F6WiE4YNFQ281Z43h0WrNX13fc3QeQeTzw4lMYfKJTaswWjMliL5a1C2SRAgBZKwUrBvJoByT8Jz1Fm0Uz9P4+/1Qf8goNfxBKIE2Em0Ul1fvkOPIYbrjNEy02fPRxYaLdcd0mCBnBJKCIhZ4dXPPYRhRCGYhSDFx0XZce8cvX15XIbgAJSXXnUaprtLHpGRhJLYvnDUt4xgRIoHOxFy4d4GrlGGc6mRVG4JPfPp6xy+HgfOxY2k0Sko+6NesrObSGj46X/PPX9xwNzm0EDWxualuFp3WNEKSS+WxejKahHwQWfZFsbaSqDI+zTyxLQth+MYff99f6g8SmoSWihLBT5EYM8+evMcQJ25uXzDPJ/pi+Gi94qLvmAaHeKA05gypFG5ud9wOJ4So9IVGCDbLHp8mPvnmhNWKxmhkEVzvBxQaEQOiBET2rEWhWSmmQ8RqQU6KGAs7V3iSJvTo2DQarRXeez55dcMX48jdOLI1Ha0yfLg6o1Was77j0XbFf/flc46jwyjJqzBxynDyic4oeiGRBQ65MOdMGzNKSiiFRknWjWXEccfIWd9ijearcvp9f6o/SMRcGJ0DWRCqUhHOzy6wqnB33HGcjqjs+cnFBed9vYMTtTkpyVBK4vNv7rmeBjSSxmuEKjzrwKfAb1+9JOXqry5L4n44YrWilECjElJmlqLgVi2/PU7YYpBSIrLGRVkboXFipRWNqZvIn7+65eU80TvJqu0wWvPhas1SSc77lqcXG/7fX7/iOAc6rbh1E97CLlaqR6cEsihezwFHtT5USAQFJTQr24COHP3EeWtRSjLGt/X3pjBET09HCJHb3Q7nZp48ucRozVAGRjdS3MzH2wu2fYMb5qr1UZKMIEXJN7evuR0GhDJYq9GqsDWW+zhx//yIFpozpZBFcH+3h5hIJSBloRcJ20CyhsNxpJRKfRXF4JNAeY92M1YbjNSMc+A339zwIk70SnLeLlhIw0cLS6sUZ33Po7M1i29ecny4g2/yt2egZ9kYlqJqSK99YEayoD5cKq1YsrYNI46X/kBrNJeiw03fbej2vW34i6yceaPkQ+qu5PHlY/anyP3xmtMIGsHFZkXJmRADKaaHhl9QisTmKszxKTOXjE+RPBY+GSaemobLRUvfWoQAV6AUT0wQcyWkNkYjdctlryhagKiN2KbRpCkz+EIqAZMyqWQmEeiUQhdNqwxLY2iVxCiFyQUDvL/ocEYxuIkvgG1nWWlY95qltcQkuJlHQoFQSR0YIbHKsE+J5uQ4Tp61MfhScPntdOvNoiAUKCPQRvP04orTeM8w7wlzQsnC+XqBKIkQvq1BScZUkW9RdMrgUmZKmZQLL8aJz08Dz/qOq87Smwdhuo/EOJNKxuea6mutRlvNo6xIQqISGCnojcLESNaFMU7MKeBTYR8DRoGQCYVkJasForENlIQEPloseaobfAwMKbHUlk5JNtbSWc2UM3/hA0oWYszUo7MgZOGYPF+NR/bOs5EWlyuf/y3+/iFljULOqZDmjJSKq4t36MfXqOnEKAS6s5yvlw9noCc98OpLESRgbQ1npq+0rJg4ZlczQIaJ97qOs66jN/UaiClRSiTkgs9QhKQ1GmMbLhYGtASfUUgWvcWWgm8UpxgQsYZ4HV01SFBF0yjDQldxWmM07cNZ9aP1Cte0zCHwws2cacNaaZZWsWgsvsDz4TlCQCiJmHIVXgrD4AOfn3bce8el6Yg5M+e3W843AlG1b9WlrKCN4N3L90j5RPIjwgmkNKzWK0rIxH/j/EulCq3XVnAcLS5mhhgYRODkHd8cHe8tei7ahs5U/rHzkRQjOVVtHCSah/q77Cu914dqFtAZjS0eoQtj8oyzYoqZo6tZELIYdNGstWGpFNZI2lx3tj9erPAmknJijJ7ztqHTmt4KemPxEV6fBgQQSEQyWgp6UROnPx2P3M51azrnyq9+izcEHwjzgRwO2OI5Enh0+RRKQA8B4QVBK87XCwipUv9SAiEoQlLInHdLvE9VmxkS987hZOCzYeCj5YJtW4WvAHNJqAfTAp8ho7Cm0DWSi7xGK5hiRqhMY6qYWxvB3gfmmHCxmsHMsdAb0FrTa4sVogqPc8IAHy4WBG0IKTFMgY1sOTOWha2bUlcKXx1HkDDliCyiJg4rzZQjX457XvmZS9tQKET1D9ylp28tjdGcrRe89+ySvu/Znl/RdtWO8KxfUNwBoySn04GUfHUTSTBNlXs1OsdpCrTGYJUkhMwxRGQGn+EUEkJFeq253c10pWCRUATCNIjG4Iogk5lSRCrBVhsWRiKQuPDg2iIgpsIQE72yyKKwBZpcaKSgsQYrJS4EBBmXI4eYyLkwh8LGNJXXP4/kLChScGkaUswkUapIhPrBn3UtB6FIBVKKrM1b/uCbgnyYaj2+XPPHP3rG2XbJ+dUTlnOPVvWxVnyNbR8OY3XvkTUeO7lQRT8+kWKmVRKhNEMOHOYZrSs/NWbwqYodD0OkNTP6YbOglEU0LXOp4RpBJIwRrISk1apuh2IkCYEUCVcyUy6spEVLRSsEnajc/sYatGxwYcYomGUV4+ZSfw7OrGbwkUOI+Aeh8pntSDHhc0YAVlQ+90WjaRDEWKkma/XWKeqNIGbiENl0C3748TPa3nJ58ZjtumVlWobjHTkPtEpwOo2QA1JW/VP0CR8Low81dVlKeqWQSTK7jKmJILgMIglaKTmdHDs5o2VNtFTaglbEIhDSM8aMFLBpFJ2RZAWDj4RSkKI23kOKLBqNKhJdMrrUVNXWGowxBFfdzAaZORAJZO6nma2x7GfP3gcCAikEV11HiHWzmh+csoSEd7uOlVHkKBhTZqW+t9fYP2w8aD62254P33/ExdmGR5fvgKjWrae+J/sDnRTM00jJEalk3S4FT8yZ0XtSoTqJSINIkslFVJHEJJhS5cwbCePo2auB2noppOkorcQLhZZ1aKeVZKM1nRFkBZNPRAGCTMwRX1JN0i2StmSakjFC0zUWIwzBOZSRxFS3mmNMmDmxtJqjd9zPkZwlrdJsjcWLmoZeENiHbJLHnaEVNaSLnNnq7yaYfIt/eyhriKmmHY9kvC6cXz7GaticOk6HFjftMEowHU5QPFLKqimJkZgzkw+EDI3StEpCEswxIosmJMnoCzlFjK6bnOM0U0rV5AljkaZnztVC85A9UsJKazolSQWmkIhU2rnPCUdiZSy9EDQlo1NCSkXbGYxShBCRsuBFYp88Y0hIGThbWPYhcBcDGcFCWbatJZRCpP6gaFHde54tOnqrCSnjY2T7Hc/A7+1JuWo6rJacbRb88Y/e4fJ8Tb9Y0/ctfbNg2mxwuy9ww4CfR6odnSTExHDyKAm7eWbvPI0xtEozUCearZRMKTGPiZPzXDUt+yEgQuLJuqOzGrRh1g33w8QUC5NILLWi07K6YRhB9JBknYBEICZYNJaSoCkgQiJmQdtLpDXklJhi5HZ2vHbVOXU3BxppeD3ODM5DAdVrnrQ9o/OgBK4U5pi5MJaPtxvuxpnryVN8QZi3DgFvCsqA0pLHlxv+yU8/5mzb0m/OWS2X9G3LvOpx+6/I3uGcpzx44hIhxtpoDT5w8p7zrqXXCuczKQs6Y4gZdnNEy8xZIxmmjMBx3hlarUArvLHcThMlgVOZpRR0qlp0hQxDSGBkFXWWRCiFx6alCEEvQJVMTJFOlOrGk1y1lU2B+xSqvad3tLLlZp45pkiWAmUFF6blJCaaIogZShKsleYH6xUnF3l+nIkpc27s7/tT/UEiDQEhNIttxx//0Xus1w19v8DoFctuzbR/ibv/nDIdCfMMoqBkbbhKKngfuR0cBzdz0bUsTIuQNXytUwmXIM6JRsFaaYYp8SqOXG3q1FVoxawsh3GuW9KY6ZXEKokoBZ8LRxfISqCkxOWEI/K06ZFeYkqmPDTsBYGwmhTqJOzWe14FRyTzepwpDdxHz5gTiOok9bjt2bnpYWJcMwdW1vKT7YZj8Hx9nMm5cNG8rb83ASELUgrOz5b82U8+4HJ7TtOtWPbnrLo102qFv/8tZRoIfq6CcPngABYjISTuB8cpZi66GrglvCA4aGXGpcJuiliZ6ZTAzYlX+cTFuqfTFmE0zljup4mUwJHRStBI0GR8gVMqJFFqairV9vOibcAX+pyRKeKFYEGLaBpSiEwlcRMdN94xhMSUZh7T8tU0cfABKRSr1nDZdtyHmbaI6iqVM2uj+aPNhmMb+Px4IqXMo7d38BuDtJZYEqdYuImBU5wxtuX8bENebXHLBdP9Z4RpIviZIuqgriQoMeJjYjeOnFLiTGsWxoCUXJeJRmqmUMghYAV0RrK0ml12dEZjtEIog1ctt26kpMi+BFZa00hZ7d1j4eAyRYGQAl8yUgoum4aFKLQlk4NnRtH2LcpofEw4MrfR89pXQ49BJGQUfD0NHELAiJrT9Kjt2HkHUpJKJqTMSlt+vN0yuMDnp4F9KjTqu9Xg97bhl0JWz18tKCbxfPqKGBOm6eg3EitnhvlrptsJlERKg/OJ4xwYXWbZScaUMJ0kkDn5QKFgheSlf3iP5cIJSZ5h2TVcHx0X2wWt1fgC18PEi+PIuRCVT10gxEhE1ENACW7GESUkjVCsm4aLTqOSoi3V/efkPfHkWeZECoHsCy7UyazWkhgCXx52eApJgJGSS9XQK8u2lTxZdNz4wK8Op+rSYzuML1iZaclI8b0KSv6DghSgjUQ1imwLr9M9MSaU7VhsL2mNZwrPuTuMZCBqVf2bQ9WSlFTtVA8lIUKoVpsloZXl1elEaKg2calgUyDnwsvDzKq3tFYTkNxOiS8Gz2MSplS7rjlmhCi0bSIhuZlmjJA1v0FKLjqL8oVWFuYQGfxM0ZKc8oNfemb0iSFVC1FP4vN5IOT0MG2rB2OjJL2wPOka9j7x2WnmabvgrF0CM6spEnRk4u2E603ADRHdW4SSOAL3znEYRs425/TrSxrtGd1X3B0cURlK0ficKSEjkqKkajKQRGGIheIihUyv4bfe0yvLQlYS5E5GpBDcnSYuNg1FGVwW3E+OV4cT51bQ6NoEjikjcrUPpkhejlWjYrKg1ZJza2lQtLJO1w4uUtTwIOTMhJDxPuNDRmVBlPC1m0lkhKibpI21KCl51FreW/Tc+8gn+xPP7JKF7fBJ0uuENwlV3lJ63gSkkNhGYhpFFJmX+9fc3d/Rdu/TrztaFRnnr7g/OIIylCIIIVFCPaucBxcLp+TRXpJTYY4BKQSvvGObYSkEsgjmIpBW8PLg2K7WSGN/d/69OI6cI2h0hlw4loxIsJaCIhQ345FSJFIqusZwZVsg0kuBC4mTn5FKssiFHBN5joyjZ+c8hcIRx/1pIsQq6tMCGqFQSvK4WN5d9+xC4DfHE0/blrNuBQQ2UybpXDeib/FmUGDKjnt34uXhwMvhjpvra5brLcvVOVYnhPuK28NEVA1RCogJGePvmtuQoajMVGr/lVLGZMF+cmQrkFpX3ZAL6K0kp1pHSml8kdwcHa+mWoOtlZgiCRFiyrS5ZpNcTyM516Hzumm56AxLJSm5sJ8cJ+co+xp4mXNGZEFJAh8LCskgI7887km5GrUYKdDUvKXHrea95ZJd8Pz6cOS95boahKSZXnlmFUj6u1G7v7cNf8oRFzN7N/HVeM9A5OtvPufxs3eR83Py8beUcIOxEjX33E0DOUZ8DISYuHOBlW65XC9wIeK8p5OSUUOTLLkUikoIClEmrlaaQwo0y7qqfn438lff3NSm3PRctJLzq56r845S4ObG0aG4xOBDQWvNjx6tURhAk3PAuYCfPbfHPe/GBiUkN95z6xzeJ/pGQrbscg0uQdXV5wfrDQAfn6+47HuepsKzzZJts0RpxflqgfcRmRJBvQ2deVNQRtC0iiQiL/Y7Zu346svPeXJxieWWMn1JDvdIVekP+3Eg+4hKQFHczSMF+NHmkrlEYgpsOsnCSm68fFhFU9X3xbNddQzHQNNVa7vrw8B/9/qGpWpQUnDeNVydWS7XttbgLqCQmFBDO5QW/PnFBVJJdF9rcBxn9uPM1/cnPu4CQhiup8DryTGXRCsNPZohV8uwkjNdkXxo10gFf7rd8njRc0qJy8XMZb9EacN5pziNnhAiuryllb0JlACbrqWxkueHHbP2vP/rT7h6dMZF7+jTDbibh/qDu+OAyBmVa0r0YRywbcuPmw2HEJhjoJfV63MpDUIIgkgkkTFF88FiwddkdGfIunC9H/m7F7coVcD1LDrNswvL422tv9ub6j6xTZo5F6Qy/PnlBmlB95acM272xMnx5fHEBwRa3XIdPc/dzDF4jNBsjOYUMl4mEoVWG95dbEHAT7dLHi+XzLnw7rKeh7rvOG8bjiEwOvewTn+Lv29ILbCtgUZwUgNzGvntiy/xzvFoEejL6/+f+isho0ql+r2cRzpr+XG7YogJFyMLK1gAd6Ot9VcypWQaoXi8WjMcT/RLBUbyejfy11+/AAWJBZul5p3Lnqt1W+vv/kTyARskLmeUUfyjiyd1/PBw/rnZMc6Om/HEBzHRPiTr3uaAEzWpdJMNc8rwQE1stObd5QqlCj99OP+mlPhguWKz7MEq1lrRTidEEETeUhrfFBoMX379is9uv2AwA1nOvB7vyS8+42mfWOZbhHtNq2pvtx8nVCmYB9OCYXBIJXlvecHgAy54ei1oqToQKRI+FzKgVKZXa74eJ551PUUVbvYH/vbFXVXNYlm1Dasry+PznlIKr68PJDJbaRhSBiH5+GJRqR9Kk3NGF0VKI58cD3xIYN30vJ4dL9zMMUckknXSTKkgrAAFRijOVY+Ugp9uzzhf9rgM7yzOWPUdja30oOvoOOQ6TPwu+N42/PviWG57fvCjH/Nf/OP/hMPtb3j9+c/4/G//Oe60J4cZrQWbdUcIGasERSoiiVxgHgMfX15QGkFCspsKr08zk/Rctgs6JbESWqXoTUvJmV45xrikuITNjn//8ZZ/9eqW54zsssLfFYRUvPPojMO8pwCHULmyOhe+vpckf0KrzNJY5hDJwfOs6XB+5FfDwJ2r3sVGS1KAp8sl0k3soqterBTu5hrGdPCWroXGGC6EwoWZjGW97PE+EGPkbjf8vj/VHyy6rWF9teAnP/4h/6t/73+MHO54+eo3/N1v/or5cKSEGWsy/cISY6STmiQkcwgcxwnv4b3tEikEN8fIfpj5hggkzhaGTmmsqIExrbakLGls5HAzUYSiCME/2W75b29vCKphjJBEfYg8uVhxuBkpsXpe51xq8t/BI1LG2uqjHlKilYrLpmHInl/vr7lNHoygLxaRBVfKcoPHR8mYAyeRuPUOReReWawqtMbw/kISgwc6+uWarfdMMXA3va3BN4K14L6Z+aPHT/jf/Ef/KeX4NS+/ueX5Lz7hi2GouiVT2C4aYkx0WlGiYHKeu/3I0QU+fLxACktBMPvAF8OJlAtt19BKaIWmU4q2seikWFnDmFrSHBC+8O9ervlXr655oSRtlhSRMUgePdpwNx/r9jQFUizoWHgpJHIEwUCnq3NKzpn3lg1HH/mrm9e8Og24lOmkwSJ5ojpu1MQhC4YcGUtiH2YsmZ3XWBforeXxYoGLkURgsWzYzg0nP3M7vM0ieRPYnBn6K8Of/fEP+C/+6f8CHW65+eaO1598zTfDgfKgB1otLKFEejRJRIbZc793jC7z0aNN1TWdRq6d484HsoK2kyzQNErSGEVrLCYpem3YTwYxRUyK/OPHW/6fz1+ijGWcMvJe0kjN1eWCw8t7QkzMqTZtqQS+2R1RgJKKBomLAR0L7zUdRx/5m7sdXw0n5lhzR5SQPOsW3OA4Oc8xR6biWHvPUmUOsaXzkc5Ynq0MMTqgYbGUXM4LZh843r01LXhT+H/8y/+aG3fPh+++y//2P/xPMcVx+/rA4Vd/y+04kJNHmsLZoiFG6KSmpISbHfvjxJAyz7ZnGK3JMXOKic/diTkVLjcNDTVTwcqqo8tCsdKGHFtizPTC8OdPtvyL1y95nWEYMkVVA4tnVxsOKRBc4ugDOYNVhpeHuSZqUenaLmZ0kfxkuyX6yCe7W746jLiY2SrLyioshvvkOcXAHDNJZWYDq1zY+4z1hc5aLhcaN53wjWW1NFzNHW4OfBXcd/r7/N42/E/PFvzko3f5cN1w/dUv2d+85O5mR84z8zQSQ8B0hmUuHObANHmkrKJdD5wSFFXoVUNqBH4RSdlw5zM/ON+ipaDk6poihGRBYfPxxzy+esLr168YD0dM0ZwZw+feIYphnhVu8OQ50cgGqQrtSlMihFDYTQ4fI15FyoPQUUqJkJL9kCm50KrCUiskmldj1Q30SrEvVQhshETp+nvaLns6a3AhcTOM3LuJ0kieWYM1Gms16e06+43h0dmCH334hI+2HePrr5lPd9xf78nZ4+eRHDylCGyjGLzBRQcpEULiGCMHH3lHCKwxrBYdQYCcHccS+HizQUtJCZmUoSjNksRVt+Lx9jHXxxOvDzu00Fzpluc+IIzCRwgzxFDopQILvemQpRBi5noK5Og5hGoFCwUhCkYp7ueILJUysTCSDs39XIVwPYopR4IsSCGoLaLkfGHpbLXRux0nXk0jf9IoHtuWzrSs2o5Ozb/vT/UHicfbBR+995gPVpbDq8+Yd7ccr++IeCY/kkKgL5rYWAYvmbz//7L3J7G2Ztl9J/bb7dec5raviT77hqmiIKtkKsukXSAkqFQCByXCBXBSEw0lDURoohpY4ohDzTQxBMkwrIE0sQwI8IByoVxWkSqJnZmkyMyMyGhfc9vTfc3uPdgnkyWrZEdK8YKZjLeAAO69L+65F/dbZ++1117/3x9RMilGXC64BJKaf20RrFIk58A+ZN48OalrYKruy1JotHK89dprXL7xRW6eP8ENAwrJmW55f67C2sFHBh+JIdEbXUksxlBygVKBA3f7iTEXLltVX5uCEJrRO0rOKCk4NZaFMtwcZqSqJoeUhBCCRoq6liO5XC5YNg0uJm6GgWs38lWd6bRlYTtO+8jd4eNtdi/jh4vzs56vfu4xXzk7Jdw+4zDccnu1QSaHn/bE4MnW0HaGIUhm71G5kEJhyoEh1TGx3hhWXYNLmZJgHwNffHBZ3eWPBLAiqgXgl09OefDq69zuttxcz6iiONMNV3FknQwLBfvJcBZ7Gmmw1tAbkKVAKcQMWzdxD1zormpHZB2ddDPVuFPAiTGspOZ6cpALVlbzToBGKoQUzEVy3nX0jcGnxM04cTXt+bpteNSsaRvLom1oxEss54uK+92WR48WvHHaEfe3DIeR/c1d1RBNIyl52qLJXcOQYH+YsaUgEkxFsfWZ13TBGk1fMuvcIEvk4DJvLR+ghYIcoWRKEYxh4HPLEx6eP+Jqt2G726OF5IyOj2LVCKx9ZHaRGAu9bBF9Yt3augYCCMHGOfZkToxAiEI14BUcUiaWTFKFXhkurGVOnlOlCb6CXwoZpQRCJXYFzpYNvTVMMXEzjmyGgc8rRdtc0DcNZ13H7W76WH/PH9mC/4sXZ7zRL+i8Z3P9lN3tPSXO+BA4zIGSE7bVxFRnnp7tBoqAhW1Y9Q2ewt6nalOMZGE09C1zLCyNRgrB6D1zDAw5M+bIV7/xmMYsCeWKvfNYYKXqLKwjsXeR271jaXdYJfEx0hqDlKU6kwYBUjBFGI68VqkkUwzMIZFyVX4nKnIxl1QdWG2hExIhDFrU68FSBK0xKCmZouP5PLFzjldjZpxmpBR0TUNjXwqGXlR88eEFX1idsM6Z3d1zDpstJXp8yOynGXLAWEvKCYHgyXZAlEKvFX1rGUNhDAWpBEZp1m2DFoI0CVa2QwrBlD0uB6bgOeSZnzx7SNP2hP3IYfZYJTlRlg+SZ5KpknSGSHs/0yjF7BN9o1FC4GWi8zBlxZQKY4hokSkURu/woZBKoeSj+bjMJDKuJEquwrdWCASVBACCtqmEqd3seDKO3MwzX/KZaZ5QUtBbS6N/ZJeRH+v4wsUln1+fcFpgd/uc3f0OmUZ8KgxzQOREbzXp2Fx4uhuRpbAwir7r8KkKJhey4lgXRiO7ljl71m2DRDD5wBADs3f4PPCTX3tA2y3IWTC4gCuFlbLkMjPGyN5FdoPj/n6k0ZLZZ/pGU0dnMy5UTQBF4mKsxT6FOQRiKHCccy1UkXkSmYlEKNUorBUKKepISAG6pqmH1Wnio8Oeu+D4YjhlmGaUVCzahvblGvhC4kuPL/ni6QWnRTLcXrPfbsA7YgpMsyOlQGMUOSVkgQ82e3SGhTEsugVTmjnEiNIGrQzrNqMAdyism7r++Rhw3jNFz23Y8zOP36RvllylPfvJo0icKssTNzARGXyo+Xc3YpX+t9a/HBOTj6iiiDkyi4gqBZELsw+4EIilvlcQhSgyPlXX50BGCWiFQohqQJiBtrFYpdg6z5PxwPU08aXgGccJLRR902DsSw3Ti4rLVc/rqzWnUjNvt+w2e0SaiRkm76r7e1ON0kSBp7s9JsPaNizajilJxhjhqFFaWoMqLSFFVqaOlfmQGUNkHyJX44Gvrs7pSoYQGGeHFHCqNe+PhVFGhhAYRs/97YCRApcKC2uQQIgZF77vByWO3f2CFDAFz+QjLtfDRRKFMUfmmHEiMRMRCnSpNLxCwRVobHOsA2eejwc2s+etmBmGGa0UfWPp7Y85peeN5YreJXIZCY1lHkdak9hMntnHyugXgtkFpIDN7JhT5tFK8vrqhJQSN6MjZs3CSFohEdaiZYCSAYELgbtx4tp5BJnT6Mi5YecCW+9pBVih0BmmErlHYBHonHh8sWaKmSSBI6u4U5KUFSJGhpyJRtJKCNGTcyEdaSeBWmgZJdhHT18kTRGIUpE/8cir9imhctUxXM8TLmZEEYyzZ9m39F3DSd/9kT6nP87x+fUJZ0mhRo83iWE/sWgjmykzzB4j6+bhQ0KQuDoMUASvLDseLjqCK2ymQC6SVtf8kI3lfkwIauKEArsQuJtmxjzxZn9KnGb288zOexqjaYRCZphSZBs816MgpcTj046c+IGBnBSSpVHErCFGxhCwCrQUHIIjpXrTmAvMKRFynWHdJU/JoAq0SBCVuALgS8HHxM55nk8zc0yQBeM80zeW1mj65qWO5EXEmycnnKBRLhDEzDBOnDYZN0a8TxhRO/jBByRwN02QQS16Hiw6YizcTo4QYSEVnQTZaMQYUKKiL2NKbGfH9TSxzROvRI+eJsbZcXABATSy3jzOxzy4PShEEjw+aymp5pMQAookx4QQEo1gChElC1pJhuDIqZqCCSFwOTOXiDGSTXbHNa9i51QRpB/kX0bGzGaeeT5OTCUhimDvZpZdT2sNi+5l/r2I+ML5GefCouaIjwOH3cRJm9l6j/PhaEbFD/Lvan8gp8KryzWfv1gTA9yOEzmr6kavNboT3LiAUnXP9C5xP3tup4kncc9P5IhwgcPs2c0OJQsLqdFJMovIPkhuB4eMOx6cLY6uvlTPAAQpCwoamTJjqfQVg+AQPCHFY7MD5lINDJVSbLMni4JAVCRo/sP8i1DXv3nm2TQyuEROif00s2qX9Laha18eOF9UvHm65ly3NAHS5JnGiZNFYRozISUUdd/zvn68HQdyFKiV5OHJkhBhM83MQbBSik5IcmMpU0KpitqMLrJ1M0/dyPU8cecn2vnA7CbGUGEvnZJYFHNO7ELgdpjIPvHwckkKhZwrpQcEPhVykcicmHLESHHEwnvmUPHZuRRcqRQhXSTXYWYogSIE6tjwyKnmYMoClxL72XE3T+x8NfccnGfdt7TW0H3MNfBHtuDXyeG2Dt33yMZyCDPZJ/ZDpNWKVWfQUleldYGcZcUd+YhMkZbEd/db5pB4fdnQWk1MEEoBkRBS4ELk7jDz4TgQWsH3/l//D/7Lr/8UU3IkUQhCklMV5YzH60kbQMXEK6sT1gvDNEXKsVgPKbBxnsEnioGkJUIqKKB1ocmaLDMxgSqCR6uOd+43FDRjCviYMVLhcqKUwkd3W1pZuJombsaJkAU5Z7Ks6u2FNVyuF3/Uj+qPbVgfmOYtpu9ZX5wx5YKaZ/ZTxIjCwmgEhd3kyLk6U8ZSGGMmx0IvM+/sR5zzPFpYlo1iLoU5ekquI2ghOHbjzJNh4EDmnz55n/88wOwc0YBpBPE4sTDmwF3OiJCYvOPhumG5NMSYIApEhlwiPntKEIwlEFtJ35haaEmwqRrBjSkScuZh3/C97UAjDSFXwxIrIAZPKfBss6MRguejYztHfMxEIZizokHQWsX58mXB9SKiKYXxcEDlllXbMMdIkAkfPa2ChVY0BbaHugbGmClF4mMhx0hT4IPpwEjg9dbStRovIaeMDgklK6t65yaeHXaMSvJPf/Vf8F/85DeZgydQ0EqQKChqkbRPiSvnCCHy8KRhtdTMrhZGAkEsBZ8VPtTbAdMIWlWgVCMxIQT2OHpZkDxe9vzB3YaFsYwlQIFeaHIuVfh5v6URcDuO7ENkyHVcCSQ9FW97sXi5Br6IWCaJ20yYrtBfaIYYWOeJ2RUaKbGmjqsejntwyoWUIKSIyJ6GyAfbDW4OvNq2rK1hBnIqkL8/gjuzcXu+dzggteSffvQuP2sbBr8niIzUGlEKksJI4TZFyjTiZsfFScdqafA+Q6wFe0SwI1JCYS8yxkp6W71RRFGYopBFMedIkYI310u+fbiny5aJREmlNj1i3YNvdwc2OfJsHNjMjtHBmAs5ZfpSWDaWV4+QjZfxycdSG/LoSSjoJbsQWeVMiZKlMdijOes0OWrLQICEWCIxzJiUuHIjIwFrG5rG1LyLCVJGKklKkcM8cjUM9MbyK8+e8WcXJ0wUPAWtFCkWOqNwIbIJgVQyB+d4dHbCaWsr6x+gCHyJhJRJLjKUSNMYMIpSauO4JEGQhZk6lnvatHx42LIymjFlQi5YUcE1pRTuDyM5JZ4dBm7HyBQSThRQkiwknRGcfczG749swX9xfsG71/e8++yG9uqG72wPjGHmpDe82i3xAe7SzKq1fOvqnrbVPLANORT+p4+ueXW9pE09fbHkBNvZc78PMAt+/4OBx6ctcwJtDa+IBSlmpiHyG7/zr+mVYSkNp7YBAquD4suLJVLVgu2QCrJvWK8bRrflMCd8go13rDuJQHMoBZIgzZkhFjyZQ4rEBBKFkoqd81wcZ8+0FJRGUlTFi81+Zl8CEc2YJUPITCJy2rcYndE6kbKA/CP7CH/s49HlJd+5uuV7z645ub7jncOeez9x0lou245FkKjdwMPlgj94ssOuqilWGGd+y3sedQ0qZU5aSatEzbGDh6D53Q8PvHrSsg+JkOBU9ejkSD7x33/0Hr1RnFhDl6oQXRB5S3VoqWonSyj69ZJ+oXj+dGBwCZ8y986xlg37XL+WckElwTYWJiKH5CkBbJEYrUlJcdJYZldvlSKZQOFMtYyT49bPNBruiuM+B6IQnPYdRmdaDSEL0o/uMvJjHZcPznjvesPTZ1vef77hO4cdO+85aRte7RasVebZbuS0W/B7zzesVg1GwOxmfvt64tV+wavdgpW2dArmnNgOAekl33q649Fpw8YFYixcqJ6lhTA7fvXXf5Veas6M5sxaYpIYIfjCYo0QEp8zBwR9v2a1tjx9NjA4jyuB3TzRW4n3R0OaIlBB4kLiKgeuDgOd0hip0VIxpczDvqPEWK/AVSHqwkorrrYHnk17TpTl4BPbmJhT5rJvMVrTaE0uEi1ecvhfRFw8vODt6zveu7nj5HbLt69vucuOVWt5tes51QpxmFnZlrdHx+vLFQshcDHxmx/d8Ph0yRdOzrHa0AMpJiYfwGv+zQdbHp8uGENCRMkjteRQJvx24r/73d9haTQX2rCSgpgKrRK8oVckITiUyE2G1XpJv+j58GrH5KrL9O00sLaajXC4KZGDRgfJlDK3YeKjw4FGSToUVigGFTi3DTJlTJE4A8UoOtnz0bTl/cOehVTcuMS1r2aZj/slRkNjIWXQvGx4vKi4eHDGh7d3PLu9p7/e8/uHe/77DzynbcMbyzUXxmDcQJSCpz6yNB0nCmSGt5/vOTtZcNl3dNpiJYzJsd97mOBb797w4KLHxUCOijNpcSmSc+F//Pa/YaUNl03Do06z2wcg87luBdQbylEVmkXHatHjrnbMzuNTZj9HeitwHnKS5ACZxJgy97nwwTRyIhVLaVBCUWTijeWCjCB6DzGipeLU9rw/bflguKNVin327H1kLonLpkNrRaMVoVT36Y8TP7I79feeXDPFBAVyLEyhKuUXWvFo2fJK2yEDPJsOeAJf6zt0LoQM2TYsG8v76cDB168VUUcYrOnROfN8U7FwUwoIBV++WLKbIg+XDUVIUhLoUrgaZrRU3HjPmbWcmYYsBe/f3nI5LbkdHCULFLWLsJ8yJWU8CZ8TUSiktJzKhpQy++xxOaJk5tGi52sndUN9e7/jfvYUJEZJ7qmmXHsRGVNiYTQLNP/029/lz75yyeurns40dOYlA/hFxfPbe9LsEbHyozfTRNMZ1lbzxrrnQdsiY+JmmLkj8mfaNVqI6s5sGroGogtMolS6Qy5MuWCNpUmBzTBzKBEnCllnvrpcsp9mzrqm2nBLVU3Z/ESLZgiBpSicNC296vjoesPF2LAdfTXGAmIU3BMopRBlqVbhQdBkg5KQCHhZDeFSSdgs+NPnD1Cy8N37ahmfBCglCSZxCJGDhylAj6LIzK988D3+1OUFD3uN1Zr1y3rrhcRHV3eE6CkiMYXCfqpr4NpYXln19UCZI/dDxON4zbYoIKIwTUfbGu7HA/fTyHVOxKN7ZGsXqJgYDoHB+zreZeBrp0vGUXPaNyihq+GVFOy2e6xSHFJgpTRn2lCU4L2bax64jtsxkGp7DQ+0KbNsBZPIuJTYJkHJigWKlTEgBIlMonCaJX/i/AIlJW+Pe65mRywFg0R2ghDg2s/sYmShNafa8n/99nf5M6884HNnPZ1t6OxLLOKLiCfPbwizI/vIIUfuRcBYxWlnefV0ycO2RaXI/TTiwsyDtsGUhFeC1ckJbSPYjAMHH7jJVSckiqa3BhVhP83ss2MQkWgE31ifMzrH+aLDHHUeSQhutgOqaO5CYG0sD3VHEvDO8+e8dnrGYRrJEWSpeZBTZtlaJmZCCkwho2k4Nx0b4yklE0shk1kqy0+crFFS8t7hwJ33ZCFplUSnqgvYkJlz5kwbtIZ/9u67/GePLnnMAmMMy5dTtS8sPnp2wzCPjM7hs2DjZ5bWcmItl4uWx12HKXV0MU073uwNpmRyEaz6lrax3Bwi3nuKyKScSQkaq4kxMY6JoURGmdGt5SvLNbsxcN73NFqRC3WcJlUDwPvoWRnLujUUmXnn+RWPly2bOZJKdQPXR7zrqpP4EEk5MiVFTg2XtuPej4hSR7ujKCx1x9dOT5Eq8d5uz93syUWglKSnNk/GEhl8YmkUD6Tm//b2O/ynrzzktdTSas3yx73gf+/mHtNqWiXopWQpJSorxrkwuUy0BaNgzpJl07GPGZUyuUiygDlNLKxm3XX0FowsiKK4P85fJxJJJ1CwUJqLruGy6ZhSZgiJEOtM2MFXo4RcYEwRIQEheHI3cXlwlT9dBAuhOGkUH4UZkGihKqVHwEkjOOTA3kWUljRH6/gzY1g2HSIVvqxOGWJiPlp+72Pg3gdsEYwpcBccjVLgBR8MA8umQSDw4WXB/6Liw9t7AplMPs4la5YoDnNh9glsQQrFnCRLY9mHTCugCEUSmbtUnVKRsnaVjOREC672kTlXjUYUVVi7MJqHy5bzzkIpjCHhYiIJySY4kFVoG8m4Eill5m7jOdsbxpAoQtJqxUILnk8zIWU6CbEUDimyMhKpwE0CISSIjCiZE9PwoGsQImHOV+xDyxgT21SgWPY+YaXCF5hEwUjFEBJPZseiMWipSOnjmX68jB8urjZ7UJlcKnZ4KQ3GSCYXmX0kNpYiBEPKWGW5nwOdFChtyDmzHSdCEtVgy2SMFPX2cYIpZWJIeArWKNbGcNa0nNkWHyKHEHEl0khV3aOpB0qXE5UrIPj2ZuD6MDPkgiiChVSsreZ+riNuCoXKBV8irRaAIs5glEDJugb2QnG2NOisMM2aV0Pg4CJDKBSR2TiPEoIxJnbB1zUwCp6NM5d9hxaS8HINfCHxvWfXoL8vIFS0CDSS3eiZ+kBpG9AGaGjExNZNWFWJYyUHtmMiB4kxks6q4xy05fkUcSmSYmYsiUjmrGm47DpK3xBDbTS4nFFSMpRIdWiACY+goBP87n3gZg6MISGLYCk1S2O5SxM5V4GwL4UhB1ZaoZVGKUmuQB+MVKyU5dWuQwhBZyw7H9hHzz7DmdFc+4CSgkOM3HmPkYUcBO8PE0vbsEIRXlI5X1jcbQ7MIhBFotGKTpqqCXIVhBK6ghSZompzrN4qZhCKROLgBw4ps9ANq0bQG4lEcTU6drvM6AIHEUgqc2Yb1o1hZS3DVL2ckij1JlIezVoBnwMyZzSKd7Z7Ns5VGlQRNEKy0oq70SGkoBGCGRhzolcJpapOqbY8QCFYZcmptQhR+OJa86iL7H3kkDKXumXrAlnAISU2yTFkgUHy4bhn1dSxOpc/3hr4I1vwTyEwkUhG0xvDw97y/sGhEcwhMbqI1RUhuGwabvzM6mhkdD/XhWdMGesCLgGyUAn4sOg0Y8icYCgYZJKQNQW4mkZiqIrvOUf2qeBS/sGmEwUsjGLvE61KnDQW7xNjCpypFi0cHsFCKayStEZz0TeM2z0pJlatpVESLSUrLWmkglIFvD4V7lOgZEEnJbkUWqkIud4WQKERivvJM4bMytRZwpfxYuJ+nEiqig4bY7jsG3Y5HOkSmdkfiygFJ4uGmxA4lQItC5uYKSIRk+AcQ0qSDQUXMznDsjEQoDW1KxBcQeSj4dYwE2KGInBlZp8qa1oLyRgTAc/Swr33qLawsi1zygwxsm47cnFEJThRGi1lNWvrDB8cRuaQOLMKaxRKKM61xSqQpfKwdymyz3UUo5WaOdUFT1JIuVSRaKbm4AKWpuIUX8YnH3fzTFEFKwVKK856y11yqCKYY2QKASslWQjWbcttmDk3iiYnNuMEEqaYuTQtQdWDa8wBmSR9axjmxLluMFYipaRQOfvXs8PFuq4MJTDniuLUUhCBKUasVgwlolPkpG9xMTKnwKVuCc4x5ciJtrRaIWXDotU82U9MMdKblqXVtFJyqmzFIBaQ1EPwxnkiCis0PgesEWgl8FS/iV5oNrNjiIVFhpxeVlwvIu6dR2RBIxVWC84by20IALiQcT6RVCEhWDcdt2HkTEpkztzME7lAiIVlMsxasJWRlD0hw1nb4FLkgWqQqsGgyNTDxdU44uJRsFgyY65d2EZKxlT9RnqhuE+RTnlOmoYQC1PMnLb6+HHiRBpOG4OQklVr+GA/cUiBM6NZaU2nDOfGYpRCiUJbJJuS2flAkIqFtgw5IDmu0aI2/uac+GgceW2xoDP25R78AuPWzySV0UrQaMll33AX/bHZGXEuUFTVz/Vac+8nzpREkbn1EwrBPmaKUMQg2B3RsLEUVr3GpWrGJpWgQeND3c+vp4mY6t5fqBCWQww0snb9fc50BvYp0kTBRV/9oOaQWJuWQsDlyNpIrNIshWBlLR8OE4cUOVeKpdG0uqLfjRTIAjMwx8i9cxTq2GNOoWoVNIRUKXs6SW5Hx7gqrKysaNGPET+yBT8U5hAhw1pqHvQtv7Pdc64bQkzsp9r1pCislDyNCaPrg753nmVjeD474pyQsrrnSiN40Dc87lvykGiVxaDYzZHJw5Q9Tw4DDZJWSp7PE14oshSoUgW/KSUaJVgoy6oxvL5csJkct6MDrVkbyyZlrKwmNqvWsm4tdjvQULGHa2NolaKUwnSkHdz7mY+mieez50z2GCRLq+iVQSi4S9U4QitBCYWS6+FG8HKxeVExxEBM0BuFbAyPVi0f3I2cW0uMhcPkQVXEat8YbiaHkQIjC/fR00jJjXeQOxAw5Tpn/7BvebVbgCysGosWtSs/BpiIfDTMWBStVNyGCZfqWJqUAp8yc6liI4HEGsPj1ZL72XEzTEhh6JUhqEirDKfGsm4161bxwX6AnGiE4cQYGqWQojDFgM2CTQx85GaeTTML2aBRLHWh1YoCLKiLpkDhQ6rjc3DEZLyMTzr20ZOSoFeSpVacLxrevz2wNhafIofZo1HkUljahis305dCyYlb51lZw/U4gTmONJY6InnRNDzqWmKWnLcNq9awi5HRZ4boeDJONCgapbgNM4HMnBJdloRc873JBdtYOqt5fdmzdTO304wyitZoBgLWCs5sw8IaulbyZBgpZLSAtVKsjEIiGOeIoo7uvDcMPBtmVk1HI2vXdtVoZBbcp4APiUYqfEr4XG8/5MsD5wsJpzjiDgXKCC4XPR/c3bGwhpAyh8kjJLhc8+/GT3QFdM7cToGFtDz3A2vfgBQEMpTEed/w5nKJ8JnzrmGpDds5sg8Zn9xx/ZN0UnEfHEFVDVwnaq67mMhHo6TOGF5fLdnNgbvRI62i9YaBiDWKM9uysJaulby92zGniLFVn7KyBkVhFyILWbibHR+NI0+mmZOmxyjDUmR6oxFKsCuB4AoaydY5xlhNPkV5uQe/qNgSELmwEAYjNeuF4On9VD2IUmSaHLOUuFz9E57nQi8LlsLOezpjufMzHiiukHNC58zlouPRsmMMjlVbTTD3Q2LjMh7P1exopWKBYBccI5k5RbSAXAQlC4TMtMbQW8XjRctuCtwmj9CaZWO4cR6jLCtj6bSm7RRv73fMOSGNZm0MJ41FScnBB7pSuJkH3h8OXE+e82aNBHqtWBqJLoJDqTezi6yJPpNyvbHQ5ce84Hc5U6SgHP/AqRxHZBCEELnziX0INNaSYqY36nh6y6yEQklJzJEtiU4YHjc9X784AyDiKxZTGxa6XoeE5NhPM1MqFFk759sYMVZy2lmci0hVufrbGPjK8oRza2ilpFOKk8ZgDJzbBdPmgCwKkRQlwjB7iqmn00NJpBRYiMIuRZ4MAxet4SrM+BQ5P3b/XYTOWJZKYU2LtvB8N/HmoqVLil5KNKBfFlsvLFyppBCywqDpRUMIGWEkzgVuJs+QAsJqFmpJJzRjjoicaTh6PRC5jQ6N5Kyx/KnzNVBHvRKJjKQIQdECVzLbgyeWhBKSORV2OdIIzUVXRy0sdfNxOfKl1Zq1blAl0ZbEqVYYK3mkF7j9jl5rGlXJTtu5IBvL5TIypgI50wl4b9yzCYZTa3g/TOxSZGk0DRZP5EQKVkaxFppGS24Hzytti9KCRhUUlTn8Mj75iCUjRb19kcnQG8XkIktl8CFyFxJzyLRWo+jolWVICZfhVFfO/hAiMGBkLfS/fnYOgBQVL5hSYg6wGQYMPXfTXE0ihSRkwS4lFlryYNGRXEDIQqCwi56fOD9nYWsuG6FYm4ZWSR4sFkz7xMooWg2ZyGECWwyvLhuGlLjxHl8UN27k+TjxStfxYRg4pMC61TRSklJm1TacWMNKWHql+GA38eaqBwGWgiyVIPQyPvmIqRqhKSGxxrI0LY7MiQAXJm78TEwCbQ2N7jFCcR8SisKpMlgU+5QIOGwRPGwavvE/y7+YIyFKopDEFClonu9HgqCO8lC4TZ5eSB42DToXlNDEIth4z584P+NEKww1FxZaYC08WKyY956V0bRaUIjMEyzQPG7qe+QqeiYFN27glXni1c7yjpu4i4HeKBpVZ6dPW8uZsZxS6LTkKs887joE0KqPNzf9Mv7DQ0iBKLW5aZC0ypJTxWmGHNm6gosFrQ2tamilYhMyskCPAV84hJlDCHRC8WrX8Y0HNQeLgMmn2twwhZQiUsLNNJNkIUvBRGabI0ZJHvQdKQQapTBaM+fCl/sVfSMwRWPILLTCWFBNw3Z21RxOKHIuDJOnS5bHTWSXA7iCT4U9if6w53Xb8cFxDVwajdW1Dry0LQstWQtYmZYPdwOf63sAOvF9p5OPp2P6kS34z4zleXRczSPOR56OijNjySVz5T1WSpQSnLUNOUu20x4tBEuj6aRkJJNT4qRZYIVkpS2vrWuxdeN3yENgPyUOsrDzgc00c58iu+DYFIFG0SnLWjYoJKMMFQ8WgSSg0/Rdw94Hbr1nHwLuIPjcxZqFaki5sE+eYYbTYBkTSGm4KJqcCofguc0TD41hEzIX1vKKaolFcOcFU5Z8b9jTKsmJMayVZdd4/syj1wEwxhCps2Ev48XEhW24C55bF8hpoGVmIRVD8NyYQic1UhkubIdSMEVHp+utTMqFJCGNmaZkrK4F/xfOKsLtxh/YOJjnjKfgi+dqcrgU2PpELNXMSyrJQ6sAw1VOlOPYWvACmQSnq4YpJgZgkIk0D7x+esbjVJ2dtylBTDRFMR0iC6lYSEVBMKY6inYnM2HOnHaWc92QC+w94OFpiDxLnrW1nNqWw+z5Tx+co5XGWE1B4HP4I3xKf3zjQiu2IbJxMyllDoNiYS1jTFz7wEJrpBIslEEpxTh6lkazMhaLZBdDdXE0HRbJqml580FtetwPWzbGMfrA5BOjL9zke8ZUOet3xVMkZAqvyI6kFNcqEVIgl4JCo6TgrFmwDTP30TGmQJgkr5+e8Fo+peTC3eyJyWFlgRC5lC3nFCYymxCIqXCvHMFHVsZwZqtY2GHZ+In33IEmwKlp6JXF6pk/9eARSimsNSAlTr0c6XkRcaENd95x40comYUZ6JJgmAPPFbRSowS8qhVaSg7BszaaU9MgUOziTEqBE6OwQnDRN3z+8QUAN7sDm9ExTJHZFbYhcc+eewLb2bFVkqJgJPFKbZ9wlRxSZHSFL7JWDQ96yz4E7nJgj4NR8Xh1wRtcUEph6z0xBlamHgu/1C4YgYnEIQSg8DTP7KZA10heaQ0CiUySvc18tJt4bmZOO8tJY9k2Mz/96DEAbdsgVUVtv4wXExfCchsct85TysBinjHasPMOXSq2UyBYqQqa2M+ehbWsTYMtsBtnAvBao2ipjbNXL2vBvxm3bAbJ4DKj84zZ87xM3LpISDCLQBaZHYmvy5YGyXMFgWoymI9jiGvbs3EzV2HkED1uL3j99AGvnQpKydx7jwuBRaNogM+bjkjLUBLbHImyjsv+gd9x2lreUAaQxChJGD6cJ4yElTX0jaHvJX/q8UMAlDUUBKH8mIt2r+eRRGEhBEsNh5jYBMfCWjyJEnPtKqmeKc0UWQkRp63m66cnxJi5PXgWSnFIiT/Ybbh5b+J/8/rr/MHTDfuQyLJgtKRXllPb8e7mFihoAb0SPFz0zLmwDzNZ1Ku/kAqdMlxNI0OceRochxLRSvCwCN6/3fNnvvImRkk+utvx0fU9UUS+errg+jCz9Q6RS52vFh2vrBZ0FC7WPdZYtlPg7feecrZY8M5mz9MUeKXt+JPrM948f8ToDnywn+msoQD70f8RP6k/vnHjZmIuNCjaojjkxC4F1tKw8ZH7EjFS0akFTQItNFOBtTH8yZMlnsztYeas0WxT5Nv7Lbvs+Oarj/ne1cC9mwgUlJL1ADsmvhsOtEUgssAKxaVqufaJOc8kIfEpknKd27+dPC5PXOeRIXpSTjRG4H3km1//PEYr3r/d8N71hiIE37hccDUE9qnqEBY0NEVxtmpYKcWjkyULY9jPgX/+0XMupOV63rBPlSv8QFn+V+cPGdPM/cFjZD3YHOaXOfgi4mryhFIPlitpuZtndnhOpWXvqzmgkZKladE+slAtviSiFHzl7ASRElvvWEvDkAMfDnv+7997j59+9RW+/XTDJlfXLC2qpqMLgn8zHVgezXJ1UTxuFzzzjk1wCCUYUsTnzKXt+WA3cjdGbtOMl5EiMmWamSbPT33l8xgl+eDmnvevR5ZG8+UHK55uPffO0SJZqYZRZB6dVsTo+ckJnbEcZsf/86OnnNiOfZh57mZyEby66nnz8hVGF3ky7ugaAwX208v8exHxfJxxKrNsLBdNx+w8GzyrbNlQvUSslJzGnohjZZt632ckXzxfIWPPLkyc6NoYe3ezZ5vf5Wdee43vXt1xHzwgaJSm7wyvRcvvTztsLsQUUFLxhfaEXZoZ5hm0ZOdnXExcmIbvXm94NhnGHHASZgRvH6752mHiP/uJL2GU4v2re957foOk8OXzFde7gTkGVkLzQHYMqnBpNSslOT9Z0xnDYXb8Dx9dsZKWG5XY+Eih8FA1/PT564zO8WSYaY+H02F+eeB8UfFkGEkWlq3hQjcMMXBwjhPTsA+ZTZgxUmJty+00sLTmSMqBL65WhFXP4WmgE5pdCnx3v+Pu3cA33zzWgSWThaBRkjNr+Xxa8F64QkeBKwWlFW+2S26D45A9SmnGEHApsm4s3z3seTZX2mMsVWv5Qbol4Phff6Hm4Ee393x0fUeXFW9eGJ7tPHP09EJxriyuZC4WCxpduFyuaIxhOzt+7cNnrG3Lbsg8Dw5fMhe64adOH7LxE8/ngU41SCTD/PGabj+yBX+vLUUWUilMqTCnhBGK3jRIIVBAIwVGF/Y5cW4sQSRaLWiMQuSCNIWpVOvsuWSk99zPnidu4kHTkAVIIVgZzVDgsm947ie0qOZEPhVaLXGl0glSksRUaQFj8mjToBtNm6ucwKCIJfK77z3hbNFhlOT1sxWyFNZasVeS65CZU8AoWErNo8WCaR4Rx99FSMFUImcRUir4lJlKwqlEqzU5J7bRcxNc/T0/5lXOy/jhoxEKo6qhy0RiTgErFa2ylTKCoCkSXRJ3OXBiGiKZRgqslIhULbX3LrOPiVlkbnXg3iXen/ZctA3q6Kp8Zlp2jeNCWLbRIwVoUXGvS6lBJBASkRWOBCSiFkQVKSVhtUBhMFJSKPzuex9xvlgiEby2XCDInClRXaQzTKVaebdK8fp6wTQnFAopFMhIJKOVIidwMTHrRBaw0gZRCps0492ILpU69TI++WiERouCloIpRxwFi8JIDSUjZbV0LxQ2wXHSG2KpVLNWCkIqpJKYkyDkQiiFgwgcZscTP3Le9CBL7VIpzaALD2098AkEWigS0DUNUiWykjALZE4YUcct98khFFghEYWjyA1+74MPWXc9GsHrJysMsG4kGx3ZhMKUE3NJtFrx2nqJm12l+kiB1PVmoUEwxcwYEqOIuFRpVpnIIXvuR4cRCsvL0YoXEa1QqOMes4+efQp1tFFbyHWIYKF0ZYyTsKqaC5kiaJPApYLPMKTMkDJTTqjRcz/PvDuPXHQtUlRqyYmso4oX1nIfHQlBIyVCFC6NraOJSpByocSCkYIxR4Kv5JRCQYvMiWyJCb717oecLnoo8OhkSYPirCnsjCbnWN9PpUIwXjtb44YZTR1fklKCzDTG4F29CV3kBBIWWpIpbIvn+ThjpKYXP7Jl1I999EojtaRRCl8SU0po5HEdrLSvRmpKTLgSWGIRR2dbJatpYJKFscRKvisZowLbaebDMHHe9VgkWgiM0kDh3LYMJSByxlLXu3NtsVIihURmEBka6sj2XZjQutL4pCwshcFH+L33nrDuOpQUPDpd0xRY6cTGwDYWhmNd2gnFo9WSea61pxZ1rDvKggVmIlNOLHIGJWi1IeTIEBM384AWlaD1ceJHNlML1RlUFUGIdUq4U7pe54l6pYcQuBLI1A2n14K1Uoij3ft511RkV65FycpUg4yQC0iJKFX86mNiTBEj5VGRL5BSUERdSqSEGCp6TiqJE5k2J0LJWClJRVKOwh1H5m6aSKXwcLngom/JORFiJFOpA75UsY8pkqYIglCULCi5QK4UAkQVi3oUWtTXVVpxsx/ZHtnZSkg68XKC9UWFEJXOUKjPJJHpVBV6KXl8YxaBLw6fMl3boJRmpeszyQVOm5bRV+t2LaEzipBrp/RcNCgpUYAVgiwKvdLsY0JLgZUKIQRaCgyCOZb6uVb4UiomNuSax6UQRaFBMpEJw0COcLlYcNF3xBwp0R+RioWYE/F4u9BLRVYFISr6MwE+R4SARivaIlFCECg0WnEzDmx9YIoRXQSdeFlwvYgQogIRcym4lOptk5IIClIKtKrFyZQDgUwj24om1ApKIebC2lpiqEOwVitW1pKyYMpVqyQRdQMrGZ8SvVIMJJSsdAmOm4/UhiEljFKArDmSIlLWIilmyLnQGU3SsBkmYihcLvrqApkzQUSygCQyQaS6nhZopCQr9YP3WhKZKUWKBiU4Fn4wl4jW8Pwws/WeISekkPQv18AXE6Jq5vIR7TulhEVSSkEjsKJS5qbs0Qh6Y2ikZGl19c/JhXXX4mOiKLBS0llNyIUxZ05VQYkKxCi5MPhAIyUgagEmNVHU7zNHkzYjJb01lCKIIqFKHU+MpTZB1qbBF7jbj4RYuFj2XCx7iJDKXDWBgCfjc6bETCMkSckf5F+W4EpCyloH6OPv5ErBaMWzw8QuBHYxomSoDZmX8UJCyFrIxpw5HP0QtJLEUrGYStbCfooeI2qjrVV1bBWgFMG6axhcRCpokCytoeQqBM8SJIVS6mHy4BzmuJ8pUQ8aUkm00HSiMKSIFNBJDamuZVlklIRIIZFZaoPPgvthJMfMxWrB2aJDpEQIjopaKQQSIScEBSMgH1HuUOvfudQ1UCtFEyVSFCI1L7fTXEfRYwQhWHxMJdMPtVP/nb/zd45F0B/+97Wvfe0H/z7PM3/1r/5VLi4uWC6X/PzP/zzPnz//YX7EH75WrhxeIaBVdbzBKEHOAR8DUwzsg2fjZ2IUpFJtileq2rJnBK90CxbWsLCa867h8aLDKDjRBikUIcPgE7fTzI074FNGl3p7ICU0GhCZtTF0QmOlQimJpxb7MScWov7MVkmMBi8K2irEkTNtlKLRml3MuJQRqqAVIOBAJPuAERqRJTlWsXAskFThvLU8aht6pZlind9+Mh3YHDUDG++4mqb/oL/vj2N8mvkH1BsmUY4cpNrRMqqKwUOK+JyYSmQXHfhCLrXjtdIV8ZqBVxY9batoW8lJb3nQNwhZlfcCQQJCgTklDskji0QXiUXTKI0xFc11Yi2tOuI0tcJlGENgnD2d0DRCVVyXhEEUpFbEXA+srVF02nCImVCqYFceDwlzgewzrRZH9GYi5nooTRTWVnFpLa2S1RZcCp4OB7bzzN57bsPMs2n4j3msP1bxaeZgzY1MLJVGIwBzFKslEkkUXM4ckkPLAgg6remNJpVCEoLH/YLWaBorWbXV6wFZ80EoSBR8Lsw5ch88pYASol6Ta0FraidtaRqsNLRa0zaaUDJj9IgEvaykNPX9gk5VLwDBsWA3GmsN25iZyURKxXAWGHMmhor5lFSBeUiZIUVmUVgbzWXT0CrFkCNRZD46jNxPgTvneeZG3h8Pn8Sj/bGITzP/oqhkuphrHlJkxWLHSCiZImr+HHJE5NqYWFnNymqKrAfWN9ZLWqtpreKkt1weXaoWRiNlPUyEmBh94GoYSLHmhkHSCFmbG1LSG4OWks5U465YxBFuIFgYRWMk2giWRuKFQGpFOTZmFqbSpHah4OqSiCxALgw+El1A6+8X/PX9dsiJQGYlFefGYIRgHwJZwoeHke0c2MfAjZ/4cHiZf9+PT3oPDiIz58icI1NJpFJn9acSGY+H0InEkCPq2KxttaJXxwJYSF5ZLOkaTd9WtPHDRYeWdfRWqVpEuxSZfOBmnMgRcubYbFO02pKVpFMaCWgpMVLiYsLniFWSE6vpjcKquldnJNoopAQtBY2uQt9tAl8ERYISBXH0icjHNVBQDx4hZ+YY8bJwqhsuTEOD4BADsRQ+Gg9sZs8meK78xAcfcw/+oY+m3/jGN/iVX/mVP3wB/Ycv8Tf+xt/gn/2zf8Y/+Sf/hJOTE/7aX/tr/OW//Jf5F//iX/ywP4Z4FEQspeRUSRKFOXtSrBtUoir5M4qGiCuKkBUeyWwEWQhsESyFpDXVsKY3goOb+OJJj9Ut377bcnWYWBnLLmWWSmCkwgpJi2ApFVD4xuU5IcN3dju+vdkRI6AlfRZ89XSFNIoxRTpZeG8/oaLkYddy0mhKTuiicD4wxYRFoRCEnHFHX4BWCUgJlxJjTPRSMyTPSlmsUexj5GZ0XA9DXWhSJOQ6WqQ/Y4iUTyv/gB90Ui2Spki2AWJJ5JLwMQKCVkpEkiyBvfO0UrBU1UNBA6eNZYi2Gq5ZxZltcHHmKydrFqblO9sdV8NIagp3wbOkxRaBVtBoyYO+oVD48tkZcxa8vT/w9n5PyAVrYCU1X7s4AwFD9LRC8r1pxqTEyaKltZqYAqVItj4wxkQq1VROcjTNmsEsNSkWXAwcQvW7GIicK8OJMuxy5Hae2UwHbvzM3tVr/CgyOn22Rno+vRysxkNGCKwQKKHxIuJTYA4FkzILIxBG0CjFIDyyFEyphi9SSVbGMjTV5dRoQasyUzzwxZM1a2P5YL/jzs9Y01VCk9BIAYiEFooTU28ZvnZ2ThCCd3YH3t5scbneNtmS+erpCVpL5hSxRvD2/QFhJZd9z7ppyMfD5TglfAGdBaJWhPgMuITsLcSID6V244BhcpzLhtJqtjFwPTuuB8+99wzBM+RIoKDLy/z7fnyie7DJiKLQKCwFpRRz9ky5krkkFW6RExQFhxywsZJDojZIJbmUDQcVKHDEZFq8D3x1tWTRtny4P7CZZzqluAkemywIUf0ndOGxrc2Tr5+fEUrhu9s9393uCCoRM5hS+InzNUpLxpQwBeb9joLhbNmxMJqUMroUtj7gtUJmQRuPI2klgwuY3lIyOBeZZkeMmZs08Fi1ZGW4D57rceRqGrj1MwcXGETNP/VyD/7Bx5/0HpwBJRVWKDTQWMnoq9japQq2MFJChiQSnsxcIq5IulIIUrKUhsYIkJpOWxaN4RADX1if0RrBB7s9GzfRacFBJLpo61iXAC3gVNY18PMPLim58M524DubHZFAKyV9EXzp5AxhJIfs6UTh/f1EAVZ9d3T1zUgKo3M4DToJRNLEXHMwpYS1llQKcwgMofo/TD5yoQ0rKbkPnmfDzCtmYDN5pjkzi4QTGfUx2S0/dMGvtebx48f/zte32y1//+//ff7RP/pH/OzP/iwA/+Af/AO+/vWv82u/9mv82T/7Z3+on7NuKh9alMzgPWe95s+89iV+68kV+6kWJJ3SfDhPTESkNIzRc3M3cXcVedA03LiRmEo9rRVBeyt4fbngrGvYThMyVLvsYgVv0bKwDU/izP3seX+Y+N7hwLZ4HnUdi6YhAVkKVr3lL7/xBh6Qqnb9z60FwETFdQ4oJbjZD9wPMxUcFtkfJrKqYxInQuOyYkgzipYYI1JWl7afOj3jW4eJ33Qbxpw405bPtwvuhsDWQ1csqkTmFBn9Z0sw9GnlH4ARmlNjEKKOGby+aPnq44d868kVU6iUlFNt+d6hogzbTiKU4N1x5P3bPV9cr/ngsCemTIp1PG1rHY/aBefHWWkVoUdxyIEvdSdoJbEZrifH+4eBD8aRTZ65bN/EKk1MHp8inRT8pTdeQSXIUmGURLW2Cte1Zk9mbTSDc3x0Vw2ahimyT4GcNFYJGiPIuTBLj/aKmBNKSS6V5meWl/zeNPJr0y1zyFxqyxcWPdfjzPvbES01RlBH0PxnSzT5aeWgzILTrjpLJgGdKvzka6/z20+u2ftAKxSnUvNkdlwz8IpeAYKn88S/eu54fbHko8NAjIGYQSC4UjOvLpec254i4Ew1JFV4Oo58bbmmBd7TipvZ88Fh5u3DgCNzaRvaRpFSQFCNk/7iG69UvjV17EJbS1KSdiWrKZKG3TyynQKyCJyP7KaJIKHTto5oCsfMjPYwxOqZcqI1/7uTB/zeNPDbuw1ziZxZy1uLBVsXePsw0iPphERSmPxni1T2aeXfyiuWvUFJiS8F1Uh+9rUv8DvPrxm9xwpFLw03LrNXM6+zggzf2e155+kzvnpyyrUbOaTqp6MRbIaZR2rBKytDIwQPbEPyiXfmA187rQSzpVNcz54PB8c7+x0Tmcu+obOGLBNCFxbK8F+98SoxA6Z6mUgquGOpFfuUWRvLYfa8N+1YKEvyEVwg54xRhk4qjPIMKdN4TxwdRirOteZn1w/5venAb0x3zKlwqg1vdC3Xbuadw0BjjqaZOTG6zxal7NPcgy+EZqkbkDCLiNKS//IrX+X//ew5t9OERnKuLU/9xCgTbUr4IHl3Hnl/vuH15YK78UCk3kDtZOJmirzZLXnQ19Hwx7ZDB8mNm/lCt2BxKjEj3M6Op/PEe/sDTkX+q17RmRafPIlA31n+0ufeJKWMMQYpBWcc68Ck2KfISmt248z3homFUhW6kRIpVSfyRguyDsxxBuAwOJRUnGnD/3Z1wduj41uHe7zILI3mkW24GwO/P42sUDRFILJiih+PFPVDF/zf+c53ePXVV2nblm9+85v88i//Mm+++Sa//uu/TgiBP/fn/twP/t+vfe1rvPnmm/zqr/7qv/dhO+dwzv3g891uV/9gR/FXLzUPlx1CQ28N33h4wW6aKkbJR86wqAQf7EdaWc1itJK4ktmnRJ8MBoHPiXscX2gXeA9TgFXXctJmbg4T9yEyz5lJRqwA29QbgzWaf3l1x1mvufGebYhc9B23k6PtGoapUgNSKUipuE+O94c9b7UrBu+5Ggceqp4vnzVsbGETAsNcUFKwaDTvb2cQM1EVsiwoBH2RJCIntCgRIMLNznNjIhPVMrzkUkkXsuE7P+xD/DGOTzr/4N+fg01RkApdozjrenwuXNqOP/HwgsPsmXxkCokT3aCAd3cDnXE0SrIwijF7NkOdcxdFMJPY5sCjdYf3gfvJsdCKi/UKF6rhlgLucQgpOWsNIUUElt+62rAwiuvgOYTASdOynzK9kYyTx6dKnRJaMU6OD/3Ew6ZlcIm7KfDY9Fz2gu1c2GXHmEHGOv/4wXYPAoJWCClpqP4OM5lTDAdVO8R3+5lrEQmtQIWK/dSlYD9jM6yf1hp4Kg22KBbKcNo1ZJE5b5b85CXsJldpETnwWFUm85Nx5k6KOsOqNfdp4jB5rDYoIfEl8jzOvNEt8fPEhzvHWW9466TlUd/y3bs9ArgODgSstcbnwhgKv3V/y0pZboLnJjpOrOHJNLCQDZMP+BwpEnTTMI4z7w17HvcLDiFwM828bnseryybUDikxBgSKs1ILfje/Vhl8baghKIpGiWrSd2JtFhRjbfu9p5bFdGtokmyikCL4ER/tmb4P638W9oGIzULqzhpKnf8ctHxn5ydsnOOIUbmmDjTBp0s396O9FrRaslF37ArgSlEooeSYRSR6zzz6sWClCW3g6NVks+vlzxoGt69HYm68GwekLLqTeYIJSZ+/eqGU9Pw3Due+5lz23A7OTqrySEyhcgUPAXF6Cbem0deaTuGFNmEwFvtmlOrOUzuKNgNIKqJnDnsEAOgJVYqOqop5kxgTUtDRIbCTZy5PXjUQrIIiiklBBVk8FmKT3MP7k2DkILGaB61K4LINNrwudMzHvQdc6g5eHFERzydZnodaIxi0Wh2vo48n0qDFpJd8Hw4b3nUdUyTYpMDC6V5fd1zOkuebme2s+I2jEitOOtbbscBHwS/dbdlZQ9czY7r6LlsGjb7agI2lVBF6qEgCwzO89QfeNC0jCGycx7bnnDaCvyhGhlOOR09KwvfPewRHIiyYISmFwYrEltqjttUKCFzFSZuVeK0belyZs6FphS6jzmd/0Pt1D/1Uz/FP/yH/5CvfvWrPH36lF/6pV/iZ37mZ/jWt77Fs2fPsNZyenr6b33Po0ePePbs2b/3NX/5l3+ZX/qlX/p3vj75yBgiqm353HrBammhVCpFKyV7qfFh4MxC8InoM16K45gP3HlPzoKlMpUgIQuYhlsXeM02GAGKQk519vWss8SU6YqsYg5RZ1nHAnMO5CmzDYE5J3wI/MvbW867FpnlDx6e0vV7D1Pkusz4lAgRXIrM2XK+aElD4RDqzOBbizVP7/YAOFuYRUYUWDYdAaqYMwmMEGgrGGPi9WVbxU2tqgcZ99npbr2I/IP/HzmYoaRMKxoeL0/RumBL4dI2rJRhrz23w4RpFFOOZFfdZ7VUpAxPdxOZzLntsEKCLBRVeDY63lAtwgiEhkTVdyyNYo6JVimyqGMQpRQ6Jbn2nkNS3McqVux14tdv7jhpFQSBL5mgMlbVK+xtDEgUc4gMIbDLhvOF5lGzIJaBw1Gk/uZqyc1dnUH1OVK3TMEbbcdMRmWJcolUMnuRGYvj1ZOOIhOdULRCMrvPzi3Tp7kGOpGZcsEIy+VqhbWSFBMLY2ik4uA9dyN0VuJiRJRCFhBlIabCbnBIJbiwLVYoiswU3XLvHUa0mEaTJYwxMcWCNpKcYYkmlETKGbLEaMnGJZwK3AXPIUVaqfjNqw2LRmFyFaElAcZ7UkrsU0a6GZ8zEYHLBSk0D1Y9eZw4xICRirdWJ1xt6uY+eXA5oIrgreWCQCaURPSJCAQhmCi8frogRs8ZhhaF94l//Uk+5B/h+DTzL/jMmAPGah6crLFaoWLhvO3obcPOOW6GgU4aos+UMhGFIMtKtLveT4icOZcWLSVCg2rh3jtaI3ElUUTVrLmcUEYC6ahBgZITlEKvFffOM8XCXXBMKRKN4V8+u+Gsb+iUweXMmOotecrVkO6OUOe/YyRIh247Tlc9+/GADx4jFZ9frXi+H6DAHBIxe0wWvLFYEBHEnEih4EtmlPWm99W2I8nEmdJYoZimyG9/ws/5RzU+7T14zhHvC6da8YXVgk4rSk6cNIaFUQzOcXMYMcYy53SEuRy/uQhGV7920TZ0UnFqTB1zDJ6lbskI5pQIseBixhrFXMAqSRGFQjXdWgrBzkd8KWxDJKREKYLfuLmlX1g6UUloPmWkFKScufeRWBw5JyiZUhISw8VC4CfIHlDw+fWau+0eKIwy4UuiIfHWsuJufU6V+58ymUIuiTcWC2YfOBMSg2LkBTjt/sW/+Bd/8PFP/uRP8lM/9VO89dZb/ON//I/puu6HeakfxN/6W3+LX/zFX/zB57vdjjfeeAMZCzMJbxJKQ6crHUBJyd47bsaZO++wQhDqCBdzTCAFja4LgEyCIDI+p4o3VIqNC6y1IxWYYsaHRCyFzohKR9HV+TRSkEg0iTkl5liV3BZJiYXnYSKXTC8bXM7sczziEqtwM5SMFoK1sSQEUyyslg2vIAk5HzfaigbLwN7X7r0RktxpPr9W/M71hpgySikytav/Rt/xXk7HhDuKMD8j8SLyD/79OWilYDqydaUoLLWus/lSsZk8t+PMvfN0QjGXKvKKMZNyxgjNGCKyQMiZKDJKVIHjjXNcdposC2OOR/xqoWkkLiSMlCSRianQUs2VNjEy50zMhZIyk088SxNBaLpc832Iiajr9fKyKFwqCCQLXWe/pyhZty2vqB5PQQiJz5nxmENjiMzlmIP9ks+ven5nGEm5OhdGKfAl8bl2wXWp43I+Q/4MYTk/zTUQYIqRKQWkKHRaIVIlgx3mmn93s+fEWHyGdBRA+pJRRRFCYaUVShZcDuRc6IVk4zydVmQFUy64BDEJpIFxrqhMWcAl6LKklXXc5nD0Y5Cl4H3iBodDshSGkKtJUsx1vGshFC4mpKjrrhOJKSaWfYNUipBypV+lyEjVu4whc0gRKQSvs+St1ZLrccSVun5DPVi/1S14NtW125VMyi/XwBeRf74U9jHQxopLXWoNuWCVZuNGbqaJ63nmzPT4VAklYwokUVBZMIfIQiuUqoWzADppufOeHZIsC6GAypBixWjHkFkd9++QMwaLFIJNCKTjWqkyzD7yNAeCLKxlxufCrgTG4zDziWgYjsZanawjk/tgaKzhVdlzmVsKgpQKc67UoakkxpTQAl6TS76wWvKvxpGj9zSiFKaS+Hy74qkbCCXVA+3L/Hthe3DJhaFETK4uuJ3WlFIwUrJzM9fTxI2bWUtLRFSReYjEXIlOMVWQxZQiY4yE8n1UtkdnQAhmMiJnSgSvag520hBFBVec6IZMZD8XhpxqDSCqaPcQA6cqsxSalCv+czoasdkiOfiIEdAIyT4F+qToe81jITlpW7woxJxxR82qi4VDTkwy85pY8Lnlkt9wE3NJyGMzbi6R19qej9JQx4Vzxn3MHPyPuos/PT3lK1/5Ct/97nf583/+z+O9Z7PZ/FsnvOfPn/8vznt9P5qmoWmaf+frbRYEUUgl4nMgRAnComTh2X7ge/dbdjmwkgasRgnJlCKEzNJKrFKEEtgmxyFWxOBD1eBj4ck00ivDzkUGH1keBSGb7HloFxglCbmQo8DmqgGIAqxQNEJSjgrulDKZVBFkJbPPHnGcSyRDIxVdI9mRcBHOleJy2WKlZB8D//L5c7TSzBR2rhaWvTFMRfDVs47fuL4lkNFFVqFwLqyUIZfC9exIqdDkzy4S8ZPIP/j35+Ba1QUjRM/gJjrdEY/o1me7gXc2O/YUHhnDAShIZh+IonDaaoxShJi5c67eABnBA2lJOXEfZholOcTIGDKmSJCKQ4pciKYW/RR0kQSV0TJXtKcAW8RRQ6Cg1FwsCHzK3Mua62csSTnTCknbWA4EBh84XfW83i8wSnOImd+4uiILQSwwxIzLic4IXJF8fd3xm8+uibKOj1mpMCnxQLVc54mryZMQ9OKzU/D/f8eLXAObIjmkwBw8Lkx0R969FFUf9L3Njl2JxGZBUrI2MUJCy8ypVXRSo4TgkD13rhq3PMAiCtykkdZoYs7kDK00RBHZeMeriwVGKkzKKAo+J8ZcDxJ1VlrhQ2TR2pq3pebePicOxDoOJDtCgoUULLRkFPVae7FqeK1pMUKy955fe/YMUHX+OtVGhlKSKRe+crriX11fVTQdkgaJzoILbXieBVezJ6ZC9xkT7f7P40XmHwI8iSkFnPNEBFIZJPD8MPDdzYb7EMhWkwVkZO2m58yJNjTHYn9UiU2s+9WlL8hcuA0zrRakDCVBWxReJqYcObUtDeBzwSSFz4ltSWQSjaykoNEnlm29zfepMKdK1rnGUQQspGX2gaVS9MawLwkzeV5vLW8uVmil2MbArz95fqSwSWI60oeUZC6Fr6+X/MtrCLJ6QtiimFPkge24niY+mmZCzrQv8++F7cEaQSbjU8R5f5zi0D/Iwbd3W/Yx8aoqCGvwpeBCIErJg6ZFHTHUT93AxtXcPG8NEs0QHaeyIVM7520x3CuPyHCiW4rUJDJGasY0MqSATxl7hLuMIaKUgFQq0SoXxpK4LYEi4DENOWakkqBkhXIYRScXPFpqlFDcx8hvXl1Vag8CH6hNPZUZSuYryyX/+v6aIAstteE8kVipBph47h0hFszHBGf8R1WLh8OBt99+m1deeYU//af/NMYY/vk//+c/+Pc/+IM/4P333+eb3/zmD/3aHqpavwi8hzkK7ibHFCuCrjviCuec8SHy0HRcmo6l0jTAg9aSVKqGRbl2XkdX35xPDzOOyK54rqPjLgemFAlScWEavtAu+Fy3wBjNLlQTolgqa1UpwTZ7OmUYI1zNjufTxGb2lLmgomAzz9yPIzfjyI13lZGeEzJKTJHMzrMdBh7pjhNlaNBYqoFHJxW75Hn/boeShV5L1kpzJjSGwvfu91wdZqaQsEpy1v8vLNSfkXiR+QdQSiFnQUr1ijqUxD4FUikIcTSpInMXEi5EHoqWR7blrDGsjOak1QQKRUMREGJhyplV0bxzqGK2jY9czZ5NTOzmgJeZs0bzZr/gtW6JMZrreWagdsO0UDRaEkXCZIHzVVx041y9agyZnAofhgNPxgNP55HbWAfEppwQUaCLxM2Rw27mNdnxyHQYJZBFYoRCCbjzE+/cbbDAQinWWnOuDSs0Hw57no2eMVcu+qqxn8jz/HGMF5mDjZE0WmKERGZJlokrHzjEikdtjMZKzW2YuZ8nzlvDg7blTDesleLhqmUTIjsfqs4oJmJOnOiWZ4Mj5MzdHPhgP7PxgZthxpNZWcsbyyWfW61Yt5Z9TmBq3nXG0DSWrCsBKGfBXfDcRVeN6YLEIvkoTDybR67czCYFWmlJGWQU6JI4zAPXuwOvqp7HytArgaCOZDZacednvnt3g5SZtZKcaslaS9Zo/uBw4P1xZAjV6fqkbT/JR/pjFS8y/9ZKcyIMXTbopMlKchs9hxJIUqCVxWrNbXDskueBbXncdFwYy4lRPO4tuxDZh8CcEi5H5hx4IBvedzO+SG595N154ip7ns+OXcksrOb1fskb/Yq2EVynGSEzUgisVthWUQyslUGkzF2YuQ4ThxBogkAneDfuuC6OuxjY+lR5QlliikEJwW6auLrb8UhZHitLf/TvUVlghebGR965vqOUSG8Ea2041Q1rDO8cDnw4DhxCxErNRbv4JB/pj1W86D1Y5kybJCZKks/kErh1EwfnkEmywNJIzZ7AITrOrOFR23FmWqzQnLYNKUOIkXgcxQmlcCoNt64W5vc+8v44c5U9z6aJ2xBorebV5ZLXV2uM0QxRICX0RrLUhk7qiklOkhAy18PI83FkPwdMABJ8EAdu0sw2hNrp/76222sEiv3sub3f8xjLhbacYY7ro2AhFdvZ8QfXV1gKK6VYK8NKGZYYvrvd8sE8sE8eawQPFx+vDvyhOvx/82/+TX7u536Ot956iydPnvC3//bfRinFL/zCL3BycsJf+St/hV/8xV/k/Pyc9XrNX//rf51vfvOb/2GEFAueOgu9GSbG4HEAe3i6G9g4B1LSVb4gBkWnYF8CTw4za2tYYepVZFtFErsQmaXkT55f0tpMjIVi4KJrufYzS2sRWhIFaCX44qnFe0OwBp8KOVeh4oVq4ehkOadMLkdGe1CslaaTEi8lSguEKWyyw5vEMhy4c5JS2yE0Gl7pG+J25pAFUhpOG4NVEuczMkLKBSdq10spzW0MnDQNYoQuSS77z85m92nmH0AoEUQiZ8FmnBkjbKnv2qvRM1JYqgZjM1ufMUqgk+UQq2Bn3TScWotSFfnqUmaYArOK/CfnJ1gt8XEiacGjZcf3hg0r2yK0gqNJ1xfX56QruPN10xNFkrKmyRFjq0AXKSmiFlrG1zd17grkeqIXFCKBW1m4CCO7KMm5VOG3kDxcKdxWsKPQSMWFbbBK4n2klIIQkBC4LJBK86FzdFYSnaTNkkvzH36V++MWn2YOBlV50FNKfDCMLIPm2jkskrvZM6fCUluS9Gx9QabKLh9IfOQcZ0lzphqsSSwU7GPi2RjYqB0/eXaB0YISJoxJXLQtv3M/sjS23hjlQqMlX3x8RrqGq3lGFYmSlVW+lhqJYOMDRdbbTysUnkSTBBuVkKryphEw5MBAYDlZ7sdUR3oKXPSK3jY82Y7EXMcpHpi6oeIzMkliTsyl0oAao9lPjkvVcKeh1ZKH/cv8exH5J1RBlsIUPe/uNixnw9PksMAwJ2KIdBmMVRyyQ+b63OYceX5wNNpwqXSdixaKXYjcuMjAgZ+4OKn6C1cHAh+3Lb+53bBUGpQCBZ2RXCzO8cDdPJKjoFESrSQnoiEL2DlHoRbqfal6jqYT7IjMJJZSoVRCygpDOAma2ykTYkIUuOgbemt4cpiIKqOBB6pSz3be8X32STmOUva24Zn3LJoeL2YaoV6ufy9wDx5zxpUC2fPRvOUutDwbJ046yeAy0xHFWqTgEAJf7lfIlNmFwLUfWSrNIkl0Y7C9Yh8SN1PgoHd84+SCpa4971YrLhcdH25HrKxd+WroqvjSeoVwgVsDIguk0EghuWwiG+/ZTLUmUIDIBTclOqvAQpbA0ZzQicKHeUAnzc0OUoxoCo8WDdbCk0MkpoQWgnPdVqdgHwnHaZ109MRotGGfIpe6ZSMCjVSsm49XB/5QBf+HH37IL/zCL3B7e8uDBw/46Z/+aX7t136NBw8eAPB3/+7fRUrJz//8z+Oc4y/8hb/A3/t7f++H+RE/iE2OKKmqAELWovxbuztuR8ccKhVH5UwjNUPINEsBSeFCBgWmVBX9Uiiyqq65fU4skJxajRKJhZIcFEzJY5AoJOfLvhbU1AL/S+eS7+52XDaa3ey5mysS1GhNzAGTq0OkFIUYMyXBm6sl4xyr9XcsLLRhDoUxJU5EdUl1pfDYtrgpsUsOUarhSEiRc2l5Mk0YqaFkQi7sQmBhqisrQtBpxdoYVvazQ6j4NPMPYCsLSUlySjyfD3yxXXE/eHaz4+CrpiMbxUXWpBToO3AK8AIdJSkWrFf0RpGUxsvM8mjX/VrXQcnstcMlj8sTndR0SvLKyZLTtoFSnZc/f96zv5k4MQ1zyOxiwAAdmqBSdYamLkYzdXbxDdORBRxSYhc9qmi0qsK2hbDEXAu3y07jUmaXM0lkkAVPYonmbg6YosiiCs9drk6YrTaAwEVFqxVL89m50v40c/DOeXKBVBIf7Q58brVk6z1TyAzBkzL0ynDRajKBVasYU3VeXmWJitXYTWaFVoKFqqY0XTI86FqSTNz5Oja0CdPRoE3z8HTJadsijiZtr/UdN85x0hrmmNhOgZATraoW7ySBFBKOh4GlbXlj0ZCc4DBF7qOHRtBahUsRlQU+V3/6zvR4H/kwTNX5+ThetrKa94cttrph1GvukmlVdb8E6GJkJTQn8rNDSfk08+8mO5KoZnzvuB2fNz03h5kQMi7WRlejBA+perjFqtLxRCxcGkMIhZAUaI0xkpWWtDnRY3jTrskicZgDc6yjt0KBRPLoZMlF19YTXsp8OZ7wW8Gxai0hZ3bBM6ZMby3VEeDoii7rIPSJanmzFcgIhzlydZgxRrG2Gh8TKeYq8JTQmY7JBz6cxwopEII5F9ZK8jxF2qSIojqt+5xolWShqnNmEJK1Vpw1n52x2k97D45G0UlJoXA9e15rG3zKfLQPzCGRczXC6qnwCL0WDKXgjmON0gumqCgSpEx0phb3jVCc2wYpEvo4On7vJzTQ2oaH6wVnTYugQEo8OF1y2Eb63jLFxM55fIx0jWUzu2pKJyRCSrKqhKsvm4YsIkOMDNEhjUQ7TZJVKxoleAHGVEjNB9NQ9X9aEURhqQ3PppEuV3PORMGRkch6MKaOva2U4fJjkqJEKT9aqs/dbsfJyQn/9X/xJaIWGKE41w290XzoDmSfuXWOOVfxmi5gpeJi2TClwt5HfMr0UrGbPRetRsmCQtILS6ck92Tu40xMGSsk68ZCqUZef+LynNO2ZUqR9zc7rFT87v2GV9oGieAQI7fBU5RkbTW3syfkjCrVInxpLKtWM7nA9uiU9tqy5XOLE3RJPBkmXM70WnEiFLvo+PZ+YCUtnVYoI+iVYTN6PnQjnkIrFJfG8pXTFQjB++PIibY8aBo6CX/7//I/sd1uWa/Xf9SP749FfD8H//LPfQ1UPQiuVEOvFR/NewiZbaiCayMlMhWkUDxeWuaU2YdIiJlOaVwonDZVcmi05KK1WDQfTHs2yeNjppGSy0VTDwha8xMPLjhtGlyIfLA7YAT8+s0dbywWSES11PYBJSV9b9nOrorejovCspEsUAwxcx89QWY+t1jw+dUKAXwwjMRSsYtdAVcK/2bY04tqS66kYikMV+PI0zgTRaaXmge64cvrJUJI3h/3rHXDw7all4L/w//5f3yZg59QfD///vd/6ctkKtJ1oTWN1myOzYF7H5hSRguJQdBbRW8kQ8zMIaMyLLVlH0NtCoiCkYKzxtAUw5Mwcx8CMSSsEJy1liwEndB89eEZ67ZhTpEPthts1vz2/S2vLBaIXAVvmxDIFDqrGX0k54IUggJ0StJZmH1m4wKuZF5d93zj/JyS4IP9gVgyK2tYCEkk8nu7PV1RtEpjjaTXhieHA8+dI1LoleKhbfna6SlFCD48DCy15qJr6ZTmb/+fXubfJxU/2IN/7uvkoz6na+rN9TM30WTJNlSX01r6SlorObUNU05MMaKiYFk0+5w4aVQ1MdKS887SIvlwctxmTwiRpgjOOkNCsJCGn3h4zmnbMIfEe/c7NJrf3l7zWtdDKdx7x81Uxy5OmobbYSal2sVPCpZaY7XgMEe2zhPIfG694hunZ6QC7x62hJJZ24ZVroSTd/Z7rKo6JS0kK91wdRh5klxtFkrFpbZ85eTkD9c/0/Cw7VgIwX/7D/+Hl/n3Ccb3c/C/+fmfJFPBO0urWZqOD+cNKgm2PjDljJICSKyUZdEahnDMwVxYS80hJHqjyLIgleCkaVmjuM2RqzCQQqYVilXbEEvVXn79/JyTtq23q9t7TBb8/mHPg6ZBFioh7ThlsuobdpMnHW+NHBmrq0fKnCLbGHAi8+aq58urc0iZD+eBJOBEW/oCc068O0y0QqKVQCjBUnfcTHuufLVo7YXkgWn53OkJRgjeH3c00nDZ9iyl4b/9P/53/39z8EcWoG2VxBpBKTCniC+1e75QCm8MMiekqGMHZ0ofFdjUOT8E1bsdvMhoUROmiIIXibEkdjFiESyOTqpKV+dA7wJOSIYUeX9/4Lxt8SGxkR4jFLHUu+UcM8vOsDOJ6GsnNheByxl8oORS7edTYkiRN/qOMQSeupkQMwGJkIKhRJSQGCXRUpKLYEyp2t2HhKfQNIpla3jYd+QCuxhZGsuyMajy2cFyftrRSInSdVZfIhlDJidYSUVQGVEqgmv0kcvGMuZKfKp2HjV3k8jV6p06XhPJSDLbFLnzASskC6mQKFotsFIQfcKLyN57vrfbc9lYfMwMIaCPYl4B5FRYK8ukqzV4zcHqQJhyJuUqigulWnW/0vUMMYAqhFyFRlIohlD5/51UWBQpCyYSU6z23pFC32hO2oZXl0tiztxHx5mxnLe2doJfxicerZYooapxIDDmSMmZpVLMUpKO8IA5Jh5Iy84H/PFZSCGwSlT9kqhrWymCmDNCVi3KNgTMcYMDWCpNKxTRB5yU7KPnvd2eU9MTU2HwAYWoniMIfEysFk1d90IgHcd0djHhEuRcjljOSqJ4vevZBI9wEFLBy8JCCg4hYaWkR6OFJKfCRHXdnWMiiYpmXLWGx8uelAu74FkYzbozqPLZ6bB+mtFqhZYVDCCzIKTa2FooVVGGRaAQHELmoWo4xIAvlVqTM2irECmRjiWbKAVfCobCLnru44xF0EmDLNVwrVWa4CKzUOxD4J3dnvO2ZQ6Jg/RVSJwyEiglc2KrudaYUqWGlULOVUviYvVyyAJK/v+w92exum7pXS/2G+3bfd1sV7/3rtpV5XKVXTa4ThkTwpGiSCS54AISWUIJhAsHCTtSsBQD0QkFufEd4gYJCcniCoGsiAtCxMXxITiAg42NG8qubrernf3Xvs1oc/HOKo5P2VBVXqv2rqrvJ01trbnW2uv7vvc/x3jGM57n/wjuNg3XbkAYQUjgBSQl2Nw6ozXKIBntFYcw9h24lMYmYAXz0vCgaUjAMvTMjGFRaPR+/XtlSDXGZzKNE7p9juScKYWmVQHHaJ8+pHE42rXzuJRHf/sMWgjQ40EwM36/i4FCCNoUWYeIzlAKATmzUBYFDIOnE5JtDLy72XBgDEOMbL3HIEiAVpKQE3Nb4FyijWm0cc2JzmeySJDHZt5IJgZ4WFXc+B4ZRh37nIhCs8mOQiomcqwYGVKkC2709mcs7RZaMC00D5qalPP48yMkEyP4ZrvoPrQB/8p7aq3JCdaDxxhFigkrx6EyRoxNiM4LSqHoRKYykkkSZBJBRNCaJBIZQZ8jS+/QUnI8b8YFI0Q0jFZzEkSWrLqxJnCbI9fBEQYIZC6dJyWHyGNgpACSRCARCFLOpJzYuYHjbCilphCKNgUu+gEjxprs04kldYnBJSpj0E5yWpZIJYhZ4MMYzLkUEWEMEnUhsHYciqQiHBYF2+i5CdB8HzukvGpcHGvxUk6sXA9JjH0fUmClBCFBCFoZqJXAKUllJIWCXXBIYKIUmUyUsEuBzXYcx72oCpQUiDxOKXUhYZRGpMymHS0UV3HgRd8TiKQ83mxxm0U1QiCSQPsxyzsIgYuBNkU2IdEIydwYaiFxMXE+eIQY7W1PKsuVc4ScWBQTVrHjji5uHRHGQ8IgxsOLDHm0AzNjGZtQGqMch7ZgiJGVd0zk909Z2XeSNkWmtzZ0l0MHZsxjVFliGPuXcobha/kNqWiUQGeQPtNISa9Hi1eypA+Rm6GnLAyL0iCEJKVx5HuXA0VSRCVYd8MYVEfPZesZyhaRBZvB31aZZYwYywtNFBgEXYLBR1KOrGNkGjWNVFgEIWWWrUPkxNQq7k5Lnnc9vQ/M6pqV67lTFMQALoye58Wt1atinAYts8BoRRICrQSzsmAVepSDA/H92zT+KulyZCYUKWaWfiDJTEgZrxMIgVGjDvsAE2UICbRSiJSBcShgUJLRgHW0IL7aOg6k5bAqkD7fDu+ThDj2zaUMq9aN+kuec9cTZCCFxFXuSYx9LVaNbj3cOknFlOhCpBNjU+ZEaCZKUQlFFxPL1o+DPK3mtCk573uGGGmqmmvXc1IUxCxHe9EUiQQCEcnoqS4Q43uTAiszi8LeZnkzC/P9U1L2nWaVPIfSkFPm0vfIrBiGRGkSQoBVY5OrZ3zWViUKIzEZZMzUWTJISOq25DUGzvuetS45nFacpIp4qyEfI4hRq9e7lpACbU5cDT09AREFm+SQYkyoFGbspVMhI+OYgHNptC4eUqaXgpkxWCHISbDpAion5lZzP1Wc9QO7EDmsK2TsOdIGhMDnhMgCF4cxQfO1FKIQKC3H/wrB3JZc9ztuXOLQvIIa/u8k76w3zF2BRrIZPAg4mdZ0PnBkLI0UhJzZhUirEn/iU/dppGSzGXh+taPtHQfKcBN7jFD0OfHMD9yvGg6zZaIlN2GgixGpIUTFOnp6l+hiIqkx89C7QEtgYS0yifGWQRtCSKMDSxCIrNBG0RjYDIHGKnQavy+EJfjxxFjXkmnUXOTMamh530OBoiwMXQjsUmBHori1WbpXVKBhUlqm0oISkKHQive7Frzjjvn+del51by12XFw2xS06kZ/8UVpufSSSTEGV1sPDolz8GMfu0OhJat1z4u8JaaMAlbZk8VYP/+idZxUFT9gCiZp9OntfaQVjtIKrl1gJ2HqNUFkajRtFxBaIqxEJYlMAi0lJgu2OeDcOLHPWM0cgYtQxDGra0SmFgITJcMwsKhrjk3Feog873p0VjRZYyz0OdPFyC4HpMtoMse6RErBwpRMpEFIAVFyYAp+t1txEzz37V6Dr4Kv7nYcVQkVBRddBx0clwUuO2bWMLeGHYFd51kj+fFPPaCyms124Ox8HCZ0SslWOnKS7EJkOSROjeBIVhRyYJPd7eAZSEVmhWfrPbPoAUGJZXObTddKQgTiaKSZdcaFQBduy3sKTSU1xnl0VlRKoXIkC6jRrNodR9MZp7pilT3vdz1P/I4KhVKKtQwM0tOGhHCZUmvu65qc83ijKe1YIxsjjRY82Tk2LuD38f4r4UvrNcdVg0aMB07gRFsug6MuDZU2+BBJXaCUgv/ZRx8hJSxXHc9fbFBCcqwYXX3IbH1i1TmqRvLRckKlJevB0w2BNkaiUuxiYpkGpsGAgAbJpg80hUYpSQyJSEJricyKjQ/sfCDmRGkkM6256TwxxtuZ9GNwJHyibVuOpzXZlGw7xztti+kFMyQUknUI+BTxaiyPLKXiRI4Jn7kpmBQVQhek6Jhoy5NtyyYE4vePb8Z3nPe3a2JRoxE8DR0EOBEF1z4xsZZGCfrgxzVJwX/70QdopViue56erfEucCw1nQwEIfFR0qXAgYITaam1oBWje48MGXMbF4bk6IloJTnUJdvosEKjlMDk0SZYJA050yVPFx0xJypluFMrzreOLnpczEgpKaSkUJKrdsvpbM5CCc5z4GLYQhKcYNFmdMFqcyIxJnsXhaLwEq9gaiyNLEEJYhhL2pfOsx4C2X5zofyHNuC/awt8AhfiOFULQRFh5SLvDTuUkhRKM9caT+DRnWMOJg3vvLjk1568IPWgKsX5MGbmsxBoLfEp8KvnZyx0NXrt50hKmQ7NDR0ZxT2lOZIFR9oypICSkmNheLBoKAvDl9drLtY9lzc9P3SyYF5YtBRMNPzH8xU6SpKUZA02SrTIfGm5or1yo1d1SPRB8JSBgcSDCI3QHKEpcuJF3HETHHcKy92mZhsjv3J2wW9fX7NyPTJJrDJoqXgSuw/6UX3PcoQhDZkhcXuPI4hudBzZRE+pFaWwTJBsVeLNR3c5mla8++ySt19cYzG0wFnbj6lYOWYnffb8/56dcaTr8Qo8J6YYNjHzJPYMsuW+mHBHlxxKy7LtsRqOtOLhtKEyli8u17zX7xj6yOfuHnNUFmgpqLXiV88uUE6DzIQUUCQKmXi8aflSu2UXxoOp83AVBs5RHJSCudY0UnON5j1WDCSa0vJwMiXlzO/cXPFb5y+4wGPCOERMCsmXv38G7X5Hea2o4Pb2ZyY0QggW1nLeDqx6h/aSEs3EGAYl+dij+xxNG947u+KdyxvwmgE4awdyGEvNjIGQM//hxQX36xqVBTaOz7GWgi9sN+yInKYJJ6bi2GrakFh3gaawvDabMCksX16vuVwHHvsdf2xxzOGts9OBNfz7qzPW64DWhhgFMka0kbzTdnx1M9An2AWPDIIbH/A6cxgTjRlvRlfC8U6/wZPxMfGJyYJCSL58s+R3ri7ZMrr8VFKRgS/4mw/6UX1Pck+WZD+WytR5XAFrq1n1nrO2QwlopOGgUjx3Pf/L1+5xOK1579kFjy+uyVLRJrgYAqREEglZjkO4funJEx7UU+RtuW1jFG1KfHXYsCZyL024pxtO7ITzoSO6zEGleHC4oCwKvrxd8my15d3tlp84OuakKNBK0hSGf/f0BettpCw0m+TZ+UBSmS91W97abNkk2LmIGRTr4Li0cBIVh1XBgVZcuchbuyWkhJOZH5jP0Qn+0/kFv37+nODGc2/SEHLiP/rrD/hJfe/yyDQIIQghsYgageB0Ud+68PSknJlIzdxInrqB//m9uxxOGt59fsnvPrtgIjUbIpeb0UknynFwXM6Zf/v8GSeyRFkBRmCMARLP+y07mbkj4TgUWAe4jJOBO3XFw3lDURi+uF6z3nouupYfOzrisLAoIaik4t/FM2w3lom1IrJOAZMT77jAO5dXeB/oQmISNXnIvK12HJaWI1twmBU3PvKOu8F7iDLx0dmUHBK/en7G/3f5GBElARByvBX73fX6m/o8P7QBvxGGQoFQ4rZGK9KTb8soxjKbmDwKaD28+/ycm6rk6fWGrQsMPrKwhkKMXfYAtZToCAfa0uixNjZljZSKle8RchyV7V3kJvT47JBRUBpx2zDn2G53PG47pBQcFJrztmPtPFZLQojsXGQmx5HQX4uDQkz89s2SUiqUloRbi7nAOHbcSNjFQEqKdFuP6ogUUrNyfvQ7VzDEzIySqAVJZhDpdgLlnleBNQZtFfa2POuya0crS6lwItHnRMgeJwOtDzy/usbtSs6u1lwMPTn1FKWi0JoUx9KYWo7TbQ+rhlIpygQpjD0gN65FAYfCUgfw0dESqbSmVwkhJCsXuPCe575HkpkXmiebLevB01hNjIHdLqJ8YlCRIEYfi11M/PbNmrJUoxNKzARgFwamtkBFSRsgZkHOGY1mFR2VTJztWgKJXXS0OXAQNFmMnulSgmFfw/oqUEkiw9jEf2dWcOk6PHGcw5ASQ0wE4bFasfUDT88v2W63PLnacL5zpDhQlpImG4YUkVJwVNakFDgwxVh6IQRWa7SRbPCoJDlVmsMkUCGwFpGqssSUmRrL4CMbv2UbPJWR1Krmqu/YBkehBc93Gb+L7Pxoi4iELGEXPb992TMpSiZK4VOij4msIgtjEHK8LUhRkrLCZs3KdZRCcdn3SC1opaf1gSaOB1OpFFmATfs+plfBxFiCGMcSzZKiVZFdigTGunhPxiXHTFlu+oEnFxd064onl0ueuIFSgNaKWdZ0KZKk4oFS5Jg5MhKRBYUyaKEgJ1rpKZMam7GFRpNYiYHDqmDne2ZlQUyJq92OwQcapTBG8rRvufGBQinSOrDrPdfBYYUkqYzU0OXEr19fcSxLahQhZfocwRhKC96MMYVIApnGXqZz11MpzXk3kCWsZKDtAwdYDHmc2so4iG7Pq6FMAhTYwjCtal60LWeuG10USWOVR/JU0rLrHO8/OWNdlzxdrjl3jks82mQqYxh8hJS5o2tUStxrGjICLRVGKGTMXNAjouJEKA5RKDIdkZk09DYxqwr6mLjebPFuoDCGO1py0XesgsdICT7iXGQTHV5HohQkndmR+O31NRMscyEhQ58yOzyV1DgRcEmjkGPJjtJ8tdvSYFhuh9GlRybaARZRUlsFSRAZh3J+M3xoA/6p0aSccbcj2IUQOO8QQmOlQAhQGYSWbFzkvWdLJlZz0zn6kNiFQO4zEo1PiZgTMkElJbVR3JmUtC6yGyJKKgYSOQsgsQk9vRAslGaXEimMdYvtkLiKniFnXi8qjBWshoAPERUTu96TRUbcTiOMMdKHyC6M9YOF1Kg8DjYSRLxITAvNvLTEMJZiDCmziJqbQdLGgMhjCqRR4/SmzicCYyMRsF9qXiENGpHGH0yhQEdYRz8eBG57JwoJtS5YD56nL5YsteZ829LFROsCFkWFxaVAzJEij0Gy0oL7k5LORzZ9REXBed+SgfJ2anSbMlYq/K1V5uAVfRrYEmlT4H5dYoyi956dd7QhsB48OSdm2iK0oEuRNgQGIjrx9cnMKULMiSQzTWGYFoboMs5nQhRMjebK9eQU6f34/mujsFrQu4RQYz2vhNtphnteNnWUOCDITCUFtbXcDD0ijbXThR7de5TUbPPAxeWOnR4437Vsb4dtNVJhksYzjoSPQ8aMPsIcTsdm8M6No8SXPiAFqKzYuAB4pJb4DB2RDGxCYBkGdsHzsJwQRebGj9PMd1HQDQ6VJY02txaviSEl2hwQCYqcIY6lbsjMFse9omBuCqLL9C4jfbhti4NCKLxPyCywSiGVxHk/7gkhjyVm+wPnK2GqDbsc6Bhr9ks0V8OASKMttNYCLaGWBUPoePz0mqU2vNi1bLxjCxRJUSXLkCI+RQbEuAYqyb26JolxjzfZcD10qNvywzZ5OhlISiBUQCiBlIKNC1z1A5vkODEF2cLGB7bRs/Ge1dAjPDRyHMzpiLjsWSWHygIHNAJkHhspN8Ix1SUHVY0ICR8j6TaYlEIgM7SDH28PlKawir4djUAyY4Z130b36phYg1ORkBO7HIhAN0RqLSmFRhlBpdRY854TZxdrdkXLZdfRR49PGYOgDJnIaCDgQqRWEiUl96cVMYMPoJPiwnWjM1UULDtPFm5ciVQmK0kg03vHjetpY+BROWWQka3zdN7TAqvBQRpd+kppcDIzENgFT5EFUY+3/YJMFplWJBopObIVJWq04EyjDaxAYGSmDwEhBY3UFELSx0gOCXnbVyK/SQ1+aAN+HxPxNosggInRdC6QYqJQEiMlOSaMVPQCntxsKZXC54xAopWikBqZJYj89cYHGK/j+pToc2QQkUKAvf3ErBSEnPgfu5WmlOm8pyeP/r05Y8VoGSqJCMbAOwKdD+ykYWAUqQCUhJQEXY7IW2cDIcAoxVFTctzU9ENiNXh8cDQoDq3F50xO44S3r2XyIyAZ3QgQ4sP7AL8H6EMYm7LlmPWuhGItIcSI1RItx5btxli8T7x3tUEL6HwkZ4EQ44RGGQSR8Ssz1v+lNDqXOBJORAqpsHp8mlaPbio+JVSSJD3eAnQ54WNimz0pjTWrVml6Pzr0CDH2n8QUqJQhI5BCYOTYEC7zqF/LWAohbzV4WFlOmpp257lJjhg9lVDUapwlkG6b15QUqCwYRKIQ4+RhkcTYPLfnpdPHgL9duVxKt240gpgyWo/OXkYqaqOJKfHkZoNEsAsBKQVKSabS4kT6umWmj+N8EyU1MY++zl0OpDSW+hgpkeJ2/c2JMktciLgYWbvR4nAdHC5GZAVKSYQXt0kMScjitka2IImMZZxOrkgIIYg54fK4Fn9tKNxBVXJSTdl2Hp97oncUWmGCHM0VYiaJ8d9SUjCQiTmRQ0IogUj/pU9xz7fLznl6OQZJMPZtqAwhj02ztVZIAVYISil593KFFII2+jHhBZRCkUi3ezCkPO6xQx4DsC4GuhAoyOPNopLIPDYupiQwUjHE8dB43Q8MIbF0jj4GpC2xSrLzAXF7a/41R7IDYcZDohgDIqPGtSrmjL+dNyJvnVxOmop70ymb1nPdDfS+R5HRcuyXyn6cAaGkxErBKnsSY5XmrRngnlfELoyVEpGEl/k28TY2V9dajVUTY+iMEYLnqw1KCdoYbr8PjTCEPC4ScjTQQytF7xMhjntwn/KYjEhjIzC3josxp9GNB3ApsewHfIps/NjULUSmlJqOgAQSgiDA5cRMjhrUSVBLhb5NUqc8GhNIIRBSMNGa06bm3mSKD4nrYaBLgRgzlrEkPKfReEFKiRWStfCkLNA53b6n7/IM/41zo63XOHSPg6JgkxKbtkfZ0Su8jxmTBZWSXPUOJSSl1jTW0FjDQmmGECnTaGUYAZEzKQneW+8QmnE6qoSTssDHUTQ+SVyKdDlihRxLIrwnCCAnZBqbOyyjpaK+tX9yZebiskOk0VmlMoqZsTRCcN1FbqIjidF3XSJpZMHd2ZTjScXFZmAVPYP3qCy4Vxc8bT1RjIuUS+k2ozBaSPUkYh7f/55Xw7V3GKlGTYTIkTZM0KxaR60LrFAMISJzphaKZ9uOzOi60yjDRBvP543UAAEAAElEQVQeNSWr3bj4eMYShALwKfHeuiOrjJSgdeZE18SUsDoTYh5vdEKkEAoZoZdx3AhjRt9mPK0ar/9KBKVUbGzi2W7AEiBBqWCmFZMs2cTIjffMNBRinMo6UZbTuuRuXXMRB26GgTYNlNkwU4abwSPJtz83Y70tanRpGfJ43Z/TXoOvgqvoMEpTIGl9QGdJU1iWwWHleLOyi5HGagqteLzd4mKmUGoc3AbcsSVnuUczbmZeJspbO9azbU8UY5Zc6cSBsISYx+m4MpHj7YAsIPnMeehAQiKNB1abqaWmDhqZGa+zK3hvtaZRhpQzpZLMbxvKtiGxjo5WjC5TEphkxd16xtFkSqbjoh9os6exltI5gh+tIHOS+NvXEgGVM45RkzLtM/yvghd9iy7GEsB8+9kvtOXSh9vDl8LFiFCJSgmetC1DiGMvRzP6LJ3okuvYoRFIaRFKcmAkT7eO97bbcf0ArIrMy4KYIimDT6N1q0+jLeHWezadG6c3M1odqnLs47PCo8XooR/IvD1saLJGxUAhNTNTojVcd44uRXYio4VEIymT4iPzOUfNhAsZWYYVu92GktH9ReRRa0Tow1g6FmREJogCkIK8P3C+Ms66HlUqjFbY22B8ZjQXXU+dM+TMLgS0UiideTHscCmjhGKmC1BwYAsuYwu3a5TUkonR7NqeJ+sOdEZKQRCBE2sJMeGFwCcg3foUCOhd5MK1wG3iVUIsoEmGWvuxGkMqBpl5v/dMgRACSktmSiONYeU9gw/sGAeGGSm5Y0s+frDgoKq47jwX3rH2HhkFX/N/GvffRMgCxFjSHfNo/SlvDzzfDB+6gP9rmfUySWZo+pA47wfk0NKUkiBgGBzdIIlZsBoG7jUFQWl0FkyEZKYtOWe+utxQaslCW0By7joOreFeUfDlzZYTW/JwUlOisEbx7KZnGwY2zrPzHiNHd4kd48MNtx7AOcOf+uRrPDm/ZrFWXK87bvwAxTgZeBgCxkhEFGMphZa44IkkhBRoocgp07UDFsVm27PrPdvWsdp2GKOQfSbFcWHVSiKFpo+JIQS2PtMrT1L568HWh2x+2nc1X/ss6yCZlgoXE8tuIBGYLAo6kXAh3WbhI+/fOI6wFFKghWQuDQfNOCnyrZsVMiZmymKE5IXvAMVJaXi3cxw2lvt1RSMVlSq43Pasfc+NC6xcIMREHeToa60lIY5ZCWsNf/JTD3n2fMU0w2bn2LhIVUiKpBnC2PfhogAxzhPogifHhKpGi7mcMlvvmErLsO1p+4Ft51htBnodxlkSbjwqaynRt5OvyzTWYHuRiDJ9fcPba/Dl8LXPcaItlR17PjaDZ2oNJWOCIcZbq7acuFh3zKWiQqFFpkZxIgpyzry1XhI9LHSJEpJdCDSlJqbARTtwryl5UDejB7Q1vFg5bmLLzmfWgx9rv25zVwAiSYQYN6r/9tMf5fzxklnWXGx7lt0AhcCG0b/aCkEvEz5EtFTsUsTFQFMWaK2IMeF8wmbBdrtj5wZ23rMdPIUUiJDZDWN+2QRJ4TVSCuqkyLdNoFmC2q+BL5WvfY4Lo0BLOp/YusAhUJZmPGwNnuwiPmaylUzQ2OQppWJuLMe2IefMV1ZLnI+c6opKK5ZpYB0NPniuh8i9ec3DacMMxcTWnG3XbF3gfBi4dI6QIlYJPONNj85jT18hJH/qk29w/XzHPI0B4LL3GCUogqAnUGtJ8IFtiCht2PixtDYHbjP40DSS6nb92w6BXd/S9T05Q3CRICM+KpSXKDfGAUUa51vI20Oryr//c9vzR+fra6AVeJnoXcRFwamyyEqis6AdIlGNCQuLpkQRQkQhqZRmJswYB66uyVFwR9dMtGHTe7rO4ZNn3UbuTxvuVxWNgmlRc7bcsXKB7eBZRTeWd0lBSoLAaAeqpaQWhj/1g5/g4v1LFlvBeddx3nUkLSgc9CawMJKYIrs+YbPGpXFmjoyQlCQKwVIIiqzoup6+d7Rtz243kGVmCAmXIKeEjlAlSVGOPSY4QIyzCr5WAfJf0+CHbtLukydPePTo0Qf9Mr7rePz4MQ8fPvygX8b3BG+//TZvvvnmB/0yvuvYa/DlsF8Dvz32+ns57PX37bHX38tjvwd/e/zXNPihC/hTSnzpS1/iU5/6FI8fP/6eH1W9Xq959OjRt/1ec85sNhvu37+PlPtqwpfBcrnk4OCA999/n/l8/kG/nFfOXoMfLvZr4LfGXn8vl73+vjX2+nv57Pfgb41vVoMfupIeKSUPHjwAYDabfc8vNl/jj/Jevx9+IL6TfO0HZj6ff9/oD/Ya/LCwXwO/dfb6e3ns9fets9ffy2W/B3/rfDMa3B9H9+zZs2fPnj179uz5HmYf8O/Zs2fPnj179uzZ8z3MhzLgL4qCz3/+8xRF8UG/lFfO99N7/W7h++2ZfL+93+8Gvp+eyffTe/1u4fvpmXw/vdfvFr7fnsl36v1+6Jp29+zZs2fPnj179uzZ8/L4UGb49+zZs2fPnj179uzZ83LYB/x79uzZs2fPnj179nwPsw/49+zZs2fPnj179uz5HmYf8O/Zs2fPnj179uzZ8z3Mhy7g//t//+/zxhtvUJYlP/7jP86v/uqvftAv6aXwt//230YI8fu+PvnJT3799/u+56d/+qc5OjpiMpnw5//8n+fs7OwDfMXfv3wvanCvv+8e9vrb6++D5HtRf7DX4HcT34sa/DDo75UF/N/OA/un//Sf8rM/+7N8/vOf5zd+4zf4kR/5Ef7Mn/kznJ+fv6qX+R3l05/+NM+fP//617/5N//m67/31/7aX+Of//N/zi/+4i/yr//1v+bZs2f8uT/35z7AV/vdzbe7YHwva3Cvv+8ce/19I3v9fWfZ78HfyF6D3zn2a+A38oHrL78C/sk/+SfZWpt/4Rd+IX/hC1/IP/VTP5UXi0U+Ozv7L/69z33uc/mnf/qnv/7rGGO+f/9+/vmf//lX8TK/o3z+85/PP/IjP/IH/t5yuczGmPyLv/iLX//e7/3e72Ug/8qv/Mp36BV+7/Dt6i/n710N7vX3nWOvv29kr7/vLPs9+BvZa/A7x34N/EY+DPrTL/f4MPJ3/+7f5ad+6qf4y3/5LwPwD/7BP+Bf/It/wS/8wi/wN/7G3/gD/45zjl//9V/nr//1v86TJ0+YTqcIIfjTf/pP88u//Mv81b/6V1/FS/2OMQwDX/7yl7l79y5lWfK5z32Oz3/+8zx69Ihf/uVfxnvP5z73OdbrNQD379/n4cOH/Kt/9a/41Kc+9Yf+f3PObDYb7t+/j5QfugqtD4RvR3/wva3BV6U/2Gvwf8pef9/IXn/fWfZ78Dey34O/c+zXwG/kQ7EGvrSjwy3DMGSlVP5n/+yf/b7v/8W/+Bfzn/2zf/Yb/nzf93m1WuUvfvGLGcj/+B//4wzsv77Fr8ePH7/sR/ldybeqv5z3Gtxr8OWx199efx80+z14r78Pkv0a+OHV4EvP8F9eXhJj5M6dO7/v+3fu3OGLX/ziN/z5n//5n+fv/J2/8/Vf/4W/8BcA+D//lT/L4XxOoQ0pZ7Yh4OLA9W6D1QarLCqCVJKitGgFtS0ZBsfT83M2fcvvXT3hjjIclAW1VkjpGbJg3ihWO8/UWkqjWIfEiRAMPvL2akOXMyeThs89OEEqSWU0MWWWnWfZD+QQWJSGnfM82ewIKaGQbEICkXjzZMb5rkcgKIxmMzhu2p57ZYFKGYnAJXjPtXx2seC1ec0yeLYhQhTMjOE8eoTSHBWGidEURnOymDFfaILzbHcB78GFyP/x//H/YjqdvuxH+V3Jt6o/+MM1+H/9a/87lICyrDk6OqVazJk1hwhpuLp5wXJ1Sd93tMOOjz76OL7fEoeelDw+ZoYYmBzfob86w0qJ2y55563foBOZEsGNc5xMpxxNZngKDirB9cUV7y03tClxPG343GsPMAbKosL5wLLtWe96RI5MbEE3dLy9XBJyppAKlzK9yPzA8YJ3dhtEEky1ZescF5ue15oaKzKFELiU+U/tms/ND/no4Yzl0LOLEaU0p3XFV7Zrtgju2ZIDa6is4c7BnNlRQfCezcYTfGbwif/D5//few3ycvX33/13f4XXTo9pyoIowKFASawugUSMAe8DSmnc0OLaHW23ZLfbMuwiScLi7jFxfYUlkVzH9eUz1t7jhGAbA6d1zWFR4ZOmzj1D53nc7ogKjmYNnz4+xlhFbUtcjKy6ge3gUD5Raknf9by1WuFToNAKIRVeCt6cTXh7twU1rmedczzetDwqKyqpKRCkHHnH93zCTPjItOYmeNocUVpzWFa8065xQnOvapgbhRWCw/mcaiGJMdHtEiFknE/8xc//s73+bnlZe/BP/Z/+VxwdHKOFoe9anl9f4qPnfNuiBRgj0UbQNCV1YWnqBaWxJB/YXm/wMfA7773FZ1475WQ+ZVIaKpW5dB0hOTofWJgSmwUX6x0fO5jjgPeXK1xOHExqPnnnDsYWWGvwIbIbBtreEd1ALSwhDzzf3hBDwioLWuJS5N5kwvubG4SCpijpdoGbruOoLDEZdB4jpGvlea2a8mA2YRUcXUwYITmoKp50K/qkOa0qprbAKs3BYkE5EQTnGYZEjJmuH/jf/l/+8V5/t7zMNfD//n/733NycEBVVBhr6VNEa0PCIvDkNNAPPUPfkVJmMpkicyT2A0Pr6ELHuxfPqSQ0paGQidxvGEJkSJneRealpSwKOp85MopuGLjoOiIwrwreOJgjlERbRUqZbgj0LpJ9QqlMDJGroSOlhBKSmCSJxJ1pxdI7pJCUUjPESIwJhcaIjCITyawInAjL6aRgEwIuJ6RWzLXhOvR4YG4rSqXQSjArJ1RTQwqBvg/EmBh84C99/l/8VzX4gd8//c2/+TdZrVZcXFwgpeQf/sN/CIBNgXuTio+eLHjtZEFdGWaVYT6ZcHp0xMM7J7x294R7h8fMy4ZCG0IYWG6WvH9+xtXVEh8yq5zZCMmgFVkJkk68tmh4sGiYVwVRKq5T5LAqKUrFtDIc1QUHtUVpgcuR2bThaDHlweGc1w4WzKc1TVFwMp9QFgVlYZk0hqIwtAgedz3nfkAXitcOJhxPC5ySGGtASdqUWKeI1YppockSVt5x2XbcbDv61nG16fjNs0u+cHbN09WWIXgInlkjmU8kpQkUcqDSAQAhxAf5GL+r+cM02ACfvHPMJ08XzOXA5voZq8unrLdLJpM5904fcDQ/4NHp60wmDffvPuDB/fssDg8RlUFIhYs77rz+Md745B/j9NGbIARZZT5+MucjhzPuHR5yfPch9z/+aT7y6DV0IakrzaIe9a6tpMueaVNxcjDnjZMjPnbnmKPZBGUFxwdTyqKitAVNXVAWGpTkfLjVYKn5yOGM42lBUgJjJFkKNimxzJ5paZiUhqThxjuu+45u6BDec7Xe8R+ePOe3nr7g8fUNve8gDExrxWJiaEygVAOV2Wvwj8Ifpr/UrdH9BjNs0W6HzAOVgBQjITi2uyXPz9/n6uo5vm9RUjGpKuqqZMiJfvBkmTl9+JBHb36c43v3SRKCjLx22HBvXnM8nzI/PKY6ucuDw2OayrKoLJNCUxlFWVoCgtmk5nQx49HxEa8dHXEwrakKy8ligrIaZTR1VVDXBlUoliFw5h1RCk6nNYdNiRcCrTRCCnY5cpMii7KkLBRJJzbRsRwGuqFHRs+y7fjtiyu+dHnN2WaHTxGRAtNKMW80dREpTaAyCdjr79vlD9Pfw6MjPvvJN/nTP/ZD/MQf+zSf/Nh9PvbghIPZhLquqauKad1wd7LgzuwQIwxKSvq+46vvv8f55TlKjXuvLwtEVaI1aJV4eDDjeNJQWk2fE8/7Hk2iMJppVTCrCialpbxdmxbzGXeOD3nt5JTXjo9ZTGdUTcnRYoEtLLYsmDYVi7qmLgo2fmAVAsoa7s2nHMxqhNYUVqMLTS8zWyIn8yl1WYAS7JJn6zucH9Ah0XY9X7o6593rS653G2IKyOSZ1Ir5xNAUmcoE6jICe/39UfjDNFgqQaOgzA4xbNluLom+BRxaaxCKzvW0u5YUHVKAlAKhBcJIosoICbqqyEaSZMJYjdCSO7OGo1nNdNpQz6bUp4fMpzWl1VSloSk0dWGwpSapzKxuOJhOOZ3PuDOfMJ1U1GXBfDrBWIspLM2tdmtrGFJmEKALzWJSMistttSUhUYVCq/Bycy8LigrjdKSQGRInhg9Mme6IfJ4vebFZsN2GMg5IXJgWmnmjaQqMqXJVGb8HP9rGnzpGf7j42OUUt9gJ3R2dsbdu3e/4c8XRUFRFAB89rOf5dd+7dcAWK23nJ89p99VRC04v1ihfWKHwbnAplTImFmuerxz7KInEyEnyqrAxZ7YZ3YyYV1iogRHk4Z6qngwmbIwkS9fb3ln3XKTAtsS1jGCENRaMTGSnBPnmx33Dg4pjaQ0AlImJMWyjZwuKu42NZ13eJGpcubMOc52A15GkmB8aD7xoK6YC8N1DqxyZJMTU6MIIfP29Y7HXYsLmSNhqSrDwzLx5X7HsyGByGgBM6GI0SJERkmBkpIc88t+hN/VfKv6gz9cg5vlmvPcURUaqSxLNNpr5gd3qWYL/LAjra8ZhshhWVIv7hKTJ+6umRpNVQaSSmQp0UVDU89Z2JL7i4JHBwfcdZ51MSfN73L64OPI6y/RRo8w0EjNzCoygbPNhvuHpxRaUliNyIkQDF9ZbfhEc8JH5nPWg8ORySIQuh1n2x6fMjorcpZsXeAjk4ZaCC5D5NwNtDlypynIOfPOzZq3th0KaJRBC8GDouILacOlGyi3klIoZsZy3E8wWmCUJCtJznsNfo2Xqb9hu+VGJkJVosqSlVZM5QQxPUAViiRgN7RURYUyBV2OhKjx2mKrgrbtyDmhzJRqNkckaGSBbRQfm03xCW5kxc5OMM2CtMwM6RwhBZVUVFKScuRys+XeYo7WmlIppDYIq3h83fLwcMrDScPWObIURCAEz/PQ06eIAYokuQ7wqKqopGIdPNfe0ZN4vS4IKfOVzYazPiCyoBSaxgjemNR8qes5cy1ilwgpYaXi2BdIJdBSkqQgfOBpqw8XL2sPzs7Tr27QwRFiJvkev1yxvrjiph0QKjOdWoR3FMbya19+G3KkNhadDVpJggvc9ANy2yFjZl5K7k9mvH60oJsEvvDsjN89u+S95ZYfPzlEygEpI2UWVFKSZWbVb7kvDjBKo7RCGEOyBe+vb3ijPuakmdE7j0SjhUSmxIVfE6WiVBWFKEgMvD49oMBzEwLLHPEicWItOcDTdcv5MCBypjGSQmnuVjVf3m65HMYbDRUzhYDZsUYjx/1XaVTYr3//Y17mGtiulqxCj9GapCTX2y0kga0lZj5BWk0UN7gYiH3PTByOgXYGtCQ5TWUNZVEjZQCfkSHRaMmDZoarE1cxsxUKUzQQ12PFhgAtBAWZgGfjBo7jHCXFeKAwkpgEV+vI0azgoKxwPiIRSCXwJDbegxJoqRBCMoRMoTQ6JrYxsA2BkDP3KAhkzneOdYpAphSgpWRhLM/6HVvvUAhySOgkOAkWKQVKSJLM3/Rh86UvldZafuzHfoxf+qVf+vr3Ukr80i/9Ej/xEz/xX/y7P/uzP8s/+kf/CIALN/DFZxe89d4L3KrDBEu3HRiGRAgJ5wOrvue96zNerC652a3p3UCSCSqBbSyqyDTGctDUHMwnzCYTPvvwEYdNwRvHE4qyoM+Kma1QlWXnxZh1V5IGiUZyNTh+5/0zrq/X+KEn50AGNtkTYuC0tpRW0aVErQosmjuTmh86POBR0yCywifJ3FicgLuTijfnUz4+m/Injw/ovKcxilVOvBV6vpxaIp4YJafa0EjNkBKXQ89ucLz97g2ra4+IAiPGA8ie/8wfRX/w+zXo6hlPt4Enl0s2myXd1ZrVzYqmmVNqS06egZ6Nu+RqdUm33bDbrGjbdmycMVBVhi984Tf51V/9Jd5557c5mM34iddf53Ay4f7xgrt3X+fg+DWUyWxdS+cltS2Ya8tEKEop6YbAV957n81qS+gD2UVCjGzbwMY5DmtFZRODH5hSAZqTZsKPLe7w0WYOcizfqSpLJzL3phWfPpzzo4cL/vjBEZ33HCmDE5GvuJZf3a656gY2ZB6VDQfK0ofE465ls+v56luXXFxtCSkgZSal9Iqe5ncfL1N/anHIMsLlckV3fU3bBs7Pz9FGo4sCVZQU9ZRqvqAjMuwGuuWGvt0SVGTAU0nFe+++y1feeoeLmxWzxYL/5tEjTqY1jw4PKGzNykWuNtdsYseGiFGKuTLM1ZgPcoPn/fNztrsd3veE2OND5Ca2DEROmxJrJDvvmaPpe5gZy4/MD/jodDZm4oAjVVAryb1ywsencz41m/JQWbrO02TLjUv87q7nN7YtbYCc4WFR0ShNFxNXg6cfHE+erFmuBkLKKAEq+Zf/IL+LeVl78O89fpff+uIXeffdd4j9hiJahm5gs+7JGbTW+JB4vlnx9PIGYqaUBis1IBGFxhWZm/MlT999xvnFJboq+cHX32A6mXF6dEwnFc/bHgSkQrEVCWNgVmim1qKUQu0y51eXbDc93jsijqACLvd0BA6rEkTk0m2pbEnUMKlKfvDglEfTA4wusJRYa7HWcH865xOHx3zicMEJBu88tdEgJcsUeRodfYjkOGq1EpbOR65dx8Y5zp9esV51xJi/7qe+5z/zMtfAWE+5doGr5Yp+tSV3meWzZ7hhYIgDfejxwWOMZJvAhwg+YBFMJlMWkynz0yMWB0eU5QJtZ9SzCZ+8d4dpXXI6ayhtgfeC0PVsk6CLiRJFrRTGABnkILhcrWn7Hu8DIURCiHTB4UNkriVWR3oGjIIkNVVVcK+aclxMKJSlUhYrDBLJTBtOy4o7ZUUFdDiEFgQh2CS4jAkXIiF7jmyJQdJ7x8q3tLHn2fmKm/VACBES5G9yD34lLj0/+7M/y1/6S3+Jz372s3zuc5/j7/29v8dut/t6x/Yfxk/+5E/y/vvv83M/93Mc3Dmk7R1POsfzswuGGHjj7inr7ZacMjoV5JSR2wGvAsfTihQCu6uO3eCoG80fO33I+WZFGByqNjwsFFcXV1R1hdKw2nluVj1KC9qq4NGipDATkstoBFYpTqOAwbFcbXiSM+uQ0FmwdgNf7j2vVZYZktKUNKbkSEOpQQDXu563256NTxTThv+4uuFzpwd8+u4x87Lg8fNrPnZywNINPOoqJkmhleQ5AQWUVrH2Y63Zxif+PxcXzK4lb9Q19+ZTDucVX7/L2fN1vl39we/X4A985odISLaX16yfP2EVzjk5POI3f+e/Zzo7oa5nVMWCSsx58uUv8qXtvyXHBFmSs2K6aBjaLZ/+4R9nMj0mr58zdO/w/OIZR7NjvFDsSnBRkHeC4XzDR+dzzLTGDT3SB2S0zKLEtY6zsytWIXI19EgCRdCcn684nWhmwlBVhqY0lGVDoUoEcNl2PG13rH3PgS35D9drPvfaCT9894TDsuDs2SWn947YtgMHa8OQIkWUvOd6JFAZydolsoCQA7/y/JzZteL++ZT7hzOOFjXjqrjna7ws/R09uMtsekjctCyfPObJk3f54c/8cV6cfRVRGJS1zJqC4WbNbrvi+eoc33kIGSEThVbcvHfBGz/4A+hSkbeXGAtd20FdIWLg/GrL45sBaywnC3h9OkM3E3wKqBSwWaGGxMVuRWwH+ijZRhAyM6wz7w1L7peK06yZaUldGN7UcFAYJLBsHe+0S6695yOLKb+2WfPDJ3M+cXzAwhY8fnrDJ++VtEPgjhsQOVEI+NLNlqCgVoJNzCQSXRr4teuBg53h+Krm7mLC0bRGm+KVP9PvNl7GHrybS35jfc6TzvHpUDCYCAclH//oIaaaYqqa6ANP331MvVD80CcegIsMracbPPNKcVidcr7ckHSmqCT3m4LNzQ1NPZbYCC+wTiODRKqKh01F61oSElXWTKThMjmeXXaszJptF2hdZDadUCfL9eUNB6XmyFZMVEGtI7WCB8UMiaDtdpyverYkCiy/fXPFD58c8frpMXVVcnN5zesnh2ydx3YtKmViCLy329IPniZKIBFzZjk4tleX3FuV1HbD4WLGfFqR9wH/N/Cy1sDqYIopDoj9wG69Y+1uqHXFZntBImJtzcRMuVlvoHecvXiXuphgjaFvl9xsOmpbgY7MZhOKZLCrju3QMylKYoLpZIY+nKBNQfv0Le7OppSLY/pdi+93KCzOtbQs2QyWlBQhCSyBIsFqs2FqFSUaKRRGQ+0Cs6JC3N7C7oZATBJsYul6TmYFp9OKqS7Y3fTMVUUbPevB4yKklHk+eAIBGcZbAi8SqxQYVi3rbY/VHQeThllTIJX6pp7LKwn4f/Inf5KLiwv+1t/6W7x48YIf/dEf5V/+y3/5DU0cfxB/5a/8FX7u534ObWqObYOdJCqZOdutqFHE5OmjhqhJOdOUlk5Z/BDoO0fnIlkIvIQ2BhZlCUKwGyJf2I6ZoEUf2KXI011HvL26mVeWG+2wFnzMiCCoioJ7h0ckHfAukoZEiLARkcN5TSE0Pid8TKx95P1uxZ2ioKoKpIAr7/Ehcbcx7Hwg5cx11/N0ucZXJROrqeuKDLx5AOsY6FMkdZFaCbo2UwhFZSSFgQLFxjt+d73lvIscbFrK/V73DfxR9Af/WYNv3P04y9U5ulyxOJpSdYGu68DUWFtQVRXBO54//QpvvvlJ/v2v/BK77Q4pLbaqmZoF1cEJl9fPubh8ipGSkzf+BDnDf/rqbyKmE6JsUfmaeV2T3I75mz9AzDuGF2ck56lqy/2jQ4iJrRtr+MiSyz7yxsGUSil8ynTRswye9qbjzcUMW1iEAOkHCIE7Zc2qCwgNN+uOJ9zgm3LMPNSWDHzm7hEfdQEXAsu2o1aKtwePkVAahVSKQgo2zvNbww0vhp75skCpV7KMfNfysvRHsmyXN+TdhkIHDsoa77aoakpZNxhjiSFwfv4+9dEh4uaCYTeQYqYoLLG2VEcTfNvStx7vBpQ6BiCsLpBFyTpKYha44KhUSXFwD2WhvVwydIF7M8X9oxmDiPghEFMmikwbI3VlsVrhRWYgs06Ri77ljfmcqAEEYojYqHm9tnQxU6IIPexWDlvAVFvm9bhZfXQ+5XhS4nIitJG6ElztJFZIFBliJsnMVeu46DzXLjLf9Mhvbq/7vuJl7MGX7yx5/d4pH3/4iDdfe51uCLybPdeblrPVkv7qGiUEd45nnHcbdErkMJZeCSm5antmdcW0Kkkist50/NIX3wXgE/dO2bmWrz5/wWrbUWnD1FrO3AqVEzmDSRJbHnI6n9ETiCHjo2DImVVqeVjNGIaWmAwpSVzwPF213JvVoDUg2PlAGDLHteYqOiqpERmGrkelxMSWlEVBpuP12ZyDumJIkdAFqongcgdlMmQSjoQMkavY8qQPnLie5qbA72/Zv4GXtQa+9dZT7hzNOCgt06JGVpFBDCglmc1mTKcHODdwdfY2R4dHdLsl7W5LiwA0xhp0oQlDoA9bokhEvQCg365JUhFLgU+eYX3DNCV2lWRal3RhwPtEpS3zSUMWkZgyvU/4HOhS4MA0IAIBRSLhc2LtHIeVRSs19uz5SE6ZSkq2MVPIAukkfpfobaCwCltY5AB3gC5GfM7kISArzS4GlGDsMo+arGAZE71fsw2BujUEEb+pz/WV7dQ/8zM/w8/8zM98239/sWjIITPThkfzCdObhna9gwRd73FBIFJiXhp88owF8wqpxyu2uqhIZIac8T6yjYlNSgwx8qCybEOg9ZnCKAoJOSYugyNTUiIp7VgvOJ/XCB25XrcQHIOLnPUDUWbmKvG0H/AhIoC60sxmBdOyQCA4chHnE7LInF8PKCGQQrB1jhgiD03JdtsRUqCxmokpQAhWbEkZXGwplMBISa0UMmWstgwhceMGNtFR6X124Q/ij6o/gKaZYa1gohOx0oiV5sZtaLsNlxfPWK2uSTGwu37K7uSUfnAMPjCbTXjw4D4Hxwdcnl0itMG7QEiKnZpy5+Q+zy+uGExiuWkZlk+YT2oONjtmDyuGrgUUhbYopZlPGyDhNwlCoIueq2Fg0u/opWbjPG3wZJE5nk6YTAsqU4KAkxAIweFzZjlkajTJRa7XO9LgeTiZsrzZEnOmKSyLeY0g8+zZaGMRMqjb266JVZRRUQnB0geuW8dy8JRiX0T9P+Vl6A8URmuKRtCUGq0VOko617NzEaUUMXi65TmhkGNfjxZYazk9OSFpgdSCIDJRGHKp0NWcum548rjHJ0G2ikmtca4jhkyuSpzrETlT3NafTqY1U5FZyo5u29O7gYvBM9OaLsNZlwghoqTgeF4xn1aEnMlACpkcMihBInFYllRKMYTEMjmakFltPS7BvLQsTEUSguu0JmVo/Y5SKqyWaA02C5KAbfKcdy03w4Dde5//gfxRNXhzuaXWFW/cTRwcHVHuHC+WBQfzCT5n1ODQUnI4qzjbrhBao3QmEfGMjiWlLbhpB/oQWA2es1VPipnNNrDzPS9WLQkBcmxGP9tuqfVYzmOUQkrJdNJQy8x219O6RMgDl9ueAonymdWwwaWx1PagmTOZT7/e2xZiJibQEsooOC4EhdREnxiyp9aStt3hc6I0mqouQSnW5zdkCU/cmjKDNYJaa+rbKujBRy52HZf0yLTfg/8gXsYaWEqBlZpCl8zLkgxc7Aaid7S7JTlHgh+IQ0eIkSzGpHBKGWUUTVUSXI/WJQlFkAqhNNZa2piIgJQahCAlgYuRTmb66BAkCqUQSjGtKqRM7AaHcz3Be5bBoaVGykybIiFlElAZzbSs/nPW3YzJCnLGBjGu00AIiUEElJTseodIEWsERVWSUazjBjJs0miKoYRAKSiEBiIB2Lhh3Pu/yc/zQ5uam89rUgKbIEhBXU1QSNTNFd3gif3YxWw1iCxI2mKUQaZESplaGbxzuDxmn0gJUiIpRRsy6z6SIjRaU1nJ5ZC46TwqFhwohSgUSisao7ncdfTCkFREyEwfAm0nmNXjLUPKGSMERgq0klipCDFitWRSGrzI3J9riqBplIQMImVCDJy3AzOjEcIgMwjGhlydBIe2wEhBoySllLgYaYSh1Ilt9AQSg98vNq8KIRSz+eFoP2gtuZqSb56i7MD1Zs3NzRUpwWEzI0vNvUcfgwzz+YI7d05RRN778lcpJjVCWaSyRGWpmkPs5HC09lyu2HWO5Y1BKUNcdqy2O2yQNGWNlmJs2AyB+Z2P4YobLtz7uNWKtnM0tSZnIAu0ENhRXhglCTFhtWRaWtqQeFAVGAmEQE6QYmbwnptuw6yqqKsCKSUphlGDCE7LEi0EtVEUWhBDptSaQyFZBk8g4+M3l13Y862hs6KyFWVZUOSCqS4gSrZuxbbdkYHCGITWpBRZLI5oqjlGaw4Wc9quY+hvEBhkUaKtRRYlpp7QJc2y60kJCqNQlFDW+GTG+mw7odIGJRVVqemCoFwcYLki92e4GAgio7RlyJmIQAqJQOARFEqSYsIqSVloQpbcqy0z1yFTIsREyBBC5NL1NEVBYSxaaUJi3BSzZKYMhZRUWqE1BB+plcJmwTZEUorEfdPkK6FtB15cLnn32TnvPn+BQNJMFlSbLbXtSTESQ2LddXgXWKcBKQQ+RgYfOWgspdEIJSFJQkp0zjN0nqnR7LzHBSi0Qkr40vMrLn2H1YrQZOZ2TKSZouDi6pp3nt8QciDKzOA8u65joWpCGpsfpVQIIchSYKUixoQxisJqQoyczmY4Pd6SOh/RYnThW7U9ZV2ilEJLBYyJOZEVE20xOWG0RBqJCGOmNlGw9Z6QEmlvWvDKEDnhB0enFK1RDAIqU9P5gZubKzbbDVmAtAUxQ1FNKctmXBdSRJLZbtfYOlMUJVZbtDHouiHvWlzyyJQxCqp6RlVUDH5DkiXaCoqsUFJgCkM0JdNpySAuSN1zQkwMIVIaTc6JxNjTYVEIKVFCEFNGobBaM0TPorK4NFpphpwxKeNyZOMjjZJIrVFKkZMgiYSJikKMt1JSACojksAKhdCWISYymfxNbsEf2oC/rmvKSrO8WfJbjx9T6pofenSP8uw5611LPzhShlSXhKiRhaEuFYqEGzxaCIZhQBUaawVKjZmsxWJKWHbkrr09MBiawvLODrbXGZEiqRDU0mCURErFu5c7vK6x0jItHIfO0ETBodbcs3r0ZvWRdYi0bWCiIqu2YxMcWUGVDP/Nm8fc7Dq+dHmDSYk7tiCnyOO+401ZQw+bXc8mOCySu9rwg7MpKWWiSPREdtHRIKmVpKwtWcKmDx/0o/qeJZLRukZONdlW3DmJ2Pc0qaz40tv/ifXqXbqoufuZH2c+OeL1136IyWSCUpJ2t2Z5/j7XN1cMCmaLA+bzQ7QCmSKFkVxeXNBuVzjnuBgCD3/0x9hdbHlyfc18UjCZNBiZiMpytY184hM/QbU5Y+cHnt8sqaLitGp4fQIxJXbBs3QDy9VAJQ3rXc8mDCSlqKXlhx/d4/Limi9eXGOE4KSuiNnxbOiYTxqSEFyuWy6vNww58LCo+PR0jgAGkbhJjkvfMSs0M605LSRZJrbDPuB/FZioMdKStaZFo+YT7OAo88DFdkmIibo+prr7kLKomN9uWIhM361JIXB5vmRresrJjGoyQciE2GTatuPico0ygqa2TCYN5f2PMbQ7gihQVYGiR8kOpSSPt5rZw09Q6Sc0/ZoDH5lmeFROyFUY5z+ExLobuFh23JlWDIOj854gBVIoPnlyyM1qzVeXS0iRRaEZCDwdOj5SlQgB63ZgtR3ovOe4KPhEM0Uw9pD0ZJ7GnkJrjk3BQcrElGndfg18FSQSq+2O3/nSV1lvlxweH/C/+BN/kvD4GTGON+frTcfj82u8z1z4HVkLMqBD5rg+RojAZFJQJouLEdNLNiGOdq9akKVHe0GMif/+C+/x+vEMlwKbeqCQlk+9LhBK8ntvPeN/+J33uH/a8MmPHjHVinKQHCwKFtKQAJ9h23ast5KDumHX93Tej2UcIvLG/WN21yu+dH6Ni5GJVbQ+cNF1PGxKshRs+47tbuwDPCxL3phPyTnjc6LLgRu/w9qCuS2ZFXqccNrvm8ZfFZubFjc4dk3JxjX0KfHR+Sm75Qu26w1JCGxdszi+hxCSw8kBTd0Qo+fq6ox+e83N6gbjHc10wkRMsHq8LbVCs4sDPjmEVBweHnJ68hBz9j4hZIzJVFVH0T8nK0FvZxw++EFa9RXE8oImZVTSNNJiRAaRSWRihK131NbSD37M/AtJlpKTowl92/Ni3RNiRhhwKbNxgaIp0ULihkDb9+yiYyZK5toAgiQyPYltGjjUJVNtqXUc+5uGb06DH9qAvzAlWhtgy6bd8a9/74u8dvd/w+m8ZrNe03aQ0XRDoh0cp4VEKIFPEe8j1aRk1Q+oHNGqQBsBIRIHh5OaIWtSjrjO8eJqy2Q+Z4vkZnPNVbSo+oDPygwEPnM64dffvoZSc28+41CXfOnFirYLTCrF1CpEoTnvHUIIdt5x2TpKq3gwLQkuEAfJRFtaFwneM5OSO8aySJLWZYSKDMHT+0BUElkYYnSUWjHETDekcVBIggGQYbwG7eM+w/+qMFojtURRUhYNujCIvmfVr1ksDjjYbhiuNgxdQM0sIPDe44eA2+2oDo5AK16cveDx02dUZcVrrz3iqJ7y5kc/w9ZHvvzWF3l29gKlCz71gz/Kum358r99l8vNClV7PnN4gmDgjdrTnn2JXBY8evCItLrh3bMlbddjC82s1BxUFZUrQUv6OLBtO6wxHE0npDQQBsesmdA9v2TpBiYKHkzGrIdHEFLg2g9c+Y5TXVEoSRc9tbakAHSBGDPvEDnOitJlZEoMfu/S86qIQyLFhCoEhbWgwDqB0ZJhcKxWa1RVUxYzyJ4+jjeOMmeOjo548qLiYrXCXd5greXk5ICP3nmDqpqha0+UgWgUZVlw9+59uu6af/Uf/h0IwccO57xuPQS4X8PV+XtEH1nYQ5LtWa8TGxuYFpkDq6C0VL1ECM/WK1a7HdoojiYVOSSGGCirkvYSvBsoySyMHuvzcybGzNoPnPstMwyVGutZS60YUmTbO1xUnBOQxkBMxJho5T7D+ipQWpGRrLctX/jie2jzmM984qMsZiU5TalMwcFkypeePGO97BB1RlmByAKBYOkddpsIQEKhsqTWBjGpuFj29NExRE+MEZKkKAznu55maniRHGW/Q6rRreknPv0RhsEjreCwmiBlQWgH+tTTaEVlLFJpmsqQomIz9KyWa6QyzKYNgoAMUJYVTkDreiYDzMsSdMDHiBeCjfdsQ89UGyoJXQqUoiCnQH/rg/5Wu+Ne3SBzJqXMbtjr71UxxEClaiaTBYcHh6xWKzrlKQqBCxKQLExJJRVlOWcxnyAl7LpINppqOic56ESLHyKdbmmbJdZWTO6dsDvLBCBIxcV6yenJCRHD2eVXuXP/AacHd4hvP4UEqjvj4j0I2w3H5YzOxDHxHB1aKQqtkVrRiwQUDDGwGzxKSarKYFNDCJFSGULaEGKkVAUzq4kpEclEHG0IdH2gwKCsIMZMISUhj4PCcECjMdbStR3tEPkm4/0Pb8DvvMe5nuQcd+YzPvOx+7z13nvU1lBVDWWXCC5i54qaEpEcSmWms4LqeEKMcPXc4m+bHWU3IHvJm0oh755y/+4xbz95wbPzCyYzw5sPFrQ3jvOdp5KCifrPdoPzgwk//Lrn/U3L++2OUkrOfE+7C2RV0GaNkYqmKTk4nDC3FUpdM8SAkLCoK1LsWceBIyO5iYIXzrMwlkJprrvAYWOptIEsmFeGltsDTYoUUvJaWfOkF6xt5O11R5SZWkmmeR/wvyq8j6SUsUZT2hIjBIcPHnL91S9w//4PsDh4jcMnb7FaPUGrCHiUEdR1w9HimKKouL5asnMDLgs22xa6Nfd2S17/k/9rXn/94zw/e4Z776sYW/Ibv/0fCeslaui5V5fctxUyjhqc1SXXV7/Fe5uOc5fQFjZEXnQbgizZZUWhNAeTOceHc8raYvSSbnCQYWEnpJjYtB33KsONTNzEyHzwzFC8d7XicKjQIjMrS2ZVxdoFdhbaoWciFY8WDbubxKwwfPFmi8iRqZTM0r5r8pWQQVpQRiCVRCqFUgVFfcCj+4blzTVPn1wQfc+Ly0tmswZba+bzKa+d3ENJePbsBbs4uuuQO9r1huPtluPXPsHs6IgXV5dc31xx1l/wm7/3Be4eVMg4UNpxE/VEEDCpC/zVUy6uNzxrHVZIXrgNYem5syhps8JIyWFTUR9OmNXVeI0dPFopZlVNip6uHZhouPGJy25gYTQNluerlvm8QQjBTBvuVjUkGKpEjpkyS+6Xlp1MFFrzZNXROYcW4+/teQUUChkF0SViyKQU+Q+/8wUenh5TVROOZiVWWK52G7xPqEKiG4mwo120QhAcRJloY0RKyZ265s2Hp/zb332P1nmsEdhJjS1KljdbaqWZjAOlObjtzRBCMD9e8Kd+5A3O255tHEt2rtsb2h0kSvo0+p/PJiWT2QG1VRih6VyPlonDZkKKju3QMpOwzaOD1FSX1BQ832xYFBVSJKzRzEyFi5FNcESdKbXkrix5usnYOPDOpkUiKLVAi33C41Vx/84Jd+YLDo5OOHr4OlIqlldPWEmJLlpiH4jbyPPtU5rDgZha6umEsq54bf6QbrVEG00bHG3YIVLGbeFOSjSf+AzHixNWmxtuVhd03Y7L+YJ+t6ZdX7MtNTvh+ZoH3URKrjdv0/WOXkCtDG0cWEfIZc0QQefEzCpUbZgWDVdyg/MBnQWNlbiY2AwDldB0wNYFGqlpkKx2jkky6KQwKlOrca6Ji+MabKViURR4KQDL066jDx6REyJ+gLacL4PV5gxSQibJ4cEhzeSA6/WOmCOVLWjKgU0cODiaMa9mDH0k9DvyZqBVPYW0WANgkCRKModGopzn5vFzDic1r5UWfXTC4+slL647mhhRZKZKMpWK3kXq0qDi6OvLpuVyvSUA2xjQCi68ZJczjYI7NpEinG06ztcDIkdmRUYIT9PUdF3gtGw4LGq65Hm8a5lXhkmZsaUhC8EkWYTQXO161qGjQWGMRhtJzvBs41lIxVFjKbWk690H/KS+d/GDI8WIMBYpDUqCiYbd5hptLSBpmil3X/s4d+88oOtWPHv+DudnZ1xcnnPczNEiUGpJlcfNYS4ym8vn/Ma//H9y52jGqVJ84rXXeevZC7TWFHVFugpoD0UMdFEysRCAoqyJ646r1ZocE0vvmTQNF94hB6i1xVrHxA1sc+B83ZJCYGo1Q0wUZUGMkZNJw0Fdswue99std6qCac7UZUGWgklRkAtFcIHL3cCJ1JRaIYWhKjRfvdpyT2hOJw2llWy6/ZX2qyADMo2ZUc3oZV2UFSneQM6URcHdOydM7h5gcsN2s2G3u6a/XnKWBCUZ5zwKKHLGyMgRibBesvq932Qxa3gwW1Aezvji4/fRRlOaCckn0rAmWYmzDaVVqOhp6hK5bumcA6nwwGASmxxY9REtFAd1hUGx6wPb3hNDQCbB4ANFKdgOgdOq5Liw9C7yZNtzZIqx2U1Igs5UtaWoCq63HdetY46mNIbKWA6RfPl6xbSQPKhLCikZ9mWNr4YAOWdyGjPZ5MS77z6jsJpZXbLOG7rOc7les9q0FIPmWEyosmYQnsNbq2xtDLWGSgtOJ4YTo/ns6yeUVcXVtuf5puUyORCCSWlYNJaTScVrBwu6XUfTNChgNp3wou24Xq9ZlA1tiAQXKKqa7APZD8wKhYqO1caz6x0pZ7RKDLueoirxLnJU1yzKCp8SN33L3FRMyRg79tsJr3FREaPjou85MgZblBSm5GSiePd8x7EtOKgKjBW0fr8Hvyru3b1LU9foskbncaL38Z27DKFlcD3u1tGmWiw4PLyLAbarHavlDdpalIvknNFRIFJGZaiTIK6XvPPr/57JxKKqKTbBhXM4N2BiJkfP7uI5q27DxGYarUhAqQuUjIToiTkxkIghUYaIS5ksRzv1CljuOro+km57Qrz3YCQxQl1q6qRIKXPhHJWRGAGFlESdiVIQgwECqxiYivGQa7SgQbPq1pQIJkohrKL9JgewfmgD/r7vaYqKwhYYZalqQxYZlRLgsDpzfDRh6x2yzJACuXOEvseLTB9bFlZDFCAEhRQcluO1y/Vyzdl2y735lB+Y1XxkcsRqkIQ2sEOw7T1X2xZ/MEE2Y2e4sYYsJV1KCOCP3z1kcBF0IpDoU8D7wHK55bL3bLthrKt2gdcXE6qq5FgLVpsdbd9z7R2XnaesLAC10JTFWIu46gPTQqO0AJ/Yxcg6RUTIHNw2xJEFbUhs/b5++pWRMtElnAgI4YhCILXltdc+zWZ3Rd9uOJ40CF0gRYY4TojMu5b3nz/l3CgO1O1kPkYNztU4a+Hdi+c8WZ5z//iAj8wnPPjIXaTf0LVrhAuso+d8teYjswlNVaMk48+C0eOocKH5sXsnSClpfUsfAo5A61rObgKDlqy6jm7wLLXmE8dHHExqpFastiv6ocNlxyZnTqNAIrFSY8uCRkrWfsA0DadSY2NgGQJt70h9osmS6e3Uvx1j/8qel0/OnohHCYMyhpADVVlycnyH9VqgcqKSBqEKCm0hlqRWsttsON+2hL7ltBCoNGZKrRQcGEmWkeerK55vr3ngW05mE+b3ZpTDhvbZErfraMNAowWPZhZZlUgctjBoo0aLwgR/7N4hwQcckTYkYsqs2p4uJYLUbNqB1jmUHvjI4oiDpuRIKXbdlu3g2GXHlXNMigqEQGZoTEFdViSpmNWC1Cl0ymxi5NI78IpaSCZJIbOgz4ld2gf8r4Ic8hjw54SQY3PgatvylXee8dEHx9w/OaSeVPj3xylpNmeaLJhKS7KaqbYsDiqU0WODuZIcFhphJB2encs0teFH5kdQlJxd7zDZ0+JIQoz2hEkgZQl4TFFSaItGkEXgzdMj1qsBZMIFT4qRm82GnRvoohhLaYm0XlJM58zKigOp2O3WbIeOPjp2KWAYbyhrqaisoSkEIWZy0twRApvBI+mHgOs8lZTUQpBzpguZ3b6H6ZVxfPSQoioQUpFFRkRBVU+4d+c1QghENzAxCjubczw7pN9t2LQ7VptrQgwQAxMlySmRSWghmEiBJ3K1vuaqhaNZx3wy4ePTAlaXuM0WFSOt67gIjuJwijBjqGyUQWVJ9JFeZO7Np7TtQFaJkBNk6IZhLBHzAh/DeDBQEtuUNIVFCUXvO5wPo3lBSnw9ZVZAqTSF0ngpAcUsJQyCkDPOZZyPuBwwSYNirO3/IAdvvQxyAF1biqJCS4UxlpwqALzviNljZcZ1GYtEF5ahKsYmsa6jkJKJUoQcyQKMHLuc+5QYXODCO44qzZ2y5ngx5/kqciMjZ06y8wPb3pFTHl0n8riZGaWYFxaD4NG04emqJ+AIOTGkxFnbQ9tz1XtihpASVdQ8lBJjNNZKfNjhCPQyInejjVNiFFJdVESRueo21IVhJiq6wXM9DNy4gRrBodVIKUgIYoS8r+F/ZeScCM6PrkpSEpCU0nB0/Ppog5UipbUMyNEaLHgKbSlQ7M4voMzMtYI4jstWgIiJLgh20XPTd8wqxZsHJXfvnnK5clyLAZ0ynffs2p6cAgmNSJ6YoFSGo7pCIrlrS16sHEqMY95dTDzZbmE7HlC9D2xcQGvDm2qs+1Z1hY8bkAl0ZhIUIkkCo+NKXdVkIdn2HmMNj4qSru+52G1ZtQN1EMyNps6ShCTFTN7faL8SYvLE6IhJkNGQIlpJptMpKbWQHEF5hghJDiiVR7u5DWyvLxGpZ2EkOYwBmb49eLYhsXGObfBMC8XrE8WD00Ouup7tdgXBsxs8q1033nAhiFkQExRKMSsNOQvuTGquN4HgWwSRkBOPb/VnbUVKmY1zZC95dCjQxjDTBnJLEhknMmUnQAoCCakVdVkirWU9eJpCU6qC3jmWXcfWDVQxM1WaBgFCjg5s+xLqV0IKX/vBzojbqj0XI2eXNxxOK04OpxRKI7Kksmac1SEFVktmdc28KTlQkpgzmbHERyEYYmTnHeu+582jA14/WXBycMzVYc92s+Qryyt2vsdFfzvJVpJSImWobMFB3SANzIqKLQkXW2KMRJd47DYAaGUolWGIgeQyx5M5SismpiKnHZFMEGmsA8+CkBNaGyZlTZaC9dAjsuGBNbhhvC3oBkdwgQNTUEp5+7oyhP0e/Kpo6gW2tiRGFxwyKKlZzE+4uTnHdSsqJZkuDpnVDQSPLUvEOtNeXaNlpEYSiWQSCoEg49LYn9b5SGU1dyaW0+mCnWsJbotMid4FupwgTUhCfP2mSyFHQxegtgUiaza+J+dITnDd9QBIDEYIhhRIITOvK7RS6FIhxICWGSUzLgtEyEQyUkgqbZFCskkOsuKorokxMrhI7wPBR4wWkBmNa8TY5/LN8KEN+E1Wo82WUWMDr1KkVAIQlWHZO/phy8O7j5hoO5bMzKasyms2Ly557WDC1fU1lwRcTogIu04SMxgEU60xSoCA2mruHxRMdOZ3N9eEKGmURglJN0RiDrSto5aSjy0miCi52jqerjsWVmGlpkuJLw0tMGZGXMog4EAKhgg+RRRwd1bwcAHt4KnCQJEsPYmyLCjLApcDAVDKclTVtNYzSFjFgYxCaZgi0UISE9h9+fQrI6WED+PZ24aCSKQff5ZRpsBOZvg0MNUN2YMpK2KYUFQ1B0bx2kHF88GziR6fEjlnbhwMmwwKJlah5VinZ43mzoGh1AH94owyS2Zao1WmHQZyHmh3AZ3h0WxCiJHnqx1vX0fmNVgl8T7yle0OgAdNQ+89Q85MpKYPkTT0RKk5nlaYucCFgTJFwiBZZ48pC4qiwOcxWyGy5M6soS8LgoDeebTOpCyZqILSaBKJq32C9ZUQvCcMHonAS4lQHu9HY4CirIh5xjKtwENwLcGDLApsUWLdwIODmqubNcsw4FMkIwCFj+Mk8UprjJQooSiN5VRnSjGhOlf0TmAQpJxv+0A83RDQQnB/Phn9sNvINtTkFDA54ZPjndvN7u5kbPoc5PivhpwJLoKCo4nhdFrRe80sRUIvWOVAWRVUdUUUktB5tFQcTUpa1wGJ7Ea3FeslxkBtCqQQVGof8b8KEhkJCAFCjYdFcftZb/qeJy8uMSqglORw1pBFxluBMIq7kxkPTqZsVxuu2x0+jf1QKUEhBRqFUqC1xhTjc79XWFY68e52SZEkjZZokelDSwo9rg9YpTk9OMAHz/OrFV88u+FwNs6pCUnyrB/34LtlRGnFNgS6LtB6T0hj8mZSaKZFhQua5yIgvWEdBkxpsWVJyIm+3aKT5mQ+ozcDKe/oew9WcagsikRZWBBg9gH/KyMpEApkFuQsYTSsAaAoS2xZ4HPg4OAOQkqqpuZI3YUUiJc3HNYlq/Wa3kdiGm+phBgrKjIgpUBKiVQSowULaVCp4fluBylTCIkVgsF5ckq4YXQMmzQlMmZu2gBFRXIREQUpRS7dWOI1tQklC1zOdDHQ+YBLEQ1MSo2RJTFGxCqSe8GOSGEM1hhizoQUIMLhpMGlRM49bvBEBVM1Zve1FiihUN/tJT3GVFhToLQCq5BZofX4kMqyoC4q6B25G9iogYtuQ+Mjc+DOgxNUHihsTeMjLg94MkbCs6GnUorgM/o2cO5CJAZPVSmMNhzWiuO6YNP1fOF8xYO65tlmS1IZaxUhZNpu4GLt0EcFd41mhibdTjvbucCZd/Q+ofrE1jkIER8TwTRsesWmbXl4NGezdqyGzVjjOjiiyDTKsihKsghMrGYxFFxFTadhZjUqKv7/7P3Zj63Zmd6J/db4DXuKHRFnypGZJIulKkmlkt2G3WgYttsXBtoGfOkb/6kNw4YNtWS1JKuqWUWymOOZY9rTN6zZF2uTgm6sLKMOmEXEwwsyEyeDec5e+13vet9nIEtcTgw8FpsPhW7d0fctJYJ3M5hck2tFtXm1whDmkc2TNa/vf4teriAc6Rn54vkzbDmxsj0pBXahZkIIA68Ojl4pSgYrDQtpwM8QJVYpoi0stGbbtOxPgd98/3d8vl3z7mZPsQq7aMi58OzqM8pKkacH2jCyVZ5ydszprWYXIg8hMIuJ9+PETy4v8D4QZcd+gOOYeXp5xfFwQow1YXeeA4Wa1Lq1HckXGqu56HqGZmYi0EeNRtBoQ0gJUcx/4U/yEf//IKdMipGggAiNaghnvvDFYkOvF0RfOMURmxownnh4oA8nNs+fYEthJ090WOY0MZeA1InX3rNUliCo3uNCMDqHTBmpwIvIotVc9g0P08zfvr/n+XrFu4cDAom1Bqczn1x9Ck++5P3rX5GPt2zcjEuyhhBmw5QKp1Afj7fuxOdYfMhkvWR0htM4crHtebjf1yTgWPmtSSYo0CHJxbPoDCl3TC5SiiHKgFYSoy0UKNL+QT+nP1aILEAJEAUoaC1r8y/ABcfkFdIo4hT40z/9Ca92N/zs6RN+/vQFm8UKqUamaWaRDKepMObInCPfDxPWakqOWFkzZlIaK0e6k+znmV5qtt2SIUz83TfvuOqXPOxOSK2xneWUJ/xx4LuXD7SfX3B9veByYTBTbWl0Ak9iFxynKfB+3PFZ3BB8RsqG0cE4C9puxVQmTjEzh4DxnpAleEXbS2KARlsWTWQyntYIEgqiQAhFyoWQHjVMHwyiBmPJs4DbWk19hcJysWSeluwOd5RSePfqtyirycOBbjrw4qqnlIhSik5JxpyZcybKzHsX6KWsYlghsBmcD5ACWHAEGi1ZW8vkHK/uD2ybhuPgKVqgrCKl+n0gSrKAVgssmpIqE6VJMFE4xoSLiV0MvIgwi4wvFjcLnIdFv2JkIswzc87ImM9LS4u1dfCoVGWJKK1otQUKpIiuvIG6Af4B+NE2/DF4QhxRGaAlawBLyomn19dYpfgqBg4x0KNYWXi27tkIQfYjUvb897/6hkaoankkMk5ULtSfX13y8bZj2bYYZQkOQCJV5r/99Dk5QUiJu9PE2moW2w5TPG8OA/MwctFI1rbhf/7xmu+mkTfBsdAaeY7Yfn2aeN5aFktD2xhaFL3OBC15dXtCSnixXmKnzEWTuL5Y8mo/8/5mJFDDaH71cM+mszxpezZNw19+8oJM4ethTwFeH6fq67pZ/IE+oT9+6NLQ6iVZFXwMFB+wvUFKRRGVVyi0orEtT55+yvH4BjkNNNGxbgNS9vzf/+pX9GiKLKALVsDaKP7yxQs+f7KmbxuMUgQHUkGnDP+Xn/6Mkmoq9PvjxBO75Nn2mmMRvH44Mrw70GtJ616hSHx9e8CHhJGCFAo+RV7Nnidry8erFSvT8ERrLAGl4bubB4RUfHyxYOFOrJi5vlrx/e7A64c7nCzEmPk3R8+VbbladlwuO372/CkxFn5ze0cohW/mASkUq/XjGfwQSDkRUwIvkCJSNNzdDrRdhy4CoxVd1zN5z3E84IYJkyJLI2kEIOE//uoek2vsO1qilaa18IurS356ueWisVhTQ9qo/wj/h88+h1RwOXM3Op72PZfbJbvg+P7uwPHhwKaxXPKG8fY1N244OwkJxsnTK8lvhomrVnHVWtq24xKL0pkOy81hQBZ42i9pp8CykXx0seHV/shv3hxwCAqRryOsbMNF19EaxbPLFa1seHl/D8AbN5CKYGl/tNfYP24oUAaMUZhGkk1ByjpgmnNkP0yURcPcFH5194bLhWaz7llvlmz6FhD8q1//mjbXbUH63XTVSv7k8imfPLlk3fVYoygpgVKYpuG/+/M/p+SCD56b23t627Jad9zNjrvTSD6d6LTmyXbJ/+l/seD1eOBhGjGjYjeO9L3EY9hIy2erBXkreN5cotAoC3sXUabhWduhhgmh4OmTa94dTny3O5KSwDnP93vY6oZF39F1Dc9fPKGUwuu3N6DgLoykLNDN4/n7UFCpUFJBS8Wm61AyIQlo23P10Zdcr1a8fvN3JJVZPX9Onk8c9+8J/kSjEg0Nf7P/HqhuTwgQSHqZ+Xx7yeWmY2ENVinyWYphE/zzyy25FGIu7FxmrTSLvmNMcPSBNAUskpWF7A7E4DnkgsgwBF8dfKi6kCurya3kia4MjQ7JYc4INFeNwsaJXia2656HMbCbHRmYpoQDeqVoW4u1is12SUmwOxxAwikFiqh9yA/Bj/akLpcdAvDOY3XAolA5kagfXKM1m7bl9njPyi64MBsapXFu5ng74GMkyEIInpgyWgmuGs3T1YIXmyXLtqGRCsXZDUNlVJIYpcmyFqeSC6fB8xt3ixOZkgsxFm5iJK4NjYemgCpgBYxGcJwiXhVmlbjqGj5ZrXixWjEnyThn3vsJnzIHH7hSgmUEJ2FwiTEkIoX3wdNISQmZk/ZECToGdmPg2/EAQCMtF6al5dGS7kNBm7rxyWRQGZcdJWdM09dmLFYecTYNq801u7df44eRaZjY3e6ZXEQJgT8LczSCtWl4sdZ8vF2xNA1GKpRQSHWeFlBdLbIGFSJNmbkbZv7d198CCl0ESgjuTg6fCgsr2CiJ0halNac0M02KIUR8zCwWms8ullwtV7ismaeJ935mDondbHhqFJuYCCJyDIExZrKQ3M4zfd8iRWYsHgKc8NwcZt6f6hnctEs2TYeIjyT+DwEpJUpJlAapEzmCVIocKy0ny0hMkW7dobsnfP3rv8Hf72j8zEpkJpdxuRBJxJSRCC6E4PNFy+cXGy4ai9aCIqtWCcACxYg6xQoFU+A0Z3Yv77mZBkKsPNj95JmKxJWJPCXKCEpL2oUhhET0BZcLT1vL51crrruWnAzTELgba00+qcCFETQi45xiP1fxb5aKQ3BctitSDhxiZhYGWRRTOFbxLjVNeiM1+nHA+kEgrUAoAQqKqfSHokAhyECSEiE1k/C88weuNs+ZvOfhcI8KS4I/MbiZLBSxZJIoNFpyuWp5/mTFsu/RSp83CGemRkoYpShS1KRUITidRu7mEScSWVYu98k5WrPC6xkVq2Vh0xq8bYgxcRw9kHnaL7jerFk1CzLg5szDPBFjZCEEF1phRMKHwOgDY0zkojjGiV5ZXHEQJOls2HF/PHCMJ+rGo6GTFuEfKWUfCiVnjFaV7tf1SBlIeSbHE8kX/DgQXKBkR9cveHnzhpvdA3G/Z5UgpyNZ12C3RL2nOqVYmpanq4bOmjOt8T///9VKk0uhkJAlMgc47QZyOZ//cs5ooMXlSIkFKQpSQ6ssJZRqaUxmYSyrZkHXNeQEo4+cvCelzCQkGwslQw6ZMUbmmCALpljtt0up+rwYCyJl5injz/29LQ1GamL4YbzaH23DX6hTp1Lql7HRlpyqQ07JGSmhbzTqIZJC4OrZllZk9uPIzf5AKpXCM5650xKBKDUJbWUMWlSOPVIipUQ3ijwXZAFRCkZJGq24c47b0YGS+JiYQiTkTNcqhpjxIqMLqJixsgo5jBLMZzefldYMPjDETKcskcLdPPP+OHHVGH7adKQ51kMjC0ooOBcQLSUiVe60K4Xd5CipMKfCqpOIkribpj/gp/THjVgCLk5IqbDKEoRnDgllElpLtNH4UDjub9mutuQwIUsgpsDtwxGfM42WjDnB+QzGnAhZ0jUaJUU9lwKKEmhrCB60LpRSV3lSCR78zO3RYY2p01gyx1A9/+dQ0EqgBUBBaYmSsOp1PcdC0mnDGDL7045NYxFSMETPfho5tIafmZY4R1yGLKtIzmRNzpHWWlSmuv14z272FCmYY2SLIITIfhj/0B/VHyVCrrxTXRSiKFKUSAU5FWKuuiSZMjGOCCTSeRpR69fd7sgcBY2W9aIQ1RqupAIqs2qqwLIIiRCVUy2sgBiRWlY7wyKwGt4dHbcpcIoOUqEAc068G0dcckSRkAVICaUESsLSSiIgiqBDMvnM3o30aEJOPMwzNzGz7TWfGoM/D3OUUVitOEUYUmCjFCIWpuSZS2FwniwhxEInFDkV7s66gUf8w0IAUgiQ8kzkP/fmotp1IgTGGC47C0Kw7ResuhZRMrvdHSEFlASXEvHsIqJkIXrFsulQqoBM1U1DSqRsyGVGqIIoBa3AGsXb05H7Y0QaaLVGFsHBTzBL5ugr3UNKQs6knLFKQvGkIjFC0kuDC4F3h8BSNbgwc3868c5nPtqsubaKOWRiKQgpzs2fZO9nrsyiDh6jY/aR98cjQmYyVDZBSgyT+4N9Rn/sMBKsFlij0GdReJ4FMURmNzGcTvg54g87Ft2Kh9u3xNMRERKHcSIXKAJSOW+YgJgKWhYao9DU4yekRJz5/ORcB3ClmqpIKRh8YJKxcv2FQFJZILNPDKkaZ1Qyo+B8HAFNEQUpJY1ShAQ3g8NKgQ+JwQVKKcRi6JUip6qa0aqGyM55Zk4RYySyZEIs+BIZYkDKQhHVrjnExNH/sDP4o234Y66WYELy+2jr2rhTnSMKLKxhozWqKDarJTLO7EpicjNZSkSpYjEhQJydbaYYKSmR6ieJEBolJUprggiUGvpILIUxJ26D493kaVS14XIpMadMCJEb72mEJuRCTIW1NfVFKmGOiZhAJNj5mWMIfLoSCCQ+F/bOYYTgqKGkhIDqoiIVW6cJgNaKXitOMXEzT4z+zF0VAlkKQ3Dcu8eG/0PBzRNCFIw2dG1PKYXZO0Cw3qxoGkuYJXe332GCQ+aAlhlSrAl85yYrlmoHpkRdbZ9iJOSIz/KsB5D1zjOa6CPk6qoSc+X9vZ9mbufIwmb6s8XilBLrmLhxnouuwYtIKakm85WCUQLnEz4VShIcXeDdfsfPri4RQCiJg3doCYPpcSEhlaYRVfp/qS07HFYoWmXYxcjNPBFTphEKowQpJfY+cDOd/qCf0x8rnHd0jcVkVW+tAMUWconkXKdAMhbc/haXoC0Z2zb4GHmYHQ6FVYqUIkZKtKzk1zrFTISc0UL+3jZW6wZ3TuqlQCqZIXneTCP7nJBnSmQBYoHdPDNmT1tEFWQCVmqkgNZKBl8IKRNCYpoKN37m88WSlCpfenABpRtmZRlDRBpFrzVKKZbOsCuRa2lppOQhOt5NIznDuj1b48XMFD030+OD80OgDt7PAwkElFz/nqwTSQF0TcNP+0vGOXLVr9j2K1oSh8OekDONUhxjvVeNrE3R7CM5JXIUCK0RUlOEQgpNLJJSYm2EcuU+37iJ05jojEQ39RFy8jXd9G50XLUdPmdirHaFSiu0PDuYlGphMrqZ23nmy82WFCKT80wusO4WrKxlDAkpFNaAFIqFttykKhxvtWGMntvTgdMczi5VklQSPnnu58c7+ENBkpA5UKLD+TrknAdHjpFxHJimkRQi4eGOU9Mz3d9hQ0Sdk55zUdVeOxeKqOyQnAs+1/qnREKc658UCq0VLgRKqf1eLgWXMsfoCSohi6RIhTrXvJgSU0p0539bUqnbKVldfUoWUKozkIuJ22nkWdeeaeMZnwPdmVkSc0YrjVUKKSFkz+wyQoo6RE6Zg3NMKdELSVGSudTv0n7+YUOPH23DH0qdXlmjK60iQwJMgRgDJWWWuqfdLJlKj6bgw0SKrr6mpCCOhXJuuoSUSBQhF96fRjYYGhSZhFECHTh7p1ZHlTvn+PXpyLfHkRwFxkr02doz5kxOkpsp8kzXKe0satN+DAkhIBUYU+HgEyEXvh8G7Nltw0jLqik8sQ1TSjWsQVtQAiEL66bjLkc6q7loDdMp8v44k0VhJSxLaxhDYIyBIT1apHwoTCdP9gVlHT46ck54PzFNE4tly6JriUozv/+KN3fvsSKSvSeHgD0HdYSxcgYloKWi0xaXIzfHI9vFgs60WCHQQiB9wvlI8I4YM7fzxC8f9nx3GlFCscyaOOfq7RtAasF755Fns7FUChfR4GNmEpnRRw4+MbqIS/BmnumPJ5zIxAxCKK50Ryow58Kiayglk4KnX3XoJGl0w7ZvGY4DN8eJvqmp0hvdM0fPKTjcD/UEe8TfC9kFUpPIJlGKR0ZFigKlBaVEctaUlInv3/Nuf+DJcoHVhqRVfUTKAh6UEGgpabRGG0UIkftp5rI50wGFpMhMm1p8kkQPMQV2buJvD3t+PQ6shOG6a2mlIOTEiYRGMoUIURJSIYrCVsIYQbeS5CNTSBxdYI7wdhjoi6iuaUXQaMEaRaJwSJG2b2hNg0yCa9sSiqexhm1nORwCb48Dq8awTC1WKA5+5BRm5kcf/g+Dc4JxAfI5Tbbq1Go+jEyCZbfgz1484+XdkUuzYKU7FIFBaUJxaBSyRIQUWKPptGLwEzenB666C9pGA4KcodhECJU2G2NgN8x8fX/g5eFEmw0LLInASMLNYDvFw+RYoPFCMJeEUpkHF7Ba4xOMsdQBXcy8ORzYaImLGaUMXSdoztt4HwpGWpRWKClplgVVJCvbs170DPvIzW7CGIVGI7Jgzu7xDv7ACCngpwHnRnYK0jAxjRN9q/F+xs0jOTvSaeDtNyNijGipECqjUGQhaoCcKEghMEKgpKTkwmGcEV1b65+oQlltBC5lcijkHBmC52Zw7JKnAWwSeFGtiitBpKZJh5KJItetV9KMqtZsHRUpaVKuD9hDmOiEQuSClnWzb6Qgl0jIEms11iqkyCxmTTS2ZpM0BjeO7EeHVIasFEoYxjjho8f/Y0/atbZOcRqt6bSpEyegJElyE9FNGCxPVwtejhO//I//huPB1YjvdsEhzSQN/3S9wafC4ALCZX66aPnqYc9fLJ5TEvUPbIr4BM/WHfsQ+HZ/5OvDgW+PAz7DP1n35FQwpfoIH6hc15AK3kCvJJTCw+TZ+8BV17A2kilm/uZ44lmzxnv4H/Z3tAvFwmpaKfl6GnjSdzxve3JK+JSRKJ48WfOZNXS95nA88mYYWbSK63ZNoXB7OpJKxkjBddP+gT+pP14sFj1FRkKaiWNdmc3zBF5x3D+QsmIa3lEevsf1z/mbX/4Hdvc7UkwYa7mNdSPzzy8uGGNk9IE2JF6Ylm9fH9l8uQJTGOaJ+SEw5sJnz7fsg+eb+wO/3R/4ajxAhk+XhhQ9nVI0WjEGz4q6JpxLolPqfCYzD7PnWdPzbFlD4351PHLVrmgy/M3tPVpXbrgWiq/HgScx83xdfdNTSmiteHK55bNmw6KB4+nIm+MJKwRX7QaVM3fjCakExmqe6EeXng+Bpmmx0pCnzDCN1VQz9dhG0YkMJhDjzGqh+HT7jPe/ecVxdyLlhFl2DC6ACnzUNowx4mPCzoVLZXizn7j6eIFQiePsOO4ycOT6yZK9G/l+d+Lr45Gv5pEYEh8vW6IPRGqITUyebez5/0yObdPSaoVG4FzhXQj8rO9ZrQwIwbeTY7tY0Q+GX+/3JJ0pZ6s9d3KcROKjxYoYCyE6rIYn6yVfrpe0bcNwGpCHA51UPOnWpCS5cycaLVm0LUv1GHz0QSAzQihKKpTzADFTnZzylKApbPuOP//i56T8t1wayXi6rxslu2AoBc/Ai9WGOTuc95SpcKUa3twObD++IGbPaRiYxirEuLhcsTsceX848t1hz68PBxoPqz5TdERkjY6CnCLWZcbieJeqNbYEjKNqm7Sm5MzDccDnTNcuWWfDv3v5DtFotFZYCt/5G3ql+Wj7HCEhl0RJiWeXG77st0idGU4nSgwoKbnqelKSnJKnaQRL29bv4iM+CFTbMIvMYX/H/f07Sil8/7df8+LJU9YXHVIVgndcNQrfW2aTOO0Hci6YriOkAmSemKbSBkOmTQqlM/tTYLlY4qUgeI8LM3pUrHvLMTh2buRunnk7BRpqsyxUpMFghGSWghQze+8pbdXjSepWIsXMdrFAZ0HKgpshYo1mkVpup0iSlZZuiubOJSiOq3ZJKR7nBBTJYtHzvNnQaFUptQL6xnJpVozZoaRHSoHRFiP/kXP4c05IrUha485iCwWchhMxFZSylCJ5dTzBfGJyAd1YtBFM80wL/HS5IYTaSCfgVAqnecTFzMfHgafrJcuu5UVriDqTY0IWz0IontqWfCE4TJ5jrFwtqyWNkqyUJqfMthiaLJACLIpr1XHVTWjV4Eism47nqw1XqwafZr64WPCkbeh0dQ7a+cCvdjucB2vqS299FnGcfMDrxM5FplBQKGwWPMSBjTIsrUEi2D3yBz8YhFQorSv/L7k66nIKCPh5IIfI6fYduyKxx1fE4Gi6lpxhngKNkHxy0ZBDrJPYLHgZA99Ez1ZZDqcRI3sWfcvz7ZZAIeWMSIWNVHzZ96w6w+k4MGeqYFJAZxRraxlz4alqEQl8hkZI1rql6SQLrcm5cNF0vNhs2awWPAwPfHGxYdsuMUoQiYwx8ZvbO463DqWglYrrrmfdtAzuhI+wG0bGlGlMQ58UN/5In+C6WyKN5HYY/tAf1R8lBJBkpoiauAigtMcKSyIyRYefdvhSiA87/OxpW0sGjtOMEIaPOkmTKxVyBLzMvE4O6xKfHmc2XUffdDzZ1qsg5cyRmsp7YTSfS4t34KCusFWhsZKtNIw5s8maPMMkCq2UPG8WqHSg85qiK+Vju1hwuVqy3w/84mLLxnYorUgi4Zznu+Oed2mmqIwRggs6Lq6XeA8zI0c34zNY27DQknt/4hpoUMQi2P3A6dYj/v4opVBi3RSd/07V0ClYLDqutpe8f7jhaV8tYk3ToXNinI4orfhy/ZScJo5TpCSFj5E9jj5lhjCD7LG24erFEqk0OUVGUV2llITPFwumJhOI3IbM2sCi0VwUi/eBNhpcDHgCjVRcmBaN4Int8SVhm4b1YsWyXfKtO/LPLp6x7Tq0sXWzOU28GvfcnA4YA43SLJuORd+TU2ZMkYOLjDmTlUQnySE5Vgh6WgqCQ3mklH0oOOcQIUGES3sJFPqfKjZXmzokPWd0jMWjDg+QEou+3sHj7NBK8bzr6pnNnpnCDIxkNniezBOKhtYarlc9wO+1ojFmKJlnK4t3AZcLOUSyFdUJLSlSyjXYK9QALE0VBfcZVFJklbFas7AtndaMceaZbuhs1TqBIBXJ++OJkwsoVdBC0CnLqjF4BykGhuiYciKWqgOMMdEikWiiKLgfaM/+o234AYyxNMagIhQKx8OB3f1D9Qjve9ZSs3eeP/n8C1793ffMk2cqiVgiQ0gYo9hFjy4AhSlH1rLhkCb+7c0DP4mJL68yfbckpUIMgpgzrZZ8tOh4Ilr8ItEozb13ldMaI789DKxT5nnfcoiRU8hICgGHkAVRHLYxXC5aPt10lSNrEyvd0Gld6RtIrvuOEGAXPVNIZCspWhBCYXKBnDPvhok5Fy5tFTSRMkoqlBFYVWkej/gwEEKgpSaimYOjdvwCtCTmSAkjaRqQ2vL8yRWH97fs9yemnCgykX0mqMzgHKZIJJJjTnzc9+y841+9ueHjecFPn2xo24aCrMKdAp3VGKPYFph1w6JteX8aSaUwpMSvxgeygqtGsQsJnxJJZN4zoYmkWdBYzaq3vLjoEKKgOoMUEqMUWkpkhr63iPUVN+PI2zDgVGGdwU2ZBzeAgFengTknXqw6rPOoCNpKZhFQRaHVo1PUh0DKilJE9co8F3RFSzGFJBIqBUyaKdbyyeUKt9sxj54pQRKZGCK6s+z8SLW2F9yUwFY3HEPk//Hyhk/WC7682tC1WwDEOTNkoSSf9As+KgvKCqyGexeAWiO/P0RUjDyxliFDnS8l7kINWbqbA+uFYdu3fHKxrrTKRtDoQmvrkCRnwarvIETufOBh8rRa0euCD4GDC+Q58ep0ZIyJ5/0S8KSYEFqjWoURivIDY+Uf8ffEmQpRcqGclyhZJETKLNqWy82GT6+eIPKeL//0T3j11a+YxxkXEikmsocoI7NziFyFjPc4LmTLMEf+399+z7P1mk+uLlm0lwiRyEFASayNxSwvEEJBKVgL98MMSFLJHELglDMvTMssC0lUbv8sqjHHMXta03C5XPL0YkMSAmEFfaPoGouWmlygXy2JJfN+v2cfM+uu9hU5JcYpMuXI/Vjr7rNFhxWKzgkM53NXBCo91r8PhWaxOud+HJjjHQDPnr+gX28IZWKe9sz7xDTOPLt+ynC3Y5gmUq6uOQSPU4KUAgowUtSzIRVTSvzt/sS1izxdLWjbBpUyOSUokU4pDNVJqsiAVJKji1VgLgRDCshU6JFEUSiy0rp9ySQEc/I0aPrGcNFaICJ1RhNpaKFIYik0Bi7aljFEjsFjtMJqSfBwShGRC4cQiAk2ugETsVFSpCQJQAh0+Uduy1liRpVCiZHROWKMDO8fKNGjlMAKWHYNqghWiyVd2zBNjpQSlkILvJsmPl+0rLXCp0I/Nmih6BaKVktUztycJsYU2BpNSfAwTdzOnjGmajOH4EXXc9FafCkMMdLqGsbwSd/hKRxcYHARMkRR+Gy9AimQKXOzP9YPLxekqEJcq+pavAjJk0VLGjM3s+cwBpyPvNoPdX0kYe8DRiiuTUsuEIxgIWQVi5RSOWqP+CAwRmO0JgSFLFWBL1qBUhbiTPYTRhbarsfqDmsNUMgpYUqhiMyraean65YLY5lTxo6ahbKstUUrSYfi4egYww3XTUvJmffTyO08cwq1wWqK4F8sV3QX6+rPmxLWKqbZ87zv8AVOsYogo0sEofjs6qJGcqTM29t7hKppgam1SA1GC3JWSKG46HvG4NGxCn1fhyPvfUCIjAZ2wWOE5IntEDLTNopOnJsBAVI/XngfAlIUKJmSajNTpITzxF+k6g6mjYHcY5uGrm2ZXSTHhBUFpQTv/MynXUPfa6aUUV5jhWIpq02nQfAwTIwp8bxp4SzEfjdN7LwHIVgZyy+6NUvTghD4XLDKcBiPXLdLsqpc/mEOnGZPVPDxtqPVEpESu/0RBMQUKRiU0rUGkpAoNl3PXI7sQuEwe3zc82Yaq7NQTuy8Q0nFZdND0TXl2VbBe/5dtvwj/sGRYzmbWFQhP0ARGQo8v7rky08+4urikru7PW1/gW1apmEiBY8IgRILb/3Ap8uOvlcMXhNKpjcNK1m1dSoX9qcjLgeeNV31GJ9n3o8DBxcQKJbG8NP1uoYYlsycPFYJdsPAi01HNoYpRsbZMYdAQHG9WaDRlJLZnW2EySCERKo6pCglU4ricrFgdp7gJ4Zx5qXPvD3uialgpWQfHLkUetUgC3SNpMMQqaL038UkPeIfHqVIpDJ0iyWNEmQfWK82KNNQXEALaJVmFgJrLLYxzN4jUgIKWgoGo7g0glZWi+w8KYRSaCWqU16B0+wJhwPL80PuGBy7EJh9RiNpDDyzPabXFBS5gEYyxMBlY5G2cv9nX53VooCn5/60xMjpNIDIFA/FCqSQKKmR54SKxkh8BBHBhcidGzjOnigKCpiygyJopTmHDUaUgCIlGRD8I6f0JO+JrjraTNNUbZhu7xFGsmo1rZJncYMk+IBtLLaxhFQpEcIIfjsc+ejJBdedrg2/ARcyWrV0GqZc2LvEzTRzMrVpee88bybHISY6o7hUmk/7BZd9h1CSi1J42vX87f0916uGMUViSfgoKAKU1ny0XpFTYjfOvBxGUPCQIutiWPU9RgqQApEyfWPQYw3bOvnAXc5852YujKahWjA+bTsa21FQOC3QwBzqyEU9+vB/MCilq12XACUlZIHuwIiWOB4pYUSrgjEt4+DQWtO0DTEL1BzRRnA4el48u+BZ1+AzdG3LFApLpbCmCiAffODlsONgKxf+bXS8mSZ2ziOF4Eq3/MnSs131GKNBCK6XHb+9v+f5cskpBKSrdoxjrGnQH22WkDIP+4Gv7vZELbhNjq4IrhYLWqMRSpJTQVtJlgUyOJ948I43+wdW1tJLSSiZJ03HR0ZSlMAKhSxnG0Uh6NQPmy484u8HIQu5ZEQp53RJRRERUMic0GSsMbhQGCZPYxvaNhKzo8REUZJxmLhaLbloLC5D71pcTDSmWh7GXDiGyOvxgdhWr4l3yfP6NHI7TSQJT5uOT7oF132LNYYiBJu24Ss8z5Y9rmSOTpBi4lQKTSP5aNOhcuE4BV4eRoIo3KfAWik2XaE1Z6FcAmM1airknDk5x/shsr/PdI2hB1yJXLYtz0ytgUYrpICUCyILtHisgR8CKVebakqBM0+95Op698nTa778+CP6ruNt8LhpxChLYxuii0QcWhUOw8jmas2mNSxDddTLStIYjRaSmBOD99zMJ6JdATVQ7e1wZD85KIpN2/L8oufZokdIQciWi67jG5l4vlwxF8lhcuSUiCUhteXJqqdEwWF2PDwcyTmzL5GlsizaBUZKzt5DtVHUmjIXDrPjJgycUgJZ2FiLI7MyDZu+OTu9FCTV71FKhTWPDf+HQkoFicS0PaZvKZOn7ZcAzFNBxISuNlJM04Q2irZpyMXjY0QbyS4n1l3DQlfTFiEsE4WlVhhVHXymFNkfHaOod9lDdDw4z+QTCsmyKDamYdE3GGGgiPrzXGZjGorMCBeJIp8TzGHdtJQUmebAwxhBwRAjWih6y9mWu/Z4+uwqWRLMPnJMnqCrXW0jIZLolKZvLCXLs1dappzlw7r8sBr4o23456lOCpz3jMOELIXj/o4hea63a1ZtD2TQire3N/Ra8XS74mANN/cDPTXRrMiCUIVOCZ4og891allKwUbAJ4aY+OZYecjvfWRMtZkWRSFKTc7VSrHtW9aNJQnBk6lFKsNvHnbcnhwkQWskT9oenyKdqGEO++j5bpwYY+IwefquRcoekQsyRqSx3LuAO9MyTjHjU+YmeVZC4mRiYfU50lwQg+SgAiRYSENnHmPlPxRyTpRSLQyVFRBUTZ00ijTO5HQCIiVL3ty+wmrNs+0FJzvz/u6ILmBSQRSQufLjn64sPiYarYgpE4IglIxK8NXpCMD7WAtNiQWpQCvB2+OIVIrtUrFoDI0xXDUdEsGv7u7ZT74WDwVfND2Tm2m1xufEzTjzukQmPLth5rJdY0SDIKNkpCC4DzMnHzn5yDFEhhR48J7LpiHkxEJrGl2vyDglRlkwFNZF0InHhv9DICrQ5ZxRKjNSKnKSUECVgCZQRCGGyNub9yy04ulmSSs1r8dEoWBiNTtQFNZWYfuG4ANKySpJiYkgCjIrfnvWYryLM+McKbGaFASR+PZ4xOrClVG0tqURgifjEq0kv7078TAHfMyccubLtqMU0EoSU+FmmHmfHHc5MHjPRdNixaIy5CgEFbifArvZc/CeOUX2PnEzO64ay1giRmr02Q3qVBwiCFplWRtDI3+019g/bpRUnXp+t0ARhZIBCS8ur/n46imUgncTt2+/pZVwuVljlGKOgRZYlOpOrmVh2WjUZY+nYAFSZs6SGEHOkd8OewBenY5455FZIJVk8p6XuwOttFwulqzajlwKz/xEYy3f3e3YzY6YMh7BVW/IpaCMIE+Jwzhz7z03eWLwnoW26G5RXVu0ZE6J+2HgZpo4uUAKmYPPTAT22hFk4eMl/GSxoAD3Y8CJQCM7lnbBpn88fx8MQmBVUx+IOiNVhzxfN7qASpkAxBB4//4dnRRsFhYtCy5U3Z2/P5DNU4SVNBquVIPD01BpNj4nUhKcQuFdqur0+2kmxoKiZp/EkLkfA1IbTCPotAIJyyxplODtGBh8JOZMBDbWUFJldWQKY8pEMu+DY0iJvmkQqtLV6q5VMufMMUemkkgl4+aMB5qmUoi3Fq6acx+YJV5FyIVGGjrxw4wzfrQndb9/QGRIcyLNGUrgN7f3QKIo6HtNjhNXneT+9kCxBiETuzDxG3+sYiMUGcOUJIJMSglFLSJziKSc6IzgJ/0SYqVj/OvbHRbBWhu2bcczq3nrI988HEkFPjYaWQrPVy0yST5perqimGIkpkQvBb+8v2WBglBILpFDdQ24Tx5RCn2RTCnym90dL1Yrjslxyomjz5x8vajnnLCtRUpNbw3blaYAX91kLBJrNMlIDuVRtPuhkFNBaFF9d0WL0RmpDX1rKFLic6VdLSx8c3vP4rxmu3ED/9N4W72njSIXxVxUpR4EgIKi2rWmlGil4s8ur+jPhey/f/UGJxMroZEJvtgseHuM/Ob9Az8thbXVhJR4tloiUubL5YY7NXOKgUPyWDRf3dyjJQhfaIXAxoTVDScCyhR6W3Ah8d3Nnst+xcF5xhwr/7Dk34c7YWvRa41htWoowLu9o5WGziiMVPhHSsUHQZogNalOFIsiizqIsAm0TEhRLYCXSnJ38EhbaUCHGPjOj5RS8KoSDmYEIgEpQQ1PZQ6RHGEpG/5k20GsP/9f3dzQGlg2ghbFs77jpS+8fphpimUhDQHBRVMP7IUyJF3Yl0DNabJ88/6IMDUHIslCDoInpuUY6lTKSklImXfDwEpJjiUTqV7+vhTG4ElIXKeRWbJsLNfbngL81fdHNhakqvSM+GjS80FQigQtEKJO9WOuG+XGwHa9YrNaUPLM04st85RIKlFy4mGeeD0e6h1sJVkYXLKIIiFJlPAoJXE5k3Kk0fBiu+V3o6shOFCajWxQGfq+wafMwzDRGkVrqlvfxWqDSorrLqKE5OBmTilg6Xl1dyTLiHMR7yIhRK5sy2HySC3oekVImbf7I1YlxhRqKF2BuWSOoTZ+CShK0tiGi+2GAvzmtOeq65BFIRS/b0Af8Q8PlTRWWjplkUIg24yQBQh1yp3PQv++582bd0RbtSKHELkda55DUpokIlMWkCXyrHdDeUKAWKpW70VvUbRA4Zc+kwR0WqFUpikNjsxp9LRo2k5BUlw0HTopOpnIVuByIvqIkoK7aSCUQgqJmCI+ZVay2rrrAs05X+reO3olcWSqvUwiF5hTBET9HqIwyrBqamP/zh1ZqRYZJaoIhP5hW6YfbcO/7i/JJXMqRyZ/RIfM//m//l/x+RdfsOk0pBk/T2xbS3cJAsM4e3qV+fnFBUfn+LJr+Pd3t1zZhudNh0WjlAQcRgkkipgFyQFIXu0Gft4sWC4NRkvGkvjqdGKjGn522TPkyP/45hadC19cLNAK/vTyijFn7tzMy9OJBx95LjtCLnhd6JTm09QAAZ8zrw577qeJORa+ejjw/3x5x8ebljfzzN5HRBYoJbg2PW2WbNsWlTX//t2RTOJCGFZScesib04zzj/myn8oTNMJ02mMkbTNgkXT8/D+t+xu7xFhQMhCCCPWWH62tUDP4AOXRfIXTw1jcOhF5D883HFhG542LQaFUpYRT6/q9IsiSEPmSOCr/ZEv255uWQPhQsq8Op1YLBVfrDccnOf/9vX39Mrws4sVq2bBP3n2jFP0vB9Gvjkd+W6eeS4tKIhNRkrJk6RRKTNlyW9e3vCtumPKmZfHiSDe8vGy493o2HlPoSawft52WGG4Wvf0RvMf3t8zTI7PuiUdCicy78aB++Nj8MyHgJIRJRcA+BJgVqzWikZ7rAaVM8UNdEryZJEwVrMfE1IIvthumXB87Fr++nDkyiqeWAtolJY01KY/ZMEcEtknFo3h4TDyC2vp+h6tJFMMvJk9V9byk6sFO+f422/2GOAXlxcoBV9eXvI8Jm6Gka/lgXfHgae2Q6BJJNCFF+2ClBJLD29u9jwcRpyS3A4zE47nzYpDSrz3jpATjbF81HdINM+WCzo0//r7e/Zh4hebC3oteTdM/N3DPc491sAPgVIKOVUeP4AWgv/rf/ff8hf/4i95drVBnoXhy0WPbD0CxTAVlm3LF9fPOPqZJ23H39zd8WTRct30JCdJOiGogsaCICcBIZC04jic+LntsUuF0ZYQBV/v7lk1DZdNw83+xC9fv2MtDD//+CnWKr64uuJ52nI3Tui7O27HE1eyqSnBRaF6wVZYdM60KfHu5sCwDyQkN+ORh/HEdtFyiIG72RFiprWazy8WPEyeS9vRBPj337xmlxyftz1rNFkqDt7xMN7/YT+oP2JcXwSW7QltOkzToXTP27tvGG9uKO6E1ILkJvpW8fG6AVWYQqRrDJ9cr2vIn5N8PZy4iA0XpiFniTKSo4/8bi6eM0RfU24fxoHn2mB1DeLKpfB68nRSc9lIDn7gu9OeRiierZZoBU9WHRcZTj5xKxyHcxMvgkDkmr1kBEQ1E5Pk4TQyTZ4sYJcS3/iZhWk4+czgY9UmKcmF0iAU67al1YZXg2PvR57ajgUGL2tA7P4Hhr/9aBt+oy3aSLz33Pk7tJBcbhcsOo1WgpxqQXI+IkJANoqulRjTcpEbQlzy+vYGqyRjSNykGaMrNeY+zDy1DUtVm6osBHdh5jfDxJeyZRKZEGsQl0sZWvj2NDLnQkHwwraoQj1MJbOfHft5ok2FK9PybhyZE5jzJKtVkpeT5wuzQmXJHBIuZ5bWMvg62ddFsFBV7R1TpreSlTZcGEsrFbFUqsXLkrkSmjlmfM6Va/iIDwJjG3rbgqxc1pQTJI/MVRBEARELLnliqM5MrbUIpVn1HSJG/va7tyipOMVITBO6SFoVeRmOPGuqmLeRhigEOzfzd6eBn8sFY4mMJeFDYgoRVRp+HQ5MuS4An/cdttRk3jE6Tt7jJscmwsf9im9PA84nDIIWQYPgr93In7crjKxWo5p6zh7GwMMUMFKytQ0pZQ7pvJLXmrU0dEVVT+MCr+eZtVF0qkWqKsR7xD88CiDEf/p+K5vpDPTWoAiUDIECOaFyQtCyaDSNMuRlgdTzd+9uUEhOAWIOCDxWaE5ELrSmkxYlNEII3ruJvzue+GTZMiRPCJmc4GH2NFbw3WHP0Wd8Krxo2xrSluBwcOyniZObubCCTq94NTqyTxglabVBisLLMfBx26FRNUw6R4wunKbCganSjrQmRMkuBGQuXDWm1ukiyEnSCsm344kLU7efjS6Mjw3/B0EppbpE1b8CBJ98/ITLi3UNFsyeVBx5DojikKanbyXWSC6WDSEGvvv+FVJnjt4TQ9Vs9Mbwcj5yYSy9NmipAMHsZ37z8MCnfYcg4byDKBl8xHSK7/c7xhAJOXG1alGy2mNPvnCYRk7jiU7A09UlLx8eiNRHikaggLfe85NugS6alArIiJUCpSVjrGnUa63wGU45k2LiRb9kqTu0kgSR6ELiu/HEs9LxZLllqRv24+OW/UPh3evvOfUdXb/i8uoppgV/OhGDg1QzE2JM5JSJOWCEppEa1SjWtlTf/psRIwVzjNynjECwVj13k2f5uwRyISlUQfjbyXFpdQ3gyhGRJY6IJvPOJ+YMMQvWWmEKpJTwpeoqnY+YkliblsM0EcrvAr/qJP4hZK6EJRdBKAUlBKbUDZpLAS0EvdQEMlNOoGBlNJ2SqFwIMWGLYUQBiU5r+gKD/y/+UQI/4oa/UH7vwjCOgd4YIEMOSKmRQqKFwYeAlbKuHREoJFrVRLWQoJeGOSeOOdapVqk+q29nRyMDrdJYq8kZVq0ikom5cEqZ28khJTzJHbfeg5QsjSGUzKuhrvyK8sT6+sAqxXXXMueEDJFcqv/1Vhu+GqprxlJqpBTMRGYZ0QgmF5FKYqutCiJJRC4IKVGicnZDypQiOURPnCMr1bBq7KNDwAeElgqrDTEGfJgRSiK1pGSPKPks6FWkEBAIihBAwQBW1ZS/mGEhLcfo2eeAlYpAoZOCu3lmCInOJBqjEUJx3VpiycyhsIuBt+OEEpJL0TAkD1rSWMMcE98cq/tEpBYMAWileLroGHPm4AMxJmQpXFhLOO2rYEgZpIQWyZTTOZU3IIxAq+pGZIMklUIUUERNwkyhOnTsvOOYBM+lppWarmn+gJ/SHy/KmfIghEBKiZIGKSXk6lGOUCShcdEhhQYkShSEkggtIApCqi5PU8q4VLAaUAJy4dZ7WgWdLCgpSLrQNQpHIoTMMUaOLhJ94mphccnjMyhRxW+vDiegrsRjSJWuqDTXbcOUCkOKCCmrt7mR/F2ZUQK0lFgpMRJOAUQUnLInl/qzM2CyIMZEtJmc8zmrumCk5MZ5Qslcth1Nq7HhR3uN/RGg1rTzjUyKgZwi5czNR4DzEwtjEJL/JKLWoGlIWbDQljlGDnHGCIERYBHsnGNKmU4blBQIAZ0xuALeRQ7Rc3QR5yPrVcNYZrKQtNZQCrx9eADAFUVMkZwjRlZTgtM8cUqV0mGFolWG7+aBQtVUqSKqDr5Aoy2j95DLObO8/mcKiVZniqi/f5kzWghOIWK1p42ORler40d8GEjZYJsVSltSSqTgiM4RwowuCSEkQqrqDCWqc5coBSVASkXJgpjACkPIkbnUh11KAVUy+xAR6ndW1QqdJQujyFkwlowrmTlkAoW21cwJMhItFUnAztXHXlSiBtSda/PSWlJMzKn2gQJojCLN9aKWVOG3LECu3vtzCPVsynr3iizqHVzjACg5kXOqjns51p+jqlZU/UDjjB9tpfSTo8SIGx1+ivTKcJgmnoYASlU+l1JkIasFplCk37W/pV4OGYmVikkk5pIoCBoh2FrLK1dtl6yMXNBwZQw/WcPgPL6Az4V33rOyNWlwThmDJJdqUzil2mhbBb1WtKo28svG8JFcs/czO+9wMdHqOsGIJWGKQeX6GJElQ6n5AI3S9fdEVW67nGlLYcr1ReliREpBLoVTTFy3msumxcrHYvOhIDnbIZbE7GYwGtXYc7GoxaYoRQn1EVo4F5vzFzxRbVibVNgnzi92ASLzadfy2+PAnfeYnNmg+bhd8iebFTduwuf6RX8/exbGoETlKwqhKEJwN3t8qpNNVQSbxrJqLVKqus5UGw5z5GY4Mbq5io0RZM6JgZW4QysVUkrG5GiKRp5/jSxwTNUh5hgDrkD0gawh5MScCzllemPITf8H+4z+mJFLrpaI1HMopSEJRUgeI2qTrqSmEBDSIoSA8+AD6vkDiRGCIWc8GW0kWRUuteXlPDNlzyAzndRcNYrP1h07N+NTdXx6Ozv6IilJVH3H+WW585HsqxWcUpJeCXqjMNLQN5JPVj37FDmlRMmCVmmE/N2juJ4/WTIyVelAfRwAorqdySJqlkqMGBnqAKdE0JAyTLk+Jhba4pvHLeeHgOA/tfuc//v17Q2ffjrQGYFWBYQk5IhQi/Mvrr791XJEkoTGKssUE56EVJIoIk+7jm+GIy7UQCOrBU+6BZ9vVuznmeAzY8i8HUdMAZEKUSSENmQpOPnAaao0hiQErdG0RiGkojWaFxcb9t5zDI6cCr2xCAo+JRoyOVeedM6ZXGrQZeUu1fOHgFPIKOUBiRUSkTNJF3IuuJzxKdCoqmN6xIdBt9qy2l4jBSBqBkMiE6Or2TIShJKgqmOSkPLcHZ9/QAFKHZw6EomMPlsEr7TkjfPEBApFg+FaNTztWw5jrM1+zjx4h5Easqj1WEKRhTEFXKz1rLrX1XMilcAoyaZvMSEw+kjKGaVrb5dLQZRCKZlQBCnX/z37iDFVDFyq1AqXMipmlIjoUkg5kZQipgRC0haNVnWr+0Pwo234p/0JR2E+DIhcsEvNy92BT588o9EJiESRMN0a3BFVFEILosrkJEkx0XeGXazii1wgpoyyiieLBbMo3EyOOQWGAH+2WSCahm/uDsgIvRRYLVhrgSTTKUkSgjFlSg5o87tkyupw0SqJ1nUaf7VcsQ6GfCh87wceUkILzewCuySYSmKfA43QJApBFqxIyAwq1Yv6QKTNibeuhkgoMpeNYqEtSmbW1nJhO0R6FEx+KGRVyDIRRSKUhPSOvrPEBDkFpKgTJGk0EYMClFEUVQO0TEpsL3oe3j1QPYHr46xoweWi5y4WHmZHSJHBw+WlZdF2uLuI8BGfK8XhwhiMAikFU06MrmCFYG0sUIW/VgvW1pCNJpfC5WrDuqsP3Rs3cpMjndSkHDj5xCEFdjmyMQ0nFRhyRAuJKtU5YFaZU8zYlHk7DXWqnARrDAthaaRgq2ylVpTHM/ghIaVEaYUyCS8lBI8qBS0yWWYas2BUD1iV6rRLUMNjgNVSczrGOg0jo2UhicyzvuWUE/feM0RHNJE/bTYsTMdvHwqFSCzQz5KF0hgEoQgchakkxpK4aquRQI4JrRRLK8m6elRfbZYsc+H1MPF+mDiG6vQUSmGKkWNIdU1eFMccOBDZSIUSgAanEnPM6JiJZUZRECRaNCurkVKyEi2XukM0j0OPDwF5znyrBoC1h/+fXn7NP/nZz1g0hawlKYI0DUVJICMUCAE5ASpjO8tp8AipkFiKzCSR2a577rNjP3vG6AlF8ournnUr+ebujiLAFWi1YiklKkaygFP0eBHolOKJqfqWyAyipuQKVevf9XrDKhde7ne8PexpZKYTuoZaFseUZlKpaWC388TdNLNoLFoJRAaXEikUhJAMfkIXgZHQtnU71QvNQjQsRUuUj1v2DwXbL1BdiyrVetJqQTGSnCOBSBZ1KKJNi2dfJ+RKVkvjlEFF+r7Bja6qeUUNaXO5cNW3HEtiCIEUIq5A33e0bUcuIzlkfJAYFAutkFGdw90yXnq0KFyqOuxKMSOlwFqBUoqCZ9FVd6GE42Fy6DMdVxSIqQ5zPRmRJKeUmHNClJpPUVF/jU6BexISMLlgZO07DQmjezrdkOQPo9X+aBv+zz77jMN8YhCZPjq6vqWPiTc37/jeT+ToaZWkkRKVPcVoKOLMO0zEnPj0ag15z8errq5gYmRlDfej418+f8rbYeDNMKCl4PKy43J7wWXbME2e2Sf+2cLgMJRS+Mh2+Bjqy7Bfsd2ucSmTvKczkkWjiVHwzc2OVUqUnBlCTfwVJfG/3Kz4q9ORXw8HhBB0UjGHiWed4jmKGYkToHRhngOLrAhnblcqGR8z7wr8r68uGVPhu+OR/3h3xzA+8lc/GBQMbmQaJrIrZJO4/f6X+DiSpokwnwj+RNstmaLDlAyZ309lC4XrVc84ez6/2mCk4DDNbLsO5x3/1cef8n4/cHM41AjwJ2s2lxsWiw53GnDzzP9s05MxnFLh87ZnSIEheNba8NnzF3gCPng6rei0YXaFr27esnKBguLkPCkBOfPfPH/GX93f89VwIGdYKsM7Jr6wLZdoJgFJ1kARk2reQ8mZgiTmwpQ90xD433/0E3zyfHXc8T/evuf4yKH+YJBCooxCdRqtwbqRRWNwYeYwz2TnsdYyOU+Rsnr2F0EdicCnV5coucfKLQJ4GA80WnOKib/86DnvDyPvDie0lDxfX3J9ecF6ccs0jsyz57BocPWqoW0bhhCZY+SiNzy52DL4gJ9mFkazbCwxJL55OLDFV45/zGShmbXiT1ZLfnvc80vvUEhWwjBmzxMjecKCMScSgrWwFFlwKaMT5FKYc8Blj50V/9tnH+NT4eX+yC/DHcM0/2E/pD9S5FJrWCmZLGuj8dMXVxz37xj2r9BkFk2DEAkFtNqSYyLngjxPvb98ssGWjF5fUEpht9/TNZJ5mvnnzz7mbhi5Ow1oKXl22bPablkuOtw047xjnDc4FCkqetMzRMeQZlZNw/XFJSkrINBZSWMU0xj5enfPdVpQKEx+ZnABXTR/ur3k+/HIb4c9GsGltaRSuJKSZ5dX3LmRkDNr24CHU4K6iyq4EnEx4r3hf/PiZxxT4OX4wH+8e8P+9Hj+PhRss8WKHqUyQhRynrn//muCO7BsFmhribLg3IyPjk6ZOuAv5aw6EbzYVAvWp6ojk9mNExfWcMqRzy637KfAYfQoKXiyXrJaL1k1e+bJ40JkXAZAEREYaRhDxKXaS16saxhmCoFGVdrOmCS7w4kUI5mMyx5XAjI1fN4veOUmHuYJJetWNBBYacVKtdW5CkFjFcLDdLYdFbmQc2IsGTkF/tlqy5QKr057TumOef5hd/CPtuFXiwXbZcPoZ968f8fN3QNPr7egNVMUOBJZRK7bjs5ualP2O5PgcxLaq3cHXo9jFS5qjTSKFYbRO377bkLKzFaBkjCcJqzSQEHKgiaxUZLSSF4fA61MVbFN5VU1KZPGidZajNQMU+RX7+95O4+sYsuFtXRa8/P1mpWSXFrLi4sl/+b1jpOPtFryTkyA5jYErMpIVS/qBxIGydWZS1iEoGi4sBLXwO7kWJpqI+rmR8HQh4I/jQgjiMmTZHUzf3N3g3SRftGh+iuCX6KnPZfbC6ZhJJHPhIq6ZXp1t+PNYQ9C0WpDr+q09nY38G5/wBrNulNIkXi439eJWfbVe10k1jqRrOVwTEiZsbHgE0QtIU+kYaRpDBrJYRz5q7ev+fo48bHr2bQrVsZyeXnFSmsWjeXpakP/8g3j5OiV4lWZSUpyEjVV0krBVAqHUH39n0iBllVLk0rmadNyUCfeDQNWKq5NR/aPE64PA4tUBi0UuiisVezyAWsuobWoziKnETXdc7ntmKaZXCK/r4E58+phz+1xwAiJ0YqsYG3hMCa+fX+DlJJtb1BCMLgj6qCq7iMXmlzYCgMrzbux0GqJT4KpQIrVJUiPR4y2tEYwR8cv393z3TzxUYosTUejDD/pG6xUrDV8sVrxP7y/YYyBXireTI6M4j5MNFohlGTOiYccKRI2qk6aAUoRrKzGqci3YUArwaIIRh43TB8CtXGv322FQAjB6GAXPeM04qaBlRb8V3/6J6z6hnkYgMTvWKbBw8vbe24OJ4wUZ62dYN2sePdwy8u3b5FasG4kUsA4JBQjKWUyGUFmqaBTlnsySmdMBh0lKRYsnlP0LJoFVjc4H/nq7Rt+fdhz33esu55eGn6xvaJRLYuF4lnZol+9xrnAQmvezycyDXs/Y6VFqcKQHA9TwMvMkgaJIIlCkoorbRiZ+XbaY4Vka3pm9Ugp+1CwqmoyKYUcEjGM3LsDTVGU5QoWC/ATjRtp1kvy5Chne9+ERMbE3XHgNAwkAah6BhfaMI0jt7d7tJZsz2fQOYc+/G5DmlGUemcrwc6DUhkrBClpopKAJ/pAI2y1Go6Jm4cjb+ORdemrRlQani8snVJ0uhp6fL3fk2KiK5L3aQYlaxK6rlvOmDKnFHHAFWdHNeqmrVMKT+a9n5FKsJDqbOf5X8aPtuFvhUR1PdvtBS+ebvHJ8/H1ls5oSJ6FgdWqpc2JEhMhBFJKdZ8oFQXNumuYYiSExBwTp+gZvOf1MPFJ13Bp25o4CsQkSTGSUnWeAIG1gNWs+kKnFXPMZAVGSWwpRF3w0RNi5ugT7ybPKUeui2SpDK2UqAJGWUypjilfLjqcjYSSOGXBRdtgZRWKNFYz5MKbYcKaTIixCpEFGCk4hsx3uz130bMUhpwK5Md19ofCOHr6VUO/6GmaBqUUnTHIc9KpEZbl5hnF35N8/s/PoJAUCpddxzhH5hBxKfEmeoabxKvTxGfLBauupTOVfxcLqOLxKRJyoRRJazSyaXiaDdYaClT3nIXFloJq6xR/ngM7H/j2MLNLiZ8Ixco2dFKjSqExGpOqoPgX6w2u8fhYw46e2AWLojGtpG00c858dzqhgDFGpKguFyutOabA6+PI22lmpQyqSDSPHNYPAWsEWkuUUiip0FYhZoUSAhEyUhjs6gnF70gpE2IgpUxVAtXN5NZaZhUZQmDMgSAL3gduZsfHy54LY2hUvQammOjjTE4RXwpFQtMCjeEiS1qtibmQS2HRWtpSEFpyDJEpZYYU+XY68hAjz1nTWclCKSz19yDxKAk/Xa5wIRBS4M4pNm1PaxK9lrRGMefMy9ORRmhcDJVWIsBKxZgz348j388TG20wpdbHR/zDI59ZAmeZHEILfvLZR7y4vuT4cMd9dsQS6BZLSnbkUKp7Hvw+T2FjW1JfmL1jjoGxJI67mfenic9WC9ZtT3MOj5zjTBdFFSfGXEOFrCJpQy8TWihMLjQFGq3OzZhgdgMhBsaY+Go6sXeBp+2SpWlota53qGqwuU5BP19cEEwgpcDdPLI48/9XpkUpxS44vjsMWBSFQAaUkCip2afIq+HAu2FgozT2MWn8g0JbgzYGEhQS1kg2fY/VDZRIChPGGDIecsafHXuKkCRR6dGdUZSmYQiJMWacCLw8Vjrjs7ajt9WCEzgbBURSPp/lcn50NIZVkRRVB1+tgFZpOmpvNkVHyoqQ4TY6XJKIJGhtfQiIAkZLIKAkPGksSSVSjpgAnWrQJHpjUFoypMhummkQhFyIlCrSlZIZuA0z++DosqopvT9w6PGjbfiFAqU0bddwcbnEJc/Tq+csO8s0LPDugBYzOgrmeaaUhFQ1pCCETMbXD78UWqNo0MSYOMbqlJKKYkpVfNEoRQqZ0xgouVrRCakR2hCyJuXIfYhYIVlaXVXc1CCShKCQiQRSSfSNZSFrYVIlo6SksVUBHlwAVXAxc4qJKWYmH1gqySFF7udIKLBSisvG4mLBn2cdCklB8Kzr6KLChcScMyv7WGw+FIQWNE2DVJkQ9syzQxXDxcUGUTwlOeR0T0keNx0RyaOFoCDxMZAzBJ9IudAZTS8FIkZOzmOkJqIZA5SSaYwix8xp8pATIgm0ahBNx5wFc8zsskMDq0azNOdLNUERkiIhUcgInrUdG2VoUkLkDAhs16KFIYQZZGEiskuenQsspWOrBDcu4LynlMKlbViaGjbiUm36OynRUvD5csFKa8YQ8TGzbB7P4IeAPKdra6tYrBuWm5bd+ICRIIogR49MdbM5zzMlRaSol0v2gUjlIUshWLWWrKo4dpwDSihKVrhUSNR/znrJJGsNLBmE1ghtScUwRM8xFzRw0Rh6XWunLwIhq5A3lQxFsDWWlZLYkpBZ1nh4ozFKE0JAqkgMcIy1hp2858pYHoLnNlS3npWwrBpDDJXHKkR1QcsFXnQtSgpCzqRcEPZHe439o4aUtcHoOs1m2yA0NE3L9fYZ2/6C7WrDPN2hZSGMIyX5OuwoghRqM+NDrA2StTTGUGLgwQ001pKFJhQQuTZoImZOc0CWTIkghaGYDp8Lgw8cUqBRhnVraFUVNeaUyUhKTvgUiKlw1XZcWosVIEtBoWiNROuG6CKIwlwCp+gZY6IRgStraz5OLriSWNrqQEYuODJSCGypVJHrroOSiTlTSmbxqCH5YLBWY5uGEAouHuvnESLrdoPWCpEzYjqRc8T7AKnmkBQKKdbkW+cjIYPVCoVGZo3zASU0SdTgyJwKRQhMhuIystT8CSk1ymhiyTUtt2Q0koWS5zOooEQQZ1c+EknCSlp6pbG5hmwiQCmDFQKX6qvY58yYE1NOqJBYSsHJe0KogVxWylozS312Sqq9pwQ2TYOu0WOkAukfe/BWve0KUklMb3Ax0jQrrq63pM0F8+Ed/v4bUk4EHxBSIKUmJ0GOgVgCp8kxxshFY+mVIRTFmOqaMGXJ4AsxJ0ojKClTxlKn8koipSIIW0VFLnGUia01XEiNRuBLwSXwEopIRCJWw0XbslIKnTMpFbKUdF1BGEPyiYnMXfLc+8gUMzdpprQNr/zEISW0kGy04dr23DNjZXUGyqmwNJqfX6w5usDL44l9cTQ/MFL5EX9/NK2maSwhDozjHT7smF2gu15hDaTxlvnue1KYCX5GSoEUkpQhx0yMhf0wMYbARdeytJaCxMXEwtQH48kXQkosqFZ1+xzplcAohdAapy13w8h+DgwictVYOqMxpRBKYQiFBGRRKAo2jeaTbslWW1SK+JhIQtL3PaI1pDgzJs+Nn3nnZk4+8j1HctPyzTTy4CNWSj5edGzanls3UNT5vJO5ahr+7HLLYXR8czxy72fiY7//QSBETQW3nWF9uWSzWXF/84qc49mm2OFPN5QU8C4gqJz/kutjIJbIyWUCiaW1NEYhvWQKmYWQxCKYUzUEUGRkMRyJNKrau0oliUZzmhL3o8NrybU1bI3ClBoV75IgCwFkcsmstGHbNFxoiUmZmAJRSTohUMbiI7h84iF67kLApcRNmmiA7+eJ+xgxSK5Vw6axHLJHK0EoiVgKF1rz882GazfzfnYcQ6DuAB7xDw0pQSnoF4ar50vm5DlOE0JZrp8+5Xq7xR8sInm8n6s5npCQCiVGcpw4zp5TdFx0Pb2xZC/ZBcdKqhr6FjNZRBKSpkiOJdIIgZESITUOyz7s2Q01kO2qX7BpLFZVdx0fE1FpCoWQIgtleNZ2bNumag9CPjtXGTAt2RWm5LnzEw/OM6Y6zTWq8PVpZO8jRki2ncEqW33VDdUeMWU2WvPldsulsdy6iVOs4s1HfBgYrTCmISbPnDxSao7TxGWTWbQ9Ek8aDsSUCCFWhy9ZhdciRnJMDC4wR1g0mk4rSAKfMq2olp0zpdq1i0JXBLFkel1QUoLQZGk5hZGdDxRZWGuD0QJJIRWBz5CFJJ/3QVYpLrVlKRQqZ1JKVC+MBqUMxOq+c4iRY46MJZOiRyrFTXCMqRpo9FrTGAMxoKWqxkO5pv++WPQ4bTimyJhS7fp/AH60Db/OVYBWRCKIyLvxjruHHVfbK5aLa3pVGN0bbg8jQSqk1KQkSKnuIWOS+BDxOXGMkZAghUgTBKeU6hoPhSm12c85MyRJu1QopYhZcnCZ16eJJkX6ViFLYYiBMQnWUuCB2+l3PvyJ3lo+ti0rrcgpcwqBeY4I5Skh1WlsEvhYmFKkN4K3MfB+TKSczz7qZws7obgylk8WLfsU+c1p4HnXsbYG52FBQxAFpx4Fkx8KSkhC8vg0o3TlsL55eM1qseTj5y9YrZfoQXK380S1QEhBCIkYA7/zBRtiAAFzrEFtLiZ01uyCw6JpbIPVmhAdomhSgm6lwUg8gvvB8fo4Ynziold0UuIyeF9oZSBJwZvdiUBE6sLTZctHXU+PISfPHAJ75yins61ccuhcEzRdSGys5D4H3h08ORXk2SO7pVLdnmrLTzYr7qPnl/sdnywWLJoFU4C18iSZGcsPTP14xN8LSitMZ+hXPev1lr5fc3H5hMNuR391ybIXTPEND0dPQiH172pgdbBISTIRmESixMCcEnOqjjpTDOQS6VTD2ihKiMzJ47OhaRTKGBKK0xx5vT8xzZ5Fb1E5M0WYk2AhQUjJYTrT0Epi3Vied/3va+DgE5ObEUpRcqpuFiGSQsClgKE6kv374UDI5zA7UR+8RmietoWPuo67EPib4cjHi55Ft2BKiUtdsChO5bEGfggISXU7UQknPYd54Jub73l2u6VfLLhcLYi5YXh4IEqF0C0lOHL8T/UgpUTImVPwxJRxwdMAw+CxVrNsFK2u7jk5V4s61VQaRxKKhzHwfhrJPrA0zdmuNTIGwcqCBw7TXGkPObFpOp4sGxrqFn7MjjFORFHYllID31IhxUqZBdiFwOv9RMrUHB8kHRIlNJuF4rPNirvg+OXugeerBdtFz+wLl0XSSsUuP3LKPhSkrFrFnBNCCDYXFyRm7k53tL1l3UCWkSlEglIUqQk5kXP8z35OEjClUgcHOZOlwAWHSqBVi1WKkjwyQ0ogmnNPWRSHGLnzAU+kzzUjac4Fl2EhHAHFcO41UymsrGGjG3Ss9N6UEt5HSqnD3ZhiNTQomZAr994R+K1zkDOac+6KqmdwbeC6bxlj5O04su4a2kaRUqYByOI/C2j8/4UfbcPv/Y6UCr7MNAtLFwSvH15T3hQ+WcCm7MjhDmwV8ezHuXqgZ8hFcHAjs5Z83K6ZYiLEyKKBpjHEKSPJjHFmjAUdFdddw713PGsrn/DmMPHL93uUkqyQXFvF1aLhetlQCrzaTUSgyZnkI1Io/uLiGfIcJS9yRiTBmDwPfs8nsUFpyZ2buXOOKQUWSnOVDbOEICVZVmHcdduCKvziYsmzRc+cM8+6nqt+hdKSy15wnCeOSVAex6sfDKf5wNdvvmUOB54+vSClIzfjPermt1je8txMML/FWI2Kkv14RBSBRlIKDG4mWsNPln3l8bvIpZX0SIZRk0XhyEDyGVHgi4sVt+OJp90TUFXY+9cvb/AknsmeRgkWm5Znl0tKKbx+e8dA1bvIqDFC8+nVsmbwpQaSRheFKjNvjyeaWIXnb73jbZw5Euiy4oVsmEzByUQUhUYbLtsFXkT+xdWWZ5sNvgh+trxk07dgDZebNXfDTJom8qMt5wdBu1QsVx19v8SYmrHw+ed/xmvzK8L0nnC6Q4cdrZSMWrEfp9/XwIIhJo8j8Vm/5RQDU/IstKSJMAOExCHPHLUgk3iG4TAHPrro0MJyf3D89dt3JK24kIJOS7arhm3fkAt8f3siUqlkLhWklPzTq6tzBiTVe5pM8pl3xxM5VcHcuzjzLjj23rOQik2GhkzRgiRq8MxV2yEV/PnFxe9r4BfTiotVj1aWy9WSg3tgiunx/H0gKKr8O+eMSx7dFO6PN/zbr/4da+O5uF4j/S1SdiitGMaZHCslR8nMGBMR+HjzlCl6fJromoIohrcpUArsx8B+ClAiz1Ydo0tcX3QgJHeHgb+9eY/StUb1jeVy1bLpLQV4c5iIUaJKJKSEFZKfPn8CQE6alDIaxYTgdjyhU0IIy25OvPOeQ/ZcSkOvC32p+RSxVLrcigVJCv7lky3XF2vGHPl4teGqX6C05slmwzc3nsnFqqZ8xAdBLoWbt18x+YFus0XkxBgDTjywOUZWriDTA0oZmgj7MJHPNVAAQ8zMWnPZtYRQz4lRknWEGy/BZE7eQRDonFn1tlJYm4aC5jB4Xh33AKyRWCtYdpp1W8/g7egr5SsXZCoIIbhuFlgAVY0TPFWfd/KOLZ4sFGMKHH1gCIneSHKuWoGoMpGClILeVsvPL/qWbbcgZnhmO/q+Q0vDsm8Y9ydirIYiPwQ/2oa/Xyx5mN7SkPiT68/5b55/yu37A8ev/o6/mk6I5Gm1YLEwhKCxqir3xzlzOs2MMfHFxRKpFWJy3M2Zb10gZYde1OZIZIlEsDAaMLQpM7kGTWEtEn95veRfPzwAlnRKSBUwRvN02xJvT4w+4Hys9mUy8/Z4ogeiqlsGHwq2FK5kw9HDm8OJ76cBlzNrbViaBg3cJk+SgkgmJ8GQBAsFPikOXtAZy6cLg48R6FhvOi6C5xADd9OjS8+HwtpIltcLjvsD4e1bnrYtf3HxCbubl/z6m2/4dYpoJdlulsSSsNJSUsa7wGGY2E2BL67W2LMe4zhMfDMNeArXixVLK4g5kYtifRbudlhe3xxpjGGpFP/yoy3/r1fv2c2eSSTkwwkrBU+ebBhiOutBIjELdMi8fBhpEiR5QlNFjyJHPl1ekMPMr+8PfDMMxFL4yHR0UrJVmtchcvKJISdmCjc58nEHTsAhRFpjueo7hnHCtw0Xy56r9ZIhBB7uHyf8HwLX19c8e/6M1mrUuGP69t9y++B5//4N07CnZEdjYLtcEGOkkw0pB3yOTM6zc5EvVkusVhQXmcbC29HXSVXXswTGEpnJLLVBBM0Wxcv3A8bONErxT59s+Dc3tyTV8GbnyFHQoHh6tSSyx7nAydd0cpkF3x4nejQQf087UwWe2ZbiMt/MA6+HmZAzF8ZgETxRDfemrt3HlHEJTmReKM2QCod03p6aBhccCc962bH2nlPOHA7DH/qj+qOE1qBb+MVPPub/+L/7r/nZi2fcvnrPOD4Q3u3567c7pChcLCMxVipgoRBC5DBOHF3kk+ttTYceYBwzN6cZR2Cz7Oi04pgdjlyF21i0Sry/HzDm/8ven8TqmmXnmdiz26/5m9PdNm5GRHZMZjIpFqtoF5mmiELJFATBkGGIk2LBIwvwRJIBEQIMwbAlTsyhZgIMW5DggQbSwIABTWxRNsoiyIKKLlIiJWZGZkZ/m9P+3dfs3oP9R1BVMlGRYt7IJu4CAoi4J+45595vnb3Xt9Z6n9ew0JqffvCA37t8xoxgDOFo8rXk/HRFvD0wjhP+6EYqUTy7m7A6kYrApFTvzJx52HaklPlgf8PTYQc58Ui1SARPbMuNgOkI9wilsFWJxyh2IWCnyKLpeHPdM88zISW6RcdqsGwmwbUff9CP6sc2tsOB09MHpN0znn3nX3I5TXxp9YTh+prLyxe8yDNaSRaLBSpFtBSUpMgh4/yE95Enq56sBaOAaUhsD46UE13b0WrBlCtQo1eahWoAx93WIUVESfjcsuOb24EewGVG7Wms4GTZk3YT0QdCqZo6KQS7caqFtVJI6ksGGVZKk3Pkepy49R5RBPdMixCJ3mo8mSFCyBkopJzpZSLkjiFVrelZ2zDMjqQV67bFOY8Lntvxk9WBP7QF/4vbp4RyoNeKdNhyN0/c3dyhYsZPMykFpJV0tmHwhcknpKjc513M7FLmiVZYbembSgwowH7OfGFxihEVmxhzogiBC57XzpacXzxgnkYOKZCLYC0N15NHG0mIdZ0mBkUrLaYRyMZSjmKekgUbNzGjWEhJERkpC43SHJgRKiOEYKkM96whFcHSKJxMbFMmURC6IGTCZTjpNGsr8THxbJi5cjM/aeChVXRNy7pNdIdX7YWXFW+//S8Zh0tECJw3S55eP2d7tYc8M8+OGCPLzpJzwgfJZpqRopBjYj8HbqPnDaVorKE1iaVtkCVzcIkv3DvDSIkPgRAjWQg244Evnd9nNw6UUlCiYIXkcdvwR+PImbWcBY1zgRgTC2NYWLhfWlIuxCIQRbKLE7s5cWaqWZGW1cBmCIlUMrlU6tT5kau+UoqTJNiLSBIZLSUZuHTwUxdL1k3DFALP9nueDQd+ygratqFvLWd9x83+1YX3MqJtLVplwnjD7sW7zFc3PL+9RcSAG0dyStjOENvEnCSTc1AKKWUOPnLrA0/0CmM0C1mNs0iSKUbeWJ+ghcCFwBzr7qtPngfrhsM4IQClBKpIzo3h2eiwSrOImiFEQsm0xtKiuOgLIlezpSAE+9EzZFgZWd0wgUbBnCIyR6QoLI3hVGvmEOlkNbcZQiCVjFB1zfLaBb56fsKJtbiUuZwHno8zX1GKpulYNS0nfeDmFQf9pcRiYXjzc2d87Y37XLQGt9ngpx2NUMeOfaBtqiv8HCXeeyQQQ2Q3Rjaz4/GZpDGG1kYWjaGkhiFrPnf/AiUES+dwISLRDDlwYRq2qa5vKClpouCBbHk+jiilMMHgPZSoWEiN6i1GmqPJbxWN76aRPZqlkNVRXAmsMeySI5W6+rA0DRdNxX4bIWiE4FA8IdcGXtaa65z46qJncVzDuD0c+HC/5SfUfR4YS9d0rLsl3asXzpcWjdXIHEiHPcPlDX7csN+PFB+Z3UTOgb4xiFTPwHn2FcqZCyFJhgT3hKFVhiQFnSmohSSVxKpfooSgCxXwgoAhR1ZtzzRnONKpSi5cSMW187Q6I4Kg87AICiNBNUdSTimVbJUFhxgJKdNKQSl137+TkjEK8rEWNVLRa8McoQGiEHB0Ay5U2MGMYNF1LIzGx8jNPLPxjidSsjSG1mh6a9Dyk005f2gL/ml/i1EZaQwDOw67geJHXFI4H+rtYhQ5g6JwNcyIkum0Ztm1zFNhjAmtC43WrG2LyhIXHWvTVMe0EvAps3ee5/7Al++f06TE4DyDqx9bo3lePFNKTD4yDJ47UdmwMUBrNRJBjBmXq3AtFMmcMjJnJDDESK5k9ZpAFKaSiTnRioYi64Upj2ilIuposWs0Vgp2c+T5NHHjHJ+PmWEKGCFZNYbWvBKsvayYNldMu2t0gbDIbDY7onPEnJh9BDLyIzoJcHUYyLmwMIZVt2ASkjFl2izotOast7QKUvEsra2dr5xxIbCZZ94/7PnZx29ipebODezniZgSF9qQOJIqJsfWTLR3BiMNISa6pu7bh1CYYiZT7d+HGFCiIBGM3hFiIf473/MuRaYY2QnFXOoM1EiBEpIsElMBay1SKYZp5Nlw4NZ5co7sxxElFIvWsHhFSXkp4Q633Ppb8rgj3t1wuN0T3A6ZFc7FI23aVrdnAZfjSEnQK0tnO5oAc4w0xmCUYdlU8X+ZYWU1QghEKcSY2TrHe/s9bz68T+tTFYPNFXV3KhQfxIpgPDjFbvDcbkZaqZhJdMagEIRYELFUCW2GkNPRIVcwxVCNi3IdeyPAlcKYMpOAWGreVqMniAJiKbSNRSnF6D1PxwPXc+DL8YR5dlhZ3aUX5tVa48uIn3z9Pl94/T5Pzk5RIbEfD5QUSEXhQ6SUdETGSqyBq7sZcsZIjbE9JiRG55Fao6Ss+OEOivcsTFvzIAtymjlMng/HLf/Z619g5RIuRabkyD5yojTv54wsmdkFpslz2E0YaXC50JsWKQoxR7wrlOM+vxcFfTz/pmNjxRHrHVwyc4rMMRFFrjS8ko63NEDCAba1aC3ZuYkP9xsuDwe+fH6fefIoKVm0DQvb/GAf1I9xDMMV482OzfP3GLZbxsMW7ydyAhd8FWRLQREFJGxHX32SjKZvGmwu+FhQpmCUojcGLWGOdbOjnoFVwznFxMZ57p3eQ8eJKXmmkEgp00vB5dH5tg2JcY4YMdemXawuz5LKz/elmtZFCiEXJAVKwedUtaSU6vhLYs7gciKgCeLfOQPJIHJFwhqNEgJ3LPjHEMldYQoBISXd0fPpk8QP7U1dpqnScpIgFMf+4DhtMmOoI0MjQR7xhwrY+5kYCvc7yaNVQwyRu2mm0aqyyKUia4vUAXk0c0lkBu95Pow8zTNDishhz2Ec2M6BmHMV70jJmBMb72gOBeccD0470hHdhKgSzZChFAkZxhQxUAv2ECilEHKmyMKcMy4VLHCXHZMoFFHNTSjiYyFHQeBjZuc81/PEISZygmGKLFtNbxV980P7CH/kIx5G5BRRUhDVzHCY6ZvEYa5+DVbV3JhDnbLs3YTzBb1QvHG2IBW4HmZ63dAqgW41gowKFTMIuZJU/MyL/Z4r77gLnrPlkhQct4MDCidK0UjFFCKbOXAtJ0ou3FufkmIi2II5vi7GXEgZLDCEgJaSXml2zkFMhJIpojDkxOALPZKnwTFTgEJTLXYoVNFTKpnRe+7miRs342N9MR3GmVXf0VnDorc/oCf04x2b5+9R/AEdI73U7IcDWkVmBzEllKrCyphTddGdZlIA1Wkerjq8y2ymmc40NFrSasVsBSKBlPUlIZMZY+ByPPD+cOAQMw9Mw8EHdm5GCEkvJFbAPgQOUrE5zJQUeLBeMpZCyqJyr8mkXA2yLBBjJEvQQnIIgRgjcz7u/OfMlDOpJK5SxB1/HYBSCKK+RCcq0WLjHS+mkSmCQDK6ib6zLKxh3bzKv5cRX3/jMQ/unXDSdhAK0+jQquBcIMeEUpVkIqkTnMF7ko+s2o7z9ZKcHHfjAWk1DZUuEktBp4gsEnHUXvgUuZkOfLAbOAjFWmvm2bN3E6IIuiPOcM6ZOQR240iOifPFCaJoChpEdQSOORKyrOtkKVJkFYAfnCOGiC+JUgpTCkwxILNgQ2QgEksFG+fC0cSz6gFDDOzmkcthYHD1e5+ngGnr/btqX+Xfy4rn7/0R8+YFbntHDoFxmFAy4H0m5YzWot7PJSEEDK5269d9y1m/YBkjOz+jGioPXwtCKcRcPtaoCAqxJAbv2fmAk5KlNYyjZ/QVwNEqgZaSkDNzTOxnT4iJ866llELOEoQgIwhU8a6AI07zeGemREqVqZ+p9eCcE6IU9kngZc29j6ZV+egbkXPBl8wYAvsQiDGDEMwh0hhNawzdJ3zp/KFtD5e5EA6OPEUspqqwc6JET6cLvZUgYecntn6ulPpSBUY5ejoZuZ5GxmlG+IBOqaKbSiBlTy6emD2HNHMdRi6M4V88/ZDL4jhw3IsWkIRAoRlz5Dp6PnATHx72iCw4aS0pFsJxVcKVwpgVYk6MY2KKhagkUUqGlEkFnMgMJFzJnNqOZ8ExpYKvcEVMqQY4Y4jcHjwv9gNXw4GNm9k6T8gFR/2+Oqu5WPY/6Ef1Yxs3ly8YNgNpzgg0uxCYwwE3OzolOG0NLZLdNLKbZ6Soh0IpiRAmdPS8t71jmAeMCDSqdt61AlUCugTIkTl6tmHm88sl/9XT7/B+dNymwiEUlLJ4rdDUroEThU2OvLsb0DmzXmpCqkImX+pBMwewSHIsldZ1pBfsYmQqhT2JgYSQhYddz+WRX51yQZSCLQIREzlE7jY7nt7c8Hy7Y+MC29kxFkFSiiIErW04Xax+0I/qxzJevPs2dx88w+8PKANzrj4Jm9mhRGFlBbIktqNjNwdUEsicyclTYsCSeDEOTNFjiqfJjhBi7fJHKLGQQuDgJq68437b8F+//wHPrWarNXsXybnSIiwVYXeIiSs/8952T0qZ07Yh53oG5gQ+JTbJY0qpPiIZijyOp1PlW/ucGVLG58LaKt6Ljm2ueLlYCgpJyoGQPNv9zM1+4Hac2LnE7mic40RtiLTGsF50P+hH9WMZD07XNFIgckFIhQsRFw7s5z1awNIYRMrsxonNMFYOuRDEHJFxpkVwOW6Y/QFbMp1QpJKJDUgZkSqRs2f0Ezs/8KVuyb+9ecE+DQzFcSgJoVqM7eitpkjBQObaz7y/2ZJFYNUpck6EmMhAEIl9iLSyrm04MkGBV+BSQJZatO1DZB8SxmjeDZ5Digw+4HyipExI4GNh3M1c3+242R8YvWfvM2MuzCkjSqG3hvVy8YN+VD+28dbv/jbv/9tvsr/ZoESdGvqYmGOhFYq1MsgE4+SYXC3OBVBipniPSp7reU/0DkvEiFRJesfmQimFnBLBe6YYeGAbPrh7zk5kRlGYciArgVKKVtWmmiuJffLcDBNBCBbGUFL9vnypTYo5FTQZXzJOQFKCrCqxJxcIpeaQjwUpNbd4IpmYKslMJAih0n2mYWQ7DgzBk0thzJmSq7euRNBqzbL7ZAX/D217+OL+krvJ8XQ38/z6fb4177meHCet4s3FmvutwUfHmDLJ9rRac2Kg5My/vdpxb2V5Y7liYQxCV/OFw96jpsI3xz2vnXUcUqQkeKPpcAVGX/h/vf0OS2O4ZxtOjSBJw9KP3JMLBJByYjKCvu/oF5b3L3c4lyipsHcDp1ZzHY/plDJxityMhSsmbuLIMmnO0Vip0BJe71YkAnexvjAUAWfG8sG8473Dlk4L7ghsREQoeNRbhLb0jaxrP7r9AT+pH9+4f3HObvZcbQ88u3yXbx0OPJ33nPUtXzg545GEyU24lOHsIV842aFz4BAC//r5DfdWa/6Te/fotCbE+sJZUuFxe0ZK1fgj+EpzemJWxJhJIfH//IPfZ6UNr3Ud93pNiolGwZNujdGKJI7GdH3Ham2ZbgfmuR5kL+Y9a6sZvSORsVmgQmTwhW9tJz5IA69Jy+d0hymSIXi+3PV4CpfeMeWMMIr7XcdbhzvenjYspGYTI8/nGQQ86pcIoLOWDDTiFSXlZcTj+yfcDp4XB8fNt5/zznTgve2Ok97yWt8TsYyzwwOPv/RTfE2+IIeR0Ufeud3T95KfaNZH6/U62Vkqjel7Jp+xirqaFjOPlSWqjPeR/8cffZOlUjxqWzoLc6oX1pf7ZZ0okNHK0q+XrJaKDy8nxhjxKXHnD5xZw35yRECVurYWS+HaR/5o3HK/6XldtjRCkkTiC+2SKUc2qa5XNAoemAXvHba8Ox5oteA2RoYMWSfuLTo0ikZrQhEY+eoMfBlxdn6fD65eMN+84N5i4ulwy7fvbjnvel5brDlNIAfHHCPfvNvzC29c0K46hjnybLunX6z5iXsPWOgWmeuLgFWZx2pJ8AGjWmZfCKFwppaoXpDCxP/76S1LZXnU9libGGLBFfj8YglC4ksVFJv1ipPFgqeX10wuklJhngfu9x37cSKkTJc1XZHMxXM3Ov5wf8d92/Km7bBSg4CF1YzJMevqN2JRnCrNC3/gnc01jRJcTzN3U8aXwsWiQwCtVaQCjX7VdHtZ0beGyeqqC3r/mvfcnptppm8b7tuWVSyI0ZGRrL/0U7wpn5LnmdEnnm0P9H3DF/slVsojurVU0Ia2pBjRWhOzICaNpTCTSaPj97Yf0krFqbWsVDVtjVFybnuErpNRRcE2llVjud4NuBiJKTEEz7oR7F0ipYRRBaUFlMI2RZ6lmU4q7mtLQ50MnHWaKRf2eEoBoRTWaDaT5zo5Gqqj+c77urbZ2Ipt1tV3RfHJpkw/tAX/1fUW7zzTHEhFsvOOxtSu6sXScK+1GArJRZ4fJr7Qq2qtrCTr0wULrdi7kcudx5WIy7GaLRhLRLGZAhOREfBF8BPrnt2UWPZLGqEgC+aUuJoOFGAUjlZYGtFASXz3+oaHY884enIGgUCgaTGc2QzaU1LlnRsJj1THFGNltR9NHhZW8NXlCUol3t6P3LhAKgUDNFExp8IUMmOApWjojOL//s57fOPxfT6XF1ilWcpXph8vK168eIFzM7spELLiLntOTMu9RcfFwnDRWTrZcHWYePfyBV/sJSIHOgRfOD2nbSybccftFOCo4pBC8qhfoXXH5AN3IXIbAkJIfvJszfV+4mtdj9GqYutc5Nl2hyqFjRs4Ez2rpmXMkbdePOPhtGDvISYgZxZYtILGGjY5EWKofhQBvrhYMIRESYIdGZnhvOv56dNTAL6923LpHAmJQrFGs58jtzkwhsiFsrRS83/7zlv8pw/u83kqvad9tcP/UuL68pZxdgxzpKC4CjO9abhnG866ltOuoVey7j8/fc5DM5JDRGTB2crQqxbvB17sDoRj0V2U4NFpQ49kTHBAsAeckPzEasndYeb1VUcrDVoqkhRc7ze0UTJTaRJr0xBF4ttPL3n9dMVuqJQogaChAQ22kXU8nqspzKlUPOwsH4YWKSSzyESRsVby9f4UgO/u9lw7//FUoZeGISQ2PjLFxFIZjJD802+/zc8/fsQTtaBVmhPz6gx8GXFzd40ODlsyc3Tc+cCp1dyzlnWrWXeWVjRcTzMru4cAAY8ATldn2FZQxsDVYc/oHD4lZGN4cnGB1ZHoJXOCsRSiKXxtfcFunHhtsa6mR0CImZtxR5skwxRYNB0ra5kIvP/hh6SzJYfDTIwSKTTQgc4operaTp5JKXIiFWd9T+MnUJogJUIJVKv4en8OBd463HE5j8RcXZ2XUrJPnruQGUOkNZJTafjnb73Fn3l4wSOxwhrD4lX+vbS42x2YZ0+MkUYrppTpjOC0k5w0hhNjsapwO0XuXryPLh5CgCJYdS2NNUx+ZHvwuBxJOWOF4eLUooE5K8YEnozRgnt9zy4GHnQWIzQFSUiZ69EhU8XTGqPRWpJL4endBt/37EOEDLK6zwF1yu5IlJRQuWCkZmUb9BQQCLwoJFFYmIZHbQ8EXviZXQikXOixOBkIPjAdNz9aoTBW8PsvXvClsxOavsFIxfIT5uAP7U29G2emFCrjlGqIIbJgDoWQBAVFORa7UiYOMaGraws5RrbRMXlBloleK+6ZhvZUszkErseMjzCLqpY+MZZV07I0mf3s2UVHKIUsFK58tJcKUUWULCQB390NXLtA8lUUZJWkV4UrN5GKQAiFJzKSMK3FZkmjNDFVYYYWkiZqzhpdLZe1ZhM8tyEwuMRaKm6dR4mqB9gFxwGBlvDhfuBUa9ZCEPMP9DH9WMdmM+BUZBQZITMiZIqWjC4yhURsMgiFVAs6dWDrPYY6ossxMaWRwdVdwXVvOOk7+kbjUmJ01eFxipE5JU6NZdF0tNZwO3i2gycVsEoRc0aqKhQ5ZM8cas69c5jY+EQqIDI0QnJqDLfjTD6ax3iRGXLtZCw6S+MVmoIQBa0K95Xi3DYg4KcuLngSAhvvGULkRGs2LiKEYIqZXfT0uhAmx9NhwbltEVh8eNXhfxlxM0wcvMOnQiMlfSnsRcGXAllgi8QKSVaS2e248xld20NkCc7NICSHEFkawYOFYdW3xCQ5hMwcIgfnmY9GhKvG0ivF4CNzisQcQUimlMkyU4Cp1CIsStjtD+xTZk5VT9VKxVLLysIOmaZIYql6kcbUXeoTbVEyV78SIVgJy1nTomTt2G+cZ+MTMcE9Y9mEGUHBpcwhJWwWbHPhg8OO08agrCSGVwXXy4gPL68RqoqsV0nSycy2FPYxcpJAoBHHCmJpW7bzjAWE0BQifoyQJD4rWtty0UjWy5YsMlMQ+ODY+wmXA+vGctJ3rBvLZnIVwZlqzo0pkWVFFY7Z40MhkXnuA0MK7OcASdLJhpOuZTOOpAy9VISSGHJASYFWilOjaYVBiIrBvicazpYrpEroTvDA9dx5xzwmpO3Z+gQU5pwYQyCrxDB5Hg1LTroeJRQp/sl/h6/iTxfzHNn7qTroUuiK5JAl3heiyhQFUiogE6eZLQmVE0JKZM4k58lZkMsRZtAq+sbUvMq5khqJIAudMCxtJd9MIeBippRMEVXT8dEtF3M1Si1F4id/NNyqm/oaaATsXSBngaFqm8aSackIJemVxAhxrGthIQQrKwCD0op1jIyxomUXSrGNkXwEG4QUyUky5cTd6Fhrg7AKnz9ZIfhDW/A/HyeSrKKgXqr6gzx7QhG4VBX2EUEqGSsl12FmrQSawjbUn8ApCZStODpXCjYlfCr0bTXlaJVBSoMsglwklMyd84QjFsyTGEpi5yONlOSS8TkduwcJqSSnjSWkwpgSK2sqiQJYKkWjLFjBorF8uJsYc2StFL3StFpxaiSNrmJdJ0TdLXSBkKDTminXr4Gou2CCuqF2OU28sVrR2brC9CpeTjzzM0kXpBAsleKss9zFSm8KIeJ8RFsBSKxW3LiJtRRoEvtpRAnJznt60xB9YCwBO0tK1vRak3LmtDF0aokqhhQlSQhu5rprrYXAx+rofBfrXqqMoHKhN5ptTticObMNc6irRGdtSw6CoUTOrKY3GhpBbwzXs2PwkQujWVvNQmtWSmKOe7qSKma7dTMxgZUaJQKtkiQEMRZmEjrB5TCxX0UWTYHyKgdfRjwfJzwJLSVaCqxRyJQIpbKafcpoJckCjBBsfWKpQMrqPkoWJAkgQEKaA9uQoSga3RBC4ERL+r5FIIixNjZuZkdMGSkEnsxcEpsQ6GR1a5ZJ0GrDJkeamDhpLD4V5pQ4kZbg62rESmkWUqGV5MQq3tmP7GLgwiiWWtEoyVoJGiXRQhCVYoNgDJGUqx5G5oKRsl52JUGWpFx4dph4fRXotCW/OgNfSgyp+mtoqWhyBQ3kAiEXQkr4GJBKIaVkYTpu3YG1FFgF+3FAlERSClJByYITAjcWKB6jWkIMrBtDq5dYJCHVkup2mgkxIyjMOTCmyCG4Ct/IARUzrZLcBo9QDcumZw6RKQZOZIdPglQiS23opQElWVnLe3cbtiFU0IDSGC1ZaI21Ei1gTho8tdjLGYlEkZBS4BG4WAs9geLyMPJ4vaK3zcfi41fx/Y9dmJlLRFI3MaTMlCJIWRJjwauErMcbikr9akW9y3zwVBJ+RghVTQJjpTeJGCm6un/3WtLJFpEqVYdcyY05l0ofK5XiNKaEkRKRCqIIrDBMOaIV9FYTjvqkhVQMofKeeq1ohELIumt/Oc/MMWOtppUSi6SVAiVAFIkS9fdNqW7oKyUggRGKAsy5kEtGCRhcZEoFU6gCv08QP7QF/ws3Y4zi1FgaZegbxZVzICCkyOA9QlaKjZWaq5AwSCyFrQvIotmIiKEiC2UptEKw1g0PVg3BF86aOhLfzBW/NIXAtXP1ISjFIXqGEhlSRKBIWSCEoC3iY/rJg2XH3gXuJofSBpsjY/I02nCiLK3WtJ3mvd3AnBP3tOKs0SyMwqh6SbYlcz3PvH8YuZwcK2NplGRFwWqJEJqDqTvgC10FzHOuUD75qth6afE8JVTJnEiN0YoHS8Pl3YZyZO3Pvq5g5ZSQVGF2g4SS2PtIIy1XbmRZBDkkKIleKM5shz0VzCFwr2tY6AWbITL6xDY4blygoRZuGzfjRGGbMqVAg0AowJS60tVYXlsuuRlHrvKIspo+t2znLVY3nNqGXhlaq/lwODClRLaahTacmYZQCnsfsKnw3A98d9zzfHSc2p5OKM6NYGEVTZKMORND5oHSuODxqaI8tXiVgy8jXjiH0YKVkgit0EUhSjlSbhJDDHjAUWiUYVscDaBK4uACAsWuRBbacsiFPCdkyqwby2vragJzv7V0SnI3OAafGcPM89FhBXRSsImBKAW7kEAVlKAa3QiLUobOaB4vWrYucDsHlFI0WA4iYI3lxFgWVrGwgn+z2bMJnrVs6axmZTWFjMsRkSUb73g+jTyf6upSJwVrpWmNwkTJGDMpCHoyg0tM8SMaxqv8exnhdAVhiOMLZhbyyBAvhOiZnCBkTc6FVlsux1z1PCUyOI+ImYOtGqVCQTrBYjYspeV8Lck5cL/raNWS/WHmMCXmNHE5TFgUjRTc+ZE5FzYhgZJYISqhT0mSKHTK8PrJKbfTyOVwqHvNVLfUxmgW1lYTL2v4N9eXbELgVCXObcPaGGIBF2cokls38+wwcHkYscpgi2Jt6ouBAoa5NgOXSA5uYo4JEB+vH72K73/cxREh6npMyJksK3YVBDFl5hgJIiOLwCiJy4Uka75NKWCKZiQgpUWmghIZ4wQLFF3fEVNkZS2NUAzOMcZI9JGNc2jqBHUXHF4JDjnSCokqAl0EVmakKDRScWpNJd+Fuk5mlWIoEaMlndYYqWm04v1hYE6ZrhSWQtIITQbmlNBZsEueGz+z9YGVqpPPXgoaaXAyEmTAp0JHnfyHUqlosvyIF/xHDTUS6NFYYXA5kEsVQB4mR0gFKTTLxrDQtjqalcKZ1sQs+cAHSgx0SvO5vuVnzlcUYBdjZebnQpLgUyEQeDHMxFKQonA4MlnRhZNWIVKmE4ZGGpLKvNEvWTQGkyU2wqIopDGcyMywT7Si7pvmnBmmxEpJHljLvhRUCORSuMkTY0g8tIZ354G7HGibOgGYUuaxaVhbzQWw0A0vdgNf7BaAoJUgyZ/QUPlV/IdEThXfihAoYWilIOQqrHalsPOB7D1GKBo6uiJICPLRvTYAuxBw4UAnFZ9bLvi5o/X7dZrxseBDohF1T3BIoe6QioxUBlfgeXBcNA2P244YAp1QdMpCga+tT1g0hkYqltpQmg5jNSdKspkPtLJ2DObsmSfPmTI8aRvGnLkOiSIy2+S5nCKvdZp33cg+Bk6sZm00LmXumZaFVZwBp7Llg92BnzlbcYiJhVK1s/IJD5tX8b3FmCPLpBFFIqWl9TDnib4IfIpsHCTnUUpyoiVaKxwFnWAhJEllxtkx5kQrJI+6hp++X4lKA4UgKjUqHunjMVWDv1QKUUi2uXDlagf/XmspKdBLRacNQiu+vFyxtiBzQeVMK0ArOO8abvaVUS2BOURCzjxuLVeuZSyFmxhJQnDtAkPc8lA3fHs6cBM9jZH0R13IqdScGM2FgYWyPB9mvtJYBqCVx/x7Ve+/lLgeHUtlaDTIVOiUZU4HuhKJwTGkSKGuyjS6Y20aEpVDfqYUM3DlPDlnrFY8aBd87eQBACMOTzW+jKJiFVP03OxnZK5eNPuYuA6BtTacmw6dAwtVYQGi0XxlteCsbWhkoRGwUIbWGJRKTM5jj/nxkZjy9bZn0wXGHLmJM1kWbudEiJF7fcfbw45r77DWsJINKRbOW8vSWi6axEJZXmy3fHV1ypwznQapqGzcV/FSYjMFeq2wRgEVa51zopRIyjD4QvKw0IZGKUwRuFRXZZYICnCTMiYGrBCsG83nTqrIf4zgcyHGak4ZY8Wh380eTzn6ISU2KdFoxUlrwdci3hiDEJrHqqW1BikkTc6UXFHdy6ZhmlOFZWcIOdY8k5a5SYSU2BdB1oKYEzsfOLWGF2lmnyNGSTqlAIWVhVZJshQ0YsGtn3mzaXAozBFv+0mPwB/agv9eY9iVxLV35ASLUdNhGVziGYHOahTwWlPoFQzzzFI1dKYBCnduZI6Z19qGDjhRkov1EgA1TLgwMcTIGBJbH7gjsiMw5Iyijo+vsuPrZk2D4U6MlFxIlT1BIzVnXcvWjdxmz4EMo+Pxuuc1DJTCbUyVsGIyY8o8MRZKYS6J2+AoSvK+n7iNCWsUnzOVgS6TrDbg80gTqsHWqpFsGvgfPTwHFNYaMpIhvxonvqy43ypuU+DSR2LMrItkrRSD89yhyVahhODhsqMBDi6xFprONrQNXE2BnDJPel3XglrF6XlFCKpdYhpmxjnhPOx84GqaCGTGkJjC0V4bxUPZgFRciakKgyjoI1F3bS0bN/PCjey8x+/hS6cnPDo5IZXC9ZxIsQrOnI+8aTuKhrEkbsOAlIJneWY3ac6M5dxYCgJHPWDfHQe6VA8w1ShML/naw4d1n9EashCMvCr4X0YshcKLyE0YSTmxkLLu2MdMozNZVSzbfd2ytoZn4YCShs5alm1mdJ4pZB73hQ44s5qH5ycAXO8O7HNmnz0jkp0r7POMQjOEACIjZYURXMgGbSTbPCFz1T1FmWkwnNuGvXPczIl9CLRi5nS15I1uSaFw7WZCjiyMZucjXzSWWAqHkrjyE8Uq3pkGnsuZvlU87iwFiY8CcuHKT9xFQ2MtwhrEPPP1J48AMG1HkQqvX1X8LyNsKUxxJESHTwuWpdBjcCGx14ksBVJI7jVLeuBFymgtMdpitSK6A34IXJiWVkhOjOHkeP6xi9zNhcFFAoKdK4wcKAbmkHGxGhxqFI9sB9ayS2MFc8SIL/DYnnDWrzi4gatp5G6e0FrxaH3Ooz6TyNxMVSy8bhucz/xEuyQC+5K4CR4lC99ygWdxZmk0b/YdKcN2KtgsuPWRIWWMklhrEK3mZ7/8OjlppDYkJGN55Xb/ssJIQSBWRHUSLBH0SHwKDLpuYkghaI714OwTSmlaqasXSPrIOKuurjbGsO7rGci4ZR9qdz3GzC5lRpUpDeATQ4qkJBDAGZoWycYIKJniE1kJstVY1eGjYxfqhCB5wWnfchYbKNW/JOVCqxQ5Z86VpaiMp3Cg+vwMPjL7UJ1zdQMIUn3/YMoZVyLCCFKvMELy5OwUaMBWd3NffsSNt65HRzCCtTFcNJY5Z4bJsdANYwxM0WOV5EG35MPJ0ShLVoJi4fV+waPUcjh2KPcp8t4U2H94xX/66IJv3e64C1WM2CpFZyX3ouCb08BCCqYEIPlKs2YXImNyCC0ZU8JFz9o0lGHg6TjiiiCJjC+Rdw8DU17x81/4PEYpnm82PL25QyXJTyzXXB4mhjCzVJoz1TBGwb1lx0opTk9aGqPYzo5//v5zztueNHuunWPOhS+t1vzi+YrDlPnQDyy1RQnBwbsf9KP6sY2n+5FoCqfW8qjrcClxNQycYbgLjtvosUrRdR15mlhIS04Qs+Dx+Qn3+sTNNLJoGg458e44cPftd/mzb7zJf/PsmjFFyJJOGU76lid0/Nb1JUtVmeWpCN5oe56Fia2PSC2YciZkOE2W6faOq2lg8rUImym8dXjGlGZ+4cs/gVGaZ3cbPry6paTMG+crng2e0XlOheS8aTjEzFfOF6wVXJycYo3lbpr55+++z4N2yS4V3t+PnPjEV9cn/OKD19j6iXcOe07aBVrqui/+Kr7vEYEoJEtl+FzTMefId9TAQ9Wx85FbH7BScdYteP8w0QoNRYJUPF4vkTFyPXmWQnHIhe8eJjbvPecbTx7wzs2W2+AqWUdoOq24iA3fmm5odXWnjEnwxLZsc2QfPYg6DU0lsSgFIe7YhpYQIjHBBPyLeMXXk+PnfuINjFK8uN3z4nqHyPD6suP55Ig+coLiXCr2IvHgZMlKWc5POjqr2c+e3/zgKffVgikIrsPAsgl88eSErz54xOgTH8wDq2nECsFh9j/oR/VjGTEkoi60UnAhBENMXKU9j+WKw+i5KzNWaVb3T5mOJpdSGfqm5bV1S4gdWxe46FsOMfFsPzK89y7/0aM3eXa3YRM9AoeV9YVulTq+dfOMlTLkVADJF5Yn7IeZq3RLklW3Ugqs25a39jfc5oHZeaaYOMTC20+f8tMh8J986Qtopbi8u+Py6obkAxdna3Z7T/GRE6E4bQwjgi/YBatOcW99Smsatm7mn33nm/SyJ6XI82FPoxWfX5/yy69/mdl53t/e0ihVVzmn9IN+VD+2oYqkIFgYy2vLFXNK3B42rJVmjhWeoaVkZVucdyykpghFYzT3Ogsxsd1E1sbgYuZ6mBjKJV+9uMezzcReBEwRNGi0NqwSfGc60AiJzHWm8KRbsEue6+BBCkopCBKNKjyfYEiFGKsZZyiJF27D49Tx1UeP0FKyHya2+6GK37uG5OvEqREVaR1E5N5qTQ+c9h3KaPYh8q2bLSurSSly5yM6a+53ls8tzxhT5trfsUwNSgp2/pPdwT+0Bf9SW4QWGCnYx7pjL6WiVYpWHEVsVpJyJqRAYxVGKDoUrRTHi6mwS559SEwlgyls5sRTN3PW2NpNpz5sdaSVzCFUgokUCC24Vxr2KlBUqaP1UlXYLiaKzFWdLSCL6rw6xMgfPn3GRdshReFi1UKGhRQ0s2SbFa5EdCo0wnJv3cKcsAisEFgpaRUsleHDHNmniBUKGROLVpGRHFJgnxJWKtQnFGu8iu89zhpL0fWl0KXIkAI9BisUrdSYoyAxpsxQAp1psUgaqZAIdCp4CkNIzDnhSAwicJgcT93I/a5HUQWLVkNMilVj8L6Kxq2SBBFZ2w7DXIkEITGkag7jgTvvMUh8SQw50irNIUb+4J33OFsssErx5GSFyhmrEs3s2ctSx/EZGql57eSEMEz1e5ESqyRWFTol2RE4pEifNJJqMpKPebkbDlilX61UvKQ4aSxZQisFTgSGHOlFFVtTqOuHSjCHxORnutYgC+hSaISgCIEXfGwU5Ckc/Mx+CHwwjaway0cQOWMkulSHySkGEgWjBRjJI9PQlYIvkv0cmUKsq0A5s4uBVBITkSEnhKyF4R998IKLfoFB8mi1QORMpz3bIHGeY/5FGqV4fLJkmjxKSJTQCJnqedtI7mbPPgWapNC50BkDBIbo2MdAKxX2Vf69lDjTLUFnrBQEVUlJi2LopSILhSkFLRU+RCY3oYzB6gowMFojBcyiuuO6nBhzIrvC3k+8Pw2cd33VCIhCoyWSzMIqZucJqWIMcyrcW/SQElMKjL5OTduUEDITcmZMgbvoOMSKPx7CzFtPP+B8scQIyaOLU8gZS2JWhaFkphQpJdNpw+N7a/Lk0UiUBCUzWoCSiqfzjp33nIsGJWDR1p+9fQ5cTiO6SOyrxdqXFktlyKo+j8nPzCXTSE0rDSrXlR2pJFMOuBTpdUOjJFaB0YWUBInqaBvIhJIRoRbIV3GmtxaosAyrIBWJ0QbvYy3slcJLQS8b5FGY63wgxYTMdf07+4AXmYmIy0cDuJh4//KOVWsxSrLqO3LOSJFok+AQq/C9iIJRkouuJbr6QiGkRMmj231uuIuBOSaWCHTONFqTcyX27IPEGEWRn2zT44e24JeyGhKkUtineBTnSiAjRN2TEggO0aFkVTEvpKI7CjZyLqyb+lZXRMYqwVIbcoYpJ05kFV7Ioyr7kDONVMwloES1YUZKBBJTFFOKGKFQWiGLoKaRAFFdchOZhTb4JLjZjWSfuVg0nHTViTJFTxKFKDKuVAMPhMZKSVIghKCaPAsSBY2of84jDCoW0Frz4jCwdZ65FJQQVST6Kl5OCHk0WyscUtV9dEJWsTSiKvYF7MOEFAUjBQulWZhq6IIUnC56ggv1wlGSs7ajUDUARQlkqU89pczOVwxrKBklBVbXPNdSopXkkOpO4EJqTBHV/CML0AWXEjOJE21wsfBivyfEzOOTNfcXPSIlBjdSENWmOycyhVKgQ1CU4CP/rAKEkpCy8tCNqHkeRERreHo3sZ08Y8n1JfxVDr6UqGT7Qi6FQ4z4nOlRR5Z0zY0MbNyEFgkhDa2QdLruLidg2TXkECFXwW1rNKlkDjmxEHx8vpRS2KaAUZIhCIQUaC0pWlAkLIQhhIxRx7VDqotzSYkiYRKZSUROlWWOiee7gRjg0aLnvLWklIglkgv4UphKdScXFBopiMcLq9Q/OCVXQhuighIKhUhCa8HV3rFznrGUKmp7RUl5KZEpiAwZOKRIBjqpiSKjkRghScDGDUiR0FisFFhVn5kQmnXbkFMttJDQNKbihUtiLWsHVZRCiYGtc2ghGHOCIlFCVhynVvRFMYVIIzRKV21fTBmfElnWM9OnxKk2zCFxuTuQEzw8WXG2WpJiZB4PJAFRFByJlBMmCXptmFVGCo5b3zXflJIEMuV4N2dRDZSutiMbV3NQIOhe7fC/vBD1HIy5ai+hIoqLEMdzCFLJ7GeHFtUpXosq4BVCgiwsGkNKhUChSIHVilwEjlJFuMe6q5RyBLRwhAHUczCJWoD3UrKPASUUSlYjrSwyASiyNpgjhU5pYincuYlI5qxrWVlbRbYpk4GMIJQ6LUWKj3G2dWG3RiEjZSYXqli+5IoHVXCYAmNIpOSQUcAnJJV9T5n6d/7O3zn+IP/xP1/96lc//vg8z/zVv/pXubi4YLlc8iu/8iu8ePHie/kSf/y5cmZKmTkV5ljXG6wEnxNTTswpMcfIPjnEcbTWHg+bSCEJweO+ozOK1tTx3cOuRSHolQIh6wNKCZcCV/NEjvVhiONh1ihFVILOaLRQWKmxShMTlJKQQrBoNLZRSCM5bwxFSBDV1Y0iaKWmU5ohFjyZTK6PtMBQEsSC0fX3pCyIuTDkTKJwIi2n2qKl5FAySUo+OOzZzIHb2fFsGvngcPgP+vv9UYxPM/8AhlRRXFNMHEIkJVCi/qB6KqrLkdiFiVZqNIJO13wDQAleX6/pbUW/rVrLo+UCoQRL02CkIJZKGnAhcDMOlFgLvCwKSgoW2iAEtI1Fqqr277VGy+oxYYRgYTRdY+kby722pRRBMYokCgiwujLOxwCu1JfHTCV5HWIC52msRApByZmYE0PKBFE414YLYzGiEgQCmXe3G+4Gx/U08+F44L39/k/5ZH904tPMwTHWM3BMmX0opCwwRTLG2jEtBXIW7NxcxYNAaxSdUbVoFoLHy56F1Vgl6K3itG0RqtCaemmlAj5lvM+8cNPHvcqPCv5GaWYynbE0QtLqSj5plcTnTMmFhTEsGsuiMTxoLAXIUtZirFRDG6MlQ6wUjQBkAYXCWBI51MmUEnU/NpdMjLXYPBWWE21QUjDmSBGJD/YHbkfHzTzzdBx4d3iVfx/F9zP/9tEzpcAcI0OI6KKQstJKQk6UUgg5sfUjQoMS1WRSS/gIlPjaco02CqSgNZqLvkMKTWsMRQocqXqRTI7nhz0i1XJHCDBa0BhJILHQDa22tKahMQ1JClyKhJhYNC0nbc+Jbbnf92QkgboWmRH191nLnCQeQZIFZKUNzTkiIlhtUMfkz7k2RZBwYi0ntkEfu8ipZN7f3XE3zmyj5yrMPJ3GP91D/RGKT/sOdrmKwF2BIRcoEinB5UQshUztlE8uomSdFkkBSkhAgxScdx26CpJQSrK0topsjUHKKniNORNi5s7NkAqCqsVWUmJkXSvq0JUEqRRGaQrVsCuqQmt0PQet5rSxFKnIWhJE9QBQQiClJOSKLM4SkIIsKjKeELHSIBC1QZwzsWTQiaVSVcArYCqJSOZmntmHwO088WIYuNx/shz8njv8X//61/ln/+yf/fEn0H/8Kf7G3/gb/NN/+k/5J//kn3BycsJf+2t/jb/8l/8yv/Vbv/W9fhlCLgjB8a27dgKkkcxHHBsCmqxBK2QUeB1wGdpcu59SSZamZecDBbBW0WrBwXu+slrTWs17hwO30fNQWXYu0CVJKnUUbgTcN9Xs6Msna0IuvLUbeWs74nOhZOiV4MvnS+SRy78she+Odaf+tK3OuCFGSqHuWReNRSORRAr7nCAGtLWkDD4mxrmOy7fJcU8pVqphmwJX88j1eOBF8kyxjiU9mc+aXu3Tyj+AIOr4UCJIOSDRFAlCZPKRV9cqgyfRKEMUAp8LIeWK6wRWUnFnFL2sBAmtClt34GurFevW8tZuz5WbaItgFImTbBlkOhbrghNVTUJ++uEFoRS+u9nynbsth1RxYEYpvnpxgdSKQ450ovDdu/oS+HDVsWw0MSV0ga13eC3QStKjiLmwD5nioGssIkKIHh9mGiQ7P/NQtZy3ltvgeLabeNZM3KaZOSQORGZx5AB/huLTysGZihrOCA5HHKA1mVAKshR0qR3XojjihyvtxIuIl5qsFPeNZTIzSypecK0FB+f5yX5d82+/58o5rFaMOfCIjhs8mYIVgvumWrZ/4XRFWWfe2Y+8szvgcyYKwZlSfPX0lGQL++w4K/rjM/B+a1nYCiAopRzPQGg16KOdvSuSlMDauirhfGBwjpnCQORzjcFZwzYGbsaZm8PIUz+yD5l9jtWnIH+2OqyfVv5NpdAjj11OMFYz+YgrGSMVvYClEHhlMEcjzFgSMRVSkQRmTtolOzfRm4TRil4otu7AlxenrI3mO7sN18OI1Q1jSDxpWnYEkiwYJTjXVeT7pcdnhCT49s0d3729JqeMMpKVEHzh/CFZCYYws5CC7+5uSUlx1jX0QpN8psiCT5JSDEZ7kJKYqBjHGLGNhaLxPjC5A3MpjATebHpcA5vouZxmbseR5+PA6DP7FJhLenUHv8Q72OeC1fVFUwowRjOGQCmFJCu8osuapA0GQdSCQK4Gp6Vq2xpj0SrQUifUVggm5/lc22Ok5nKa2IeAlAaXC2dKE1VdzdHAWtW5z8NFy31aLoeZF8NIAGRR9FLyeLkCJfA50hXBi7HWnWdG0yhZNzoAVxIY0PnYWEYQjppvqSr2NobIHCIuVXfdc2lYtop9Ttx6z2py3EbHnCNTqpq+T9rh/54Lfq01jx49+vd+fbvd8vf//t/nH/2jf8Sf+3N/DoB/8A/+AV/72tf4nd/5HX7hF37he/o6TzpNay2hFMYUsKrhf/zkHv/6xR0HH2iF5ExZrrJjz8S5bAki8/Z44N3riTeWC26PF48Vgill7ubIw37J5/rK5n9iLH2ETUz89MkCpRWr0fF8nHk6Trw/D7iQubAGaxVRBJSJPO4afum1C1Kue35SgmgMKUKLZSSwMpJ9nHhvcCyixWVHcaBkNTTSQmB0wEWIJOLo0FKwVoJf7M74lnf84WEgi8TCKO7Zhqu9553J0UgwBXLKjPGzZfP3aeUfwBe6hq41lALea5SS/NKXvszvffiU62FGIziVDZvseN8feNh2zCnxrc2B919MfHG55No5Sqhjwr2cud2PPFmd86jvEcDnm56TAs/dxFeWa86aBWq75fk8czU43t3umUjcW2qWtsPnTBCw7Cx/6fNvkFIGY9BS8BDwgFnXrvDSaK7nA384jdwrDSmBnCK2QKcMwkqcGbhLM70L+BhR0rBQll9cnvMdP/GvdztKKSyM5KxtuNrP/JvtwAqNUUcH6s+Y0+mnlYNvND1dWwvuGBNaSb7x+Tf5vQ+fsnEOIxQnWuNi4tpPPGkMMRfe3h748PKWN5qGIWUO0WGlwkbB4A6cdS2f6xsE8IbtWQfFXXR8bbXmpDHoPXwwOa4mx4vxGZsU+S/tm3TGEFIklEzbWP7ikZajVO2cCdmQInQ0ODwr27CNjve2W9qo8B5USohQWMgG3Wjezwfmo+h2P1TKy4nR/Oere7wzOv7VYUsomV4r7jcNl8PMt7cHVlLTCIHIMKbPlmj308q/R13D+tgdTTmQtOB/9hN/hj949i77yaOLZK0VOx/YEHliF6Tg+e71gaunH/DG+oQhJg5+QomCK5nt3Yb7zRmP1hWN+LhbssoKHyM/c/8+Tdugd4an48jlNHJ1qA7mF+uv0VpLxlFEZtGt+OUvfQlLJitTyZiiOXLyYQQaa9iOA+9ev2Ahe3yaav6R6IVFK8WzdMDFkZQSLkSslZzbhv/p6RO+ubvj9/YbYsn0puFBv+TuzvHdzZ6T1rCUYJNgcJ8tSs+neQefNZZFZ5ECUsoIIfjFN9/k7dstk3dIMlYqxgibNPEwroiy8L4f2G23PGx6ZjzeR1SBGCQf+oF103FmTf0aytIawZQjX1otaTVYr7h1gTvnuB4H5lz4z9RDWl39SxKZtW756XtH4g+2rucqjQce2TpF75RiHzxPxwNNUahUKCRSSGghaZTkRo8MqUcxEedYjey05mv9kisfeXc8kEvBaMWysbg5czPNtFbRIWgKzPElcfjfeustXnvtNdq25Rvf+Aa/8Ru/wRtvvMHv/u7vEkLgl3/5lz/+f7/61a/yxhtv8Nu//dt/4sN2zuHcH5NmdrsdAEvREgp0RvH6eskQIuvG8pWzM0Y31zWIKFhi8MCLaWIpFVoq1tqwP/4Q9lRO+MEHLqPnYd+wdw0uJHqrebjWdC7ybDOhVODZ7EjAwhru/IQj84ebHa0xPHUz195RhOJmynRK4vJMyIlcBFoY7vzI5eS532imkNi5hGk0K9PgcbjMcbWncCDw3e0GIQRBFxqpWWKIRA4EOlnNvoov3CXHhsRaCjoknpr8Vv7QyjBeSny/8w/+5BzssiG7Qm8Nn1+vmXNgpRRfOTvjUTcxh4iPhd4b0HA5DByEwWrNRWu5Sw4DrLRFIbiNnrfmAxernskpbsPE0iruL3p6rXm+d4S844UbmBFoq+oOc4Lf3x5Y2KlehG7igW253E9YqxnnER8iuWS0rvz8dw57HlrLIQQ23nPSS05Nx410HFJmjIkYIErBt7d3iF3NQSsMK2lRKnGbYqUelASpcHeYuSLQLSyLERy5jjw/Wyn4qZ2BKwwiZhqrOF33hBJpdOLzZwsOzjL5yOgjKyEYbcvTYcAogVKStRXsS8BIzVpoyIWdn/kgzPz88j7Ow11wLIzi/mlLP0mux4kQIu9NA1MpR1xc3VH9/c0dvba88I7r6LgnOiZfXccPbiaTEVJCgdkFLifHRdOyiY5rP/OmWXFq4WbKZJHYpQpb2MvM24c9YhA4DUYp1qoa0t8SWCgJpaLxDi4w+4xpNWqqK0FGivrn+wzFp5Z/ogojO2M570/w2dHZltdPzhgax+QDo/c0jSGqxPv7PVIKlJb0nWE8cs2XqTo0b7Ln3TBydm5I45rbMLMwiot1z+BHdsPMFCJP54GBhFCSwXsmmfmDyxsWWvPhMPBinri3FGzdgQ7Lxu2IOSIFFCmZZ8flNHPed+zczO0w8dhKHqwsN+NESoIpJWIJzKrwnZtbAMaS6bTlXHfE5NinmYVSpCJRZAY38l5M0AlkyKSj/mohP1ui3U/1DhYSkQut1pz0PSEVtFY8XnTMRuJiwuVMD2gaLv2Eou7wr6xiLh6VwRZZzbhi5G729L3Ae9iTaJVgpRVthrspMCXFjfP4XBBSEI4QpremoYIsXGAXA8XCwVe36SEcSKKgJOgCY0wcvGdtLEOIbLznzDacGU3yEBR4kSkUitQ8308IIGhopGQhFLkkRgJaSSgRSEwuMIsCFgiZJKr2zn5C87fv6aT8+Z//ef7hP/yH/ORP/iTPnj3j13/91/mlX/ol/uAP/oDnz59jreX09PS/83sePnzI8+fP/8TP+Ru/8Rv8+q//+r/36y5lhpRZa8291QmPqW5q561lbRWDC1wPDoOtCu0iyEWSiyDnjIsRrST3rKURgqlommwY5oRuAxSYIsypMISIVAUSVO/HTBLQaoUUmisXaEpmFwIh1R3rP7jbsDyu/KS6ko8QEp8TLmauSqgCjVxIJaOV5mRhmALMse7//9T6hGd3I5RqwFSIbPE8bhpczkQKPlVxWymFLBKv9U0VJymDEYJh+ux0t15G/sGfnINTLgwxkqXhS6sFj1sJJXPWNvRWs50dV7uBpdEIEk4IPlK+plDzdyEF521PKyWrbGkbyxACTgaEqIQV7wPOR6I4alWErDukFJZKspYdV+PM3is2ztdDTib+5eUL1osOlesurT+O9XKBQOHSRaYYibngI5gezpYtfio4l5EK/qOTe7x7dVM1Jbnm2KAib9gelzOB+rMUSiZJiCXy+XXPvsycGstCGvxnCEv3aZ6BBZhTRCBYLzoWViNC5tw0LJRhpwI5zjRCI3RkGzMUgSx1N3TwmU5HHqo6Ol5rWUfDztMZU/MlZFyByXm8qi696vjVC/XyMUhuXGAf4e6oH8g68Xu316zbFp/qWZdyRYnmXPdoSwzsQ2QKmVFHLpThrGtxc2HvPQnJz64veH9zCwV8rrAGpxIXjT3mn2SOAZ8T6egL8GjR4IJnZRSdVszuVf69jPxTsv7da6NZLxZ07bKef/2ahY1s54m436HRUBxjcShUXVsNsMueRmXuG41Bsyia1hrmFNiXSKYwhYjzmSFEQgGZc+2UlroyabXiAsULN7KIDVsfqpFWzvzhixecNA0HnwgpUkQFYaSUySGgpKxnbYr4EtCqZdl3TPPMIc0kkfna2QUfXt0AMIoKZ/AxctE2DAkKChd91SwIjxCOx4senzwnjaFTinH67EzZP+07mAL+WMu1jWVtLYRIryRN0zDJSJkDRkEiIUI9v1QWEGEk0ivFiVKoAl5WjZMPVbytcnWRDqUQYqp1XEroXKrQnArbEFIweE9UijEGYo6UYnhnGOi1JRxN5HIpSFn1oSFGcpG4FIk5kWJGtYq2EbhUmGOEI/bzqa9ruDlCENVFureS6Os6kU8FXzJVOh8471qmEllqRSMU0yfMwe+p4P+Lf/EvfvzvP/MzP8PP//zP8+abb/KP//E/puu67+VTfRx/62/9LX7t137t4//e7Xa8/vrrBDJDDuikkaKw1FXdb5Vg5xxXs2PjPUupSTFX7FwK2CPRxB2L5DFnxmMBpJVk7wNFFiyymsiUQkiFJDKC6timjvimXkqiEhxCIvpIyQUjJC5lLtPMIRaW0pIRuJKYjn5nCyyHmKGkyokukS5L+k7zwCrWuTpbllyYAXkkB7kSGZXikez54nLBv/YbJlEvMwH4knitW/BsHglHesdn56h5OfkHf3IOJlH3hHWOCAmdbSi5YJXiep54PgzcupkTrUmxog8DgTZnjAJxdOWdSmIfjruvSrCZPVcfsU5ShpQpGQ4lkqNkoQxKZgIFqTQhF7ZzYIgVx2mLwMXEh3nCSVihyKVUa+9UM+Kkadn5SCwJJQq7FFgHw6Kz3BeCVdPiKbgYmQU0SFKODERmEk9Y8sWTJb/nrjjkhCgFKQRTSXyxXfHdWOkBrhTmz5DT7qd7Bka2OZJzFZy1ykCGRiruZs/15NjEOnUiV8ABKdMh6KRB5EQsmSBrRzNQxbo7H7hNMylXHLApVOMZGYmlOtiWUsXpC131Rj5mxuhJJSIBH2r+eVGwpeBCYYgV/Qlw1lo23uFihJIZS2AfBatWc6E62rap4rWcmEqhlarqD2LA5cx53/Pl0xW/ezmxz7Ei7TJ4WfjZ5oyn/kAW9eu5zxCa+NPMv5jqnrowBqkKfdNQyDRGczePXI8D2+A4VXWyExCEmOAIxkip0uu8lhUCQMWqzslz60dyLuhSnaFjgrvsOUGzUBolj8LZokilrq5uY2EOAXJh9p6nIeBzhCQJOddmW6kNsLU2bIMnxIg6TsTHEGh7ywOzZNG3uBRJOTPlTCsq/WoIjllG1l3LF09P+FdX1xxypaxJBE5G/uP1fV6IHSEXfIHP0kLPp34HU5hSQuaMOJLrZMpIKY85ETjkQIekiGPDoWRKFhghKaWSEYMQzMcmaqMVcyxsRaDkmq8iQ86ZWVb6WINEyEIQR1pkLoQUGWPNs1wKISQ2uRALKFFNvkJOpCNxrKHSHVNOSFFrzDklWqM5UZZOa1KpLxyRghaKnBNjjniZaW3Hg97yznZmLFUXWKgi4AfNmmsxQxGEzPHl5H84/lSz0NPTU77yla/w7W9/mz//5/883ns2m81/5w3vxYsX/3/3vT6Kpmlomubf+3UhIJCZs2dyEz0tQla277Nh5LvbPb5kHusOF9PxQUQWSvJI90QhSDny3BV2MZGA08Yic8HPmaVRpFzxnUYoDiWhRGate/qj1bc5FlGTT6RI5a7LOhZqtMLHTFG1FzaXxE5ECgUt665rQ8EqyS5HbBSsVMOTxiCVZBcjv395W98oC4RQWdZBwlwkXztp+W83t0QNTal0jlgyp7rluZi4mh0xF+xnqeL/78X3I//gT85BraCkTCDig2d29mi2Uvhwu+Otuw2ugOxaxliYcyElT1KKC9Ow0JJUEs/8xOXsmFPmXmeREd6PAyt9NJjJ0ErDXQ7MSO7bBSslSdSPvXA7mgxzThhRO28+Jaw1VRB5RHnlY/FdSqEtqU6SyGgt2EXP7aDpFy0PlwuMUGxC4LeffkhSEl00OiVKycylcIjw1fsrfufqBU4W+iJpjsLiM93QSsP744jLnz3h+L8bL/MMjETGHBFRMvuIkwFU9Vh+ehj5zn5PpICxJCGYsyDkBCKz1opeVQTwbYpcO4fLhQc0qFy48jOSjCkCi8QKxV2orrsXpqETgkhGRthkTy4BnwuaihAeY8IISYyRRijIFV+bZanozZwZvUOUTKsUPkVuJlj2hkeLBVopdiHw3zy7rAQMZQgxs0+JiYJH8FNnK/7F5VNGmeiKoCsCR+ahbtmYmQ/cjEsZ8Rkq+P/78VLzLyTGlDAhkpInBIU2dYXg6e6Ot29vSRRkU0CpCi0IAUqhNwZNLVKug+d6ngkUHiwXtKlwPQ4IITHleL8Jw01w5BR52C5Za0HMGSEzl34kBpiSR+SEojA4TzaGOaW6tpsLORVCibUR1hgGP6MSLGTlp9/NjifrlteWC6SQ3M0z/+rDD0FUmt4YEi4kJpkZcuHrF6f815dPGUh0UtIJySwjj5dLXAp8Z7tn8An52Rkw/Xvxsu/gLKqwWqdMjIkQIvpIrLkNnmfzhMuJCzSo+vJVxbqVYKdy7dxvVGEXArEUzmWDBq6CR8qMKQpbqh/OPkVcrnv93ZF0lz1sc623Qqw9diEEU4gVU1vix2jMXArp6EbeGoOLnpIzVlSD1p0PdNZwZhqkrL5N395t0QgaqUm51rG+JELqeG1p+aPbxFzq+mJTJI7MibZMOXI9BXxM5PzJCsE/Fd7gcDjwne98h8ePH/NzP/dzGGP4zd/8zY8//s1vfpP33nuPb3zjG9/z516gWKDRuRobxZLY+MgUapd9oSVKFjbZEXXhzGruW8taN6gsWVARlykXUk6EHPA5cCIlN6OjhMTWeT6YZ65T4GaO3PiEkYLXmobP9wuWpmXMdWrQKUmrBFKBp9BJhUySG+d4PjsOLrHKGovgw7hnk6Zq+pXraRCjQCSJLjCMnpvNxGOleKQkJ0ojskTnSjG48iPf3G4wAhZCs5CGpZasULw/DbyYZsaYMVJz2vV/mkf4Ix0vM/8AlijOpakEHZ9wMfHMTWydQ0nNyrY0UnETE1EK7nUtry36j03dOqlwuTDGyBQ/wslG7mvNZorIormLiW+7gbfjwDZnbnKs9vB9z5urJSfWkLNAGk1vLK3UCCQROBeWEBKXs+PDaeImBHpjsAo+zAN7fEV7lUKjJCknii8IMnfTgWe3d3yhXfA50bHWBiUq4/9CNVzNA3/44SUy1r+HhVD0SrOShm8eNrw3HdjFgJaKi1c5+HLOQFH/3lUGH+q05ibWSVCUIKUACpcpE5XkwlqetD33dIMuGWMELlSk4uwTPtR/LpTm2k8YpdmkxFvzgXfjwBQi+xDpVcOjbsWT7oROWXxMVRfQaJbWoLTCqcxaSJgTd5Pn0jkOMbLUGikLL9zALnpcyqQIKgliSshk0UWzOzie3+x4rBoeKcsiF3Sqk1eD4mqY+MNnl0hgqTULq2i1Ypk0bx8OfDjM7ENGKM1Z/x/eWfxRj5eZf52y9Z4VGRcTMSa208TeOWKqHW8tJJtSiSQnWvKwt1y0BgNoLdgfc2oMidFHnPcs0NzODl0kt97xzWnLO34gxsLOR7RuuNeveXJywnrR4VJGG82ZbTmxDcYqvCpVy+Yj19PEczezS4mV6TBFc3XYs58jY0xV1O0jk5R4byhBcLs78MHVNY91wxPbsdAKJaDRkoXR3BwmvnNzgwHWQnEiNSfacpZa3t3ueXc7cec8RQrWbft9e54/avGy7+CuKFZCoQt17TWm6sERZkQuNNSPHUpdx1lLwbnVrIxB5urVNOWCC4mYjkZtMdJGOIQAwrAvmadx5io7Uir4UlBas7Yd9+yCtbXMKWCQ9SzSCiOrB4WRGUJkH1ytTyOYoxvvjR8ZYsClXM/BlIkykY9I251zXB1GTqXhgW5oRdUqaVW9AjYp8cHtAZkLnZAskPRC0EjJ1eS4neea21KwtJ/sDv6eOvx/82/+Tf7SX/pLvPnmmzx9+pS//bf/NkopfvVXf5WTkxP+yl/5K/zar/0a5+fnrNdr/vpf/+t84xvf+A9SZ0/Zk0QklMTbw4HbyfHONPCg7XEhQZac0XAojjlknjQWg+KQMldh5kRaziW1eylhHyO3LhN05KunCxo0QcxoDQ9ay387HeiVQRlBUhmpFJ9brBhjYm/qzqDKIIvgns34nLnxEa0lGkkqdcSELkdJrsBIRScMJgnu5MSpl1zOEFJGFTjXDQ96uJ4d7+eMEZKLpiFHGKfaKTNUwYkuikYlNj5wZjqSmNESTo9K889CfJr5B9UnIQuBS4lv7+64nQeejp4LU2kQohTWxnBIkTkE3jQrdE4ckuM2eO43DRc0BBLSwiZErodA6AQ/d/8ekmqr3aiGJ92K/++4IWTQRpOFoAjF587O2KfItR8RKSOipESL14UkK2ZWo5BZIGLmOg8odTRsEgWhQEmBA0ZZPQNubmqnQpbChe2438OLOXLrAkLChdUEwE/1EFWAOs4RlihGn3lkFpQyYZTkQfvZKbg+zRx0KaOKwIfMe7uRbYhcu1uWFooXXKiGZAsvZs/oAk9shykwl8QmJpZWc6Eq3UJZ2ObIszRzmDI/vT6lBUROWGm5bzt+f7uhVxJhAJVplObLy3uIF/CCiS5Xr4YLIQjH7+/FNKOkpOT6dZ4dBtCFIDMGgZZgDURV1w/vppmb4YBLFa13Xzc87htufOCbuRrVPDaaXODaD0gyfRbYUo12eqWOZ2CDjx4tJBfNq/x7GfkXS0BTmFzgm7cbHswjl26mob7APWh7vBA8mwaIgceNRZW6azymTGPhXmxJKmGAbQp8kGYOKfG10ws6wApYacOpbfm9zQ1IjbDVyKhIzcX5A94cE8+TYyUFq1I4zT0pVcfxu3FiYRoaBD5nLqctYBhloEOhpcZqBQbS6NirLftDNSoEwboxnPWKzTSzP3iygPum5RAiV/sZVWpnvzmaLFoFV8OBhYbbUAXyD5efnYbHp30H+7pRgy+eD9yWE9nULnnUkAW6wBLNlgixGk/aXI2zRiIWjaIABaEKQ4nc+UDQiS+t1jTAHYL5WMx/dxpZKo1Ulc8vheBkveBRCuzwGBRtlkcKZsSLWltKFJJMyoHdBFlV40OJQIqKia9/oMJORUZfX0AosFCK3go2PjKnSBGwVgpPqC/AUmCKqNNV6n28jTNWKGTJCAHL5pPVgd9Twf/BBx/wq7/6q9zc3HD//n3+7J/9s/zO7/wO9+/fB+Dv/t2/i5SSX/mVX8E5x1/4C3+Bv/f3/t738iU+jj2gpSHlzO00szzRyCR4epiYUyLnTEOhNZI9EaEWHFJiKokzKdGqMM8akapddq8FLZkTY7noFpAjuyzxQTHnTLaCBZoHqxNOm6Y67qXIw1XPcNhx0leyz272jHPkpDVkBbIUrCgUWdimQq8UX2ktZMnBJ668Y9lomiBwDlCFBBQBnZFMvvDdaWLyGSMFQSXWtuN62GOSRBRwqdqSN0axOBb4LldB6H31pxrS/EjFp5l/AFMWGKGRJeFDpG9bCvDUDfiQjuJEwaJRTBG0Eex9ZCiJM21pMNx6j7UaLWFhK3XqXHec25ZcAndOVNFk9KScuWc6Hp91nHUNIgtkgIerJftbz2rZMDjPzTAyxsR9OhIgci2ujCxMQFsEr5seoQS3s+fpMNM3Gqcl59qSlWAWtYA3Bibv+e52rHb2WjCGxJnpeJHu6KTAiSpAVjGztLYy04FFNKyV5sFn6KXzUz0Dj/ujomR22fOaMjxNmQ+HSM51FVCo6vm9yZlHpuBSxsfEAtC5MIXaMWq0YlFAF8mF6Xm06pEhsY8Bn+oaULawMJrXzlectw0igwiFs1XPzWFm0WtihMMcuPWes49H8Lka3shqGLiUhgvTg4Ktc3w4TthOcY5hrxxaCebj6k/XaaYQeWccmFO93HIRnDSayy1IIcmi4FJ1mpRSYi2AYEGlazzWnx1Kz6eZfzMSZVpUiQzzCJ3BO8+Nj4iiqMtllb1/0A5lWobgmWKsOqSscClhpKazgpwkTUpcyNrBF9mzTYEpB3KKWOCib3i0Puek7avfbc7cO+vYbQJ9Y5h9ZDeMbKaJ/viiF0N1BRcSFIpWaj7XWYyS3M2Op4cDplXcMz1dqp3UdARq2K7nkEaeTwccNd9CKZx2msPe0UhxNOjKFephFFbVCe5K1YbPo8Z+fx7uj0B82ndwqvwvcpZED73V3MXIJnlKqm641VMhVU8mIRhFNa1qjgss3kNjBUopbBFoWVhZw7ppKDmhc0DkTErVwbm1mpNlz8KYql3LmbOmxftCIw2BwhADex9Y2ZaIR+ZavFef5noHn+iGqKtL9U1wNAhOZEsfEkEKYimIXOisZkqFq+QJR4dfn6EzDRsiGkkUGXf83Oo4ARBAVzKtVKw/IaVHlPLDpbjb7XacnJzwX/zP/wwgEUKwsJq2lVyOEzIJtiHiUsYeXdLWjaaRkiEk5pBQBXqjmYNgaRVCFpQSLLWhlYptTlz7GZcSVipOW0tMgV5qvnJ2yrppcCnxdLsjC8G39gcedA2Sugd2PQZaLeiNYT87csxQJAFB2wg6KZhzYRcivhReX/R8ablCZnjPHSgFTnWDVTDnyNuHESvqjpYQkkZZ9vPM5RxIItMpxT3b8uXVAikV780HWmm4by0r4H//f/0tttst6/X6B/z0fjzioxz8X/4vvo6QGSUE66ZlaS3f3d5RUmaf8sc7zVIUVrqlbST7EJhiwJbaKXo+ek5bjRYSpQRdq+iz5a5EXvgJ7yMNkou+RYiClYav3TvnpG0ZU+TdzS0ya/5wc8PjrkcUwcY7no8jy6alNYr9NBNinSplURAUzqzF5cSdr+Ywn18t+Omze6SUePvI9T3Tll4oXDzmoAKlqyPgUmmeHw5cplQF7ErxuGn5+ukZRQve2R9oleJh27HWlv/t//n/8yoHv0/xUf79l7/yHyMoKCE46eq64rf3e0rJhFyO5m6ZoSTu246FkdW1NCZ0EZyphqvRc94q0AKp63nYFM0ueZ47R/CJVtQzcCqJVip+6uKcdWOZY+LZfqDExL/db3nStSgkuxC5HCsHutGGrZvJJSOFwOXCwig61TCkyCY4Qk68ebLgq4s1KUneHnZkChfGspQKFyLfHge0EGhZu6ad7dgMe97PjhILvVDct5YvLlcYIfhgnGiN5l7fsJKa/93/5b96lX/fp/go//43f+V/QhLVa+a8XbCwhve3dwQf8QUqVLDCNR4sVnRKsPcBnyKdkJyrhudz4H5bHU+TBGs0i9KwSZFNGAlH0MZZ0zHFyFprvvzgMau2x6XI880tJcM37664v1hAzuyniatxAmM4aRqGcSKXglCSaktS3VTHmLieJ6YY+OL5mp86e0xOie9sbiAV7tuOxkhcnHk2zUClrBVR0FKwmWZufJ3ur7TmyXLBF+/fQ2V4d7PBGMP9xYq1avhf/x//8av8+z7GRzn4v/ovfhYh64vY0jastebpNBBS4iP0vALGlDlpLVIIfKrEHCMkS2G4c5611QgpjihzRaNk1V2G6hqthWRhGmKOWKV4bb2qviM5cTsMlFR4Og2c2hYpBXNK7McZYTSNkUwuHvV0lb9vlKQRhqlE9skTyTxpW17rV4hYeO4nQLBWFivAx8xdrCJcIarTudCag5sYYyJkQSNFXV1fLtFScjd7pJKsjaXJkv/D/+k3/wdz8Ie2NaKUQFHXZRohSD4jKHRSMgpBFKKuRJTMuTFcOseUM0XUBBBCVOc/GVGy7nLNuUBJ7FJgEwIKQaPqyOVcW6QUpBjxUrEPgbcPBxbWIOGIWKouqlJWJfhpW1c7hhyIsRAEyFiIx5etXCdJ5FR41DWMMSITuFTV5JpK8GmRLKVAyIqmiyHijmrwKDOdlJw0mtf6jojkNky0SrE0GssP1fvaj1UkWUWyBonOonLHKUgp0FlQZOUEuxw5s4bnrgqI6gTx+FwkROpLQ6E655UU2IrAXQiVEawEicJDrUFIggvMQrGLgW9v91yYBkUlVAgh6sKYFKSSOW8WhBQIJZNTJT85Mnf/P/b+LNbWNM3rxH7v+A1r2Gvt6cwRGRFZOdVMFVnlgq5WY7DU6htoLrhqEFIjIQq6rZLAXTckVquNxUWbGyxZtrB8YRkbW2AjBhmlUZWgqikySaqSqsyMyMiIOHHGPa7pm97RF9+OhKIoVWRVnMyIyPWT9sXZ56yjtfb37Pd93ud9nv8/BuQ484u4eT/3JxOufY91ks5HfIYoJU2KlFJSK4WQ47B8jAkXweexp3EiBPPScm86wYnMevBImamtouD7S4f6u0UmIyUUUjAR6qYqGSmEJHHj9MyolHSoFOsb+crMWD2XWYBkdKQUo1ynS5BTZOUcl95js6CQEAUcaYsCovMMwNoHvrnZcqAkJGh9RMibwXAhcClyYmuG4Olvwj4x9si6NKruxAQgUUlwe1KzHSKyv5mvQhKloMsJi2Aqx03Z50yIkS6lG9fWTCVhYjX3pzUk2IRAYRQzM7q87vngiTIhhKSUiolSYwsCjIW2GydxnQU9MFWabRhwKZEz5Bt5QiREMpox/nxOBCKb0LPyA1oIrJQkJVgqS4Eg+kDQjsYNvLm6YmJKUgi0wzBKeaZIFoIYA/PqgOA9bXCEFHERhjweSGJK3541MEjuzg5YDy00kkAkKkmSiiFmTBajqZIQtDGQ3NiW1OexWjxVgnld8OBgTnSJq67F6rFKXIjvnxvO7zYRxj1YCvRNMp/eS6wEYw6XBZ2ASkp2YVQmEwhEBn2TPL/nmivEeGsQEzQxsIuj6piSgqwyMyUBQQyRIKCLgadtSykk0Uec8Ag9OudmJYgpcqRLUsx0ORPyuF7FlPCMkurkMSeVWXBoKpz0yDgQMmQx5hGOUX1PSTWqDYlETGFUnwICGSskhTEcFyUCSe8TQgsKrTEvynjru8WOyEwqUkqshlFqK4hRl1lIgWI0JBIyUQqJEQqMwAhBmQSFkAiRiGKUPGpDYBM6ltpQWcvSWCSjzrTOeTwgkGmHQIqwjoHnfmBC5FgV9MHT+DQuDubf9ZRKRu3//kaWc/DiRiXDYBkXxsb5UVq0UJzkgovB08bIka64Dh2HysKNooEGUoq4mEhqPDQIMSrGCDnOBRzYgpVzXHvBQu03uxfFVehZSE2OiV3nSVKQRULeXPNaARMl8EJQaIkKY9JcIChiohCaA5MJKuFEYgiJi2ZgLjTHywnHyZATaDEm7z4lhMxcdw1DCqxj4qIfk7gjqWliYEiRkDNGS2weZ0FEgpzG1ydGiVcnEkempJKa5DPrLiByYmE196Y1j5uOrQucVjUb33JgDZmxPURlyGk8LGgxJmDjzakkiFHN4LiqeLfZcN51qP1+90LYhtEYSyfFqu8A6INDSjs+J5GppaSLAstYJKm1RiWB8lAIwaJQRDUqNzXOc9YHZiimleYoC0ijbGvI4dtW771z5JzY+sDztqcpJHOh2IbxIODHC02IGZXHzTIG6GLC5YjLCQUsrKYUoznOdvBIAfNCcXda8Lx3NClxWpY0ceDQG5Cjf0DOQBwVhkQW5DwWcoSSSDXelB1Ulms3cD0MHOjv36HJF8nGeeamIKXIdbvFAX10aMaWVItggmKLRDE6gUolkTFTBoGUmpmOBMbTYBczZ13PnbKgtIaZsIg83r6HFBBy7FLuhh4hEmvX8aTZUtmeZRRsh542Jlwc+5ZlGM0nuTkkNmG8+Q8hgXYcGUOFYEiCbTOqUlWF4vas5qLr2cTA0ta0fceBNEQJQwaVFSIkUhy9UDIw9gspBBKtNPOy4qrvue46lt8/HT3fdboUUGrsmd/2PTC2M2cSiPEQUCBQckz+rVI3ve1gwlhUrZUhy9HHw+fI1nnm2iK0phZAyqNsZnYIocgIBufISdJGz6ofsEpQx1EOO8TRjDAgsDEjkiTnsTjWxzTKgubRf2lqJBZBSIwF3yyZaMWyLFk7T58iU2Nps6eKmiAgiLFgLWMkpPFgPRp0Qb5p4bZoaq1ZxQFEps7vLw/80Cb877YN98vRGOHRzWZ3ai1NTFSFZW41zo+qPV2M/OSDJTlLto1nsx37oU+VoJFjpajJnm10HGjDbVPSiXFxiDmTYsIoxSZmkusolMQBC2lZR08gkdXo3qYEWKlRLtM1gW3ncDFQKMFBYWiHROdGJR8pBaVUFErQDgOLWc2JKljHwDtdR/SRGQJdSHYp0ofx5GmAudEoRm3gA22pTIkwBSFGKq14tx0l04TerzYviqdNjyorZI681bcI4J6tEMC8MFRGEXKiaUaN8j/y2ZfRWrLetJw9WzN4uGsKrqTH5UiTM23KY9+7qZgJeWOMNQ6EhyBpkuM6O2beo+TYRvOkazmsNFIIrNZUQlAIaPpE2wc2LtCmhNWSW0XBZTuwCXEcFs5ilBKVgot2x+nsgKUueCZ6zkNHtZPMMOhCskpjDyFZkIkclAaVJClqDkzBgSpBK1KIaJm57h1XDFDtb5leBE+GntdkjcuR1/vRmGWiNaTAxBgqO2pF94NjC/yBl04opWTXOM4vG4KDpdbsyPicaXPg2vcoZfl0MaOxnnZwDN6ToqfQFqlg6xxtiDjgpCjYxR5jC5KITMhoIbHSELuIT5L1MGrwKwlzq+liYhdGPWsALTMG2LQ9t2ZTbpU11z7wTr/DrjOHSkOluU6BIWVSBBkTc6lQQK/gwGoWxqCkAhJTY3hr27J2iVyJ780D+pjzrG2ZThVDjnx9PcbfaV3hYmJaWmqjySFDAE/gs/fvoaSgbTq2l1tCHJV7uhAJEtoYueoGDgrLp8oJOzvQ+1F5JfuALSxBwWrY0QbNkOGoKGidQ6kKawTa5FF1TEpCkHgXWA8DrfMoJVlOS4bGs7nxIxFkZM7EmNi2FxzMDjm0Feddx6N+RUqeu6YAo7lKYztmIFIKWBiDTgIfMwttqHRJzBrkwKywvLW+ZjN05Gr6vXxMH2s2fU8lJwzAuRvzwCOl8Qgqqym0GvesbqySf+rWMUZJum5gtWoJMXGoBDsV8Ckz+MTWRyoNt6wlkAguEmOEJDBSMxDY+oQJamy/VpptDKjSkPUo4VllkDIDGsc4uNunOBYjjGUYPGuXv31oJEMOma1rOKjLUXwg91y4gSAScyQUY7GuTxmSxBCplR4lSWWi0orCjIdqT8AqQdMFts6zeJ9zTB/ahP9QWUJiXFykQgjBwpZsfWDlemSGJZapNqxi4sGDuyzKiofPV/yLr32LWkoUmie7npASWUKJIefML59fcNcUaCPJCkQcT0yPug3bGLldlpyYkimj0c2Zc9yaGl45mFFJy5urHY9jw3m34WeOjjkpCpQQVBL+5cUl1wlqpdmJwDo5cij4hmtRZz1+GPWC72AxSXJB4MDBVBZUAjYi8GRoAPAq8YnFDJ0E37i65p9dPaUaNEFCFpFA4ivv8ypnz3fOy0VFimNbwX1ZIoTglq3ZpJ6z6MgRFmgOrGIVA7fv3uZoOuWbj5/zq28/5chYQLMLYx+8T2PiI1Xif3r6nENTUChAClCGGnjseq7iwO044ZaukC5xmDVPdgMnVcUrixmV1Xz98po1A2/tGj5/espRUaKlZGIMv/z4EZXLLCvNdfBc9RGVBd/sGr663RKGRE6JUyQ2Zx7jOIiKeVEwR7D2nkduw+ASO/leDMJXnp3xD5+8jUUjZCarsRXkazc26Hs+WF4pSoxUBJ9ZYhAIjsqSjQ9chAEV4ViXHJiSLkQ+cf8eh9Oad59f8ebl66NeNXDpB3IGFzImgJWZX3p6wYO6BJEZIogoyVbw66s1l9FzS9ecmAqtJNYb1i5wWCvuTydMlOWblw1P5MBVt+MnliccmQIjBXMj+Bfnzzn0sKhKrsPA0y6wCZk324Ffu94xhEBKmTmaQORNAocTSyEVVkg64Cxu6VxkoxKvzRfokPjq00u+ePaUShsyEBlbO3+9WX9Pn9PHlftlDUj6mEbpaDEWtXY+cDU4VoPnQBUsbU0IiQd37jCtpzw7u+D52QqlICq48oHgBT7CRFmcC/zzx8+4O6kxjMZBIcOJha9dXzPEgZemc07rCfPSomPiMg7ckhUP5keU2vL68+c8czvOuoGfvX2P07LGqLF3/5cfvcusHTisJ1w7x7ppMDnzm9cd7fm3EGo8qNz2JbmHdxlYzDQ6wwxNrxXr1OFcZh0Snzw6QqfMv377Hb749jdRUZKVJMpEkPClq8vv9aP62LIsLVKOOdN7eWBhNSlldj7Su8gEjbWaECV3jxdM6opnV1seX+7AwuBg48bDX84ZK0dDrm9cX3NoKoSEkOM4K1RpHnc9HZHbRcWhKSizgQF2KXMgBEdFhUXzbLvmOTtcSHxysWBqLEoIaiH4zesrIIxF4Bi5HhwtibdcR2x3lHJsy5ygyEPmKgVmVmPT2MoeFGzDeJvVk7g1mSFS4q2za36dKyyQpBhvbyW803wXjLdeJAfSIqRAS01tK85TNxpzMKrcBASrmwrmrh94dnFNW3Y83ux47AYKkSmMpohjy02ScGxH06T7tiBLQZYSIyQqZ1a5p5KGqdQcYymi5IKBqTRElTlQFS5kNrGhJ2CAY2V41HSsXKTWChUTjY90eTRPtaTZ4wABAABJREFU8HI05tri+OomMMuGQzFe//QZbASUoJEBQ4FCoQGtMo87x1RpznYDgswmOIjjQGaVBJHR8l58uGauP1bIBEpJplpyoAyr3vE0dcgYyBmSkDRqVMjx3vHw8XOacsvTqzUX0bNNgYlUvDSdsvWejOcIhRWJW2VFFImYJTobrNSsU88USSULllliQmQjMkUB3SBYlAUxRi63DhHyeGWtJd9cb3hsOubGYBL0LnOBY9t7ogCMYB0DX766ppSKY6kRWTCkRBdbMIaGRJkVBQaLwaB5J26YoFntBjKZlXKAQPuMQqHkzYAR38fOWy+QIYx28aWA26XlKnmukwMiEghZcBUDlVI0yfPs4pJ+3fP4csujpifHRG00L1Uz+hhZiwElC5SA+6XGxcTgIsEntBJcup4ZkgLNAijyWG2aGoUDZtoyhMxu6EjJMVcgMLyxWfPUjG2SdRIMQ+YsDzRdIoiMMJJtCnx5c0GVFQc3Dpg+ZxweZQqa5CiVZtSeGC3k340Oi+BZ0yFjYhMjkUzqI4XUSCtBS0TaV/hfBIZxJsMqwULVnPmetQskRr+ahGBNYCIsm+h5fnFJZ3ecX695NrQ0KTJVmvuTKV0KbF1gpjVDTtwpLUP0pCiRWZEUrLqOiVRMKamjhn6skNaqYMAxNQU+eno3oFNiqjQxC776/IJZYTmpSubKsuscj13HLkZEFmgk2+D59YsLpsYy0Z6UIoMPWBSlLVlHwUQJZBIkn2hj4G23xQjNk+0amWATAz2JIo4uqqVQo06R2O/BLwrB2HNvpWShLCvv2aWAjmO7aZKChlHS3BF4vtpSNwPn25aLODDsAqWS3C5quhRpQ2QhDJbEkbV4EjJlZMrkJGhTz0RCkTTKZ/roiTlRFAbnAhM0KUZ2yY83/UickTzatpTaM9OaIiacC2y9x+U8tmTfqPI82zZjYUTp0VSMTEkiS4kAinH6gDyapnPuxsHc875D5kxPIsqMSwmdFCUSmSC9zzXwQ5vwFzf9nBHoRUZkSRsjmkQhFFZKCjWe+NoYeHKxYWM6rtoeHxN9CtgUKTA4MiFlcshYJaikHK8mGd0h51LxZt+SM9gkuYoeKQJRJLyIKJXJIrELkdXg2PrAcWkYsqKJmR2BLkba3pGzoJYGJSWtDHREhjTa3QeRSEJAHm2a1yROdc3Sjul+yIKcBYFRPx1GSU4pwUqFEpLhZng5C4GQ4uZaac+L4MBqnMz4lNmkiBN5dLjNYpwbUYqptpRS0sXIxfmGnW45a9rRpZJILzTL0rP1no0fCAKcB2PgwaTGR4gRZlrxcOuIKaOTYJUDEMCO8yrGKAKZdfBsvaPJngemZJfgiW9pvSekjHMeS6ZEoW/6nxORkCNFlmQESoyLSgTOs+NUWpZ1TY0kp7FytSOghEQF6LJHKcFEaUqpaGNECkgyIxWjNNqeD5yZHosNMY/Dg4RxrakyWCRSKUqjWIiCBs/jsw0r2XLR9KP7uA84Esc2sPaeM+fwKnKYFT2RW2XJTng6EZkby9Y5YhLUKGLMbHMgKomVko7Rk6IJno3ztMlzagq0ljzvPJswDo6rkHE5MhMSKzKBjM+JmBLaCwb77wbqhphYE3m5nrCwmgpFzhKZA50EqQXESDcMWCFH8y0h2fWeINJ4MaYE+/B7MZRak6UkpkwvMgbN1geMzGhhKLWiNJKZ0GwRXJ9v6XTDdbejj5FVHIgxclJPxlsB1xGBmVQMQnOrqsk3DrlGllwNo3pTiWTnHNvgCTJTKoVCkOUYf80wsIuek2JCbSPP2h2N86QMKwYG5zlQhkpJ+pAYUiCIUVZYa0U9jD3WjkyXPFMzYVZYSkY3e0jsfCAhwCf67CikYq4NNYq1d8RxthN9o4q258UwVZosBCmP4gSQ6WPGRDBKUSo53kIKSUCyWu1opWQzOGKMdHEUMXCkUd7c+3HgW4JEsiwsOY6CF8ZoVr4jZYFJgjYEdmL0WhpnRW6cf2Ogi4GBxFIXdCpxNXj65EkhonzEp0RtJEqMiX7Iow+JuZnrzGGci0si0hA4MrPR0Cu9l+xn+hu5ZJHAu4CRUEqJIdOGRFRATijx/g+dH9qEv/GRrCVZZIJI5BvdaZ8zlRZjRf1muMELyeN1i2ZUQZEJYhbUwuDleJVjbtR7rFDjEITIhDQm40Zk4k3DaSTT5XijMjD+OebMLjhcymyDp4sRU1kUit57JBmZoE+JHDNzrUYlHyEYdV0yMgtSGqtaMmdkhlIqTsuSu5OSIYzGCy4EtBgPMzoKUhzlFoW6UdkgEjNICUqOgbHnxdCHhFNjzPkcR2WlLOhzYiYktVAYMVYatJA8uh5bW7oYKIQc7bW14dp5Bh+QCCqlkHns6ZNZkEl4kXDJ041uHkgp8GGcL7FprK4mYBMGYk7svMelcWCtUppKjZP9Sgo6xqpBxVhFHafb9NhPncdEK3FziJAKIwV3JjV3b9QnNn1g8D3yxm5ex0wKcRzoVBolMhsRyCR0vlE02G94L4QhRpKAmBMhjwP8OWe6kJhqRSnEqBolxuG0R9c71M3rtFBYlSm1YRPcODAmMlOpsSiaG+M1IcbWrESmvVFhMTfqZyFlpNJIFC5FNs4TUrqRno0c2TFGrAiAQCPoCPQxMdWjh4gBJkiigHyj255vzGisHNexk8pyZ1KTg2AzeGL2FEJSCjWOkcdAUAptx2G8ID2Q0ElAHtfHPR88rQugFfE/+Al3ITE1/279yGmspD9er1AiM6SAFIJCKqaqZOM9XQhjBVOPJlZdBCXHquyQIipr+pvb6kCmj4EQM8YohGI8QAwDOSUa52iCZ15NODCWnTdEBFppOj+uoxMxajdpCZVWRMbBcnIkM840jZpUmdPpjFuzEt+P0ogh95RKUQSFSeP6FzUoZVAovIBMpMxq7B7I+xvOF8UQEihJzOByJCWQSuBywjKq8EjBuI7lzMVunLVzaVTGK+R4E9PGUfFGMt5Kyzw65co8doxEMcpr+yQAgQQckZASVbakOKom7ryHPManS5kDa6mkolSZKMa1eBCjsl2JRIpRvcwIyc0ZcTw4jPk+mvEgsSwKZqUl+fH3LsYBdSNTLGImp0hCopX4tvoeOY9eLIwHovfDhzbhvxwcEoVVUABaaKZCcZXCaEYjYEgRqUYHvLOuH6f3uRmURXFia56ljhJFJSUWhVWaXfac9wNBjLYOQ/LMtB0lvHQmJghxPBA4IUhRcNEPJMZTZhYJUSnqpOnzqPuvhaQrDBfbjgOjkCJTinE2QEvJeRyHk1p5IzGF5kRZPjmdMp+WXHWZy9CyS5lKGqqcUUAKiZghK0EW4GRCB9DyJpjiPtl6UTxtemShsEreqD5JamCVPBMMAmiSZ2BMyFbNQIgRqxSLajSFqYzmWdNSCMGxKam1pVeBIQQum4GkAS3YJEddWFwcNYGRiRziqDoRBZFITKM0bHhPlqzQ1FiWuUCIjLo5ZDxpew5JhJvhtpkySKF57sar7Dbd3JBJyR1b8bnlktm05rILXPstu+CYSU2XA8jxbjFFiCGTBfibQ7AOEpFvVHz2fOCc9T3KaoyEIme0FtRSc50Gasbhxc5HhPEIIpe9J2SwSjG3BXMKKqO46FusENwzBXNl2ALOJ67bHseoOLH2oMyY6A8CUspEMipHfBZ0PnEeBjLgUsYncEowSYq51GipKJTmQiauW4cWCZklRgqOlUEqOM8RcsQztlLWWrOwmldmNUfTGesusvKRNngWKNZJkaSCFPEkHBIEeAWQUTGT3egoveeD56LpoVJoJSnyWNSYGsPzLjC5OQT0cZSvTEmx8jsgYZViYi0TLHM94fmwxgrBnbKm0gqXEz5ErrsBTyDmjBeCShtcCoQMXoxrTI4RnzMb5+hDQGZBiGk036wEU2E4LEuElEiluWwkl7SUMRNJoxN4UZBT5iIFREp4A0YIaiRzNJ88OmY5Lzm/2nHR9HQxcFhYVr1DqgQ54uKYZJIFTkEmUUaFSGJUBdrzQrhsBlSpkUqis0DmTK0Mm+TIo1owLiaiyqQkWbtAzhktJaUxlIxdGzs/oMU4+K/FmONtCay9gzy2p/V5bB2KKZG0gDgqQQ5pVATqXCD5dCONDSEnfCGZJsV01N0EBUEInHOYmMhZoKRgqkebulUMo6oUo6qQEaPk7UldMKlKdp1gGxr6FKi1YufGIknKmZATOY8qPUmNLcciC2QU7zsP/NAl/O/5gM2toCPS+tFp7ZZSRCVZ+RuTA59u6ooDJ6YarwLVKIFUock588b1CqTgVJUUSrFODisSyMBuSBwWlpOyYqIs1maerBramLh2nm3wpJRJSqKBbYhIITBytEL+mdfuc/buloOYOXM37oMiokJm1ToOCzMOyqVELRU5RQbnEHo8ACgEUgmUErSdoxug7QZ2uw4pE4MP4+1EzBRBMvGKKMdhS+Eg+/EQIG+Odh8y/7SPNO/9LGeloZM3w0Epcr8siFJR+FG5YptHqcoSgZWCIUIUkonWHOqCnDNffX6BkIKjyYy5sFx2/XjFKMd+wjtmwj1bUyuDLTTfvFzhQuTS91x7TyBTS0VImUamUW4sj46DP/tDn+HxW8+ZZ8GTruH50JGkQrnR9XlhIeVI4xMLNIpE3wU2elwQlRSkHPkJqWg7R987Nl3D+W6HlKN6QS8ziUzlE9Z7ohbkm0pJIpIDlDf9g/sY/GB47+c4VRInPL3PpCi5PS0ATSdGg8GcIkpKIGEw2OQwjDdPixv5ti9frDDAy2VNJTRXw4AjE4msQ2CmLEfGUqJYVAUP/ZbsYB0i2xTxzqMJBDI7IkYIjBglP//gyyeszrZMW8mFd6ycA61JIdInwcRkghyHNefakNJAiokNGRgVz5JMVNLSdY6m96z7sS1TSsmQPSmO/9Z6qNzY67rJEGMmqfHOwOR9/H2QvPdzLIzGiUjnIzEq7lqDUpKJUvgY2Q4OjabSihpD4zuEGpObpSrJZL56cU4l4Xg6YSosF+0wenzg2brMcVVwv54wtQW1rHhz85zkM9d5YOM9QxhddFNKbKVHZUmRxxvwP/Dqa1w/v6QSkvO25aLbkZJCeDn2/KPIMdEwFvRS9rgALsSb6r+EsqTSlqHL7Ho3tgv1A8FFnI9jVhWhyImJDOSsKVJGy0QUbpT2Dr/157bn9897P0tjxs6O5G9cvDGj/KYYJTJdGA+eFvPt2ybJaC5YJUXOmW/ttlRScFoYCg1r7wlJ4uS4js51yaEtKJSkUJJnmwaJYBOhcRGXRi8nmWCHRwmJkRKrJD909w6Xz65RKbPyjvUwHjiCj3gEhREMaZRan9383uDBc+OaKwAzOgCHzjH0kW5o2Q3dKHE8BKIUiJwxebx7kFKg0uhsntPYmiv9+8sDP3ROu48ePeLBgwff67fxkePdd9/l/v373+u38bHgW9/6Fq+99tr3+m185NjH4AfDfg38vbGPvw+Gffz93tjH3wfHfg/+vfG7xeCHLuFPKfGNb3yDz33uc7z77rsfe6vqzWbDgwcPfs+fNefMdrvl7t27o7Phnt83q9WK5XLJw4cPOTg4+F6/nRfOPgY/XOzXwO+Mffx9sOzj7ztjH38fPPs9+Dvj/cbgh66lR0rJvXv3AJjP5x/7xeY9fj+f9fvhF+K7yXu/MAcHB9838Qf7GPywsF8Dv3P28ffBsY+/75x9/H2w7Pfg75z3E4P74+iePXv27NmzZ8+ePR9j9gn/nj179uzZs2fPnj0fYz6UCX9RFHzhC1+gKIrv9Vt54Xw/fdaPCt9vz+T77fN+FPh+eibfT5/1o8L30zP5fvqsHxW+357Jd+vzfuiGdvfs2bNnz549e/bs2fPB8aGs8O/Zs2fPnj179uzZs+eDYZ/w79mzZ8+ePXv27NnzMWaf8O/Zs2fPnj179uzZ8zFmn/Dv2bNnz549e/bs2fMxZp/w79mzZ8+ePXv27NnzMeaFJfx/62/9LT7xiU9QliU/9VM/xa/+6q++0Nd92Plrf+2vIYT4LV+f+cxnvv33fd/zcz/3cxwdHTGdTvmTf/JP8vz58+/hO/5o8/uJo49jDO7j77vLPv5+K/v4++6z34N/K/sY/O6yXwN/Kx+K+MsvgL/zd/5Ottbmv/23/3b+jd/4jfzn/tyfy4vFIj9//vyFvO6jwBe+8IX8gz/4g/np06ff/jo/P//23//5P//n84MHD/IXv/jF/KUvfSn/9E//dP6Zn/mZ7+E7/ujy+4mjj2sM7uPvu8c+/n47+/j77rLfg387+xj87rFfA387H4b4eyEJ/+c///n8cz/3c9/+c4wx3717N//1v/7XX8jrPgp84QtfyD/6oz/6H/271WqVjTH57/7dv/vt733ta1/LQP6VX/mV79I7/Pjw+4mjj2sM7uPvu8c+/n47+/j77rLfg387+xj87rFfA387H4b40x/sfQE45/jyl7/ML/zCL3z7e1JK/ugf/aP8yq/8ym/798MwMAwDzjm+9KUv8Zf+0l/iW9/6FkdHRwgh+Nmf/Vl+6Zd+ib/wF/7CB/1Wv6sMw8Drr7/O7du3KcuSz3/+83zhC1/gwYMH/NIv/RLeez7/+c+z2WwAuHv3Lvfv3+ef/bN/xuc+97nf8f/NObPdbrl79y5S7kcyvtP4g++PGHxR8Qf7GPz32cfff5x9/H332O/B/3H2e/B3h/0a+B/nQ7EGfmBHhxseP36cgfzLv/zLv+X7f/kv/+X8+c9//rf9+y984QsZ2H/9Pr/efffdD/pRfiT5TuMv530M7mPwg2Mff/v4+16z34P38fe9ZL8Gfnhj8AOv8H+n/MIv/AI///M/z9OnT/nMZz7D3/t7f48/8Sf+BP/dF/4CtxcLaluitKUFCjsh6oI3H77Bs/PHuOBx3SWlgkldMylrootcPV8jbeYnfuo/5erx1xFpQIeOePGclsCztsfFzEldc1BUeGG5LSPnTcu7uwalFLfmNa+cLjFaUeqSEBO7wdM6TxwGSqPo+46Huy0pRgqhEMKAEtydTXm4W6OVYF6WtH3EaMgBREpoAAGb5DgylvvzKWvnaWNCKclxUXEWBnYZTqqKuVIYBYeLBZO5JXrHtk0Enxlc5E9/4e8zm82+x0/yo8vvFIP/w//wc9w6OqLSFRkJpaUoSrIqkDkhSACksEPbClJiaLZE59HG0qaOq2ZD2lyhFOBbhkdvsvKBs25HEzMvL5bcWx6izJSwfsrltuWtzQ6tNbcWM15eLqlLi8oSHxOdd3SDJ7lAkgIZPE+2G4YQUFJjpQEtKApJ4z21NcwKw7b3lKWiHSKi9xRZYI3EWUUd4HRWsQsel0ErzbRQPG0aWqm4XU84sBqrFPPpAfXSkJxj23iiz/RD4L/6wj/cx+Dvkd8p/v53/9v/JYcHc8pygiknJKMpiylCKkAAiZwTZWHQJK7Xazbb57i+QWWFd47VEAi7c+qqRAfH9uHr7GLg3W6HC3B/PuP0YIGyFaUcuD5b8/X1FiScTGs+cbKktgqDxAdovaf3iRQyMUYknuuho/MRkWCCRheKymoGEqU1FMawGwZSBBcjofOYDKWRYDQiZW5PCnZkAqCFotKadRpoZebYlkyNxijNQV0zmSlSTOzaRAiZboj86b+2XwN/r/xO8fc3/jc/x/3TU5SQDDGSjGEyO+Xq+ow33v4G7z5/TNf33Dk9YlpWnBwsKMuSSTVlPj2k2V2zC4rN2RuEvic3W/L5E7yWNGkgCslyOmdaz/HCYP3AsLricdeBFiznFfeXcya2RGtFSJneJXoXcH3Pde+YK2hCT+cD0UOJQVQgrcQgqY2mtJbox9W66Xq6rkXlTK01utJEn1jUJX2KJCEwUiMROOnplWFpCyZGYYxiUtZMF4ocI7sm4H26ib9/vI+/3we/Uwz+r//7/4ZZWSMEZA1FOcc5T11UGGOxRUFZ1RzMppAS55fP2O2uIUcO6pp12yFEwdBcMTQrwvaCfPWEPmfa7CApjmYL5tMZfVLIds222fC8HdBGcTirubWYo63ESsPgAz4kXEp0LnLtdhwITfKOnff4ADOjKW1BrxwyQWkLysISQ6IUkuvOs+laTE7MrKGoCqILVFritQAhUVkSAKUjXhlqbSiUwiqFLSzzmSRFya71xBgZXOS/+qv/7981Bj/whP/4+Bil1G+bLn7+/Dm3b9/+bf++KAqKoqAsS5RStG0LwCQ5FqJDh55dG7lyjrpa0CbJbn1BGhpqAaeLQyZacf/lV9FKc3Z2wfnZhrZt2WzOKA6P6fsV3XpHIcAaxf16zq71HM0POVie4Iopt7srto8fU1lFyhkpoKwMnQ/cnk+RQjAfAru2Z9dpRIpUhebJMJBUZF5YamVBSHoS2xw5KkpO5xPW0uFUhiExeM8uenJOLOuCQmiygXYI7IKjTBKhDbum4+tNw66uuD+dcDqtEN5xMCmJQZG8x6WIMmPSKYT4oB/lR5LvNP7gd47BzcUTlrLHllOSKkhMqXRG2hIlxxOcHzpWqws673hw9yWMlmhhqGcLci/YXj/GWoupLbKPDDpTCMG9ekYzRI4WCxan97CLU9pvrum9p3YahEBLsIWiI3JvsUAKweA8bdfTdgOd90wnJWd9T1aKaVEwUQYpBZvk6aVjYhQHVYVCkmpBBHrv2bqADZK78xpCRlvN4HtaHyhjZC4Ldk3H6/1AN+t5eTblZDIBPzCrS7CS7D1DCoh9DH6bDzL+tlfPmOQOVU9JYU4oLdOioqhqtNakFOn7DiEyWgiETAiZsdYwLWZsNtfoEEjTKXJSIfodUglKJXmpnrJrIsfLQ05v38UcHDLdXeDXLdYoQkwIAaJUeATHkxlCCHyI9D7Q+8xqs2NWWLbrQCUVtdTMtcFoSUeiJUKhqK1BScFuiAipcC7QpghKcqsucDFiSkl0Dh8SkoQUiXZwvNW39KXjzqTmeFoh4hjzpECKHkdE5H38/ft8UHvw+dN30P0lRgiGkBjKitc+OaFtN9RFwcunt1FK87lPfZqqrNBmgvcNWikODo7xfkvTrHHFlHJ6iCrX7C6fkEXm1mJGknB66w4Hxw/o9RSevcs29jwNA0lmpBrjrw+BO5M5UghcGBP+rre0VxsOJxa/y2SlsJViJgyUgl2IaAG20OOBuDJ0IRJTYggDg/MIEg9mFbtdT1Vo+iGQUoCU0NmwdYGnoSGaCjGpWcwqCJ75xJATxDAgUwCTgX38vccHuQaKfsCIiNESqUqMVRAdprQoIUhxwPWB3mQUmRB7XOyorGW5PCRwDcJAcYqoK7yMDJunyCQ4nk8RQXJ8dMTB8V28meKevIFMjgsfyFqAEZhSEcjMpzVSCEJMDCHS9J6hiRway7YVZK2QCA6UpSg1VzlDklhjKQqDiIlSGtqUkE4SYiIKOJjXbLcNpR0PkjFFSBHyWCC5DANTZVjWJeWkQqXEbGIgKggO5xOK9xeDH3jCb63lJ37iJ/jiF7/IH//jfxyAlBJf/OIX+Yt/8S/+rq/7xV/8RQC6zZpt7iiMxAlwfUAOniZq2mEgSU1VltR1Sbu5QhYLpLYsTyt+pDrg0eO3uLh4wu2XPoUSmdjskGw4qUruHUzonWNdHuEP7nJ8eMJk/Q7+4buYG7kkBbjguNhuebA8RkpNoQArkdnw7mXP/aMZdydT+uC/ffpqPeySIyuJkoocBbvOYQuNCJGt86zDgJCZxbwkBsk725a1H0+DtZCUWnBqC15vdlwNPQrIUaCz5iRUCJExQoAQZLlfZP59fq/x9++/9r0YbJot60tHKmtEOcENDtltsYeSajJHCon3kV3nefvJO3zykz9MvTymbbdsty3bbUPT71iePuBgOsdfK66d5HhacfugxsVIXxwSqyPs8ja9rRFiS6ElCFAi4WLHs13L/eURWkkkChk1yQWum4Gj6YS70xl9DEitIEEiY5XFpICSCrLCu4wqBCJm2pTZ5YgF7iLIWvO87TnvPSkmtJKYWnC7mvCGH7j2PUUjIGRygGNXoQRIIdFSEmV+wU/1o8MHGX/r9ZoyO4Zmhyy3dKVhkjSmMNjqgBRh5wfaXcdkOiVby2x5Suhbrq/WrNoti9kMJwq0Nbjg6JEcTipuH1j6LuAnh6jZCfPDW8ihBQFWC7SQGDI+dKz6xN3pHKMUCtBktIhcS8G0qjkZHIMPKKEQWt7cEimMACElMQFRkH2GkOhzxotMJtGFgBKSs65nkxIiC6yESguOY8nD1LNxDp0FyUGaZo5uT5EKpBRj/In0Yh/qR4wPag/2XaIRG0otEMrQxoxrzum9R6GYlzOm8zm3bj2gMDXZFPTDGtdvWa2u6L0jScdkOmMyOSBpw9aUTK3ik8spKIlanqCP7jEplmw218SUiSRyzsQU6YLj+mrHrYMFSmuMlAglkVpTG8tkUjP3geA9RkiMNjgJKvRkmYgx42MiiETTOZzzDCnTknBZEJVCSMGq68dDKBmrEtNCkWPNKgV89GzajhgSvo6cOINUAikEWipC3sffv88HuQZG73FpBzKhupI2JnxOiLImDg3R9WitITsEElvXHFYlOUTOVtfsmi3Hy0NyMUFoRWzXBKFZTApuLyaIlJGHh6jD25Tlgt3uOfHJY4KIAITocKFj4x0n1RSpFIqMJZNk4thOmJeKEDxKCCQKkTUIKJLBS3A5EwZPESOZgB8GSAmfMm3OJCnxOXM9BBACiUAJmGpJyIpV3+GDY5sTIQaWRYWLBktGSokSGol/X8/mhbT0/PzP/zx/5s/8GX7yJ3+Sz3/+8/zNv/k3aZqGP/tn/+zv+ro//af/NAD29j36OBD6LSINGGlx64adNNy9c59JXRP6Dud2pGLC2dk5gkAWIFTBLji2myu28Zt87tVP88rLC3bB8+qtOSp2LOclWS+4qqZELTHVgi5mJtJQGcGsUIigyMGwXq2oixKFgBDxIbLqGk7ylNOp4bKPbEOkUprLpmdSl7xmLUtrKKXEoFEhopXgTl1xEjWSzKmqOR92lEqyQ9PlxFWCkyGxjY6X6gmbwdP5QGM7+lDw9rc2HC1KREpIxl+kPb+V32v8vffa92JweetVutwRXMdB2BG05fHVlpPZHJEMKSXW3ZagAqcnh0gBMThEztRlSdM6PnXvNRbTBX4YcD5ydHjCp29NiNGjlOS8WLApC5p2Q8Cw7RwLVWCUpJQGskS3icuzC2b1BKUkMY0LRxsHHDUHU012kS5EjmzF1RCZFoKJnlEbS6kMrXXIENFYpjNNSiATWDJb1yOlIIbEzjmCihy0im0M3Ckqeh/p+kAnHKEY+Na3LlgsKozIY5VlH4O/hQ8q/g7uvYJ3LWnoqenJhebZsyfUJ8fknHEhstk1XF8/gzMoppboBpKP5ABXZ+c8eHBCWc7YbRpCgsXJMa8dTVCuY1lLNpNDhnpGCIGL52dsh8iBlWgUU1tgIzRbx6W54mA2xQiFiIkQIrvBMVBxUBXsBLiYmFrDdQ8FiSNjMFojsiQgsSaDgperKZCQGUqhuHIDhZKklOlTIshAOSi6lLk9Ldi5QOsDReqZlYq33r5msSgxApSAnPYHzv+QD2IPFsdLnpw/p/I9Jwclmyi4ePQEU99CWBACpCx59OgdTk/vUBpL9g3N6pzHjx9xubqkKQSfOLxL6FrcMDA7OeFTxxUVHpSmL6YM2UDbcnZ9RiRjlUSkTBklVZQ0Ds7PLpkvZmipSCERQ4Tsgcy8UjQiEOLYQtb2DhcS2oxttlKYm/YzqKqClDNTpcfCSpvoYqJWEgd0KdORsdGTgGNb0LlA5z3kxEzBW29G5ouKUo2H00GEF/04P3J8UGtgdXhK73cEt2VGQCnL0DZMyimNTyQBZTkhYwkxIkMk+gHfNwzDjt1uy/07J8RuTZYaMZljDu/w0pFFxQ6lJH0xw4ma6By7rcMpmCiDkTBFI6Jiki1Xuy2zqr7Z5z1x8KQIoJgaTU/GhUwMie0gEQKqQhOkIqR/V5idW4tVmpwSKkO3aogxo5QgZQhkIgIVBC5GigwhZoYcUSLg9cCTR1fMZxM0oCTvu+jxQhL+P/Wn/hTn5+f81b/6V3n27Bk/9mM/xj/5J/+EW7du/a6ve/jwIX/lr/wVTm/d5s7t+6wvL/i1r/wK7z57m//ij/2XDO98jefPX6d3A0ZbXr3zOc6f/lva7TkTO0FmyeAaaqNY1if80I/+IU5PT1Hbp1jtWV9dUk2miAhKaZa6ZqbnPHz6Fe4cHdKHgZ0b2GbBbaWI7cDrnFMJS4gSF8CQscCTx8+5PbHUSUCU1EZRkLmrJEoIms5x1vfsSGgUDnhwMOWVxZypNZw/OePO/IAYB9Z9R+cSScLWjqdLHBSMgbL1iTebK+q1ZHZecLics5zXGGNexCP8SPN7jb/3XvteDE5vHXM8O2R9ecbr3/oqzfOnfPZTP472iZmZMJ0dcjQ95ctf/kX6ZsO//J/+EXcOb7OYnTBkweZqw/xwSXJgZM28rBlEy9Pzltn8EBFBTkrqskb6QIyJ4+WC+ekR17sNbrdjoWou4o6zzZqL7RqXNSErSpEoYuL6asNSCwoviDEjVWQzdLyyWKKkoG0Hzq4bjNVcx0SwiRNruXtwwEFV8fzpFSdlJMbMw6ZlmzJJAKpEx5a6y0yVQgtB7zzvrreEyxWTM8Xp4QGHB1NUWb34h/oR4oOKv8XpCadHh/i248njd/m33/g6f/jHf5rrq3PqeslieYuinPDw4evsdtd433Hv+Ba3jk9JRvHGW46zsw2FDtR1ydGkJDzbsH66YTo/RAhgpikmJYUtcMmjioIf/fTnuLi4ZHN+wUJOuI4d28ExuGt2SdFEySRG1DCw3ayZi4wIER8SPY63rnf80L0lSkLXO5ou0MVM0BBax/2TObeXUyopOX9+zYOpZRg859uGjQ8UUnJsSiBi0RwpSRSRloF3LxNls8VeSY4PDjicTTG2fOHP9KPGB7EHf/7HPo/Rkjfe/Dpf/rVfpWl2uAF+/LOWe5/5MaZHdxn6jn/5z/8Zjx69yW51yQ/98A+DknzlG1+h2fV8/sf/E7pBUhrJTCgK4VhdOTg8ICUYciIQSFEQ2x1Yw8t37xC8w6bETE64oGUzdIhVpk2KXciUBGxKbK93VCqTXaT3kYKe83ZgWWgE0LYdza5hWU1IQFUXFBPFQW2Z25Kriy0neorWmav1lsEFkAqsATygqQpJypEQEo+aloMAF6trDmYzFrMZUu/j7z/kg1oD1aTiwckncEPHwydv8vTtr/EHP/cT2HbDwdExpp4SYuDJ5TN0iKzPzrh7tGRaFTzcXqKU5nLVYm2BRqOlYT61dA40CmJG25p6OscPHZthRTU74JXb93B9A0NHJS0Pzy+Zz4EhMAjNkMfZNwbHNji0gKEPdD4yLQ1XbuCkrskxk4cBYiIXhhZJVVtKIvO6ZFZYnj+/4KSsAXi8G9i5NBb8DqbQrLHWosgIMjFnzncDk15yfdUzP5gyn1aU0r6v5yJyzh+q8shms+Hg4IC/94/+b6icWD1/yLN3foMn1xvuv/QSD9cbztdbusFhlOLV49sM0fH8yUNc75AIJqXm6M5tlvUp09k4SFRayUR6MnDx1r9mtrjL4cufoz66Tb+55q1f/QfsrGS3u2a9aSiF4g/cO2W12oKAZgh0LtOExDYNvDxfMNMgY6IZHKt+YOcCD5ZzlJEgBJttz67pqaaWc5eQKnNSlRxPKmaFpd/1TGYlTTcOIDU3m6bxAWkVZ+sWI8cyllcZLRLbGMkR7lQ1s6ogSfjv/sd/wXq9Zj6ff68f38eC92Lw//F3/08E13L17B2eP36D57sVn/n0j1AUBS9/4oc4OrpH2275p//0/85nPvOjXDx/iA+OFDMpwuHpXZbLKUPrSTki8oDwo+RW+/gd5ke36coZ1wG26ytu948484GX7t/l2fkF7fWan7h3j8vVFqUT28EzBPARhhBZTmZMa01uOtq+pwmejOZkMcNUAiFgte5YbXrq0rIjY62mFoKD0jApFX03MKln9F3PVTewiQ6fIpOgcNnjfEQBSWaCyJgEl64jCsFpNWNeVyQj+F/9jX++j8EPiPfi7+/+P/+PKAm77QVXV+/w8Owpd5Z3OTw84rVP/hjHx/dpmi3/4B/8X3j55Zd49M47DP2AtZb54ZKynDOflzx7/ITgPZNSc2teAHD+rTeYLJZsdUWrCypjUO9+nSe+44d+4DM8evqMy7Pn/MS9O1yutlir2Q4DfYAhSAYf0Dlw93SK9pHGeTYuEFxmbgtmhwVCCraNY9s4SqtYe5AyU5WKRaGZKYnrAtNZSecc14OjiYmUwPqElCCUIqeECwEXA1pmGgFt8twqpyzLiiwE/83f+OI+/j4g3ou/f/D/+T/w+Mkjnjx9yK455+nFik/d+xSffeVlisNDKAuGvuerX/4VgjG8/rWvce/kmMV8xtnVil3f8uDBa2yurlDGcrg44MHJEshw9jYr39PPjkjTQ1TKTN75Kp2R6OmM3XqF6js+c3qb9W5FSorODfisiGhycmjgcFqRnKcbBjrnGAbBfFpQ1gVCwKbpaTvH0WRCK+FgXjF4j5ZQWwV9oiglwWc23jGkBElC71AqoU1JTpnWDTSuZ2o0rQ1sW8ftcs6srBhy5L/d78EfKO/F4P/+//w/UhUFfXPF6uoRz9ctn7x1l3qyZHl4QlVP8d7xrbd+k9nykCcP32ZaW6w1NO1AUZQcHh7RtiuMqSilQXbjfIDvHmEnc+zhXeRkydANXH3ln6DntxFGsLp6Tmy2vHS0ZL3ako3EO0/MmqwsRmZyzlRWIZyjGwYaH5BIZpMCVRQIIeibgb4ZsFYQbcG0tmx2HVYKZlbj+oHpYoJ3ieZmNjMDRIg+YIxG5owLgSEGtJIMKtD0iZOyYlFXJCn5r//7f/S7xuD3XKXnd6Iua6wx5GGHu16CMBSmoAKKlAkxoVKiXz/FHpwipSSliLEFh4enLJYnaGmxdYXQhmwNanbK4cEhq80Vg52gp0vqyZJmu8X1PW5ySJCGUlkOpMZIzWI2RQrIsiPkAUKkcY5d7BkcpJDZeUcTPCopFvOalDMZSDERUiRkKJJA5DhW7GNi6BwyZXa7HTGPh5S5rREonj+/REtFTwYElZJUWqAQSBy7FLjqB1bO86E6rX3MsGZKVZTEfsuwmZKForQ1bb/lavWMKCJD36FTT983CCXpti1d16N1yakWkCTqZqEQuuBw+UkysFk5Gjsn6gIlIrYsGFaBnUjjNZ4QSGOQWnMwm6JkJtMissfHQJMDVQr0uxZ62IZAmwMnVcVyPiHk8Zq5LBK6iKyJTESBZuyvdiERtoFCJnbbHQioCsXEzBFSsTpboYRmS8TkjBWS0ih0FHQx4CRs3UATA+y1p18IuqiYViXBd/jBo6NCS8tut+b6+jlSKrpuB6mjNIJ6UrJudqw2PV4pPnV0SmFqDhYLmr6jqCYc3n8JqwwXK0eoLVYZBBDd2HLWIehjRinFtLBorVke1CilcDmSUwQiuxhQAi62HbXQbGNmExMTJIezahyuE4JYZFyMxAwTa7FaUuiMzJnOjwO6m103Xn8bw2xiUFJxdbZCAj4LQGCkQglBoQQxOaKQDNFxNWRi3M8xvQimsyV37gBEnp95gigxxvKNt79J+2bAJSBHRHPFKit8cJxfX4GQ3Ll1h/VuzeF8yTB4eudoQqYt5syrmtWu59nVM1QU2BgYhgHjYSczpU+IBFYqpFZM6wlCGfw6koZISo4mOqa64KrpESmxdo6d88xFwWxSYGsz3mCJPA77CiCDCBmTBWTwPmFjYNvEcWZFS0pjkUhWgydnRRJj4cQoxcQYSm1xOVJJBTkxOEfj9y09LwqtQWlJFoLeewbnAPBh4GpzgWrXhOBpNpf48bGOtzRCUlY1SUiUUFhbo1SB0BZRVhzUS5pdzRACSRVjjkcgo8j1hJgdaIU2Gq0101mNkHAVI8SEIOBQ4BxtmygFtCHRpjQWM6qKaMZ9MQaN854uJrIbB3KDzwQiMUQqAZu2R4oxV5gpg8qC9WpHANJNTV4qSakMRjC2r8lESpFmGHDx/WWCH9qEX0lFWdXk5Smhe4XioMHFxK1FZhgiJDDaUFaKqp5xfHqXbbWhKiru3nsZoeDq+pxqPkcqQxTj8EQ1OYDigPXQYq8v8VnSe8fk+GXUfEb0Cila5nJMjLTSbIZMmkwJ4Zq+aXAhMThPynI8hWUAQWkUSEkhBD5FjNVUdUHjArfnBd4NxDiqDEilIHgu2h3TcjIquUhBSmMg6Dw+XCuhUIpCS1zMzLWlFIo2JkLOJL9P+V8UIUSKScVscQLxNebdQJIWrSsuVxdcNxuUlBwdniKlYDo7RKmCYehBKMiBs2dPqWc1QhuKcko1PYaUsAfHRCuJOVNow8HpfawpCGFHNZtgc0nWG7QAXRgu+8A6lOx8YOsG1sEz7XsyniJbhJAoqZFKEgElNDEGrNJMJiXODRxVNT4O+JhIKaPJCBlphp66KpBWo6RAJEHOCSUlhdLIlNBCoIQkiMxcFyQlGEIgpEQI+x7+F0Emo23BZLbk8PA+RbFEoPBp4MmzJ1yt1ygFi8NDrK04Pr6FMDXd4LHWQg6cn59jS8PB8oj5fMH88A4qScr5KV1qSSkihWBaTykffIbgGurpMVoYnDVonbG6ZJcUwUDTrVn3Ddd95P5kQj94bKGQQmKkxAiJtBKlFTElrFHMbtbARVnhYyDFSAyZRILo6UOmKAzGaJQY+7dTzggE8j2FaSGQUhEzHGhLLTQxZ3LK+/h7QUzqOdPpAcaUJKFJ5gzfdDw7e8J104DULGczJlrx7NE5n/nkZ5lOZ8ymc46XB3zzm1+j3W0wRYEqK6azJdXkiN47WmG57gIibLDdQHSe4CXFwRJTFFTSMkkOLUEVFbGsqdWE/uqS1fUl2+iZTAo2fmCmDVIqlM4U0qC0wmiFv6mGloVhiJlZaYE89v8LEEowBEcXEkWhkWJM0FKIhJzQCHKKpJjHYXVrSEkyEYbaarSQjCoJ+z34RZFv1ielC3Q5ZzY1ZKEIMbC6uiQLqIsSU1QIoZnPFuScUVpRlpa261itrhBGYa1GGEFRFiRt8KKkdRtC21NkyCkwOXkZMTskhIFpyChTo1SiqiqSrpkUR6w3KzbbFX2GeYhsfUAZC4yHCy0EQkiEhBgTUgtsZQm9p7IG5zI5ATeJ+yAyrvWUVYFSmpwhhogPYzFN5LGVR0iJ0QpioBaGysgxZlMmuvd36PzQJvw5JzJQTBecvPajRD9w9vB15svbtEmQ9SV1veDk5BZSSZa3XmbTXGOU4s7xPS7efZMnD78FWjCdLbGmwHUbbs1PGQbH9fUFV9s1s9mCOye3ePCjfwRCz2+4Cmd2KDWg9TU5S55dBYblfdY6sQ1PxxNj0MxqQ5kzIWq6GIkis2kHDuuKdvCEnChLi9KST946YrNu+dr5JW302LpiCIGn3cBLRQ1RsFu3bLYNu+QwWXDPViSZQEHIgivXcFrWHOmCWfKEFOn2ChUvjKZtKApFNT1kvryNEAPf/MZvspjc450n32TdPGG5POHTr/0IWimsnVKWJZnAen3JxfN3ef2NX+fk1j1Obz9gOi3Gg2ASHBzM2EWH264plOGllz/NyY/8Z9y7eMh6e4Err9HTS8z2KYjMo3XPu21J1yeia3BZcBp7DmYVc205xuJSog2Ry3XD4byi6weyEBzUJaWU3Duaslpn3r7coMgsC0Nzs2DpyqKB3a6l2faQImWhuVWUxJgYUmDnPKvgeGAmlEqTdCSRaPp9hetFEOOAC57J7Igf/JHb5Oz46lf+FVpMefjkbdphy+npKa+9+jkqMWGxMLz6akEGdu2Osyff4t/+xr/hzt2XeekTLzOfzpFK0g09E1Oy2q242lxhlOKzr36Wz/34H+H+2VNiHlC3A7m7ov3Wr2NQXPWS6zznUb/m+XpFypJPzGYoJZlayVJKQlS0IdKmSM6KfnAYoZgXJVp57iwmPF2veNo4TM4cGOiCZ8gKJSUiQ7Pt2O06Yo6UyjBV3Ci3gBdwNQy8NpthNLgQiTHRsI+/F4HWJZPJFKVnYA4Z8r/i2eVvIqXAFIaDxSGfeeWTPL264uyr3+K//aN/gpfuv0yIjqurZ7zxxm/w61/9V9x9+ZOc3n2J27fucDQ95t/8xpfxmzO215es2oaQElpp7h7e4X92/0eQYqAqNdPcYZ+/QdSazk4p53fo2m/wuH1MjInbJhF1YlpqjkSBjwnvR1UeHSWrZiDHhEFRScGdkykX657r1Q4FzCtFHwY0JUFKpICuGei3PS4Fai0xMeP8jSKUluwGz+mkwApFH/343vcXTC8MN0SsDWhTcnzyMqfHmWGzJmfJensJwOG9I+rZIYUtsVLQO4dLDknANA1vP34LM62ZTA6Yzw9Z6CVPL9+l2Zzjk0O3BWVZM59V3P7sTxNdT9s35PIE1a9RmzeQStPYE+YH91g9/iZnlxds+47SVkSjMIVkKhQpQkqOtk9jO2bfo5WirkuUktxaHPB83bBaDeicKa1k0/ejAAsZUqLvPF07EFKgkgYNDDEBGoRl6wNHxdjXH2Mi5Ux4n2fOD23CL4Qkp4zSmum0otSGu7MJr7/zNlpbjNbINNC2DRvneO3+SyhzNOrsRsfs1l3i1xS/+Zu/RgyZupxy/8F9Xr79SV599XPUVwv6KJGqQEpNlJLFcsnXX//XXGy3vHJ6xEt3CyDyYNrzr9/5Ndq25UCUmImmbXpiTNyaahal5lAU7FIiCcHG9aw2DdaOV0FSCoYIpipvrqYinU9MrEb3Y1WhD4GNG9j6npmqmFlBdB4pNX0SbFzA+UCrI4HItnP0YVQm2PNimE0risKMkoJOUi+OuH37HutdSwyRNDjE0LJzGwrGVjJTWrqhIRvB4vAus8URX3vz67z5+CGnR7e4f/s2d2+9xMmtT+Ev36ZvdqQUWK/PqOs5T1dP+f/94j+mVJFP3Vry6Xo0Wfqh0wnx3S2XeKIpxwQpwZVrqZRgZi2lspQJHIkmduz6cVi3LmuUkgwRqmqCEDs65yi1ZFEaVs0AGQYSm+TY5YE7dU2NGavFWhGzwg+Oq25gMTNgBV2ODDkx7A+dL4SUFDnkUU7JQAjw6muv8ujpI3xKDC6T+8SwHSjqgkE6UHGUZ9WZg8MjnPf869/8Cm8+e8QrL73K5179AQ6mc17+zOeQ51PM2Tm73Y7HVxfc6bY4I/kXX/pXfPYHfpgfuvcZnj38dciR28pxfrVm5jwHy2NsLWk3A40KHBrNpCgQpaWMiUEI+sGz2jiqwrA40KgEQwwcVjUPL7YMMTC3JSd2wjtti2Q08mq9o4meo6qgVnIcqpMSkRKDj2wJrJxnIQwbF+hCoA/xe/2oPpbElOmHgRgc00LxQ5/4NNuzt1ltN8Q4EJyjaTZcXlxQKoWSGiElOdy0y1hLGwJnl5ds25anj9+lKmd87fWvMp1VBAkhZ9q2w6iCez/8Ej/xoz/LV7/6/+V4ccqdgznvXryBwDPvLnn47nNk2/KJ5RGZwGbjGWwiSoe1hlJLXJJEIdg5x1nTYKTieDLDAmGQLMqSN8I5MQbqouLAlly7gEIRfKR1ji4MHFiDVhLlM4VUCKWIIdO6nlAUUGjWztE5z+D38fei6PwOMyjIkuBHk6nlwQLvPfPplJgzfYx0l0+o68OxEk8gRIfMicOjI955/JjtpuH52QVav8PdO7e5tbjFye0jWu9QeobVFVpEYpTMl8e89W++hjYTjqoSSyJHR9U94my9wgTBqyefYL17wnDd0+LHpN8qpBY4V+KEgwHOm4ZJUXBqxlbFEAPLyvD0whNCQErLgdW0MSMR5JTwMRGTYGnHeSsRExYQORGdY8vAETUu9rQx4FOiDx/xCj9SIJQY23ZMhdKK+Z1PUJ5fce/2S2gkTx9+i6wq5nXNu8/eZu1XaCt4+fQBLy1epVt3tMOYGO+aDvodX8dz+7M/Q1nMSa7h+flbfOmtN/hP/9B/TuxrZlZSzAtOK0WK4y/ywXzKD3cDZ1ayCZqcM1fXHfPaM6SaMIyJ/ryqWBweUFmLUYbBO0SGI1uRhnGwaCokDZGtd0yUpY6aK9dyIAusSBRGczitiHjaFBDOU0jN7dqi+jlow7NuR588SSSE2F8nvijkTW96yB4XBsK659ate5T1FiEiz56+w8XzJ1w9vSJqTVVbDo9PmdZTZkXF9eU1Fxdr2iGyGjasdjsun75Neuk505+uOJhPaVrN46cPeePx29x7+ggZFCYkaltgRYGMN734teQHjjIyRZ7sMoWVyAA2plFOMzqklMynE06WU8rCcsUKnzJKGuY1pOjp2g6dE71MbPNAFSwKOOsaFrKmkJJUWg4nM9owMKSEJDM1ksm0QkZwGJ50jtY7EGCS+h4+pY83gUhkXIeEEBwd38dFxcs9vPXwLb758BFmOuV8u8G7Na+9/Aov33+F03LGxcWTcWgsBjZPn/L8+RlvfvVL/PjdT/DDf+y/YDGZ8E7/kLfffchkUvCzP3XIxcUZfXfF1eU7nFmPR4GAydzyyaOW8ybRpJLKKJ7HM4oITUqE6NE5MrcFy/kUU1tqsR5bI4RkUlQ38TdQiEyfBZsuoW5Mi7ZtYjIZ3UyrwrCsi1H6k4zNYLXCYOh2gojkLASu4vjTUfs18IUQQiKENV27IYfE/Vt3+U/+0H/O3//H/y8OTw45WhyglOQHXjrmD/7BP4DSmevNOSH2dMMlm9Bx+/A2q25H1/Xs9JaD4oxPVpanMRBVRJAwylBNCvow8JXXf5Vnb38dt3pGOFp++72UCg6LHX3f4VJiajQbtaFOgigt25yRHiZGsTw8wNQVRWFx3YARgklZjPE37FhYSUwFGU24SZS6bkAXBqUkRWEojIaU6axAhEyVI6UWzFVBC7hu4J3NDjc4Znlf4n9R9G1EiR4lGQsfaChGkYEH1QPavuVyc8EQBxg2bLtrco5E35OD4+4P/jBtu2bTt7RtMxr2rS+olpfc+cP/GZMDRds7rlaXnJ+d8elPvIJSd3Hba6LeMDClZPQ1lwqq/gmrVceqcVg8GxWoEfgUWA0JieLA1iznJVVtKbQh+oDyiVKPDuFD75iXEhcUCXA3n3W9dchCEUVCFoK6Lul7hwPi4LEESi2oW2hVRxCS8zAaxVXvMwQ/tAm/QCKkIQmBTx6BxNgJs8WS8/Ulu6blarXlj/3h/wWLxQlvvPWb5HNHv9lx1j+h7gRSJMgJmTKFFMxzonnyDl9++pyj2ZTp7fvELDlfXfKVb3yF145OSWlgphMzEXFRU1oFeCYzg3Ee33iSHwgKctQMWdPEUUFiYgtSTKz7gW3vyT6iTR6r+6VhcJ5FZTmoDSFmnu96jqpRjmmiC3oTwYx9qikqLvqBhZBMpKCQgtoq3tqtmAvFrckErSRd//4MF/Z856QUiTGScyaT8d7jY8bYmsn8mPngCDFx+8EPUJQlWgqevPsIF3vKeoLfjANFEoFJAZsjZU64J2/zq//wGZO6wkzn2ASr1Zqjo0R/dUHwHaL35J2lPSgoLUhgXpdMbU8hPZUVFErTR0kvJG0MpJiZM4EEm35g3flxMYiRNgmK0rBuB6alZaEKQk5cbHYsqposwAiFURJjRk3qEAUb51FaUxuFkeNA5pVwnESDsQVCiVGjes8HjmZ87kKCMQKrC6wtmE7mnCyX7DbXeNfyiZdfwZiC7Hu6ds1bb73BcnHI5cUzhBAYIQnJY1NkNiQ2T97hn//9/yvTSsF0yvFM89b5Gb/0pV/Eb85ZX1xxlhPzsGOBYtyWYDKr2YVMs+1pBsfgwBMo+kzv42hYZAsisNt0rHuPIiOzICaFKQW7YeCgMCztOK/0pO84NgZBRpIJSmGsISpDN4xr6YFSVMZglOBkWnAZHLMkOVaahMTFfUvPi8D7BslAoQWz2THF9IBTU/CJ+w/YblYYM+PevVdI6ZpXX/sxqnLB87MnvP7mv+U3vvEVTJLcPjlheNTjgqOMmdpJljmgycwmcy4wPNM9gxllBS+fvcP1dgXdCtNcMNUwrwyBRFkVFDuPdB0yCw5URSbTOuhFwMiMURrvEuthzXbbjiZJ1jD0nqI0DA4W1XjjKYB165jcSBrGnMdCY2HpQkQFwSYM1NJQGg1ZUFUFfUoUwINJhZyW4y3cnheCj+/twTDaG4/fl1KSk6OelFTzT9IPLYWtGIae7fqcTbOj6VvefvtblEZzcbkD55gowcI74uYJv/ZP/z7zxZTp7ZfJZsJ2uyXGgO9bmt0GlXum6YBoChQDIiaqwlCp4cbJOXFgSwTjbayDmzabSIqJi+uBYReQQLCCFB0GS+M908KiSjm2Xw49SilKCX1MIARWGRyQtMC7GyNDCSqNxphKS3JMHBqDFoymhu+DD2/CL8dBMCkNSldorfExcXR0m+12S3d3TW3V6LonNDl4pkgYIufPH8NmxbHK1FoQpKCQkoXO9K7nyfaa82vDPd+wXMz5yZMpsVmx6te4tmWIDhs8x/YQWRlAYEyBEgMpJLIQvHa8IGaFE54hOWLM7IYef5UJKPp+wAdP7yT3lnOqqkBpRdc1dG609t66QKUUZMgZJrbAGkvfR2KOLMqKIo1ObG3K7Do3Gj4oQUiZJDLuw6Wq+rEipITPGcFYXY3AtmvJGbSWzKcV2c2wWrCczUjBs7twrM6fsu5b8uaag9ghsyMSsMBMJtbR8/j5JVpZ7hwuOV7M+OFlie5WiP6KIiXc4Fg3G04mc6pqipSgC0tVWiqtkCJzaznjatcTgiOmQAAumy0b3xOQo6JFDPSDZHkwpZ5UHAuJH1p8dDgfiEjyzYS/jILaWmShyEhshoOqRsfRldIJwbZ3OO0pcxrVrxhbhfZ88Egpx4Q/Z4QQWGNHdYayYnlwgD89phKjy/dsWrFbtVw+ecrV5QW60LDbsPQDMSechELAVCW2ecfjJ1dYpblzvORoMePHlgWcvUPaXiP6jsszj/ED1eGESW3RZCqjUAL6wdFFz8u3F1y3HVlFfE5kL7nctGx6zxAzIo2Dx0NIHFUVVVmxFIJ2t2VwPS5FQoBeJSAxjZqZNUzNOE9iCsMkCVRODCHRucw2BryIhARaK7yQ+H1LzwuhriZUxRwSKF0SEiil+OEf/EnefOebdG1L33bcf+lVJtMjNusVu+tzmqtL1tcbjjMoIyhji8yeKknqoPAycdEM9ClSWsWnFyWzg0NM7hCXl6PEYYCN6pjMJyANWkWsLTF6IIuGBsetxZRN75GEsSBDZBc8brNl1faIG7MtpwPL+ZR6WiO1ou9aYnSEEPFR4PsOgPmspi4tCEnf9wwyUKoSlceW3M6FUZ5bBKbSII0kSkEz7AseL4oYB3xUyAgp8e3bvCgESo7FiJQc1iiMkRhZ464FuRsY+p6zb76JGVrKPIyGfkJSZEEXIo+vrimvSu50A8ujQz5hM93ThzSPvknuG3zybMnM5lPqUgNx9D2SAkcgkTmdVHQhkfI4TxRzpo0DYRO5aAKWNDrnBsViXlKVBUIr/NCSYsLFzM4lrByLKpXRlNbe5LuBKBRSg/DgQ2ZIgnaIKBPRMaOkwOdMO3zEW3qElCAlUmq0LtFKEEJgUs85PjohhZ6DgwlDirR9iy0sajrD7bbsLs+Zxg0zEZEiEWVGiURKgQFJ5xyr5JitBHfrxCePT7hqE1e7Lb4f6IeOKkdICwSCFBMpjVba1kiSNMxsSScKuuGKlBM5w9OmhaalkAUiJbrgkUpx61BijL5RoehRahzQWLeZRGYgMpOC2hYgJW7YIZTitCxJfpzW7n3Ae08tFRJBSoDI7PP9F8dY1x+TfXHz5/5GFswoQVkWhElNZS11WZJywXS64OLsKWePH1L3OyZxwKeBkBNKCHyIdFLReIfvAgeFop4b7i2O2XQdRgYuBPgQcG5A5IgQmpQ8IYMxhnld4FREKEUfMyEGMuOh8eF21PmvRMFE6VESUQrmywO00SymkkEN9D4hdMI5Q/ZjDNayYlpWaGtovEcIyanW+H7cHIcYCXGMdS8y6UadIqX9lfaL4L24gzH2pJAM3qOkpqomLBcLdOrRUqLFuD5pZRjankfvPOFIZcoQKaJHklAI+hTxJDauJ0XJvNC8PLPcOz5i1bRs04BJmbZp2ZCIswIpClIKpJSRclwDnRDUk4LrIRDEgETgEjzZNgAoNHNrR1k5JVhMKoxWzFSJjA1aJoRK9IMipFGpYi4ls6JAKEXTdhitOJwVJOdx3UDrPF0MCAMhjTdSUkAW+4TrRWBtyXQyJaaMi4ngI0LCvfuf5LppOTt/iraG2cEpQmh2uzVD35Li2MJQ5EBqGoRrkSmSpSQojUOMkr7B89Jywr3JjJeOZ6z7SNt3PI8JHwXOj5KaWY5rTEoJpQS2UHiVmM1n6LlhtT7Hu56UM7u+h75nt+s5MGZcFFVkNpugtaKuSjQDMWR8iOw6yaoLDDmyUDNmZT3OD4bEkDPLSUn2kb51dI2jHxyDClghMMIQgK7fzzC9KFJyhKggCVKUKAU55xslOoUEcvK46JESrLRYY1FC4ZodsW0QyaOSI+Uxj+sjgKT3nqaLTIozTsrIyfKQVXtOt11DiKSUcL0j1QNCGFJiXAOVwBQKgaAoCkRdsWuvyThigrX34D2Xu4GJkagsMFozP5hgjEEZgxPDt39PBIKYAkNKzCclB3WJkIrrJgCSSWlJwuM7T+cCPiR8SBASWUsi4+/n++FDm/BnoUZpQylRSiCRpDx+qHo6ZeaOaLwj9wPr3SWL07sM9ZTN+hoTe26VNZfbQBM8Po6KPziY2wqFQMuMUYpC2VGNREMpJrx+doHKMFUaKQSdiyTf0/aOLBLzeYFL8Py6pTw+IeYWLRIuB95qRkOHO3ZcHF2K2MKydp7Dm2rDvNIcTkqOvUIlge8NW0aHy6KoSCmRxPjelvMJwUd2bccQPJURTFVNiKOUo1ECu79OfGEoBIZxgQGQNwmuAISxCD1BFz3z+TFSWkxRcXAL5psV+s2vcnsx4fJpyxATQ4rEnAkxs7AlJQohMoXUVNpQGokVEkVNvr5GxUwtFUZrXIh419O2HrJgMZ+wy44nqy3fuNqyrCTzwiBS5lE3AHBLSqLJDCmSlKRziXjj2zCtNItpgU8SkxXbdeAqe27VJXVdkyXIEEFJ5pXBmYK27cltx2FdcDV4tJRYLFoqlNknXC+EnMlCEAAXI1ZF8o0EpVAFspqiphOqcoLvE5PZEa99psJaw+7iOccHBRfPrmmjZ0iRkEel6UMKZsrSk6i0otIGozWHUyjklDevt2gfKREomfEpM/SBpnUgBCfLCVNf8GjV8eZlz3IGs0KSVeZZMx6I5zlBgoxAGEUTx5Y4JCymGjWrcD4io6DpPavsUYUdJfOAPqXRA2Ba4gfLNkHvBqZGj2u5UggtKRRMw4d2G/tok8fCVCKR4hh7qhjbX4wpmC+PuH3vZaS2DF1DThkKiy4MdQos5iVXz7ZEF/Ep4ISgM4lF0qOB1U2yo5XESsmilhR6TrgaZwYoLUJkfBjovKDtGjKexbwgZImeLrl3/zUu/s2v0Axjwn9+swfjI0YKJAJyZjd4XD+QgbqUWG1IEbKXpAjPQocqCmxhb8o8EpkVR7MpPgREyLjcMin12A4URslYi6BiX/B4cSRiDMQ4irgkIYgxIoQga43UFikk7eUKEkQbsdMp9WxOfrdheVBxedETXcKngBeCQWdm3jLTBU2OaAlGgDFwaCSVnHN1sSIlMAhyzvTRE52jbR1KSE7mM2JMdKpkcfIKm2eeIDbkHFmtx2p7nyKxTxRIpiicH1uUACalwahIiI5+MFw10OYeaSxFUdxo7wu0SCwnU4Lt2aZI13oqC1IqnAhowErJxLy/OboP7UophEbIAoQmpgRyfOA5Z6wpqcoJISZ+9d/+Czg/4zM/9T9Hbq+o+ys+ffsQqwygmWmDE4k2RVYMbPpIQo0tFlJSCQkuQEzYYnQUrQvLvLTsup6HZ1csC82z1Q4lJZUtcKix2jBdYmOHkSCVw/c3iSGZJkXWISGFZ9lteCVO6GMi6fr/z96f7WiWZXl+2G/P55xvsMHNx4gcK6uqu9UlSi1CotCABEGE9CB6G93rRi+gF9ClKEDUAJFdXQSJ6qzK6sysjMEncxu+6Qx71sX+ItUUQCiaKldGFu0PRDgQiAgzt2/53muv9R+Yg+HoZ/qrK5aHPdkrYmoWVJWERrG2tvn/KolThq4ahKsEpSFUahXEUok8hR59btTafMED8O8GWAulUF2PlJkPH37D+nLL9OkWebzlT2+eY2Xm/uHAS2CKgbvo+UQgB8mgNFlFlBVorfCpIvOC0TDlRC8lzmhO88Jv3+155TTv7o/0g2F72UPWEBZ2o2fjejql6LQk2RUIyKkyp8wuNtHP6+OIvNAsWVD0wDJbxuDpNg7iHrEYUhQEnyky431Ga0XIEWUltmh8UDgcKimgTfugkstTDX4O5FLaNCsV5rkli0otAcHKOpS8QotC7zrevfuaq2cvCNMDJh/4xRfPsWnm3mpuZMccEg8x8lA8iszGWpIqGKPRQkBIFApGw6l6nIHLXrPEzIcPJ8gz39ztWPWO680KqqHMC/e7hd46rp2iU4KTVQgBaaycakAbTSc0p9D+9IS5UMyKmBxziAw3Dv+wJ/tCrJIY61mm7HDSUHLBGkPnOqbZYy0csqSmAKVSUSC+X6z8E/79UEqz/cultoeb1dSzI5cxCo6Bxw/f0r38EV9/+294/foX9ClwEWb+9PkNtZ5QUvCq6zmGwC5FxphwSnFhVyQVGLqOQRt89sgMCjjEqbmSCMe4LHz1cGKrHF9/2uOc4fJihXGOL37yz3j5J/+Cr37zWziNlBy5z+X39MtSmkWnL5X+OGJebhizIKWOeYElSrY3N7h6i54KGfCx0YOEEDzbbEixIpXC9ha7do2PndrDGa0QufA03/98EELx/7512086n5vmqGrTT6TApV5hlUTJnnn6QBcO/PzFc/paUXLP867jMUT2KeJLQqPRSiJLRSuBEIXgPSBQCu7GEScUl53mcZ7Y7fdslOHD44HOGjZdh4/wi5dfYq++ZH+6Y9lH4jwTfKshYxSrorBKoZ0hnL/vEAJFW/wsmINkuBoY6wm3ZES25CgpMiKEpeuhlIKwBjN0dD7hSARkCxITTQsV4h/5hH9aAnfLLauu5y9++hOk0mhteXt/y8r1bK7e8GV1/HnydBVWTuKXTyinudheI1XmX8+/a7tfoAjQSuND4i9eveDHz1ZsXY81hvm8DumB//WPX1Jy424/zpFrp3lzc82UJd/udnw7nrjsOn7+fIvf/YbTpx1LiGQq94tng+TlxcCry46pJiYqr91Ar6BXkveHA1VIng0dNsxcKnjz8pLb/YlvjgcKkn3wCCxWwKp3bPqeZy+eUWvgV3f3YCFSMELT0f/hPqR/5Pju4NdaARX7+8fVWQyOwnZbisq8efNTcjwxL0fk/MhGLkDl7+/vkQpUAYXkRbfmuCR+/uKKL663rHuHM4YaClEZegX/yx9/ScqVVDIPx5nnSnNzc82hCj7uD7z9+sSFtrx81vO/6F/wbn/k/tC0BZ+mmZv1QJ9hrQXbTU/tDVebHqVgpSSPvk36b5zBjRMXRF7ebPl0HHn3MCGEYHcaeZgCby7WbNYD1mr6ixWmCm7zPRnJgYJGYuVTw/W5ICqQCjlHUjUsKrK1K/Q5eKX2CU/m+s1L1ige9/csD7dcGQFu4MP4DbkkQKCk5IWylAW+uOz50fPL/9oZaLFolfmPv/yCcm70joeI1YUXL68Zc+LT4cTuduHGrvjiSrNZX/LWzxyIzFVyDLCxmjdDjzMCTyKpwo2yWApqMOymABW21tJNgUsFP77Z8nGceT+10LopeL755Hm5XjH0Pc5obm6uUCrz/sNt++EksNKhnxr+z4JS8zlgsiCEJP87UokXV19yuXpOTIGkBP/0n/5PeHw88PHjHfv7Oy47gZQDfz3OLWBIVqSVbJAwZ65eOP7i+Us2vcVqRfWFoMEi+V/9+EeUXBBagbNc58L11QVBSj4+nvj6ds/NyvGv/tP/I+4/+094e9yjhUQVRRgzdmV4rTq2xsBaIKzk2bBCKdgq+PbxSEVyterZHHb0LLy4GLg7nni7O1GVZAqRw3Hm5XrFetXhnOH6+RWySv7m7TcAnFJLvh7W6z/QJ/TfBTiMViiViDEDmsPxQN8350alDUppJjuRAZNORD+hc+aZlmTZLMxHkSgCVsZizvf4T26uuNl2DE5jlCLnAliUyvxHr24opQ316Cwde/pVxylG7k8LD9ORK235+jf/BfAr/v5wjxaClTCILNgT+SJbXqwVxmmqVmyUogd6a/n4OFJl5WJw2DHQ28ybzTV3hyPvHvZIKTnOkYOPPOsHrlY9nTXcPL/G18CHu5ZBsFSFkoZhcN/rp/mDbfgvNlt6KdFatdTFAlDojMac08isMfyzn/wpK9fz/v1XPBbFwQfYPVB84+CVnCm1UpXAGM31puPLmzWb3mGlRMlKOVM3AIxyFAHkjKuwO3l+NX7gIXhqySgkd8eZL7dXzPOC9wEtJavOkF1BxkIUgn1KrAbDq83A1bDGF8U0ex6PsU2Ll8RKghOZZZI8TpnJN0X3JBPPu54UPVOsFF3xIjJOC/vUOLIbu6ZXXVOyPOHzIUuEEKDP0XgANG2J1ApkxYcj2gwIYKJwHzz+YUdeArGAEK15ElLSS83zjeH1sy3rvsMY/Xv7z1bkhU5LqgSfKmMVPC4L07efyKKiKiy5MufAalkxpxYpb4CVNlyve6QS2M6Cqlz0hot1z7rvKEVxmgNTycScOZWMK4UB8L6w9wtzrBgsSTV+twBCikQRyapR1R5yow1t7YpOOcr39AB+wr8v5Fk7UshSgBZ0Urd1NhlkbhP/Wli5Df7xHe8f7vjw6ZHrJAgpUVQhltImtKIlNQ6XmtfXG7auPeSkEr+/CGTOKANCSUpKlBB5PCaOywf280zNQFV8mCeMXnP0mRgyRgmklnSdIIuC7QxGQ68UViv6XlGy5DQlxpiouRIqaJHpAgRZeZwTS2xbzUV4ts4ACR8XfG2/b1Mi92cdzY2z9FZTnrJIPgtCTCh9ppCJNk3NLRYERPuclOrRWlCr4dPjRz6eDhymhVimZhqgJUvJ1Nw410ZLthvJq+sNW2cxulGz2luiAgllNEJDFZKUJfs5cVjumGZPDAmfEh8PmRebNXfjidvjEUllpTTdWpNkq98g25m4HTpW6wFfDH4O+FTxObDEyKFWVgUCmUPwjL40w5CzPWdWMKdEEBlVRAvIPH+nl66j15YUn86/zwVrWuBZKYpSMqV4cjVUuvO/0e5kozRaKsJ4ZC6VpRTycU8KkcVU5lixBUyFqipXg+PZZsXgLEYLpPyvU6O1Vq3hP9/N+6LwY0ZmiakCHxN3y4LRlpmJQ8wMUuJMIXagosBKg9QObRXaKTon8UXhZ8+cCqkmQo70paKBWCNLLI2PLypzKkgpyWTmlEiiWdWHJXLv2x18NWwZbEcM349W+4Nt+I1WuK5HSElqjJ5GoxGCXEpTbNdKDifcess3X/2Kx/dfEXePxN2BmCuqNDebRIUKMheqgK1xGGEQEqoSSHmOgk8JdEt8lLKiEhxzYH+a8CXhtKZH4UtiN058nGasVWglybJghaAUgZCifX0EvW7CyQ+7yGAUSmvmxTOfJiYludSCSHuUCK1QSqFTZhdnBqVaYEhKPNbEwzSdD0aJqu37PSzTH/aD+kcMUVv8upAShEDKxh8spa3rjDFUIstpgtUFD4/vOOw+cTwcODwcKKmgpaIWQRGt9kLJiNo4fG2VCEIKhJIYa6gxInRB1Lbe1kKynwMFj1aSWApKSWIujD7yECd6bella6y0qoSY6KxG1IKRGi0Up3lhWcApQ6mVJUaW2VNK5YWV1JxJtVFGnFKQCqOCIio+RmpuU7pQElYrUirYKsgpsfenP/RH9Y8WQojzX7IZCKTCkpc29RKgq4QQMP2Kv/36Gx4fdvglcDtO5AxKSESVUEDIs8g/VbbdgJGq/b8lKCmRVpNTQdf24GxR8ZFD8KQ54EvEaNuoXjESS+LeT6yMZdAWJSTFthqXRhBLRlWBEoLRe2IUaOGouXDyAR8aeeel1ohQyRVQAikqtVQ8CSMNlEKOremSJXHRD5yWgBKalOvTGfiZkHOlNHcIxLnJp3zXGAmkbLzhFBeUlHx892v88ZEaI/fHA1pajNKEmIn5O2Z8MwhYdQYpBQKBQoCSKG2QKWJ0pZy/VIyJQ8jM80SMGSUFvZbMOULKfPInasloJFpJnq0cYwksoVBKpXcGJSRziIxzaneqMSwlcT9NvPeZL4ym6spSKkUJtJCNJkEio8hVUpJgSYUlVow2zCEC7Rw+TPMf5gP67wCUkhjVhKkZAaINQGopjdNfEoqMlQKjHVWPyJrx88Lj/oTMYIXCNj+65rwXK1ZJnNbIc12L7xwhrYaskDKfGwBBLpUxtrPquCzklLFCklQzT7mPIyuj2QiNKaBSReaMF5klJowRSKuYfCbHuQ0utGbxicPJoxFsNIgERUikUc0gJhWWXCmykkpsutAAS1igKmIpUFsg3GFevtfP8wfb8MecUTlDqZx84EopahUYpTjMvq13YuTum7/DKcPHd39PerhFTRN+9njRGv7cbFYQVRBTYaktyUyJDKK95LWQCK3b+pIMAiKZMUY++ZlxSWhRsaIVYCc1iw88Bs9zN5CoTdiDIFXwuXlI1SohC8YY+XAY+en1BmUMNUTGJSGMxGIIJaKUZHCt4WeKfIoLa7umNwZfC/t5YUyRwTSjp5QLPgXup6fL7nNBCIlUrdGXonGTy5lXLYXEyHYxVD8ia2WajmdngJllDiRAS4lP7dKUQKZwjKXVtxBoBFUqqhQobVliITfPHRKVMUbuF08R0AuFNhKrdbMqDJF98NxYA0ISK1ipSTWTRXtYFBqXdfSBfQr85OKCXAoxZnxMpFoZpUWIZjnWG0OvNPWYuKdtv5yQhFKYYyaLSi8VUbZHwpQ8u+XpwvscEL//tTVFSkhijPg840xHZ9uFlaYdYnPF/eOetARUKZyW5TzVF9TC7928UqlMqTnupFJRpbTKlBJlNCG3RoZayaVtmXZLIFIQVJSqKNGCsGJupghb61C1iduc1NQqGFOEWNCubWPHJXJfMq9WmlJKc0iJkVALg24hckIJOiVblPwEuxJZ9Q6rNCEXfEwgMyvdkzTkCgfveXhquD4LvtPMcW7VgUbvOf8jIQS1Fk7HR6iBshzpRKJK2M0B0zUjgilXyrlxyWeHkZQjQUpElu181QKtTUswL21iXkrhNM/sfGQJza3uwhnWWpMopBA5Lh5Va/vDUgWDMRAz9zmylZrWIZ6Tn8fI6+2ANgotJbFk9iGwKkBuj47OaiyKefL4mqhnSkmpMPuETxUrDZ5KTIVQEofztPUJ//CQUqBUO4+klFDb55lzIuWIkgpNQeWMMisG1xEkkALTEjCo5qgERAGBypwixVdiikglEUW3x6eUaKOJGdotXCklM4bE4zyDMexTpAMGY875IpXRe7bdgKyVGArEisqFvYjYRdAZhSuCJWV8iaz6DqUEVQimVBFnB8peSJQzGKOQBWpILLX1o0q1/vXoPXP2yKqQUhFTJafA9D1r8Afb8O+nieQ9tQou1ms2TqOVoLOOr253jLPnyhRu//ZfU6REpkAnNFJoglLE2i61LCpaKZSQLDmyIPhw2nMz9HS1R1dJqaB04egDNaV2QfnI1/dHvjnMbJRipUyb0JIZTIcVGqsN0xwotW0Ket1sEpc402tDKoKUJD5lvj6NrK3C9Guy1EB7bIRSmHLC9W29LmjOPlMprK3msu+5WxYOi2/FKx0BOKVw9sN+cun5XFC60Qgk56lPblzW1oK1vwsKYjkgYsbg0FViasVpRa6VmjNzTcgqsFKhpeBUCx/3I8+HnsG16W2VApUzPsZmBVYrB+/5+/2Rj8HTS4NRCq1b46ekglgJAXZlbp7tUnFVBlIu7INHo+iLhSqoCD6MM9fWkWsh54LWiu4cDIeorLuezlkosMilUT2U4XLlOAbP7X7GGIWqtCnX4hm9J5QnH/TPgcp3trsVREEaQZkKITSniGoVykjm/VvCxQt6o/H6O71SCyvyPjCTkLINNkqtjDnx7rTn+bBlEAZkBSFRoeJDJPj2ID35hbeHA7fzxGA7tGzTpEatdCxLgKrYLYGJNmU1trmefEwnNmjWVoFUpCK48wudmRFVo4SmUwWtNIXKVCXWKXqjMED2hrtS6Y3janAcl8D9NCOtYAkRpQxj9Mwx4p8oPZ8HpWmVvnt5llLJFGT97iEgqKWwu3tLjmueX20x4cTjuGeWEh8WqAJfK1lCUZW5JsiVj/sDzzYbqlUUAUoUlC7MIbF4TxWVJWXe7vfs/ALKkAvEWqEIBjlw8nM7A2Uli0LJCZcqIkkmmdnoHqkNQrYH5W6ZWRnPqlhMkWx0R143D/MiJBe2Z6UdqoL0ib0wOO3Ydj1LjOymBSstgYiRhiUEUs1U+eTS87mgVBuy1tKymVTWUCQxB2QWaNWD1DDdU2xHLyxGCLQsLeMIyKkQasVT8bIwmkxF8mk8ciN6QFFFpciAim3otvhIqc3u8+44c3sa2W4vmKvCSIHWbXAxxYxIilMIzFlCFGQpkdWwz4m+SrYZajUUkZliQoiAtm2Y6DoDTnGaPEpU1lajlKakzCAVJ1fptWHjeo41MC8nQqE9YqxlyRFqQZjvZ5zxg234v7m94/XL52yHnouhYzfPbEpBG0ffr+hsz5VaeOZgvP01fHrH6XBAVOi6NTOBxMhzo6klU3xlky0hZ759OPBstQIqh3FkH2ecHrjZWj7EyjePBz4cR07nBMdeFnLKOCHplKJIwTRHvplH3qwvGbRpZ2LKlDTzZnMNNbOUyts5oKTjyq353bhgQmrOGzUzzZmtUzxfr6BWSmh2h8+3W37++kdYB/vDkXRKKKF4Zrd88glrA521DMqw4mm69bnQOIOZQibm2Nx6zpoJZRRdZ5BB8OHT17yXkr/+v/5fOD08ICv03YqFwsKItR0iZXSquBGeF8XbhwNXqxWJymmcOdwnNvqRq+sLvj3OfHvcs1smcq5YNAMZXaDOnrhUooQBy6fF84tnz9g4S62VKURSqnw5rNtBlyS7qJCqZygL30yBrbZQJXOFUwhc28JNd0EMET8vOKl4vd3y89ULrNMcTyO3pyNHH3juLplDwqqEdZq+k1zmH+wx8scNYxqfuULJgsf9kUF3DGpgs1lzuVmh8fzu/pGD/i0f/s1/xfHxAS0kl/2aQ84tGMu0TZJOsI6SU6l8tZu5XK9JJE5j5rAcGdhzdd3zzfHEpylyCIlpWXBKYkn0UWJKS6dwAvY+MebEy+0FG2uJufA4zqTk+en2hpACsSqmamBlwXvez4WtqNQimBEccmoWxOsVUgioGVUrP7l5wT9Z9VgHx9PEN97zPga+sBd4In6euFz1vL5Yk56Cjz4LMqXZA1bBdzIjVRvVp9HMoGSP3f2a+3DN3/7VXzI+7hA5Y3oLufD+FDiojJEwFEEfIKTKu08TV92GYhInH5lOAfe4cHVtuZsm3o0Th5jopGTQHY+7R9ZCga7MFTZ9zy5Uxlz46YsvWPU9JWXm40iS8M8vXjGeRk5TANlRVIcPB96GxCt6jNJkVTnmguPEj9eXCMDHloz+xavn/NQZ1g4Oc+D97ZHf7Y88H7ZAZU4LG+24dj1tA/KEzwP1+6l+zQpBbQ4Y1aCqRUuLVQLCPTZu+C/+9X/O8eETImd614OUfJo9xxKwwFYqVjhm4PbkuV5dtC23n/GngtORYZC8PZ64nWbmklkrw9YaPn16j0uGZDRjV9h0HQ8VstW8uXxObztyTpzmIwef+O8PjmXyJKGZi8Wryg7PFOALN7DtoKqFd/OCBrbrjlorMUQ0gsvrgRdujXMwniY+HhcOMfF8WJGV5BhmnlnLlev5vtmDP9ibWkpBbzpWpsOeH9C3p5EZz+FwxCRPEkfennbYh3tq9AxDT61wGpu15Re2J8ZAjJVQCkEJJjIpRPbTDH2l6wwvbl6crQwLuszEmsi68GIYyCHTkZhiRhYwUTP0imMO2CA4zTOz8jiheWEGZBEMQCzQS8fV+oK+s4z5wI/sBRttUQISLSX38XjiNCdO2UOFK9vx5XND8IGQcgsoKYVQFTllxumBle+42lpwmk9PKZOfHd9xqKFNHAD63jH0ilIzYdjCu79HRM8wDJQqmMeFtTX86eaSu+MeX2lcQQ1HMj4EjtOMED3WWX5xvUVJiLFgSczFM8rMn2y3PE6BIRl88eQq0FVgcyUjuVSOnU8ccsUIybVxTNOBlIAq0dow9B29W3E4PHC5WjNo1YLosHh5yW63Z8yRKXqgcOEc21XH6GH2C6cYmSrkoiEUvJ+wE6w3K0y/4hCeJqyfAxYQZz97WVrhFZmpAnrXs+p6kl9I1rG//RuUDGwuBmoVnMZEpxR/fnnD3fLY7FVlWxlL4Hac2B88Zu1Y9YYXV1vAkfOMQ7CPJ+5T5GfbKyARj4lMJkjR1tHAlGFaEh+nZkEMBakUU5AsPiJVxTnDetWjZUfYn9gMfUuKri0j4lAj0zwzT4HU8qFZG0N/JQk+kIGT94w+EnwmCc8+H7lMmmuhGbRll58mrP//Qv53timlZEIMcHWDetyjl5nBaISzxBDJIfK86zhOM1BQUtJZB2Teh8ibeSGJStdZvri+RmlFyY3e+hA8DyHwF1cvYYko4zj4SFUVK9o2NDR1Hse4EFRFItHrgXKKTD61oK1Vx3qzwrkVwe95NqzptEKIwiAcF6stp0OHX76jEaUmNl8Z8hg5IDn4SKwVZy2DNExlYo3kmevou45jeLqDPxtS0ze206fRVqwacFrgHBhdgEq1W04f/i3heEBIg9CGkgISy/Ne8S5lSoFOaK6MxgG308zz6cAzVqw7x8uNBqXJIbBSMGbPPmd+ennF8XDilVox5oinUGuhT5kQEilJklZkKynVoMQalfYtL0AKpFa4zrA1GpbAZuiRWiHIbJVCbtc8PGb2IWOFQJaMlNC7C4IPnICYoKBAK5SS+GlChkjvBpQynP7YKT0b17HpW8LuOLcp9q/f3xKFxUi4qAvL/B5tB37x4+f8evkblmnG54oUmcVnMJJIEz4WCvclcDF0lAq/uj1ysQm8vh5YDwNgSGVB1MIz41gp00JebMJZxd3Jo4RES8FuaRfRC2NQyjQ/9goxLpRc+TCduLCOVae5XikgYIWgEwKjvqOCSAbtEDFx5xce5khvNC+sJQbFEkaWUridJkIsXJkOSmUrO5x2VDdQzwfXEz4fGodQn/2Av0PBaY0qiWnckXPm6vKCTacZjxPxXINhKdBphNRcGEEqidvkeeY6hDD87mFmNUdeXPRcrh21SnLOaC153Q/c5J4b13MpLRvZcT/NTXhJ4dM4okrhpVRkcWbZlkpZIjLD22nPc7vixkquVhKBp7eCTkSMbNkCssJWW1K3auFuRWC1xajm276EgCdz8BlRFc83A32VzBiMgygkKdUzzeMJ/9CotZJzRQmF1u2orlqRfGicU5EJ86HVnxu4UKZNqkpBiESIlWoUThlWVZEp7GrhwnWkAr+5e+TB97y5uqDvNkChlIKUghd9x6Wz3GiLKgp52XHvPdZonNYc5oBSkh/bHpUrIiRqLZQYUSHwTdnxzDku1j0rJaFGrCo4kVqYjag4WXnlOna1MvvAEjNWSaQ1xABLiBBp0fPG8eVWs6YwHTVWa2YKMQX809Djs6BWoMjzsOOcMSObx70UEmKkLjMCw7br2Paa8eibfaeElCNZCi7PQy4DJFG5cB3PneLuOPMYI1d14GK1QmRBzuCq5As3cKUdawX0muf9NZ+mgNIKaxTHJdIpw4+7FoIl5oyoGVUCacm8TQ9c9z0X2xXbDqSaWCuBKh6Eo9aCyJltb1GuYwyRWhNOSwaryXNiDIEcYQoRKzSvVxtkTdjQ9CaBQk6RMT/V3+dCqlCKpGZByumsZ7IYo7HWYpREh4DXoCV0GmqKzZ+/VkrMSCV4rh0lF1yRSC1Zd4ZnUrI7RZY4cl0qrrtAikzKEi16XnWVSxKdEEhrGIYNd6dj49SbRtU2wCujcT5BhpoLZfGImPn16cSF1gzDwKAESkR6EZERJE3rVBCNxrNa0aJZC0plrKrEACFlluSZpoiu8JP1GpkLk5GYaplyJs8LIXw/p6gfbMP/nYNEKpUlJVIK7KYZWTPbiw0dBX+65fLmBav1hqHriT5RoieliJGSvO55kRV9bdHDyieoEiNbRDyp8HhYyPGBF31PKYm9X3hcPKeY2SvFVmme9QNu66gCCgVtJHtmfrbdoqwh5sq8BE5+QTjFzXbASU1OkbvHPZXcDj8MSjmUalxaSWXlDMcY6ZHkJfEuH3hcAsiCzC2muQrJ8N1UwimshhADOUp4Omw+G4SQGGMw2iCFJtdCCB5nFVZVsj+y//QOpTTOWnpnWaaZ0UdO84JBcJSK1yvNRjtiKThvoSiUlBQBImeO48Jv3j1yvbLkVNgvnnGJzDGz5MJKGp6tKi+2PYgmnDO6TZ42G9UapFqZ58j+FKgGXm0HOiQxBR53+yauCwsrLehd12ownx2DjCYrxRwDk194NwfGHAi1IkvilAoFgVWaUiqDknRGMn034YhPNfh5IGjzq4KsbUU9p4VaM9SMHw/cv/sKrTXadvR9x7R4lsWzG0dchnFwfDE4VlKSSmUVS5NfConPkZorh2nhq7rjwghqTZzmQPCZJSfeihNbq3nTD7y0GiWbTa0WEkqhW1vM+QExzYGHOVIUvNp2OKEJMfG4awmUY/B0RtEZjVbNhUUiWBtNTplpqUxLIC6Z3ZKwzpB8JMoWpnRxFqv31mAlLDlRl0LyT0OPzwEhmoOdQFCrAFrCKUU0B51lYTk+AGCNpncDYQnM08zjYYIlMlrNi7VjbRSiwhgrWUi0qPhaIBeWOfD+/sjgJLVWTosn+kRMiUcxo9FsN5aXZqDZmjUzBEXBaYVzHSlXxslzGEekglfXK4wwpBjZ7/YUWTmGgJHgRI9UkpIFIlesVIQaGX1kKYnTJLibAp11zNNIoSKkpjemcclzaU58pTAunnEJf9gP6h8xSq3U2tyZOtsDGSU1UpgmHo+ePB8QVeP6nmFwpBQ5zYHjtECGYBTPB4OxIKpACEWSEqclhxCJOXGaPd/eH9j2gpLAp4wuGZMK9+FEyZntZcez9XAOR4FJZxCh5YlYRSqFY1iYxwnVCV6uVygBIXru7u9xnWbKEaEkVtgmVj//GbBaEX0z1whxoZTKrqv0vcPPntzcZ3CyaU63xoGBSGXOifQ9hx4/2IY/58yyeLKAJQV8mNtLLxVMBVsjp+WA6Qbm2eOcpeu7NuGvEacNJ+B6ZbmQkIugS4L9KdFrMKYQc+W0ZH47PRJXzdbo7TLx8eQ5+oTRmpdu4OUqcTm0QyKLysZpSk68vFizlMq0REKEJDO9cby8XFFy5XDy3O6OVAVHGXBCsOp6jFAgKqXEFh5Bo2mMS+T+OBFPI9Jp1lUxk1hZy8Y4KgLrBIhC8Aug0PVpuvq5IKVEKY0xFi00oSS8X+idQ4nCMh057R+QShG8x1lH3/dMMZNyptOKeVm4ubjksjNkIVmFnocpNt4hTZi5pMzv7neclhYg9HFZ2M2BJSVEUDw3AxcKrrcbrFYIYN1ZOI1cD44MLD4RQyLUjLGCN5sVPiameeHxkKAW7lLEVOiGNcY0PmTK5RxBDykmDtOET4n7FIhSYHNmJrMylhf9QKUJ3KuShJSJqfw+3O4J/9Bo1BkBIJqLSQljm66WyLLsefj0AaRgiQnbOfrBcQyBHCsSwTQvXF9cce00GcEqwik0d4tUmjtUiJGv5keenfOrPs6JY4jMObGImZfrNc9sx+XQHooVGKwh18S616AUy5IJHqooWKd5tekJsbIEz2EaqRT2pSKVbN7XQoEQlFKwsk2QY8oczw5sZVlYrQameUYZwdZZbmxHRTA4g6qZOSdyEtQnG/TPAilUsySuNB61aIJtCYTgWcY9y+keXGFZZpyzDEPPFCNLiFjgMHt+8WzNTa+RQnAqkikWck44FFUIciy8e9zT20abnELiMHvmlDmWxFo4rgbBRdc3m2MEgzUIkRlcc3Gal0igEEvEWcsXVxtmX5inhdPpRJWC49lxyHYD/TnPoiSQolBLZgqBafGkXJiN4dlGsd+3B8S277g0BoRGuUoRgtlH5pCITxqSz4bmMNbMMpzpEbSJPUJRQyLHkTIfkLanVFgNHSUnlpgYl4AslV0U/Mnllq1VgCRhmHNCK9Uec6JlTjzMe16GdgguKbOEljg/xSbMfrZa2PYdWkpaRFfTuWy6Dg2MMVJiIKXARjm+vFgzpcQ4LdxOC6vYcSITq0AbR6c1iEo959iEGBjnmXFeCLEgBrgsgrhEhASjFN353HRKIXWzxY6lkr5nH/iDbfjHaeJht8OXypwzOSVs6Zlrwo+PpHyHzInDYUc47VkZwfW2RV+HqVCB8e6R8mqDsZreSNTKsjaGs3swIRWyiNwuC785HgH4Zp6Y5oTKAoNglp7fnfb8XFWu+zWDdlSjueo9SsO7+4lxiZScCUi+1A4pBELBEgMfDyeKFtwVz3EObOyAXimohVwDRWvmmLgPgX3yhJSYUmSeYFCSmcTr9Yo3qzbdTUims3C0l5Jeqv+Gn+AT/n+HaLkIqrmKKNH899ebLdXvWMZjC3YTcPfpI1Y7bi4EWkqW84rNPcZzrkMLELk4T0mVVpALKRfIiVQTX59aqNr7eSGl0nz4a+GUA1+lgNGGZ5sVnbMUKbjwEWs0744nDqfIvGS8qVwrA6n5Xo8x8nicEVnwQUcmH1mvV1jVVvYlV6Iq7PzCfVg45UgthePhxCQquRQ8hS9WAz8aOhCVxxR/71k9KIMzTzX4OSBEs+M0yrByq3Pqc3MRyWFkOT2w+BlP5nj3EaslNxcrtBTU0B6Uj3f3iFLRApwS0GmsFzQvnMhSCrvYrOcOY+OBfhwjuTYP6kRuqedixCnFduWwVkFVXBSDtZbb48zuFBmXTDVw03WkXCglcQye+zk0rrUo+BjZOIsSLSG81rbDOE2exxQ5xUjxiaIyD3NkVzylVn68WXHzzCIEdFqxFEGM7ft15gd7jf1RQ6IRRVEorTFCAQkpKsv0wHT4QPUHknLcf3hLpwrXFz1SVWbfzr+7rz5BaXQepyXSdjifKcVAhVQKhxj5FBZ2vjUtxxDItX3F4AtGVm59QSvJhRvojQEpCCEydJrdGDjOC0uJSKdZ2Q6RCrUmDmlhN450wjArOC6ezhpE3wECWQGVOeXMsWZCLYhc8TVyuz9xHzNxibwRgpuh3cFYySm3nIhaM05+P4eUJ/y3QBGUKppfPgKlOoQqCCDPM2I5obKnOsnp/oGVs6zMGiUKu/3Y7sClPQKHTiCFJIsOkxcMmpXWLDm3sycFurmdJVMOxNysi+eSyULxcZ7RSnHRdfRG00nBNC10SvJ4HDlMLThLG8VKKBAZLSpVwawqJSfuwsLDcWm13HcIQNdKVYpdnBhzJCMRUhJy4PYhEXUlkbgwmtf9gBCCUw44mkW7EGDUH7lLz/3+nsN0YlwqYwDlFP/kzZ+xURX98FfE6WukgGckPjzuqRaKhF3yfB0OAAydQQqF14ogBGFaWoOlJCHSKBZO8+fbl2xSBCqnd5FLZ9gqQ6QyKM04Jj7UgBOJlbbErLgaegRwITXCSGZZEP6EBT7cHjjIwLwElCxUoVgryW7JiFLpa2XJhbf7iefDwJQCMQVKLqQqeB9nVkojTYcumrW2vNx0VOCv3u/ppcUJQZWN4/aEzwNjDIq2iq6yNSLXFxes+p5v/v4vuXv7K4RW9BLe3z/SV4mWhWOJvC1tzfv66oJiHYtUiNwuqSZ8K4TYwmE6rfmzy2co2n+Tbx+QWdJVwcN4wJWIz4KPjyecMAzSUYhcDj2UzLpaooRFZWLJDNLx9e2RexZCSqhaoGgubbNHFEKjqiHmzP24Z1AdoSYomVoqUyncLpHLvkMpg66Z3louN2sq8Pb9hAVUUW21XZ8m/J8DXdcxDAPWSKxWhKWgFKyGntuv/pbjp98hRKBXitu7R9ZSgkjs48Lvcns8vrq5QFjDYtpkaPERH8DZQIiZnGCQhj+7HGiKp0otO0yVOCF5O4+4OXILlKz4cZW82GoihbXqIYNOlRozc4zsROalkny6n/mUR6aSyUlQUmVz2ZGyQEmJlbL56EeQeUYpgS4SJSReS24Xz5V0OGFYakYJ2SgfwK8OExurW+pvzESeKGWfAwLRDFKoNOa+BiyiVIRfkGlCaY1Rlk/z2DIgFIwxcFcCVHj+bEPnNMFYghDM08KcC4OSxJAppeCU4hdXV6xta0d+eXuHqgKk4DfjgftYSPeBeMz89Fqyumw02sEZyIKSm82wT5n7FLnuJe8fRj6GmWP01JJJSmKzIivolWOtenIt7P1E9o1K1ITxhkUkHpaFZx1sTE+xlovOsXGm1d+nB5KEODe9lPzhtlF/9EgpU7OgytbYQnOnQ2W0jBhVMNrSKcduzueGvjLl/PvB6JcXA73tQQliScw+MJfKID0hVmIBpzU/u7nh5uzK8X4HoSZOMvIuL4BEnGZySPz48pKb7UDOkavOAaCNZj2AiHA/zrxUKz7cnphlIFZBrZpc24Ai60qvJBspybWyjwlSxiKZESRZqBI8AgesVz2j92ilGVzbQNxP7XsiF0wWpO9Zgz/YSn2zfUbVhnUPWWj0SnG9jpz+/q+weYeQlRImrq+uUeM9KM1hWuiV4udXl2QqmsBvjiPPgmVjDceQUbQi6ACJohZJyRMezS54/my9wZoWQR9T5ZvTkbXSvL7QfJgP/OXHW1yt/IdvXmKd4E9eXDCFwt0U+Hau/Ha341JrjHGsuxXFVWqsaL/QU/jm3R23akdSkiln7o4LQgimLBjPa9MvXM+X6wsewsJP1yvW2vI3H08clonX6zXDOYp8jIX94cmW83NBa4VSuoWzKYHdDKTlkb/51/8laXpASkv2B6yFNxuLVpJ5iVwx8B9+scKnQJxO/HZ/4Mo51lpzCpHhHJxmJGdaQz2LdeEweX5qHb0xGCkZN4avTye2tuf11YqvpwP/6cd3DELwL9+8wjrD68sLrreZ+2Wk7uGr04ENkrW2ZKNJOtNJxyGeGJLhw/sH7sWOKAVJKwIT2mqC0iTV+NJdD8+Gniknfra6YGU0v/z4wM6P/OTiAgdUaTilwsPpqQY/B5x0yCyIKVMUlFyIx3u+/fqBujxQcqSExKb3fHFlUUpzPAU2RvA/eLUGlSmHPb97PLEeLSttWEpBKUVOjT9fSiXldM5lEEyT57XSzXJWKZwUPISJQRleXRq+8Uf+b7/9SCcl//LFc6yzvLm84HpTePSBj8vCQ8hYChdmzVoUKpWhKu7Cgk6Gr9898Fa02PqhGwiqRc1FJamq0RQ7Idn0HSEX/rTbMmjFbz6dOOaJV5tnbFFMvWRUidMTh/qzIItIrs1GuuQKyXNadkyf3pHHDxB2SCLrvufNoClrx7RENlnwZ5triq74ZeG3xwP9bOmVIxawSrPgsUhCSsQa0Ckhk2M3eS6KoHMaqRWdvCDniteRH23WvJ9H/rNPt1gh+ZdvXqFUz836kvUQWYUFGyKHORCSp9e6hQhWUMowp4k+wL/99gO/lQLrNJuhJ2EINN1gEZUgKn1ncM5wCs1kwWXBVw8nDmXimd2iyPjeMPnE6J84ZZ8LpRZSTEgF1kqsGwDIpwUnElJVckiQR242FcgEb7nur/mnP+oIeWa70ny7G9FKoKRgjpWN1TxOhUpkWRKxgF4FlHNMk0dridNNR/onmw05FVaD40cXPbfzzH/59QOdVvyLZzco4NlmhU8ZuSxcy8KH6UQFTNEYBFIIjO4gLQxF8e72kXdSooxlax2JiMcQYiTESBGFbGG1XYOxvFCOvCz82w93RBJvNlt0KhxrZaqZmP/IRbtZSayzbJ3Bih4xGAYmgsyInFuTVCshRUQsaApba3AXmuuVoFL57bdvmWIkhMReaqxSWCN5v0xcWUMvdQuwqZJDCbw9jVxrgyqV7DM5FsaYCKLy9/sDU2zpes9sR600FXXMjEtgWRY6Wbjebni3P7LkghYKJVrR3IXAj01PFRJfKzVlNJW5JGoRaCG4NJpSK99OE8fpyFY5BmVRtBCTXCsfpomtEVx2A0ZK/JNLz2eDkbpFaxXIWkLNjPs7ptM9Io2IHCgZUqjI6BGqx1qDUpp1hVINvzrsmZbIuMTmKa0Uyjm+HUdW1tBrfXbNESyx8M1p5korDimRhWiK/Jg51COnh8iSG4f2uXXUqokBphgY/cJxHuly5dWw4pvTET+dE4GVRJnKMcCPrECeRZBOSEKIjNljc2HJCSEqHfDJJ6paeGY7NsKiC8RQyLGyCwFTKpdON+eN+sRh/RyYxhNd34EAUVWLe6uZ6fCISCOqBqiRFAXVR+gVfa8xRlOrRpbEX9/dMZfMcZlwUnGhLJ2UfONneq2xQp4TwjM6FL6ZZ9bAPheyltRSGFPlWE/UXWHMlZIza6l/7xm9CMNpCRyXmVgWbhDcxgDSNHcWUalCMgV4riWiNh2SqJXZz0Rd8UtmyZFC0x6EpRDrxEXfs7YGJQWLh5oMu5BYhGdQGi1F29o+4R8cJVYwhdryuqlKsvgTh8MH8nyPKjNOCnyMpBCw3UBnDXIr2ax6ZM788puJWMCHwCwzg9RYKXgXA2vp0DQReKmVfch8GmecqEy1ILVCAd5HvplnplRIhbOGRJ1drDxTikwhcFgmDmHhUjnGmPClomh8515JPvrEq6IwSIxqv/oxMZu27ZoKpFwaL5rMtIxcDj1bZ1FCMPmFJWcOMpHSjEmKWgTpacP52SBIgEcKgzUOrRRhPhCXGcqMq0tzZtIdaSnNwEBU1p2gNz2lOt7dPXIKnqxa+GVfJAr4VDKDUCgjGu22CnzKPMyeXiuSaMGtnVBMFL4+7VlyYMmN6tppS6VZ1S4pE0PCh8gUF3qpufcearNHXiuNyYWjjwwpI5RCmmYvO82eIAtRFZIqlFRJKROpjP7AsMoYt0FW2XpfWbkdF7SqaCSqwPw9dSQ/2IZfKInUilolXkg6LP1QOZ6pSlIKihB4vyARIJrw0CiBOV9Gc6oIBFPOxFy5UpJOZJyA+xBwstArjdIajcBpTSATY2bOhWkOTDlyoSwPS7PH641BCcn7Y6MNxXpOYKUyOMXzlSUUOMVAzo2HuzaGeKJNiZXCSImocIwJC8w1o5Wk1qYOj6lyWCJu3UI9Ss6U1MJL7mdPrAqpMlpqlHriT38uCNFEiAgQtGQ8ZRSkiKCilKJISc4ReZZXCkCKipKibY+qaMnNMeKFoOsMBY2Vil2MzFQ6A7oIHIKVNgQSc8zMpdmKHUOk6xX7ZcFpw6WzOKn4NE8AJCCl1HQuWnEzbFgonOZEqhWlBJ2WxFxIFDQSK1sjhi/0QlFLRiLItblPyAohRTZd36avqRBCRgjFo/eklJG6b1xGY/6An9I/XsSSMOdmQhTobIcZVtTqKdUjRUEpgU+Fek6AVpxDkiTUpBhTpVbBVDK+FLbKAI3m9RgWnNI4bahVopCsjCLG1AYdqQnTTjEDgvenmZWz3HSOrTLcj83owEtFToWSEloKrjpH1YbjHEklIaXAakGccntYiKaPUhUOi6cfLGPO5AqxVHLJiFRZROCqX1Fqa8R8aXTMvffcJ88X6w29thjzROn5HGgS3bMhpzifb0UQ/UL0M5qAMoZYwu+Tx1WtGARCt/RwhEAhiaXx41eqkgkMSOYQQEqUbuqAHkFnNZTMXAo5VVZGNAFlLXw8zWxNx5Xt2CjJ/dg2iz5LUk7EHNu0tbcIqzlMMyFFkNAbRREt1Vcgz8L32voHZdBCUEublOacMLSgYSUVuULKzZGsKsXtcWRJnlfrCzarjjA/5UB8PkhAnQ00FBpBFpUYI7lkEpVaCz5Ezl07lIKkokzrH6fcPPgLnC1lK5wNLKYcqaUZdBgETrYaLFSWUkhUlJLEWphT5v1pYaUMl0YzVMkYW6PtY6XmQq6ZzhiulUVKxSkGFDQao2pOaR6wVGRp1svHtNB1GkV7oAYpCKKiisDnSJ8rpRYyUFEYo7kbZ6SqPO839M7yfbvAH2zDb43BGkOsiqUKlJCstxfsnCVFgUjtgMmpNctCNpu4NttvxPasFKooCrkp+IFC5sY5fj2OLLniS8UBb7qO16uBh2UkxMQpJnbek3LmctBkCVIphIC5ZKap8bFirvRCs7EWg2btDF8ax8PseZxnUsoMxqKlREiB1Qormy1njS3FcMkJVLNpjOfKPKTCGhhTQtVKyBkhYUwRnQU+V5ySDNb+wT6jf+xoAX+tniStiV9tL3HGUc6R1lK28C0pG0daUPm9/04taKURSpJiW0/6WuiIPO87DtOJY054KXCiZU+8Xq/4OB0JKbLkzBwTc0hc9IZaClIIpBTMOTP51vDnXLBV4LREa0XvHG/MFTs3s/MLIWe0aW5QuUKpbWsRyaSSUVoy5dgEbFUQS0UKOOXCupYmJEqFKWeE1RzDTMyFhcrWOrZPLj2fBfWs04GKqBWrNP3VFcPasYxTO++qammoSiFF2xSVUqmiiR6rlNRcm5ODAF8zrhaureZxmgm1EgEpNJed5fW659O0cPKRmAuISioFVzU+Z4YKVjZi5OPcGv4gwIh2WfZKs+47OmO535/YLTOpthprj+KMQCJoA445RbpqSLVZ5tUKITeKzzEXrqvgFBOFwpIrGNgvMylEXq429K5jk59Ek58DRQjKWSwpzqeaVhatNFlKqBKkPP+igQq19V2C2lj/xqCWllIez02UqZlr2/NtnPCpIGiajq0TPF/3jD7gYyLWTKwVXysOSS4VWQVGtC3R7rv6yxUFGCnYWMt2sAym58Fq7k8jS05oY+ito8Z4/jZrs9UMgcuVAymwtO8xUVC1KVqiaA1jzZlU2tbhYTq1M/+mY3t5gXgaeHw2CKHPfxmkVChZkcZQhEQJjaQiaiaXitASIc8DOgF81wnKs1i3Qi4VLwpDKVwozYeYmXNFSEWnJZfScL1xHJfInGqz4haVpWSc0KRSQLWQS1EEc2xUmsXHNuxTgo1xXPWGwQ3slpk5tJpDK7RUJNrDhQq5Zk7Rs+o0NeUmjBeCIkEVwUIlcc58kIC2GC055qYXFcYxrNYU/Ucu2h26jr7vSQhc1UQp6fsVw3rNOD0Qc6VWjdaGLCUGzo1/a4ByamvF5ZgxSlNpl90pws8vV9ylxH4JTDEQa2VzvWFlNPUxEktlUZXeGKKsrGXzbp1y4i4lemX4YrWmUimx+a1b1Rp6auV6vWbb9RQq3+wP+FJYad2ClVLmQGIqhVQLh5y4nz0rZ9CypRdi4EDlshTS4pEUZG3TMyEqnVRslGFr3Nm47wmfA5VKPdtdCSGRUjJsr1ldPGPceWIIFCEx3cCCQQpQWiJKs5WVCjZrgwoKkw05F3alokvh9brjUw3sl4D3gawrm6sN204zZ0+kxderXCmlsBIgpGUKhQ9+ZqU1r9ZrqBCPCwLoRGv4S/Vcri5YdwN598jb44EFyYU1OGWQBU4htQdFLWQq98tCryxtTtwaxAegj5m5Ti3tULZtgEiKS6NYac3a9qj8tGX6LBC0i0JUhGjWdOvrDa+/fMP9u8p8PFBrwJmOQJuFCdWa8ZJbjMv1ume3O7bHa608eo+Thh9dDtyWxGmJTLNH6cTmumfbuRbqpST7mMgpU41kUBppBUtJfHU8sraWL1aNT1tCBFGwSmOdRshMbw1vLtZkCu9OI05INtrSG40+n31BVIKGfQ6cckVLgQGChGQqI4UNiSW2mixUZBLMIbGVml43nVQuP9hr7I8bZ02FqBWKaG4gvWN7dUVQiRpHlAZtBgKaWjPCSISSTROSYdVbzBwRpTDnyDwvOGF5ee3oiaQxEENikYphK7nuHPcnRR4DMjSNitBwXRVuZZlL5dZPbKrhRdcBsLCgC3TS4pyjCNjYjn4LuRa+PYxMSfKiW1HLSE5Nl5AQ7Gthi2TJBSsUaAO1sCuRQ8oMpTlLIQrKNHFv1YpLbbjuBi77Lc2D6AmfA1K1yb6UCtAUWej6HrPJmByQxVOyRJRCrhOy5lZ/olJIyCS5HBxzrvjYskWmmti4Nc+s41QyaYmEnPGx0m1WbDuDRlK9ROUMZJKs3AiDXglOtXJbEjfCsD0HIoqQqKUxStZCYYWkWw+sjeHjceR2XjAVLroB4ys6F6qoJFVIZ/H6GBJSte2nE4JTLkxAT6HWjFYC4ywpZbQ0bEx7XFx2K/T3dIr6wZ6Ug1NUCofRs/OJV9fX/J/+z/8H+tMHVp3DdB15PHH/6RM2B5LVUBW1CmSVZCJ//vKCQQqMbCmT76Y9z3VHCJF/8eYL3u8PfDzsMUry6vqC6+tLtivHPE0sITHOiSkXEpJV17PkjE+RjRa8evUanyM5ZAYt6LXE+8JXn265wpFSYg6ZVAWHEvjzzYZfH498M88YJXjmLD5XXgiFtoZjLcxRQDGsKShZSCVRaiuGXBJLyPzHz37EHBK/2e15LJ+I3zNh7Qn//rjYrFhvNhhl6a1DSMmHr/4KsVJcb/8cWWE+fuLbb/+WkDxdKFDbHLNKCanw5vISWUFegi+Ft6cTX7iefQj8xbNXfDwd+Xg8YqTg1fWa6+trVl1/rsEW6hIQLL6JhqaUmGNi4wZ+9PIFKRfCxUSvBb0x+Jj46u6eTW7WZVMMLLEwl8CP1wPfhIlfzyMlVbYoiqr8jC2b3nLvPaEWrLW8EJK7EEhALU0rs8SF4yz4nz77Eccc+HA48ZvH3e+3XU/4h4VMbbKvpKG3HdurFfd3X5Gl4os//x+jMRxuf8fXv/lLgvctTLC2KX/jlmZ+8eZZs4GtjSL07WnPRhvuJ88/u3nB42ni4Tiif38GvmDV3fJmGllCZFwWAleMo+dy1XFKjWK2cbrVH5BjYtCK3kh89LzdnbhMI4HCXNqUNsTIm/XAuxB5O3uMgmedJiuJmivXwIlEVpJedrxQknezR+U2mVtSYkoz1gj+o4vnzAEOc+Dd/O2TaPwzodMGpw3f7e9qrcgFlFZcPH/Twi2XicO8a6FWRUIt1Mrvx1CvLzaslCKkyn4OvN3v+GK9ZpkDP1lt2LGwH2d0kby62vD8+TWr+x3Pp5klBMZlJtQV+ynwbNUTC8wx4zS8evW8fZEIVoPREH3iq8cdNxlCKUxzpPpCrp7BOj5m+O00YYTgRdejLxwSicuFA4GoMlIo1kGyY2rv7SKYUuIxjNRS+R9dfEEohXmZ+NWHEx8enurvcyGntj23SqNSARSvX9ygrq6pOZLCxDLuuPv2a/CBamu7g6ugtvUory8v0eJETIk5J3Zh5sYKjsXz+vqCzbQwzjNKSl5dD1xsrzF3t2yWiZglU9T8aLVld5wY3MBlKYQa2TjF1WZFAoZuRaclvRHEmHi7e+Qm94SSmEshFChzZqvgLhfuc8BKyaWxuI1tSbwYHqJnyZlcJalECgqbBXUKHEviGAMiF/75sCFkRfKRb3d3PPrvdwf/YBt+RKO9ZGCp8MuPj/zpZs3HnUeYNdvNJdINDPtvWds1flwoNSHOnK+cJe/uHvl43KOFxCrNWhguB8fH3YFP37zFSsUr65BSMo5TcxlOiVIqshQuTGK70tx5w9pZxBKIOZK1QoUI44HOGYzsWGLlt5/u+bvDnjdK0gmDFZKfD2surWZle95cXvGfv3vPEiOD1LyPR5BrAoKNqiRd2afCnBv9SFKRQKyZJWc2WuNV4ptyRCvNtbTswpNg8nPBKcfKDi0cTUsEYEzitAustxuc66BMuJLpry7x49I2AmdKZ8iSd3cfWvBQgSoFzrRwkPluxy/vv2HlDF/2barqR8+ePSkFIKFF4kJXqu3YqchFN1CXwJgmZhWwecEfRpzTGO1YcuG3H3b83XHPGx8Zup5OWn6xNfRWcOHWvOQZfPst8xwZlObrcALgRGw+2UhOtfAxBALwmja/ClROFLYovEp8jDNGKQYpiU9bps+CLJuGRJmKWxtKyRQcu5NHmIVVp5DOIfLExdUlfl6oNcHvz8AWaHQ4HBFVIpXiSg9cDI5Pk+eXv3tH7xTbXiOlxHvP/mFHSoFSCrJkLjRUC1oZVl1HXCLHnDmRsaUQxgPufAb6WPnd3YHfjkdudKTvNA7Nj7sLVtZwNWi+oFK/SnifcELxoSxcScuIpFMWLSr7nLidM5OCSvv9pBKZUkJJhVeFe7Vgq0KnCk/BR58FRQqEVugKlEKsFec6PhTJyhnMao1eXcBvvmZzuSLOnlJat18L5Fp5d79j8Z6UCrFUht6inWU6Tvzqm4+snOFqcCgpyT7weHeAsEDOyFK5UOqsU7P0zlBDIYVGc/wyBObJo7VCSIcPgl9/3PEhTizV4KzGWcebjWajNNtVz8vtgHqXSTGyUoJvfYChsQNW2eCF4iQyH+aRCORUkBJyrogiuVICdCSpRI6SGAs1PDX8nwtaK6wUnAljLMAxB+J0QJ2Hucqtsa5glf1vPAPn2ZNzoUjBYCxohT9OfH13pHeWdWdRUuC953Q4NT2obuGUqmS0KoRBc9Fp9kvgtGSOVfCqFPw4I51FSUsIid/ePvAhLcwVjNIYIXjtNIM1DFrxcgNfPR6pudJleJsnstuCBFfadixWOFFQUhJCQgmBJxFJOA3aQcwJn0ILB5u/n1PZD7bhV7RUO6OgsxJRC7oKVIb58RNhOlCR3PQGUiLF7/zNJRVDEJmNtdS+YwyZU4wccmAfF+7nwI/XK7ZdR6cMQjS/15QyJVdyaaFE1mhwPdta6bQiGoXNis4YtAysjGSOkTk3i8zfnU7sY+RNqqwGjREga8FpgxAFI+BnF2tyiNSUmaLlorPYmNj0FqkljyHymGYcTTx3plDilCJJwfvpxKfjzEXf4ZTEiSc6xeeCNhatdfMIV4KWbaFwVZKmA7IEjHA4mcm1kGIg5wxCgmx2cM/sCpkLh8WzC4m9TyzLHR+nmZ+sV1x0KwbjEDTBtku55TEkqFkxGIF0ilglRkNvJBfF0VuFqZVNJxhjZDw1ofnHMFKqpFRJryy9Eqha0NogSkEDf7K5IHeNrjGlxNpabJYMpukNHnPi03GiV3BKHikEqVR6NInCrR+5W2Zuho6VUqzUD/YY+aOG1qJNH1XHtt9QRKWkiEVRw0SSIGWrg1oKIbUzsHHkDblWttrCqmP2mUPKPCbPblkYS+HHq46L3mJNcxLzPtKLlgeSSz2fgQacoU9ghKRTsrmhWY2tlaFT+BgZM8y58n6eiRmMEax0hwGEykgrECWjgS+7jqIySsFxNlitSTFz7TqUUQzR83E3c20dc/Qs55/H1hmsktz7mXfTxOt+wKK+t2DtCf9+EGehJLUJHiUtTJLqidPCUivaWkw+kWolpkjJTTtSzlumrVXIopgTTCnxUDzL+8AiCq8vBtbGor/TxvmEtYlU23lTK1irEa7HVt++H1nojeLCOjolsYPi6BOnqbCUyqe4UFCknNkohznTYK0SCBJawpcXG0pM5Bx5d1qAfNbDGaoS9Cnx9e7AximWGgi5aWnWvUWUwmEJHESiFwpZQJWngcfnglQSFGRZKCgcLZE2HhdEiSSlWwItCUohpf+PPrBWNs4iY+aUInMseJE5PszElHm+Ghg605x6EKSUySo3o5R8puhYSbEamwXoirOSCzp62zNIiegES2yaO18yD+fJfKAwSIMTEqUqWisMFSQ8W60oKZFTJC6VakEJwbNVz5Uo7HLgfjfhrGauqWViULCyJYsflsBYc8vCqaC/Zw3+YG9qoRSu65F+4XT3DQ8PHyG/Z6sdnVXUGvHLA0pAmGeoESkbnSIFTyIzh0iugsFqtFEULxhjQAlFqZI5VyIJpQQuCcTiEalQMgilEU7jz+KgY5rQAi6corON6ZyAoiSCQiyJpWSeuYENEpszSjb/VWsNRimiT2TRgpmWGBlD5GQiK624C57ZF3xOmAqd1SwpE3LBIOiVQijJ69UKg2gyUgHYJ/7g54JVFa2g1Mi8eBCaaVmYjju0c4gUkGlG54CfR6jLuQYrMTRnqHnxpCrpXYfUieIDk89N+Cs0U8qEsoAWbIPiID0iR0quSGmQzpBqYRc9h3MtXFnFYFq8d6y1CdaFIKTMFBNrp7lQFkdFlJY67YxtNRgTQRROJTDHzJQy+xC5UIKHuDDHis8FTaUzjljzuYkUWKEQUvFq6DBKtjTMknkK2v08uNhuGfoepSQpe4zWxHji8PiJ5AdS30EY0aUyhZGSE0IIqIWUPDHBEhJCaobeoHIheRjnhNQSoRXhbLdapaCWhMgz0ALhhFIIZ/BVs0seXSNGwHVnGWwTCZcKiHaNxJIYU2btDGslMSVBFVQhGKzCCoOPC0XDKWVCTIwxclCaQUpul4XgK0tuaa5GaWKOlFKwSjWLYll53jmkqGghocDm6Qz8LFCyiQxDDIxhYnAdZrhACkOc96i0IK1ExZllnik5NrFkFZQMMVXCEigFOmdQziFyz+FwoiqQRpPPwzYEDLUyzgFZCqLQDA+cIRY4+kLMAYPgwuq23QICIIxBVMg+EilspGOoFZ1C49zXgrEWbRw5RqKojKVZeZ585GFZ2AjNIlqq+Cllck4t9C0nUikYJRlkozddD+0BUhNUCuunA/CzwQgFSKoQKEUL5sue5XSkxpnOaezgkKXgw0LNCSmaIUBMgVAEfgkgWxCrPk/OTz6DtmA0GUEtreFOEabqqblQzltRYSRJVOZYSCJhpeLSGTqjQVVkaYnNpdbfu1H1xtAXhckFKSpCyPMdLIkxUmRz6JtzZoyRO7+wlpKTFEQKYwqkXLG0ez6XNuV3QpNlZTv0mFyIsQnKyx970q5QEtc5Ujjyu1//K969/zW7Dv6HP/sz1qtLTJ6Ylw+QCzEEqmivwZqhlkiJmf00E2rhsrdsjSIjmUtzmki5MqeEOtvDiWJINdBVhZYSqSVROfbLwodxQevA8842QYcolAo+Q1CNv5EodErxxWrNVijk+YVYpAEkymiCzxyD590ycVwShxCoeuGZNfxumtmlgKayVc2f3VPpVOPfCgQX2vCnV1c8t5q7JTGlTPc0XPhsULK2MK2QOI47hBp4PHzi9vE9F5tn6GyQ83uICzF4hGgq/ZKh5ERYErtxJBjDtrN01pCr4C4GBqMJEcYcUKqSq6TLHQGPg3MNWoLqOS4n3k8LGsHNdzVIJZ2tZ4sUZCqxVjTwvLdcS4Wo7cFYREvMVEYTUmYfPe/nkf3S3KjSPBKt5m1cOMWMqtBJSW8sPgecltRSKaVy2Tn+5GLLiyXw9nTiGEKzuHvCPzjW6zXr9YoQZyZ/YCNWSFHYj/eEMJFnjQn3yByJ8WxxKAQ1Q8qJFAqHySN1o2BY0/JSU1owqrCkZiWHECTRhLE+Vgaj0UqijCKpjuOSeT97jBY8t5aN1Zize49PhYppBgal4KTkeedYI6k5sCSowiCrQGlDCQtjTXxIC8clcPLtQXJlJG+nhWNKKKDTEqUlCEUnFEYolDAMBn622fKit9zPzb7WPDX8nwVKKqSQlJIJcWG7WqHcDavtc8YwkpYHqp8gelL0zR1FCihQSyGGxPHkydaw7jWD7XDVtM11WQi5IkUzRkilUFJmTNBJgZESqTVJdZzmkYfJs7WiGQ8YjaltCzXnSjWWWiqIxKAM18qwFUAMLKmQkWwGgVCKGhLH4Pk0zxx85BQL78eFvYCxFqZSCKUgawUkpRS0bHa3JVV6o/niYsOYJMcpEc55Ok/4PNBnNxyBxBiJPPs/JZGI2SPDhDSKlBM+xnbPSUktUHIkJ8lunOm6thW3QqJioehEUIIlN1c9Swsz9SkTUsBIgT6LhZOyLHFh5wMDGm0lRgskiYRsSbqq5TGkBFq0R+mmaHRJJCpJKlZiQBlDSIUxJx5D4BQic068n0culGSqEGqhlNLyShAoITBatjMUje0ELy/WzL5yXGZCDOjvmQXxw234kSgKDw/f8K/+q/+E3XFH+vFrbg4rNpsVr3rLau3Y3+9IypCkhpSpKf1esFZKYMmCY8jMGU4pkkQmxkIvJWujGbTG+8a7zlKincYqTRKChyXz7hg45oXnsoNUGZeC8IXVWpCyYB8SPrcp6OthxfPVqk33c2FJgSV5jidHLaVxY1MmhMwYEgn4uCz8djoike3xISTd2ev/Rml+vt5wipnfHk/8pF+z6hwhRC6SxyFYnkJnPhsKkioNqcC4LGzWlrvH3/J2ekBoyUYobPzEFANJdQgpztSwxiH8jo4Va+UUm2XsXBPCFo7LxIBhtbYMTjPHQimKmguyMxhlKUJzt3juT4HTMnNjDDUr9lFyjIKrPlCr4G6cWXKmVngx9LyxPQNnf/5SiTmxn05QKjllRCiEJXIMgUTl45L4+6kySIU9e7lfdD1ozdZIfrresguev9s/8uV2zarfkNPItYm4IlieVtqfBfnsCZ5TIkbPIjMXl69QV39HmBbi7OmWT8xxBuWoUpBihpSRWZLx5BDI0nEKjafoU6Cqwjh5lDSs1wOD0xyXyDGew+GcwhhDlYr9Ivl0mnicTlz2lkXAQylID1frQqgwx0BMlVwqP+pW3FgHOZOzQOSITzP7vYJVS5QuKeND5OgjOQkeF89vfKRHoasCARvjQEuMUfxivWFJ8PW48Hq75nIYqFMFq/Eyc6rL//cf5hP+W6ECSikG61DGIk3Pm1/8B7wXkeX9A3J6IERPMZIqHSmVtimiUYBCrSAkc261WURzGzkdFnoHF5seqxW7cWGaFoRdYQdF1ZIkFONSuDslpjBx4RylSE4LjB4u1pqkNSFkFp9IqfKj9YYehc2ZVCOhZmJMnMZIrSdIGRESKbZcCo3gzi/sc+LCaTqlcVLT66YC7lTmJ9sNMVfejQuv15dcDh11ihQt2kP0ad7xGVFQVKyUv3/YD3aFevMFh4ePMH8C/0CMiagUVTb76poLojSXnQqkIplSBRrtrFeKx+mI1Y5utaHTlmOcmOaAHNZYZ1BaUqVkKZXJaw7Rs3aVkuGYM0IIrpVmTppwttBeUuHG9lwqg1VN8B1jIcTELBZyKeSU8T5ynD2HEIHKY5j5BAy61Z8VmsFJsIIO+HJY45Pgwxx5sXYM1pBSpjcKg0J8T6eyH2zDDxEVd6T5nsPURBSnNPJv97/hy43gy7pG5V0LZNCS/TShUsHUxr9fPEjb8abrWGIipsiFFXS150MeiaFwN3mk9Mgs+Mnllk8+8eKyRwnFw2Hilx9uAbhWHYN0bNaOy7WhVvi4m0BqRGi2SkIJfvHsuiU7KCilUJAs3rM/7BDJkYXAlzZFWGrhxlpOudKf0wMyoIXmhV2RleSfXfa8fnaJL5WfHEdebFYordiuN9xOgUcfKU8e6J8N0SdCmCllwcqMCe+ZHt/zs5dbnomFPgXI07kG4WFazsEzUFXlmCOjVdyse+ZQ8DFxbQ2DVHzYJZJM3J4K0rdX/D951vH2GHhxuUJJw+1h5t98+IjSleeyZ1CSq8Fxve6owIfDhM+C4hsFQxvLz59dAgGRLbIWhAiUEJlCRecjWmgyhUU2LuMLaznlQkfFaEWVAoXixm6wveHng+RmtSEU+OnmgvVmhXWWtYD3YeToM7U+Bc98DoTQwmWEFBitETUiaCLGtfBcckCJiUm15Mj9tCBSRVeJUIrkC7435/qr+BhZ2cb5HMMMDo6LZ04RKeDVpePbKfLFZoOQik/Hhd982kGtPK+aoWie9ZZn25Yw+fHQrAWSj4ylILTm51eXQIRcKbngqyLXyG7yaAJaW3yWHDOcqDzrFTHDdWP7UyQYKXlmB5w0/Om243LT4yu8HBLPhh4lJf2w4dY/MsaAyE/19zlQc0EKiVYWRGQOiRBGQqn0ZWLNDiUmgmrBP6fv6o+2bc9A6A3P1o4YYPYeIyNbWfiQI8sCdxSMVUhRGIZLPk0L18+uQEruDjO/+7CHWlkVhZ8rV88czy9X1Aq73YRPEJaFKRWUUfxoO5A91GqoxeKEo4rAwc9QNUIIpgTHUDmlxMoqVNZ0KKzUSNEGHs9Mjxs0P3M9zzdrshR8GTIbtwIrWalL3o+f2M8LMj8NPD4XilTN8e7fgZKKobtim44YQM2JoCQuwT5mSs1oUdEW0pKRSrHuO8aQWpikkSgqJWXm5LkrFWU0GfjJ4HjIHusMFcXDGPmwe0RLyVVVEAVd38xfKnB3CHgVyEvEp4KSii+3V0AEDKV4lMzUVHkIJwYMuhSC9ywpEUUbPjtavo5SklwrmcJrt8FJzReD4mLVk4TiJsLgNFrB2kkephOnJUD8fuGDP9iG/3/7v//fMfp7bobC/+Z//j/jT66umMfC3e3XnH7zwF+WO5xRDGtLSoq1NBQRCTEzL5ljSLy5XGO05rF6PiyeT/vmSLJddayt4S7OHFPkZugBGIB3tzNWa6yS/PeeX/D//HBPn1sybmcFm05zebnm7d2RKQRSqsQKtSjePs4oUvNLBVJMmJxZ944pJN7PM+/GBYvkZ8MApfKldZyoHObEmCNVVKKSXOdCqnCYEr0xvBhW+MWzcmu2W8szP3PKnrf+ySHgcyHlIzl2iBiQ0wNf/fqXPO//lA+//h13h/eUHJBGcrXeUGtiIzQ5Z0KIzD7gfeFnmys6ZzmKhbsY+HbX7Aq312vWUnAXFh5LZOM6SlFcKsO3nyaUVjgt+Q9eX/PXt/fMiydnjTOKTWe4uVzx1eMR71MTmdNiwb85HNnkilQByCwxEzJsnCF7eL8c+WacoGp+1HcoMj9B85gLU8ossYU4BVvZBs8eB3pmcI5nQ8c0zkSl2KxXPBs3nObA23T4Q39U/yjhuh5ne0Q1pBL55q//78Q8MH71a94/PkAMrAwMqxUpS3ppySISYsQvE8ELfrZZY5zjWCMfZ8/fHQ7Mc+SLmwsGqXgInlOKrDvHTZYMKN7fzvTGsFKSf3614a8fHphy85qel0AeTDsDP93js2c+p+SKUvj7x3s2WaB6hSqSECOiBNbWEELlt/sdH5eZjVK83myRInNJzz4uhFrPATOCbCWrUhhTpSyB3mhuOkNMmdnCZr3hYgns5sC34/4P/VH9o8S8nNiUNTF4/P6O/S//H4TguH33a/YPH8l+pFeS7bon1YyVkqravbeMgePs+enFis6teKyew7Lwzf6IKvB6+4wLK9mnwGOJWKnJuaBS5t3tSGcMg5L80+drfnn7yC4EOqFxx/H/xd6fBGu2ZXed4G+355yvu527v74JhRQRQg2kKSlJZVBVkFAklYZZGrIaaMwQGCBjwgg00pCRmGEwKQyDUQ6YQZlVkRSiqoSUoJRCiua13vttvu6cs7u1a7C/CLqEeoHCnxTxfJm5mfv16/fz+51191577fX//VlaxZsPznnxYs8xBqZaSCcb1W88H1mXgtEGZxQpF0oqrF1HHBPXceRZiDhreL9boygs0IxJkNIMLrNR2MGzjJFspDmd95bzHsJ0INqB5WrBvfWSGBOPj/s/6Ef1Qxu283RLz9IaNlLh+BTLPbYffcr+5poSRpzV2AqlwKChYim5MsfEWIS3LtZNMKsyL1LmWy8ChcTlasPadIySOUrGGk0oQgmJJ89nnBOsVbx3tuKj7YERmOcMuqHVH1xseHo7QSzMudVruWY+2d02M8DOY8mknKmlNg3IKDyLI4dc6IxlqSy1CAOGCCQpCILVFmM6iHsO3YAKpQE7HKQ5UczAZtVzEWfGknj0GUllf2gL/seffoMHm8qbZ2uulOJ4c8PtbaCkzHGaQTJG9wTxpKKJc8CIomTYxZlDKWhb8c7ifWHT96yMJ5G5t15htWYxe7axWdbsUuHq/Jy73YiqTRxChQfO8+IQcDWi58pZ6LgsFud6VibRKdtESrUxs7dzZk6VlbPNpdVAZy0pzZSaqaqwsI4HfmAXA0aa2DjVRCypzdOK5hbFV9dLFs4ScuZ6nHgyznzVWN7uLtj4gcsuclvHP+hH9UMbw/I+3XDGtL/m8Uff4tmjR1zf3hHjxHg8oqqw0T0ihZQ0Y2pezrVUYlLMUdC24rylqx3rvuCVIlK5WGywStHNM6sYEGBbZl6/fI0Xd3dooDMayZUljuelCdPrVFlNjrPzDb1z9Gj8wiJVkUszaDrmhGRHZxQo0LrZg+/ixD7OZBFWxnLPd+znCU+lU5WjVHIpoCpBEs+BdzaXrHpPKJlHhx2Pjwe+qgtvDh1nQ8/VYsmL/atD58sI7zv6fsHh7imPvv1bPP30Cben/ItzQktpY1ulMBcIY0EpKEVxjJU5Zs7tGm86vNNs+kKnNqSF4vJs00Rg88Q2zlQUEcXrr73Jze0NUDBGUXLFobiWNm/KCEPfs15bls4yWMOFUidxZNN5HHJCRU2vM7U2jYA2jrv5eAIpCGvvuN95bsOM5EgVYVbNiZWqKRiuNby77hisJZbKsynw6HDkx+qKrluy7jrO+54n9lXB9TKi8x2SA8cXH/Lsd/8/jLcfs9vekVKgTDOqZKq3ZCnM4ghjxOk2trWNmW2GB9bgvWLIjstuwcoqVDUsug6rFTbNdLEJFCfg7Xfe59Hzp5SSUdYhWRhQ3GkIOWPnyHrO3BeDcz2XJoJWSOXkMK2IY2aqGkoz3hIjKCMcSmSfEqVWls5ybg13cyamTKrCWIQgBV01MRXuULy7XLDoPUEyzw4TL44T71Lp+p710HOxHLjZv9qDX1YYLXgj2BJI457j9gZzPHK4uWbabZEcEWdRvWcuTRBL1Uhp698coVqDMx7vNKse3lCKgmfdr7BKY0vE5+ZCr7XnjXtXvNjtmlgbi+SMOzmSzyKYIGxCpYrBOYu1hmXfTNm+g5LPU6TkgphmGFhpgJftdGRfE9UolsrQK7grkUkFilKIQBYhA0mETM+7iwWDdaRSuD7OPJsTX9aaznuGrmPlO1z5Aefwv72CN9aOe04j08ztbiTME0GEQ4hYVVH69A3owtPjRM2Vzhj6bsFQE3OpdF7ROcu678hGmLJi2Q1oBUna3OlxznwcDrz/zvsQKocwc5hnqhTOjeZxFWKCw5zYHQK35kCnm/Pu0DmMgpQLMX6Hmy/MktG1UhGmHJlzs2eW00z3vrRr8E4g1kTVtf2qUCgUBc47vNZsp5lHhwMvYuRH85Jxihij2fQdK9v9wT6oH+IoktjePOTZw2/z7OEn3Ly44ThtSRmOc8QpsMs2q2q14vnxCFJZOc/Q93RSmYuwqOC0YeE8rlb2ubDqu4YBqy0HDyHwyX7kK++cwzyzj4FxjpQUWWrF0wqxZMaQ2B8j1zcjHkus0DmHQrWNKwtZQJRAASVgaPmZJDNKQU728QdJHCWzxjFTOPnmUGqhUgnAMHi8sdxNEw/3e17EwI9mYZxmjFas+o7B+z/YB/VDGjEeuXtx5ObRBzz54He5eXrNGLek0ohMTlWWSmMUOF15fBiBSm8tQ7cg10AorWDyWrP0Bqd6Zi2sO49CUUTIRTjkyNMp8SM/8hr6ODPGI4cQiDGzRPOC2mZZY+ZwDNzeHrBaMyVh3Ts0tc2pSiELUJrlvZwK/iCFXIWJTKESqrAtiX0uLGrzcohUAhVEqEqINLqL15p9mnkyjjyfj3w5r5jngFWKVefozStKysuIw/VDDk8P7J5+yO7Jtznut4SwI2QwpWFalaLx0Kk8mxKmFnqrWHQDqUZyaQZITgmD1fTWMxXNatFGuIpq+TemzPY48ZWvvkE+HNlPI/spkmLAw8lMs5CKcJwjL272WG0IohisQ9MOvjFXRiqxZEptuik0BClAZUYQKlEKe4FRChtlyNTm/Nx6JDR/VY3rLcZoppB5ejyyDZm3RZimCWMMy6Fj6F+Jxl9WLFTBh5kajkyHO+5ubjGmcDwG8jxjKHhbUcpiNDzfR6q0OtBbT3SaVBTVGDRCZwx6cMQCi75vOrtYEWmEu20JvP0jP0GOHzLFiSlEYkjo2sS9VMgFxqlwt5txWjNnWDqLRppjr1QCilRzo+3VilLq39tXK6VCUW2PDQiDUkRVyQqSbi9USjNV9bbDGs0hZW7myDZkpBTmEDBKs/Adg/sBp/T86OWSja8slCKHyHE/Ys3MNEPMgvEaoxVIxirYTxMxFi6GBZfrC6ROXM+R3gu91mA1dyUTRTA05qpGIVKZY+B6nsnKsBgWbMPEzTRiVcNhaqOYk3AMhZvDTImFq80SRDVHN1WpVLKopq5WMJWm3rdKcUjfKfgrUhWHXJhKQQQ8lqAKVdVm8FEriWaiUESIpbKbA8/GkWPJqKo4hMwwGPresVwOf8BP6oc3Hn38O4TtE24ff8T+5obD7kA1hSkUUip4p9G054QS7qYREril4XLVscyZmymw8v3JLhsCipgrppE0MQoQIcTEXUiIhs2wYB8it9OMqo0RrVGUAlMsXB8mcoQHZyukakrRaN1yMOZGj3KmMGZptwhaM+fUxo2qUJXiKIVjbMV/L8JRC1mBaKFQydJmAqVCSIltmHg+jYyl/eRMU2IYPJ13rBavCv6XEU8/+T3S/o7D80ccnj9lv93ilpU0C7FklAGlDFUqjsJumihFuFwuuFyuyVm4nSeWfsDSDgiTVswU/Cn/rIJKZc6JY9YopTnvl4zzxM08IkVYmBOCUypTyrw4TJRcuLdZkkvLEUVjtYeTq6SlcCwZrcApRSjNnq2otnGO+XQ4yJVLrUiaxnI/YWRTaWug0ETnhxi4nkfGnNFo5hAZvKd3juUrSs9LiYff+g3S9in5eIcugfEwYkwhhIJXtulK0Kf8y4wxIjmjh44HmwWUwnaOeN+hasFSCLUSpeKMQimYU3vGoWTiPBNFuFysGKfA7ThSSmJpNL5qAkIsws04U8stb55ftsJcFKjWXY2lMkml5MRREs5qBu2YS2lr9YlGNZfCWIVchZVxIM3oM9X2/8q6zeVLLY2qEma280SQtubPc2RY9HhvGV6tfy8t7DyRj5ESjtQ0c9jvMXpiikCp9FajdEUoWF04zA2MovuO835BtMIYEgvrUZJRUqiq0W+80Q2qkRpZL+ZMKBnlBs6HJTFM3M4zIWUGA6q2nAhFuB0jSnZcbQaotRlrquZ0XkolZCim1ZteazqjkJqxpukASqmMIqBhVsJKOQyFWTcQQkPOtoK/iCLWyjEVdjE3E7gKU4h0zrXxy8VnWwP/0Bb8Q8moY0aLwi8MsyS0CoQEa6tZe4MU4WYc0cYQ0UgVpGRyntE58PHhhovOszYWlTNPUyIjdDWhUWxL5BBmXsSRd4YVv/PxR7x5dY+D0+wlc248zvXAgagqe8moeeJ2Dtw7W3GxHMixdQxqVUhN3KTChVbcUbBGszp1n0JJ6Nr4/UGk8aON5kmJLL0hxkDO5dRNiFQqh8ORbak8P46MMXMbIqE2gV6PwnvDavlqsXlZ8c//p/8bhAPLwbHZrDmmgqmBFCsrZ9h0HiWV63GHsRYpNB5vKeQQKOOBh+ORe73hwjp0yUx5AgzqlIOlBI5hYhsm3h42fPOjD3hw8Ro7bdjHzMo7qqtk1Qqp25yZx8LtOPPa+ZrzoSOmRMlQq6bWzCFFLguMSTCdoXaGWiFM+WRSVEnSrhmX1vNomll6y3GOhJKxWrFPzTV4t90jNXE3Hgi5MIZKULWZzqBYOMN5/yoHX0b863/6P5HCyNJ1XK03TJKwyqHQDDXTU6lSuTtMaG1ItII5pIykQD7u+UCOXHaeDRWTEjm32x1b221kKZFDPLJLM5d+xTe+/XUeXFxytIZ9ynTOor0j74SYhacpchMi96Lj/mrF+cpSYjsklpNB057MWansJeGtw7mWH7lWutL+n6MIoQjGOK7JaK1IMRFLQWPYhtDy7zBSS+FunEg5MQYhqUSv2tfsneF82f/BPaQf4vj2b/0aNmfWvePsfMGYCjXNpKxxBpRqBlt3+wltDLUKRVpDLsrEPE88zBN9X1lJRedEzArTdbhiUEBNwhQj2zLRo/jNf/3/5UfefoujNe0G3Hd0psKYiFVxFxJPQ+BBirx1ccX5ajjpm1rBH2pmnwSXE8daGIxlOBXvsdZmnoQlImQpJAx3ZFbGkaUQKFgUKQcqleN+JknmdhobDahWxpTxbgABbzSrV+vfS4u7x58Sj3u8hsuzFUka/lcyeK2xugFSDiGitEZMpeZTAZ8Sx3HP3hQ2ncLlTA2Bo1R8Z3EloYB9ChzjxJgC91zPt775m1wsl8ymMkrCed1uk6ZmAhhy5HmZOAbLvbMzzodCjKfxMSAXxT4VXIwEI4h3eNOMOKUanGj06eBbRNDGMKNxaCQncikYXRld26Nvxgkthdt55hAi9QR/4WRENljLuv9sa+Af2oL/6nLD8/2B7WHidjfzzf2ex9OBq82CK+PZx4reJQrwpT/+f+Qn7TdJhx37KfHJ8wOLteNnzu8zGIfQuu6XzrHsOvYxYb1jTEKKQq8dx1K4vXvObz79iLV2vNUvOfOOmzCjc+HL/QLnHUUrlK0slgOL5YJPn+0YQyIX4TgH7g0dTw9HUs6srMV4RTLCnplvzxOX2fCGMRijUUpxtfJMkrjtFKW39LbjTC94lHY83B5w1nATAi/GgLWae4sOZSudVSSxOPVqsXlZsVxYwvoe2+PE8w+e8eFuz7MYeLBesO48dyViDkfuIvzv/8//F/6Y+y3S4cAYC493R5bLnj+6Hlh1HUo3nvNGerrOMwXorOEYFfvc4GMvwsjDwy3z40/Z+IH7w4JVr3l+nFBZ8WObNUYbZhGqSSw2nvVq4OGzHYepkLIwp8i9YcGLaSQDXakMsTLXyi4WPhpnllpxqS2Darbf5+c9IRZuLBRtWBnPuV/w8d2Wb97dcN45jlHYhYpWiteWKxRgfaWIYaVXf9CP6ocyemvpV/cZDyO//Y2P+HC/Z9aK82XP/eUZa9txCMJdTLzzR/53/FT3dfJxx36OfHR7x2a55md8z5m1OAs4zfKYWbmBfUjYznCMmXEqzLnyok58ctjD44859x0P+oEL53g4jSyc4c3FBowmUKhFWG++swYeGEMkibBLgde94+lhRKrCqYo3csq/wDfLkUVRrLThwhgciugUBylEq9DGstCOlbY8TyMfbfecGct+zjzdB5zSXHQDylZcV0Esa/8q/15GnJ8PTNmyPc4cPn7B8+2Wh9PMph84HwYWJaOOM2OMfOmP/x/4cvchZRo5hsyj5yNX6xU/Rs9Sezqt8KpDSkaUZ8wZa4VjmrkbJ26mwKXv2M07vv4716yd48Fi4GIw3B6OVJd5Sw84Y9qtD5luqblanvNxuuOYAiEmdmNg4+F5zNQIplaMknZ4nDIfjTO9bY7RC6W57DtIlUlHlKn0aBwGg+J6Hnm4v2M9LIii2M8J7RxvbFYYq+n61n1d6VdjtS8rqsxEYzmMM4ftI14cJp6QOesdG+vpk4axCVYv3v4JfvTyOXlu42APb3dsFgs2Hjpt6BeWvvO4KTMpQ8gRaw1TzuxiYp8y2lY+vXuKvtb0xrB2jpXteH53SzWat02HGTyJghTBLDRn/cCT6wPHUMlFiGXmYqF4epeZjwntMqkrxFq5iZmPYqDXhl5pPA2wY3RhJ5WZDAaccehc2MbItdZsOkdRbaSts4bLU5PDW0MS8OqzTXr8oS34n1/fkuaZHIXR9kRgZQzn3nE1DFw5x4Di4+OBr3/91/lRVZEcqEpzeb5m1Xmmccdud2j3zUCuivurFZ0thGSIWSG6ce/fHJbsxokvrRcYY5GqmYtwOwWcM+wlsSqGTnfMufDNh89443zNnDJCMzYqp1FSYxR3qdk8G1VZo7lnlvweM9IZom7FvvWWP3rviikXusOOZ9OMZLALYTErdiURUuCQM+eDpzeaf/bBB/zMa/dxdYWzhrNX9f5Lixd3d8zjREqCd76Ra3AsreVq0XHZWYZa+b3nO/6f/69/ztd6MCmTUSyHJSvvSHHk+ji1/KhCzsLZekVHE+eElKlZWFnHG2c9+7Fjc/KCqEoz1zbuMxjDYYq43qG8ZsrC1z9+zjvnZ808S4RGzdY0JBjsJDCHSi2OtXPcH3o+SDMGjSiYdEV1PX/0/IxI5my749kYiCfSa2dgL5nd1CgES+84M57/+7e/zU++fsWbZoXXloV7haV7GfHs5pqUEiWmNi/tDRvvWDrF0hc2XROBl6z5jf/1X/HHbEHlDCjuLVYsFoYUC48PE1kSRQRRhgerFb2FOQnh5Cp+v+944B27KXDeOaw1VKMJtZJzxRbNsUwY76hOM0vi6w+f8c75+jSWAZzo621QDHY5MpZGjzozHRe+w05Tc7QERmA99Pz0ekMk8ek08mIOhFwx1qBnxSFmdjUzxdZA8Vrx//j4I/74W2+w0qa5n/tX+fcy4uGnz6g5oaVBKABWvmcxGC5Xlqu+w1H59tbwG7/x63xlUGjJiCjW3UDXwTgWtsdE6CzWNlGiNhprLSkVQrYY0/Pmuuf1VcccwdmCluZMA4acNaDZSmCpOpy2zALf+PgJ49XM7VjIoqliaLPPla4abnQk5kw+JBbGsB4sXfEMqmIUiNY41/OjFwPFCNfTxPPjzF1ooxRaK7azsE9HZil03rBUjn/16DF/5N4Vr7sBr3VzXH0VLyUevnhBmQNWBN970MJCLB2NmHjmPabCk+OR3330AW+7DDkhtY3Grr2nSGY7BfYnk9SiKgvj6awhJKGUprG7WC55bdEzjtAtfTN/U5pSDcVoHLCTSKc0WmuOSvHw6TNYnzOGTK4VtKIWy1hyQ9M6xV4JtWR6NK/5BXdkSm1iXq0MG2N4d72hArdp5i5GpizYpr5jHxNzysRa6Gxl5S3/6uNP+Oprl9z3SzqnOes+2xr4hzZTn1/vMVaour0xA8KsFNs5cmY9OIfRCo2nHkeeKkFXwRiL122TmBsOmk2n2AyWoeuYs3BIipwzE4WkKwvlOO96Nt4157OUSaUgWhFOorMKBEmkXJlF8SxExiLMRlNrw3AutOJmDGSBtXGUKuyL4G1zrrznbDNJONlEv2Y8K+9Z+MZAf2MIbGNClCbpwHWMJ0ffwpwzkhWiFM/2IwvvGeiIn43G9Cr+K+J2HyhhxlmDNoUzFFsFd2Fm6R0Xrolphn5gTInrJFjaWJbVESlCOqnuzwbLxcLTe8MUaALb0rQeSRUuXc/VsOJyyOzmxD41ka0omAu0ydP2tVQGlRXXYSJXOCLUCp1SLLXlJs3kothoj0jhmCvetUPmRlvWqpkbZaW4xLLyHUZ5hgvPm8vIXWhM4dg5xpwpophyIZSMyYJXlrt9ZGMLw8kx+FV8/+PpdkTVzOA0ndOskuIgwu0sDDayMobOOxTg0sjDWOgRnLH45JBQyGIoubBwHauFZek6xiqMQQghMUumGriwlqth4HLRcZhLK5RyIqnmRvmdkNrmdkzVPBsDExBqm131KHqluU6JWmHQFkGYJLNwDovn3DnWSiMoslJcGcOld2RjWHQDr8fILsyMAsVqbkJsIvNUiKmQjKIrlpsx0ZuEN+ZV/r2keHi3Y6ELa+eIppIkUcVyN2dWPrP2FmMtzlj6knk+JlwVrNb0SuNmzTGBVkLvNSvjMa5jmxP7NCGxEmtBW83GOS6HDukt+zAyiZCqIEk41oQX/d1+RkJIpfJsDozPd4y1AJpeGTbK8jweqbTXKyJM0m7EtbH0Bs50R1WVgLCUymboQcHSdZx3bWRtrpqldbwYD83ETpogU0yiJOH59sDSQu8dMeU/6Ef1QxuP7vb0CJedb5pNQEpbA3svLK3CadDaYVNklzNaStPGEbBaNafbJGx6y9lg8VZxDMIhQc6FsVayUqyN5dwvODOeUSopN2rTrAoRRS+nznFVFAOGypN9YI63HAFVNZ1qNwOzFHCGpfbU0kbdTGfAwJAMliaiqhpWCq4GDyg2veEyObYhMVUo2bDLAVstpTbgi9REB+zHxNImvLOEz5iCf2gL/r0E9IkyMqBOpyGNiKJIJRUhVJooRxT7lFlqQIS7MGNSZTwVJ2hFIKBjoIjBK4+IsHaGhRkgCFkUKMWLOVJSRleY1HdGITKDVqRasVKxGK5rwUvPsneMOTGlwsb0REkUKme+HUiUUWz6jm9db9mFxJU3LJ2ld4aNN40XXCu9LlArU04o5fEnAwanNWKEQ264x5o0T8aJy80a7+CVq/fLi10aKSXiMdTQim1RClUVVYSSM0FZus6zjpntHFiZSl8VuzlwVImiT567p43KzhBjoLeanCsbb+n1Ep0rWTRKCTcxkZKAVCZJjFKZYqbXCkvFSOs23ElhIcKit0w5MabC2nbEpCgKNtZiVHNtvlg4vnW7ZxsSq86ytK6RnqzFWYMtFa/bzOBUEqVoOmPIInRaUbVizsJYEyEJDw8j54sl3viG9nkV3/cYJSJSEO0YOs3CWQ6xklXDX0op5KLRCGsqu5QakkkpDiHQi6KIpbeGuSgkClMJxJxRWHLJbLxj4TQqNqPAKoWbmCg5o2szCRxFmFKmVwoL3zWX25VClyrL3hJKJuTM0g0IBQysTo7h3mjOh46H+8A+Z876gZWxKAUbo7FWt67/Ce055sxcK95YUpYmWrcQS6HUyi5GPtrtWXaOy968WgNfUkQKuWSq1pjiUdoQi1BFt/03C1YJg7OssnATCitV6YHbGKjKMuZM7xy70PQZphZCbV3+lDMrZ1gYkJA5zgpjKtu5fS7SBJJTFWIsaBQOhasGhyYiSFWcDwOxCCUJ1np0DiQqZ85gVMPuXPSOx2PgkBIbb1kZx0orlrpiTZupLrRb2JAzWTW0h1HQaU1Rqt3QUtjPhSf1wOW6x1rXnD5fxUuJrJpu4iBCX4SqTyalpVJyJZdKUprOapZF2MfMUoHVmmPK5JrI+kSsO+VCbzRBFFGEmDNLq+m0R8WMEihVMaZCTplcCgfJTFWYcm3Lq9ZoNF5XQoEksBw8WSqSK0o7UAklwsI5jGvggrPe8+w4s8+FM9X0b9YaelXxRqNUc/GFpndSonDGIdIO0ZT2enMqJA3Ppoll33Gm7XeuWP//xh/agv9oMrWAp1lXRwClMco0WkRM5NNozMJZDqmxzIXKIUU8cCuJle4ZC5QpUU8GR1c9lFy4GjoWpuMuj4xZCHHm+TjhK/RKcZsjoVZ2qS16XQVlGz91soZN33N/4XkxV17kgrWOzjuOqYkgV941BrtzbJ+84CZm1rZRgzbWUnRlTIWhVm6mmcfHA0/nmTOv8c5xLu124FAVQWXiVPAi7FMkZAEU+pXJ5EuLmzxBFbpUqVUzlkJSloVxqFoJKZBqASwLa7hW0li6NFfTWhWTLnTaMUpGzRVbKr2xXG46Yo5c9gv6YeDZ3YFDLExx5vkc6avCSeU2TCRluCuZddX0teKrwVkDzrLsOu6te66nkesSsMbR6Y6jBHpnWFlLby2bwfCbzwLblDnzlY02nFkHGqZc8LlyHSceHg88HUc2eonRmqW1bd7VlEbByAVK4SbMzKWgAKNebXgvI4LK5CqoYkjVoA2omjBWoajNVKhWpFSWSrGjUlAkqRxKaP4kJXHW9xyLoswFoypLYBgWpFq4GjydUjye94xZOEwzz6ZwyrPKbYwErbkTYU2zefcVOmPRSrOynjeWPXdx5nosWOdYKjiSWVrP0jgGa1kOlm/tRvZZmIAzq1lp3eAEpdDXyl0MPDoeeTJODM4yaMu5FRbeM9P8IWIupJx4fjwwXpxxpdSr/HtJIboy5wpJWDmNMZ4kE71pzPGQM9SKwdHT8MJiFOV0aNM1MpHRxjBOM1IyXS0MbmCz7Ag5czl4BgxPdxM3RTA2cTMHrICttbmj2spNSViBBZWVUqyNQzvD5dBz/2zFPkZujjPGeTYycFcmFs4wOI0zmrO+45PdkZgqR53ZOMeF81QKU8p0VbgJI0+OIy+mwOB6oLJxjjPryYBOMKVIKrBPkVmgKoNRrzr8LyuUaY3WoxR8Fqo2CAmHQok0UytlMFYxJMWtVLAKpRQhV2JNFJXR1RBrZcyGpdE4Z1FaSDly1nt6ZXkxRlLO3KXENmZUFiiFMSZmLcxS8LU1fDsxdBi8say6gatNzzEndlPGac9QEyEWBtMMNDtjWHeeh3dHDqXgjWKlHCtrqRTmXDCqsEuZ69Bu2QdlqdpybloOz7lhjkNp/it3MTJJ5QyF/YxL4B/agv/RFFhry6VzaO3wZO5kxAMxCbukyaLpO9eYq9pyyAWLcGaaHXMMlUkHrNFc9B0/dnYJtM7UMc3kYshKkVW72tkeJ7RqCLq5FG5CZt1Z7vWenBKdgYVzxGL58bMzLnuPpbH0N8rgvePSrJmuI0YpBOEYZ2LMvL9aMEomVNhlwWrhJiTu5ue86Tu+Ne54kQLOWBadowNWwOAsZ7VjMJYXdeJHu44Jy0JrNLVxrl/FS4knY+TKW9bGoLXF1sJNzBhTG9IyWyoZax0bo9kYz0wm18KZcwSBFyEQtODF8Frf8eMXZwDcEJlUPd0aVKwzRBLXx9gWtVqZSmEnsPaK11YDOkUGNE41V76vrK84Wxo6NMvqKEbwHi5NT7xtzpQWRUiBa9G8t1gQq2oC9RQxWnMsgedPA2/6jm/Pe25yxGvN2iig47zrWHjFmQiD67iNR95UHTOahTXNDrx+Ngbwq/je4smYODPgdaXEyiEFJhK+Gg4RSspU4XRT07FSjkkqEdhAE5DVhvWturLpHT92tgTgSCVEIZdGE1NWk3PhxZipClCGuQrXVDZK8dpiQOfcbOCtRcTw3qJnM3RorfBo1sax8Jal1TzMhcF4NHBMgSKRt7Rnv1iyT4kXtVK9Zx8T+3jDPd/x7fnITU50xnBmPL1SrF3H0jgigreK22PmzaGZhC001NM426v4/sf1MTHoivOgasMCA2jVxnu2U6EKWOvpg3CuNEEKUmGtDTkXZgIdmlQqC2f58mVb/8aamGJmxtJZi3UdzhrGGFDaoE+Y1kMtKBQXvUOHwlJrBmMQY7hcDJz1Dq+FXhdWDtwAZ92SmCLOaLIIY0rEVHjNDUx9ZVcz29wOInMWDi9uOPeaj8eJbUqNbV4NSlVW3rNxreAXrUk58e7ZEo9lMJYK1FcJ+NJiO2YGrzDOoLWnlEIykQFDKpljKJhiUX5ozuNakSqIFDyQq6GEZs4lujAoz72+iaxHGuGnlEIxBu06InBIM0kbjNeUVBmLoFGsnUdLwaPxWEQbzoaO1dDjKnRSWWgYek1XltweC1a15vI+ZmLOnGvPG4vEmCoTwlI1jOzHNwcGD89S4lgEoxTGgcGwMZ7BGKITtNM8Pux5Z7lBAQujMAjCZzt0/qEt+E2Fg0RUFDqp9KJYaUvMmbuqmYzCKMWZMXRYQh7xxrPUDk0GHIdyxz3V40VxZjSvnRYbdjeMs2aMmTkWrkOiSGkmCJIY248xm87yvuspDp7ZSPNDEKKOiAhewzFlXqTINkXcpLl3vibGoY0CzYkilaWphJh53w3EKoxVeBwmtDV8MO24yY6lM7zfDUhVHGMGb7mbRxbBMPgO5wd0Svz0W+8QAestKE1+VWy9xBCu80wshQdSGQqcoSgJjkZTjEIrxX1vscAuRpxx9MZjtKbLTcn/1mJAA2fec37Kwby74VoqdyFypLANAWMsFc0xzezJWBQb73lHe6w1HI0nSiKUxC5VILMwnn0YeTIf2IaE1nDv/JwYM1Ot3OVIorDJHcdYecN2iBYOknk479HWMkvieT5ybnre8SsycFsy3mjCdKQPDt857OCwYvmJt98BQBuLoBl5dc30UqJkbqWSC9Tcuusr74i1ELQGY7+bf32BsYAzno22rIBA5OFh4rz3aBHOlPruGvh0d8MLVbiZFUbgZpxZLAAPhzkwCmgBsvCm03R+4OgDuTRSRDINTnDuDbtp5sk0s0+C1jPn5z1XpqNWuJPAXBPLbLiJEw+s4Z7WHCTz6TySjeK6VB7nmY3xvOOHU/4J/aLj2RTwSui9Z2GXjN3If/P6AyKgvaeiifXVEP/LCKXgUDPEiheFt42gRIWpGpLWaKu57zu8CRynGUsDBGy8ZhwLt6JZaKGIsPCO9b0TUWm3pdrKbZzYTXAbJtaLNVkbjmFumhDjuPRL1nkG3XPs261pVpY6ePzJSOkwZp7NM7dh5jwU3j4/o6w6ahX2pTIiJ3+SifsOznXPBFznyLZEfIJPA1yajjfdggy8kMh9P/Bsv+NgPYuhZ+gcF7Xnp157A7AYr5tnxB/cI/qhD6OEsVSMwKYYINMBSheOopiCwsTCA10QEpGKNQ6vLR0QsnC0hrdsh9RCbzSby+/k4A0vVGU7JQ6S2KfI0hhyNkwlNJ8SrVh5yypmrIHZnzyctCZ7izHCwmr2YeZ5CByycCUT9zaexVJTRTgWmGtlk4VbCVxgWNs2tfJ4njnqAjFjimbtOjbeIsCuCBc4XsQjXju6ztF3jnVy/PT9B5QiOGeoKHL9bHvwH9qCf1EtQVWW1vP2akUpwtdvb3mjc4wktiXhtOFqtWF/mHDa4pRh1XneXG+QUribei6851gyj44HDg8f8VP37/PBsyNbiXTKMGiLs5pF1vzuPLFRmlgKVcO7iyXXaWaX2hxZOoGml17z6X7HISbmkkhSiAL/y92eHyHz337px3DG8vT6mkfPnrWi73zg+gA2Zhaqgq3sKXx5/Robo7k6WzE4z2FO/M8Pn9KJIZXK43RkSJH39Rk/f/Umd3Hi4WFms1jSO8ec5z/oR/VDGxvdkQ2cOc/7pxz8eLvjvnWEkjjmhDOGi2HJ7TSxrg4tmrV1vH25hhB5Nk0oSQ39lQJbhJ+6f58Pnx25kZlOuUYMcBaf4OvzkUFZplopuvL2sOQuR44xMNHswmsWlp3lm9tbtnMghACqorXmN+9ueK8Ufu7LX8JZw+ObOx5e36KU4t3zNTdTZIqRczTnCiZRvHF5ycIazldN8X+IgV9/eEvfOXa7Hd+et/Te8iMXG/7bB28yhcjH85a1G/DKcpg+m633q/je4sx5kqpcuo4vbVbMFT68u+Ve58iSiRSs0txj4EUILIymN46LfuCNpaWUzOPjREcmSuHpQRg/vuYnXr/g42dHnqSZQTk2xrMYOrqimTIMtRljoS0/dXHFLkSex5lIIqSCSGXdWT447NnOkZQCSjeqyW/e3fBWHPgTX30fZwxP7448ut6iJPFj52tupso0R8615dw0Hv+DsyUL5bnaDAzOntbA55jSQxr5OB4w3vDOZsN/c3WPQ4l8tDuyOrnwjtOrkutlxMIakjKce887yyVFhA+2ey6NaTPtRWO1Rg+GfYSBDqMNi2HgjYsNNUR2j59BKVCE/X7k337wlB997T6fPD5yVyZ01QzGs14t6ZLw6NiIUqKbQ+mld7yYC9FlRDQxFaoE1jnyCTDNiWOIJJ3BGW60JU4H/tjb97Fa82I38fzmSC9Cv7C8OMyklFlWzUp5Ftby1tkayDzYLFn6juOU+RefPGzobBQfHQ/4NPHO+ZqfuHqNUoRHu1uGoWu3pMdXe/DLCn2axx+c52wxULLw6XzkDNBaQDXDqwiMRXBF0WvFZvDcWy/JWcjPrimUduO5j3zAlnev1jy+ztyljKnCwlgW/YJaCtsSmFMzCuys5bLrORZhKoLCtFHKMtI5i+0WPE57ns0jgYo2mic5E5Lhp955D2s0L7YHnt3eoVThS+dLtpMQY2CgUdMGcVydD3RGuLda0DnHPmR+49kLrOmZ48yz+cBSPO/4NT999SbjNPF0OrLoBnrfkeUHnNJz6RzRQI9mNwbGWlhZRaea2UDVDWs5S2IuMys30FtH5wyd00TJhCzMphCqMCKUOXKYCo/DyEU/4LRCVOOh26pZOEMu0lxv0cSiWHQ9ymVcroxzIpeEqgpUJktlVxK3eWaUQlcdu5j4Nx99xP3VEg882KxABKcqzgSOSpgkIVnojOfNszXTNKOVRWuLMgXIGNvxUAJzik1UZBWLrkPyzFwTcR7pi0e9muh5abFyFkzTc+zHmVIUnTbNZVIZtFIYrYgpM6XEqlvgtGqcZ60b4UQlsigKEKqwi4ldjDxJIxvvscaC1jhjUKVZdFObdX0FkhI2rsNRGBC2WTjWSBXw4qhURgp3OTLWQpXKPkz8m48/5mqxojOGtzYblAimRurcDGomKSQlrLTn9fMN03HEaY23DpMLs0Q2OJ7IxD5FjK5Qm2dFqYVY4FYCTudXorWXFEujKKbNqN+OE1OpmHrSNVXdTAm1ZkyFYw5sbM/KaBa24p0iimImkXBkpUgKJkns4szjkFg6T28MRiu8M+jYnMX3uQnjpLa1qu80FsWERmRmypGSDFa3EcWoCqMIxyyMpXBMmn/z0adcLdZ0xvHGakVJCc9EqQ1qMEshUVhpy5vrDfPURim0MVSbmSRAHfi0BA4ps9EKqCysRqTdEIxToTcW/Sr9XkqsrCGrii7C88PEXISFNm2/BExVWKUZU2IfZtb9AmcMvTV0RpO0Ikol5Ta6mJRCcmGOiechMvQWoxq4wnsHJeOtJiR9cl2GIJXz5QZRkVjhrswcSmDKmnM0pgOlWzE21UqnIl5p/u2Hj9j0PYPzXK0GdK2oEkApBMVcC0Kh147X1isO04jTDmMcuMpeImuWPCZwqJmVQJSmx9JaM4sQ5oDR+ruu5K/i+x+9Niij0Ai309TAKYCW5jZrjWLhXSPYFcW663DGYLXCa6g6N2dxsSeNp3BIiX2cuc6RwToUFaWh7xQpKnqnCUW3cZ9T/p4tLujSniyafa6EmjA1Y3IB22qCXJuT/SQFqzv+7ZMn3Os9Xhsu1ytIic4ltnMGDfHkoOt05bXVisM8YZTB6kYFPEhmY3KrL0tB5YaK75wFEYJUxjjTlYKVH/AOP1q3+Sep3KRA1pXeGKqq9NpgtKYA23nEIWgF3oAz0L53xWrRNbvsUqla0VvT3POqsNE0ig7tNfZhwp0cIAWwSpOrwldNr1pRZbXGGoOSxpZ2qvFegwhTaZzoKWY+jVuyFN5YLblcDJQiTDEQqQRVmChtdhZDpw3ZNExi5Ts24wVjNVlVqlJUmh7AWcXj48w2RUJM6HnGfcYH/Sq+9zBKoxWUWrlJGVMV3jaGvdcar9vw2DbMmNooAJ3TDK7Zr4vWXAwDWtpz1botTkVpjqqwMrpxe2nElbsUQVXmXMgiGNNcSZ2qeDRBBGcUC2ubtbYkdLaIUcQKYyqcK0PMhSf7PTEJb2423F8tkFI4TJmAEChMNRNE6HUbR7Jan0bWWr5NOYFuG68yoE2znDe28mI/cwiZUEtDzJZXOfgyQimN0e2weBMSJVc6p6la4ZTGKkVVmts4YU8UM3daA9XpkZwvBqj65OioWXhDrZpZVda2fWJGMKVyndqcaUiFWhVaK2bk1GQxBKkYpdvaWApWKULNiNHMpTKWRvKJpfBkP5Ki4s2zNfeWA9lqdtPEXAqRyhEhlEyvdfMS0G1Es8mRNUkyFWGuQjUKpXW7Yneax7vYIAsiGJU/82b3Kr630MpgqeRauYmRLJWudyijsFW1Na5UdmGmSDPl62w7EHxn0HSzGlAxkCtUbei9a06hqtApT1UaqZVSCndpJlCIpz0YoxDbhJG+CEEy6JaXsWSisexyc1itoom5YE1kwnJMmSnDG2vLxXoBUtmOM1EJUVWmWho1iFZnOG1RSp/2WpoWASHUtm5rrZAKKNjOgUOOpFQbWjG/6rq9rOiUO+E4K9vUnnWnTo4fCqxS6KrIRdC6NeGcVjitTyBrzaL3kKAgKNOAKLVqZoTenj6vCqVU7nJoDsySkQq26u/2szpjSSKIgVobsj3UQkqx5UhtjvYKYS5CHEeomQeLFWf9QLWGubQ9+Ds5ONXK0pq2xyvDd0yjqqqNiOWEAjjdSGalZrSBreR26JTClAXzGc+c39MA+N/6W38LpdR/8OtrX/vad/9+nmf+8l/+y1xdXbFarfiFX/gFnj59+r28xHfjKO2EH6WJbKrSGKWJqm1cThukCMdpbr+XgqoFrZp8oaJ4/WKNd23W3RvDZd+jtNA7SzWKWIU5FeaQeXzco7KQsiC1CeGsMYholtrRGUvnLJ11IHBImblE1s5x2Q1c+J57vUMqRKWYSm1Ok9bhrGOuEKgUVU9CH4i1UFOhtxaDolYhV+EghaoUF9qxdh6jNHPOQOaj44EXc+DxeOTDw5YP9nf/Ve/vD2J8nvkHDc9VauuUbqWSbcWqSlJCNRWl2+awDwFnNLVmrK4425Ya0Yq3V2c450BrvLNcDkMTOTqDMq2IP8bIGGYez3uSFKaSiLVtJpaWp7016FMHfuE8Gs1diRxyYNV5LoeBy6Hn9cWAVopqm328UHHG4KxlKpqgIJ68LThZ0ecQG3WlKmoRcpHmDwCsleOs83hnSRWyyny823M9zTwdRz457Pj4sP19P9sflPg8c7AoA8qS0eyrIJwOnKfxGaM1WcE+zXhrEN3wr8rAd3wb3t2c44yhKoU1mo1vXdWlNxhnCbWyj5HDFPho2nOME1PO1ArWWpy1iFLt9lRrOt2461kKM5VEZeE71r7jzHveGAa00lTryLXdEjgLXWcYRZOAqISMUGolVCGnTGd16z4JFIFUhExlqRqjvXOGJEJRwkfjkV3I3ITI42ni4Tj+/h/sD0h8nvlXq0FhKGgm1W7VUbUV46cTZSyZY4gYZdu+qRT2tC5W4I3zDa7zYC3WOTa9R1tF7w3aWILAISXGceKTeeSYIqE0RLU3hq7zVKtOXjYK6wzGGEJK7GvmNgW896z6npW3bIwiZ8EsB8R40BZvDL02zAJBK6ISUm1Nt6kkUsp4a9AoqlSKNCF4pbColjPrGEz7/hLCw92W2zjxfB55ejzy9Hj8fT/XH5T4vPfgdpvuqGgmanN4P+WiMQqjoUhhThlrDKUKRjUMZiueDQ+WzRlZtEZZw7L37VbJWrRtRoFzLhynxONw5JgTsWSKCOq05uYc6K1vCGGrwRqiwI7CbYwYaxm8Y7COC9+hKidXaAW6HYSdd82IEM2EMNMOFjMFSYneGgyaIpUiQK2tiagtG+cZjKZIoZJ5HEYOuY0K71PgJkyf6f38njv8P/ETP8E//af/9N99AfvvvsRf+2t/jX/yT/4J//gf/2POzs74K3/lr/AX/+Jf5F/8i3/xvb4MOVWM062oOplijClQRFPawChdsRRjWJqepIQsjc+apZKAs85zGGeGU2e+N5rtNPPVxYZN7/nGbsuTw8Rrqmei8poy3KkCWjV2tGvWuV+9f0YQxbe2O759d0eigCicqXzl8gKxmqMkNkrxe/stJWvuDV17QEVOCDON8ppF1HgM6cT1N6VgvG9CqJjYxkDSreB6W/fErnCksdmvx5lHx5FDKow1kZAvXHf188o/gKI15oQOFFXxrqNKal1X1X6Ql0pzNJqls4g9nfpLK2YqsHCW21gxUnFaYaowjTNfXazZuJ6vb+94tD/wOp5oNBvRTLahPb02nOv2/f3Yg3tkET683fLh7V3ryirHWdfx1YtL8C0HV7Xy7dsD2Whe7xdsug4prfCfQsJagw0Gi8LoykzBFPDeNgZ1zBxDICnhGBP3TQfGMSvheZh5tg98Oo1s58CoEklXbH6Vg9+J72cOGnvqpldBnKJf9ARJOAwWi0dhlRBMc+EuDmZVCaX5isw0HcBRz1ilcApQwiEc+dJyycpZfi/OPDkeuRTNTOa+8ozWglEMXvPWwlOB987WZFnyzds937hpRIhcCyu14scvz8EoDjkzKMXH+5FsNPd7z6o3SGneu7VWTO9R88hCFEvdUdGYUvCdbzjHOLMNY7saJ/FAW6w2TLVyMweu9+2QeZzbbWnRFZO/WDM9n1f+aWUwqo07VNN8IKZU0AV6VXGnW/JZKgOaaiDUylQqw4kWNbhW6FupbSZeFaY8897ijL73/N7ulqf7I+dJMdvCVfFUo/HONHND24gq755ZioJv3O34+hyJUhmqZqV63j07Q3nDVBpV6OHtiOkHzm3Pxpp2G1Ur1Rh6MxBLpiuKDktEUUph3fm2T8fIHBLOOCJwpQ2DNkSlGGPhZpp4GPfsQ2XKzV1Vl1f59534fu/BSim+c3o0J8+ESWX62syrWqM0E7OmN82NPGtI1O/uwWvnOPYandusbNKBQ8683S9ZOsfHccv1OLLOhtkUVsa20S3aeO5Z7wB4d7Mgy4oP9ns+2O3AtOmQe37B+2drlFPMkvC18nCcMVlz3jsW3ynUa2UqQqcdExGtVFu3S6Vg8KZNE4QEYxQG3yZZltrgTbthOk6F/XHi6TSSUqIqA1pTPyOt8Xsu+K21vP766//Jx7fbLX/37/5d/sE/+Af86T/9pwH4e3/v7/HjP/7j/Nqv/Ro/93M/9z29ztq38QetFBmLVcL/6ctf5rcfPieEiKJy4R15jtwyNRShFH739o6HT5/yI5drQoDtNOI0+CgcH99xcb7i7a5DAW+6gfVSI1L5yc0lZ52j34+8iJm7mPh4+5ADwmvrjt4ZFE3MqwfLX3j/3e++fe3U5ym54MqKCKxczz4GPt1uGaqnlIAJMCJYr1kpy6Mwsc2RHkjHjLWa+9byp4crvjUGvrHfEyssveHBUrHbJT49jFz1Ha9pT66Vff5iCdY+r/wDWEhm7Xqst5RFK5z/1Fe/xr95/CnHmElUvNYsjOW2TFwOG6Zc+Z3rHXf5OW9s1oR9YlsmnAWfC8cQeH244P7CAop3u57LVSVI5cr3nHULPhqPvIiJuxT58MUTgggPztcMxlAQslUMtucX3nmfcvoJ1lpzz3XkXHhvXQDP0sNuPvLhdWDQBgRsSO0mwre5w5sQTzlYSMeCtYYzZ/lTZ/f5ME58eNyTRVh7y2vLgd1u5tuHOy58x6X2KCDUL9YM6+eVgyYXBmcw3nFmHUkp/tT7P8oHj1+wj4mAYk2HJ3GXA2/VBSoXPhhH/uV8wzvrgS5rPpkChkovwkdPd2zWi7YGKnjb9ZwvoRrhdXPGWef46O7IsznyfB/44OZAoPCLX/4S3hmgYFxlcD3/4zvvAiDGYBS8dsLaudIQs4Oz7MaZj6Ytg25jRS4ktFSssVhleZqOHHMhm0ieBactb+mO/25zxW/HwNNxZqqFjfe8tVzxbJx5OgXu9Ss2ShApjOlV/sH3P/9qmVn4Dq0dUTlmU/gfvvIVvvnoKbfj3Mz9nKFOTSN3X2syiU8OI797fc29bsAbzdP9gQooDbvjkfvrc+4vOjSVd23P1QKSJF73lotlz8d3Izcp8cl44H+5eU5Owv/1K+8xOIsms3aGTg/89++8Q7GmDW4ozbkfAFAL2IfMws4c58yjKWGqxhaBMEHJOGsx2hDyzDwntC7EWeGU4UJpfu5szYf7zNMQmUpmYQwP+p7r48wn88w9PXDpmvNlSF+skZ7Pcw/Oaab3lrW1nOkepRR//P17fPD4BXNMoGBhB6aQCGRWZiBX4ePjkeN2z5tdjzGaZ8cJVQWn4fmY2GxWbHzL13Or6RcDRmveoqfrljxOM9c5c50THz5/RBHNf+9fZ6k7bIZFNXRu4E++dh+sb++LhnNniRle9wXxrQ6c58yz8RpjBFM0ZQwo2u2FVW0Udw4B6JA4oo1mg+MnzZInMfMsjpRSWVrHVd/z+HbPfkrc63vc6X36bP39/4qC/xvf+AZvvvkmfd/z8z//8/zKr/wK7777Lr/+679OSok/82f+zHc/92tf+xrvvvsu//Jf/sv/7MMO4UQZOcVutwPaG2qzsOk67i83HCWyto4vX51xmANzyiSpLHrPVIWPDnu8Am8Nrw8dISRMMVyIglzZSeBTifxM8dwF2IbmuHd/2XOYI7spkEvmeZgJRqM6TQoaIfPb2z2DrjyZZm5CYO0d+2mmcytu5yO5ZKxWdJ3jJgSujyP3+wU3MfD0OPJet+C11UAsEzopQhJGXVBa8c2buza3alWjFWhPRtiS0NQmUE6Z7aFQvMCgGEMgorC6Mdi/SPH9zj/4L+Wgg1xZesvr5yt2IdAZw/urc3ZzYEqZnIXOd+wRPrm9xaLojOHKdoSYWBmNEUvNlV3IPIozG7/kboSbPHLuPOfLJYd5ZjcJuUzchdA0J95SooEofGN7oFeaJ/PITYxsXM/1dMR7xzYEkshpftFwqJWb2xec9x3Pw8yTceTdxYr3z3pirLjc5qwnLWjj+eSUg8VXOuubJT2ZfS6YWikISQp3IbKNCdtrxhApyuCVQX3BOlyf1xrYZYVQWLuON1ZrdmlmgeH1zQXLaWTOmVQUGz+wJ/PwcGg6C6O5t2yHP1sSK8mIVA5FeF4KP7mwvJiE7RxZe8ty6BingERpVLIiKN+6rKkESqr81s0dK++4iZFjrjijuZ4igzM8ORzIAl5bdK0cw8izObK2hqMUtiVz3zjeXy55RsJmQwImk8ha8cEp/7CGzrXxiUjr8BsEKxVJhf00czsfKQa24cDSepxqTsNfpPi88q9Xmpwy667n7bMVI8KgLG+dnzF0njEmJBcWgyHHxJPDiEawWtEbx1wFYqRTIBX2MfE0Bi6GJft94CYlVp2nX5gm2o5wU2emUjBascCwQ5MRfu/5nmXfsUuJXRaqUjyNEyvp2IVEOo1faK0JJfKt7S339q55maTE66bj7YsL9mX6bv5FVdHa8Wh7h9opilUn40ILVdiTqCdlXc6K3THxNLxAd4qbMHLpezpjaYyYL058nntw53ukVlw13Os6osksMby+WbKLiZALWSrroSfExLPxCAqUVnRGs6uJZRR0biM6uyrsVeGri46xtDqwtxrrLbs5IkkT1ckVWkGvNccTdOPTw0TvM9sUOEpm0I67WPAUDtOMSMWYph/Y5sTj44H79shRhLuceV31PFgOTEZQIRNrZVaKhObpYYc6KooCZ21zuSezo9BkxQVKJoXEp1KIVng+Tpx3HZ1pvj2fJb6ngv9nf/Zn+ft//+/z1a9+lcePH/PLv/zL/Mk/+Sf5rd/6LZ48eYL3nvPz8//g37z22ms8efLkP/s1f+VXfoVf/uVf/k8+roAxJ3znWCyWXPUrkMpZ1zFYy34OXB9GFtagUtvMqtUoNCrDvgprBfdsm4Ne4+hwzHMmLQyKypwTc6rsp4A3hlQKulZybjPUvdE4PM/niU7BbQhMkumr5l+/uOH1PnIokVAyoBj6niTCMWWcy+xTc1CbrWCMZjU4JlU5hAxS+fHLC/7XR6f5Nu9wpnDUmaveI7Su7VgSoQqSwYrw9mLJsc5ceMdSG47HL47L38vIP/jP52BVlbEkuuoZ+o6L1RKVhYtuYHCefQjcHiesMuScGSWibCON5Fo5hEivPJdGY4CN06x6R0yZpB0KTShCSpntONEbRykVI4VQms37AqjW8mjcsVCWuxSJpVJs5TdubniwGNjHSM5NUGm8p1CZ0kzR7QYoVyHngsKyGPyJphIoSvG1iyu+8fxZm1mtGp8Kk0lNbKw1nfPMOXAnmdvQDqnvLNeMzFz4rlFdxi8OlvPzXAO1Ukwi9EpYLD3ndgARNt7Qq55jiNxNM+IUM4pjjFjdOudaDNsUqSVzoTVaw5k1rLQnJQEPeNUEZCGznQLnXU/OQqmlidGK0CmN84pnc2Qqwj4XQhG01vzWzS3nved5mCgFeu1YGNvoZSmSxVAUaNpImzKwGjrmMrGPkaoUP3l5zrefv2jCOLH4Ellow1nnGxHKWULN7GphGyeqhneWC0JIPPAdvdLcpC/OgfPzzL9S2+2dV5Vu6LhaOJIIve+4MtDNirt9M7b0tTIdJqoWlNNUMlNsYwyDaWLBhWtaIwDTD7iTK+8+Zm7nxOXQ1lGkNOFkKfRKMZwOmrNqvjdTbDeU39qPnKnEXQokKVitWHiP1MouJ1RptwrGNOiFAjadR0pmzokC/NjVBR/ePIcKYQatIgtruT90eFEsrKdUmGvhSCJJ5d1hRVDCg67HW83NFwiV93nvwao2OlJWhn7huRoGisDSD3jr2hj0lBAj5KKJc8YojbeWqit300yxGm9Aac2gDBe2pxSDtmBLE4hPqbCPhaGzlBKR2m4PKZlBK3oMt1NkKMIhRuaccWL49t0d66Fv5obSqELeWlIV9iljU6Wo5tcw14hiYNG5JrhNCWUUX1mf89H2to0OUyEHem253y2xs+JS9YwmEKtwmxNJwVv9gjQnrqzHWcN1/my3nN9Twf/n//yf/+7vf/qnf5qf/dmf5b333uMf/aN/xHD6Qf5e42/8jb/BL/3SL333z7vdjnfeeYckhaNkfCkoU1l4DwWcNtxMMy+miUOKDKrNiFbVZvub5RaoUkmqMJvazGJQrFxHKJXnYSZloT9ZEucMs87YCAvThEpehGwhV2Ge58ZAL4KqlZgKj8qMRmNof461fvdaxWDZhcScE0a1RXNMmcXgeXCyWI61EkthpNCfyCqHUgi28MAMfPlsyb8+jOylkBHQilIyf2xxxROlGpapVCb54iw2LyP/4L+Qg6VwVEJXCxVh4dzJWdJyHAM3c+CYM05XjHKIasIwpOK1QlU4lohzllgLBVi7jjEK10RClXZTk5t4PBmFTrXd2uhmPqe1I+rCYZ45ngQ9mkpIiael0QFUFnKplArqu3aYmm2KRClNS0LhmDKLvuPe2jIsehKC5MK+Fjqg5MpEJtjC5XLF++dLfnMcGWlElNbrUvzx5YZnSlErpJO4/osSn+camKUyUejklH++RxfotGJXMtsYmEum1NKeBZUiBVMKGt2ebck4Z4hFKEqx9p45V+5U4iiZripMFmJO7DqN5HqiYDS0nTaFTGWfAmPJSK2NTJYKz2UmaQgpk0slIWh/0nMozTEVtAZvNJHKoWSGvue+UqxyR1KCyvWUf4osmUkK2Vqu3IIvd55fH48EXZmqkKpQRfFzizXP6wi1MpVMyF+cpsfnmX+lCElXkoaqYLAWEcFoRcpwKJWDFKxkilREA0pRKtQCVSpjTNjBkaqglOGi7znMgZ3LjLmgs1BjJqXMuCjEmHAoFqqtgZVGaTrEyEEytVYqba17Pk9EdfLBKbl1+Jtind72TcgJdEaTc3MuX3QeZzwLqU10noWjCK42l+BSM5XKA7Pi/QvHv3k2E2slVEhaUErx3rBiTzoViokQvzhjtZ//HpzJuiKmwQgG31Gl4rTmEAu7kJhiASfUqk7UJ9UaZ0phSzusLZ1p5Dul2VjPIRcOVRELkDM5p+YMPRRCyhjjWJumk0JnMnBIkbFkUimUKowxEWpkrg10UYpwRLHxPQBaWcbTTUGnNVUKh5wYeseVMSylUKjUkjme8rdQoEC1ms53vOs837qZKUUTRYiS0dbwZr/gUNoaeEyJ6WUU/P9xnJ+f85WvfIVvfvOb/Nk/+2eJMXJ3d/cfnPCePn36vznv9Z3ouo6u6/6Tj1epRKkEKeQSibkpmBWKx/sDn+x2KN069wbAGuSE0jRacBWmmkgorudIEXhnabEoPjlOUCsbZThTDotuJjQJXlsvObMNv3QMM3chEGMiIqjacHgxFYw3HCVzXg22QCxC0pGqYKkH9vOESKLTkKRwPQc2y563lwNKa25T5DceP8Y5x0o7bkJkrk0jIMDXzpf8z58+YRTBKehQRCr3+56QMx/tjxxSRr5g4xT/fnw/8g/+8zlYspBMy8GQIsF5tDEo4NHhyKe7/enqWeOHAaUtoSTIhWVv203UNJKs5nmKlCp8CYvJlYcxUJWwrJqhNmHwVjI6FR74JavOkBBGSVznmTlnjjXjUHilCDHgOsOYEufKAkIsBVVya4v0nn2YsVVYn+gFL8aJLw0Db50v0VqxnSO/8+gpWml8VYwlM9dK1hoR+NJ6wb8gMZWCropOa2YF97uBmAIf7UeOqSBfpIr/P4qXuQYmKYTTjPA8R5L3dGg0imfjkUeHEasMUiJO+hPOshBypNMKV4W7mhGleJEjUuFHOo8p8DCPlNI4+ENtHdA7SVDgnvNcOE+kcluFbcrsc2BfOflQGEKsDAtHqEKHQp0IY7UUqgJrPIc0Yis4pRkRns6BH1kteatrs7jbGPntR89AWWyl3Xapejroat5bLfjnVZgBNLgKucIDtyCaxEdjI1XIF6jp8R/Hy92DBUzDEMeciSFjTBNS3s6ZZ1NilIyNCYNBO0OVSq1gxOA07POEFc91buAA7wspFV7sDwTJuAI2V2qpjFKYYuG1znPmPQG4Lkd2KhNy4hiFhTOsvCVKYc4VrYUlGiMQS6GYjNaKtRvYpQNFCoImReFFDLy7XHJ/0fNAG7Yx8dufPmm9/6IRyRQlpFoBw3tXPf/q+TOCtMEeBzijuDQ9xio+HI/sYiTNXywNyb8fL3sPTilSO0fVilwLuSgMAqryYpx5up8wFUxRuGow1iGpOdx32tIZ29zmveYggqrC4BQ5zRxCIz3WHJGSqEozSmGfM29Yx9r35FopKbGVNq0RomAVeK2YUsJqICoWxlAoTZSbbbsd144gBYUwVAW18nQe+ZHVOfdPa+AhRb759JrGvmoNvcYX0jhneW/l+K27Fxxzo5ahKtbAynqKiTwLkV3JjJ/x0Pn7GgA/HA5861vf4o033uBnfuZncM7xz/7ZP/vu3//u7/4uH3/8MT//8z//PX/tjfKc21bMH0PimDO7HJlyxes251lr5XDi5F4oy0XVbQQCOKrMKIWYC0FaJ31XErYIMQgrZdinzDfHI5/kkURlNo0kcOY7XlssuVx0HFLGOs2561jZxiBOptKhSCFxKIWtFA4loxKUIjxNE3tpnPMcCyUIL0pkLIVcFdeHmYfPtzxQPV8bzrg07Wp6oRULo3k2Bb79+KYtZtaw0o5ltazQfHqYeXKcOUrBOsfVYvn7eYQ/0PEy8w9g4Q0bY7FFcQyZXZ64C5FjaAc7aw21Nl8HYuZSae4bx6W1LFBIKW1kImVKKMRY2JXmSjpnYcByyMKHceaRJIyxJMB3DfX6Zr/k3mIgpMxCGy6MZWkaa1ikIlIJaWZfIrucOcTcTMBK4mZuvg+pwhQLMgqPUmAfIxRhux/59Pk1F97wo8OaS9OhC3g0a+u5Pkx84/EdtQhLbTjTlnPluDKOj7Zbnu4iU6lYbzlb/td3dn7Q42XmoEUxWI1SlTFlUs5c58gxZwRDVaYVyViMVqywrJRjZRxroxGjUVhyKpRcCCVzF2dqiRxDBqXYA5+K8EgEbRzaOLxzbLzntW7gtX7RHM+xXIhmqApVK+RCQRFjYJcKY2k3lnf7kRfpQCgV5QxiIJWETYln88wxRrII17uJD5/csTCKN91Aj4VUGzHKaO5G4RvPblBJWFfDZfVcKc8DPfDB9sB1aNf8g19wtdh8H5/oD1a8zPxTQKcqWgohRmKeGUNkTgmDptcWVyHiGLRliaGrGo9m6VSDWRiHxEwOmTFFnqUDkAhSsRiORXiWE3sRTAbdG7recbboeW295M3zFdZoOq05q5pl1Vg0HQ2ZPc6FYyrMGaYoPL694yZNbGOiakPVzT8iofj2fs+LsRBz5Xp35OOnL7jvNG+6Jd5UYk5QhIXRjFPg08c3DF3PxdBzYS3nqq3BH2+P3EwJOY3xXqxf5d/L2oNtrfhckSiMubRfaKYqGBS90qArJTan+R6NswrfKVadJhtpcxgxk+bIGCM7iRipJCNoD8FWdgaCMRjj8TSUqzPN4ff+sEEph6HiROhos/0dbapESpv5V1VhquJ6PDCRmFIkZZgL7IswivBsjhxjamvgYeSjF3esveNyWNB5RaqFJAVFYRwnnt4cQRQeGJRioQ0LbXi2n7iLgmjNxne80S8+2/v5vbz5f/2v/3X+wl/4C7z33ns8evSIv/k3/ybGGH7xF3+Rs7Mz/tJf+kv80i/9EpeXl2w2G/7qX/2r/PzP//x/lTpbfHOUHEvid+6ueZBn5pDosOhSOcPggBdp5pae173DFCEWIVbBe8tiAqMN4hS7nHg2zYTO89OX52jgOkzEkrnnF/y/t9csjG9Xkgha00Q+sfI0TgxFsaqwoVJKIio45obwhOYk+HgawUMxsFAObw3eKpSBKz8wxcjHYyDFihHNeafxHp7OsJ0TouHSWY65sDuM6GRYS+t4AWhjuB6POAW1VhSVe33/Pb+3P6jxeeYfQOcsWRdGEr+33/OgzoTQimKTKhdZcaxwQDjmwJmy9LUSc+ZGIt4bHsQetEF1sCuRp/PMzsMfvTpHl8zNnIjiOe87fut4aKI3Z8BojDG8v1wwhswjmRlK6xIkhIgwoihSiVqaKq4Iz6UgvuHHOhqKVlvNUQlvDWuqRB7dJEIqGIEz39jsH6vMmCpFw7mBhObhYYsSzRqFORnSdEZzGwPagkTQVXH/93GV+4MWn2cOKmvojSIJfGs3MkpmG4RzrZAsnOXmLnoAgk4sqOh6MnETg/eWq5hAO7SDbU58Os/svOUnzq5wFJ6HwIhwsTzj28eRAYPvHcY1r5P3l5fEXPjEzPjYnIdEKYquxFQ5AkvaCOVUhC2QIyz8hDcKb0Cs4oVU7vsFKUYeHhIhNEH4ykGnLR9LZopCRbOpkEvh08MRb32buaxC0Q2IsWMCBzEVXIX7J0rGFyE+z/yrtMbCfo58wpGYhG04sPIaSULJTbC4p3IURVcUTjKFylE5zvsOPDjtQWluS+TpNDEbz1fWl/TA4+OBg4F7/cCHc0Rr0ENj71ujeX91H8HwUdmjBsFUBVURyRitmYqgraFqQVQlOtfABH6mV81Uq9rKVgkrFCIjj26b5smi6a3izFs+Tg2zjNFopUm58OnhgOkc2ApSUQUCLf+UVkypYMRy5V/twS9rD05Go3XTWz69nRhDE0gbrZG5MIjQadhKM28rJSJSiMqwFYPuHX0JuGrpbWVXEo/GIys78GW/QAEvsqYjct4bHsU2HuhcjzEOZzSXS8fxiXCNIbmAQ2HRFFXZa4Wk3HQrVchSCE5jYqbo5kmhNBQtHIpwbnQr+ENEijBohQXe8I5Hc2SrDUYZvHIcxsJNPFB1u1VTtRXspQg3RJRTHLPgq+HSfbY18Hsq+D/99FN+8Rd/kevra+7fv8+f+BN/gl/7tV/j/v37APztv/230VrzC7/wC4QQ+HN/7s/xd/7O3/leXuK7kapCNG0ur8IqK25zsxuuRf7dLCmCkYjTjllgksbXXRXYTdAPlt5A0bAQuHId94YVUSa2WTMVxUwzHrroHa9fbjjvm3FCFeHeemC8C2w6zxgL+3Hmdg6cL7omxAip2XZTmwuqMZwbh7GamxD45BgYFg6FYqF60sl0QavK237JQQJPY2xXoBUkw/nC8Owg+BPKLtEq/qXWeN9mFNdUNtbxeuf+C+/iD1d8nvkHkLWlopuhW8mc14FHZeTZfAIDq8YWLyLsiuVyPRAzzKliiqKLlkiiM5ZsKlkLvcCZ7tgMjpwUqmRSzMwS6Z3jvh948/KcdddBrUjK3D9fcb0NbIaeIoXtPLGfEyvnyMA4RUSEqsA5TW8UF66jGs12TjycZ9ygsfOBhR1Q1XCsGdGFN4Yl+1TYx3riu7dxusFp9kXwQJXmGYFp+gLvbev+IWyM4/XPuNj8MMTnmYPF2bbYA7rCedVsY+BhSRRU6ygBBTgUOBs6Uq3MSVBTwTrLqu8QRXMqt2Clcobjcu3ISeOkYGLCnmazB2+4d3bOpuvRVVAxcnG+Yr+F9dARSuQ2TOxjYqEdXoQplca81ooeSzLwwGmomts5cpPa4VelHWs2KKmMpSDAA79ETtfZg3VUDUZVtCkEoFPtKjvT3C19MdjBA4ouV9bactm9yr+XsgdbA0qwAl0WVqZyNPAkBFJOqCKYrDBeMzs47xbM0RByxjbBD4NfYE8GcWuprJ3lQg9svKVKQjsQgSSZlTN433H/bMXKO3QFlRSbxcC9KeC9ZUqZmzlwVwoL7/DekGi5ZKxhaRoz557TdEpzlzLXqTB4Q5wyIWaqquTafq6Gvmv+EEY3Fr9RaNfc6/bbNrutsrS5aqXwGIaTN8AkkUFpLq35fjzaH4j4vPfg3jm0N2ijWRrFAz/w7DDxjAipYgugIHuYjHDpB6bQRNmSI4vYY3QHRpFKbdu2hbXSrDtHlIg9HegSlVW1YCwXqyXrzjeHVEnc3zjqHpTqSJKZciSSUaoV8yGHpnFT4DUUCg/OziBmdiFwO2eMVkjJrLuEEkeVNqZ+NliUQEfPxlS00fjOQoUdoJLgqqLQ6FJeKxa07ztq6DQs1WfLwe+p4P+H//Af/pcfTt/zq7/6q/zqr/7q9/Jl/zdDO1BVsVCee8OCrrOUMBJyY+pqpUELiOKsH9jn1JTPtTLGyrkx7Gqhp9BrTa97Fs7gteHhccttSsyl4JTGGM+7S83KWHzV6KoJOfNkt0Okda6WHjpvWBXLMWswmje7nt08UkRAWZzS9J3BVMs+Re5yJml4vx/46vklJVce7nZQ4Z7veRwTKWZSLFxYh9atgzvGmSOZqKCoZr38+qLn/c0GbTUfj0euhiWv9QNLvjimR59n/kHLQQ/0WDa+RxvPWI7sU8QZQ28M5kTCuewd2zwRSyXWgpYmCr+jcN8qejzeWHqrcVXx5DBxlxJzOuWg9jxwlV41Ea6xQsyFJ9vdd533dG0zeBYFRUhOuNcP7LQinoSLvbZ0HnQ17ENmmzKzrrw5LPnJs0t0KXx7f0REuHSO6zkTU2GXI2fGgoJaCluObEsm0szvVsZwf9HzzvkGazUfH3d8tT/jQbdg9fuTAv1AxeeZg4M1VFMx2nDWLSgoxCnG0q6pvWnX2ZIyS+PZS27CriqoUlFKuDaKy86z1ppePMbAohge7UaO0p69RYG2vNZBTzNJ0rVRJJ7u90gVppJYeo9H0yuNBvJJU7TTkSk1d15vNOedw1XDvkQOtVAMvL4c+PHlBimKjw97qJVz13GdM6q0kchza0FDrpW7NLMtDQEKwtpa3loMvHd2hraKTw8TV2fnXHUdn+0y+4cjPs/82ww9Utv6dD4M4DzEiTmF5kBqNNpUcsl0xnGUTFa1GUfmgkeRbeXCeRbK46tHmcJCDJ8cDlSt2KZCKaCM4dy1IofUnKRzLjw/TOQKL2rksra1yBsFSbX8Wy/ZzoGUWvHljeHMO3xVhFLY58IkwgPT8UfefkCP4sPdllIq57ZjnzK5tkbigAZR5JjZmYk7MnMSnMCgNRf9wJeuzums4dNxz3v9mouub//uCxKf9x7c+bYmWKUZXEdGEWrTlNiiEK0QK0xS6NXArArJVNLp+XcpM1vY6I61cgwYMBWH5tN5Rov+/7H3Z7G6ZuldJ/hb4zt8057OfGLKwZlO29iF02m5q4S6q5GoqgvUAglLdAnEhYWEfUOq2sBFkyB1y+obhLqFBDdu1FIjkFtNdVN00yW5wAk4KVO28ZDOKSIcGefEOWeP37e/4R3W2BdrZ4JJXESmz4mIzPh+0lZE7HP2jm9/77PXetaznuf/pw9AFhhhMAY8QErklPExcN3tIEBPZCE1iHKz37uItJZbB1M2XcfgA2RohMJWBukynQusvWfMkZerKa9OZmitOL/uyDExtYrrGFFBMsZAg0Lksp87GVimEZHLzEItNQe25t6sRSrNs37Nw2bKga1R4QUZb71X+JvBDAOoWHpYQyi9qEKCFkVuswMaJYsM3DeslzOILMkGnExoWXTBhhSRGVbBsQoRSdmgEIIDrTFKEVzAIdgGz1vrDTNjCC6ylZ4sysR3FoLRR6aNYfBF9zxQTokhhHLwiIGQMuJmyO5u3bIaA1qVwQykRKjiUmgQGC3J4mb4d4z0MTIKUaQZpWJaWe7NJmQo+sWymFHod6m/uufbx4mMBlSCFDMrNzL6WOS6pEChqHJRq6mlZO2LiokClJBIAUlkRiI6K8iCIUZELkYZ2xtFHSskWcIcWa6l3ch4Y8jx9nZDayzBB3aMxY00RlCSMUSaVtOFQC/LkLsk4gL0MeFjIqSi8JQj3JtO2Y0O3ff4CEIqpFSEHNAiU6NIAvocGENkiImgJEkm2ptq8f3JFASs/UitDHNjMB/emckXShIZLTL6ZnDsQpSWgm/8xksyVmS6lKgMbGLZcEr8gcqJdcjUVmGygsyNnBx0KbLNAUlGS4WXsBAamSVhLPMf2xB4a7tlphW986zlACnThSI1F1JRrtrGQPTgUyIQSAGGGBmTJ+aEFOXW6P5sxnp0GKdIMaO1RurM6MuguZWKRPnaIYfyzwhCwExJprXl7rQp8Td6WqM5tAbSh3do8kUiFRgkKgl8jFyNnjE4QgwYZYr8YY6MOaFS5toX1TB5s26Km9ufShZvEgRsfCD6SC8zQRXpTykFnsxcC0JMuN7jEgwp8bTraYwuErNZYG+U+IQs/c6NVqxulPASmXRzI+tdxueyBopciicvz2bEGHnS7+gIJCXQRtKNgQSYG4WhwRflq5HEGDIZQaMVTaW5M52glGQTRozUzLRB7LfgF4aQ5RaTmBlcoE+JXQzEmFDFZxeVEylmlCnCE7FMvaJyaYMZcqJKASsUKgs6VzT5e1v2ZC8AKYlArUWRZvcOJ8p+fdYPVEKzCiMxRrhxM3eprLGzqmbTj/jkyKnMEuSkiX7E3aj/ZDI+Re5OWjySpR6K6piQGKUZfCCIhLl5HYMPJBVxMULpM6BWkom13G4mRCFYh67kgUoT8rtTKvvAJvzb4JkoRUqRi+2GKCUxpnLyEiWNbhCsc0bE4lJrpcAiqL2ArJjUGi8zQSTGELkeHPdMjWk1EwkiZYwo099VFkQJu2EgxWI6dNE7ttFjfGadRwYSYyzyhN6Xa8QsJCMUWaVUqhKRzFRqLJKYYNk7ZM7MrOLutOFicOwI3K5bdt4xjRov/23rjnSUoUwJgUQU5bpcyGIlfaAt22FkRWbyIWrpea/Z+sBUSGKIXHeeVEEKkUoJjAQjMnUu/XwyKZQS1ApqJDZKLIIpiSE4TNa4mLgIPbdlxWIxYSEyPqZibpU8WlqCTHRjj8yl5+/c9TQpoUIZDu9zxuWMMQo/lANGSIEuBrYpIpLCx4QJmbnWVKIk+1fbHgTUleH2rOayH9jGyHFd4+LAQTSEBCM3KhsxletMmfEpMcpENAIpJFJJTqqGi2FgmTtm6gO7jHxXswmOGYrgI5euxxuFMZpi+l4G2upQkmlFRipFLRVtlpiQEGTWwbEJjiprxpA4G3tuSc3BYkrKfFPhZkiBqTBkkdj2PSlGtilyMQz0SpJcZJl7xgRjAmkkKQRSBpcSXSoHRJESZ9FhQ2aqVOmhJnOx7RFCMKs0dyY1y8HTp8i9uiL6wARNSgIXMyFSpJZzRopS1c1KEY1EyjK0flAZtm5kMyZquY+/F8EujMyVJPjMaTfijUCLhEgCVJnrqaNgnYBQlGyUljRS0UhBlSUbF9lkR7Kl1ebRsGXhNXeOZvQpopQkicSQAwtRErh115GDJQhYebbINJUAAQAASURBVEeXA9kHViFjlC7FFC1JKZFcJMTAkEMRKUiSVe+wLlHdJItVhst+RORMrTW3Jg3Pup5titytajrvaZQhpMwYizSsDKK4A9+0kwUBWQuyFEitOawmXO06rlNHbfbx96LwMaGkIvjMauzwGsgZKQSSIl1tgsBkiVLliWkhMECdbmYoc2bnRqI2+Ayn/UCbFMeTKbtQ1BeJgj4HNGU4txu7In2OYOkDVkZ2bqAXEp0lIpd28xwjOhYZUJ8yMSd89Gz6hIyZmlxGQJLgfOyRosgqzxvNUiSGDLesxftYji9Z4EKi8xGRYjmQkFBZEoUg6dLPb5VkYSrGwbNNGS3fXafHBzZSz4eRSdvic+LNYYcAHlZTUEUrvzaSKBNxAOcC/8nH72CVZLdzLC96dkPiFpoulgGdPkQ2KXCsM69VLbvsGQZHGCMxZFSlGULi3O+otQElOa4qnvXXPNAVwkgUionOmFwGij2wDZEYEhOlqBvNtnNcOU+0RcZL5kx2ibUbOJlNOUoV527g67sdXiQemoo+S9bREXLEy3KrMTEGRTncHFrDtLYgKxKOQ6N4tHNc9I676cMzMPles9oNNHVNSvDUOXDw8rRBCEGtRenVyxnlMlHBT7xyH2sEXedYXvbEEDlRiWvnCKmc1nc+4ieJmSyKAGN0xBTJXiCqQAiZ837HaBNKag6z4XK34b6u2ZnSatGmTC0UGMMQIzufIAgWylBVmstxZHCJMZUr7qkEm6AbdxzMphwEw7NuV2IwjtyzDbKWXPmRIWVC0siYsEishDpLDpVhagzaaAKRRirOxp6YM/ftPgZfBOfdSNU2iJw58yN4eHkxR2uLVGWdkAFSlDgin375AUYKxp2jWxVVsNtZ0/uRkB3OJ1xIDI1koSxaZMIYiC7iVERoTZfLnNKiiiilmWXFZjewMJpgJDIndEo0QiC1ZdNFupBACCaVpjKK83EkuiLvaqSkEQkbYXQ9B+2EA205jR2Phi0uTbhbFVv7dUwMIiJyxkSQSjK1AiE0U2uZ2gZdN4RhoDKKN7cjZ37ktv3w9PC/l1x0Dl1pSHAeiz74bVsxrQy1MdRSIk2GZSTqzI9//B61MfS9Z7naEkJkkSXbGBidZ8wQkyQ2UCtBysUHx99Icrq+VO9Pux0HlWVqLY2LPLq+5r6tGIwhkMk5YrLAOs3Oe0LM2KyYKMnMVLyz3RF8RlqFUSXhDzmx6soePNGGmHY82myJQ+DurGZeF+8cUipV5ZhuKvsghGZia+a2gboihYiVgks34sbA4YdohuS9ZukCx0aQBXQiQYIDW0xUlcxokZBZYQcHLvCDD08wWjL0nvVqBDxTp+niQJ8TDvAqEa2hjpIkIjFFgg8MlFv9qOCyDxzctKqJGHm23XEkK2RVpI+Dj0wVHNcTEgEpodIGKUBLuHIO4TJGKYwUKF0KGZ0LzFtJYyTPes+zfkuQAweqYkbxZ/IZpBLF/4FElRVGKhqhaYQmGU0SUEvLeRq5dp75u5wj+cAm/HdtXQynyLxkaxCCuTGsE6zwmCA5ljXHTVHFee2lVziYNjx+dsnbZ18BMtZqlt1AyGUgQ9+YZv3Lx0+4XzegygNWKXIoLad9xyaOPFBTTmSNyAEbFc+I3G8sDyYTFJLfuljyxO24GFf8r+4/4G7TooSgFoJ/+ewUsd5xUFeEnOlCQFjFb3ZL3HKJVUUBYBYVu+uRt2zi2JbHYIVGa8lSbRliYlTw0eMTVMz85pMz/n9PHtNEibaSIRWjHZGX7+tz+l7moKnpBOScOGkUAkGFxJO5Ch6N4JiKqS1DXK+9+oDFdMKjJ+e8/uS36WPEYosxR454EpUSZB/5H58+46FpkSozykQSgSM157LbsPSe14zltjZEGUkRvhYHHqgp338wodKC3zq94DwGLnvPf3r7LrerBiMlM2345Wfv8PW0405dkwRso0coyReXS7rlGp3KQfSBrRiHzFubHQd1zSAobUooLgh4JRlT4qOHJ8iU+bWnT/inTx+TQqK2ijFnxpz4zXDxPj+p701uVYZN8JAyJ0aBEOgYy3NxCZkyDZmmkaik+NgrDzhoJ7zz5JIvnH6Js+SYobkOpR0iCagbSSMlv3L2jDumRRoIMkICZQVd51krqC0sVEbIRO8DWxIvT6d8fDpHo/jN81MGEo/6FT929zYnTYWWiolu+JfPnvJOumZRa3IWDB6MEXxxfc3q4oI6ljbHO3LCeuNZXnpuT2o6HZBCMlOWpQ8UL1T42GxOCoH/8Xff5pfffkqIDmEhK8GYEm748BhvvZfcbSt2zpND5L4s8acIJKnZRU/vBW0S2KmEpHjlpYcczae8c7ria6df5tLtaGMpSqQQCYCqMjYLfvPsiqnRaFPm4YzUtK0lRbjMgWwMKM3adHR95neD50Gj+cRsTq00v3F5QW8FS9/xIye3OapqtJRMtOJfvvOIZ+uOVlNuQBEcNVPe2Gz51eWSGgkxcSIUa7ejW40cyIou+eLtYxr62BNlMTv62GJGipkvvP2YL7z9mHTT6pSkYBDFtG7Pi2Fmio5+jpGZLLMStYMoI6OJyAS1k1Q3qexLLz9gXtWcna04vfw6lyRmsigqhpQJIhNlJpD49ctTprqiNhKlQTrFUdvgXOAJkUwxYV0SuCbTJc/93PKx6RwjBb+9vGTpAk/dmo8czJgZjRGKhbD8+vKCt9IKawQ5SXwQNEryRrehW8fyapPgQBnONp4zFTlWkk5EgpDUxjJxAocnpsz92YSYEr9+fsavn56BAoUEKRlFZAjuXb2fH9iEPwMhlvaIudFcBceWQEj+ZshMsI4eg2SdPM/Oz+mua55cXPNo19EFzyJZ7k9bdiGwch4jayyKe5MpIUfmSnGsFQFYpQ4VE5OkYIjswkjKmSNrcVowqyuGnBi8o1UwswIjG3777Iqvmw3HVcU8GXY7xyp7ogMrNVkornrHJnvqrJghScCYEwZBipKLUKpaktK/1afEO65Ylr+1XqJSca1EQyKTHdQSWgEqfXgGht5rylYhaYRgJg3XKbAmom967x1wicdIWA897zw7Z12veefymme9Y+1G5tbz0fmMnY/EwTMlIRDcnVjGBFOtOVaKKAWrOJB9oHGJno5z7wkCDq2l1YLjSY1HsBkCFsNEJSam5qvX17yjOo60pUWxHEt/9mUYmSiDFYaNc3zlaktlFVUqsq7+xrHSSIOLDi0iSgg85ffvWXTYKHh7vUIjGGImyXJ1LwZBJaASApk+sMvIdzVCFq3pSioWQnLlPQ6QsfTGDxliKm2Myxh4dn5BZzc8u9pwFh2Xw8hYJ16bN2x9ZOUibVboJLlVNwQBEyFYSEvWilXvimuuj1wHCFaDlhxPKpySzG1TChHjSJ2Ke/Odtubrw8CSsnmp3SWrcWQnEzZHWqFojKRL8DtXG6zUTMtYCV4kuhhpreVKREIISClRoigPLaOnQvHW7hqZMgOJPo8gYRIlKkKdi+HOnuePu5mXM0ahc/Gt8QqmQaJkaT8YY6alKOWcnV/QrzvOlzu63rHuA6mGl+ZTeu/ZhshUKkxS3K4jg4hYMlM0VWXZ9CPXQxFBSDozmIDOmpNJw+gzU9swhMSm79FJEkXkXtvwzHlWKTMRYPrIxmf8zaxTrTSt0vic+fLVFUIqZkogybhcHMpL649nwBOzQqayBm68x0jB034DscyojDqhs0IJQUoJQ6bK+z34RdG5QFYZIwUmSgYC1yZhSOgbI9aBjJKJrUtcnF3RWcPlasdm9GzSSLKmxFBK7OK/NTKd13NCyqicsVJiJhbnAmf9yNYFUhypTaACjo3BA63+xq16pBUaB2gFb262TE3Dwlgux561G27mTDJWCCZaEnLm65stWmqmFJUolzMDnipbdpTZu5QpMtjJsXUegeRp3yFymQPYEqiiwVJmCIRImPTuBkk+sDv1cWXLEFiIjDe2xZ0cS1+U0FRSYaykjgqD5PTZimupON/1jC5wHR1RwFFTsw6B5TgiskSYjJGak7ahFgKDxGjN6+srQsroKFhFz5X3aF2GdbSRCBRdCGz9CFlwr5nijODRumPrA2RJFzwxRo60xUpJEJkhRbqcqH3peQyUqkOfExsZeWXSclhXCBcIoRg0bL8xqBETfohIUVRSWiTXeJTICAnIMri358VwrCyjKNUAlzN4wU5HbIxUWmNUUWZqlWTwcHa65ForrrY90SW6MSKEYBcyV85z7gdklkhT+gBvTVqMKHFhteLN9RafE1WW7FziOjm0EQhdTvI+g3eO3juyEDxopjgr+Hq/YxM8MRYr0i2eqbRoIXG5OPBuoqdBIaXEpEzKNwkUmY9NFpxUFlIgxMQuJDY3qj+ZhHceLRVzIZkgeZoGYpYkSo+/3OdbL4RDbejIpChIFFOZVfJMssDIMsRVKUUjDOs88uTpFWulWXcjeYyMviRssZqw84Glc2ilijukgNuTBpNBZ4GpNG/uenwSyCDYJM8uRbIWSKWIIhOSYBsC23EgJrjfNiSreToOrPqeTnjGbmAXRiokIhU50JhgHYqcsqpgjBJyZhQJJzJ3bc1Ra3BJlzmSmFknTxaiHEx9oLkRVpgKuEwBQVEJSoIyobznuTPXCpcVJNCiCBRsk0P5QKsElVaYWpUbw5R4dnrFUm/YdZ7kIkMMEGBMmbWPbJyjqSpyjkVhp6khJWQW1NryaLfBJZAp0/vAmDJKS5QQBBGJMbEOkZ0vLZJ36wqlLU/dyNKPrLMgdI4VjgTElAgyk0ViTJ4QAlaXNVFQDgU+Z+5UDSeNZfAjfYrsAqxCJIsiVSxS+X07qAxRZlah7M85FRW9tJ/afWHMlcDfbDAaic2wTB6dBRNR2sqUFdTC4GPPk/MlVgp23UjverY5kkTiQDfsYuLae7SWaCVASI5bSwyRlBOtEWx2rnguZOidx8VAlplKWcZQvJK6HBmjRyI41hWjyDz1Azsc5EwYHSsfSKl45kiRyVmyS8WcdaIlTgBIfC4+K3cmNXNt6PzI4CMuwjJmnCgmrzkXcZeZMtSo4j9xE4NZ5DKH8C74wCb8/RhwokzZj7no5soblROjQUjIAoQWqCx5dLWGnBliRElJLQy1MKzH4j6qKSYICoFPEZXBpcxAoBbQh/JLKygKFj4lFtriRZFWUnHEJU/nRwiCSWuZas3EeFIultu7EOhDohWqSGxSZBaRlIFeWTYogcCIYihxq625N1swdJ5lN5BijxVFQ1iQCTEhZcRqhcjgSEgkKhfZ0vguH/Seb59hjAwafE6ELMrJO5fbGcs3bKozSgsI8Hh5jUTgQonBRhcHyuXgy1C3AKtE+QUVCSVSkQ/LJQEfYwYhiUrQxaK2s9CaIKDzgUuGMkjkPT5m5nVFqxRTbUg5Y7LiOjhcTMyRqFwGz6SAWhZVq6KKIdEIEomci3LAvdmEYfSsuoGN7xGAQQAJn2JRxdJF6cXnYvylbgak9rwYxlAW/JBSGWClCAz0iFKpz4DMaC0QMfNkuSkqJjEBglppGjTXY6APsQwwSsEgIjUKJTIhZVyGJkqGWIbehCoW8ykkptoQRXGGXg8jKUW23uFj4rZs0ErTyNJ7TU5sibicmKAwWSCzAFFug6IoMy9CCBSSknZl7kwn3Jk37FzgenS4YUCKYnCXbw6sWiq0Ll4lIWUcGS3Lz5M/RNLE7yVjSHghSAmyiMUXJwlGoKGoQUmZSVIQveDpaouWkhgyQYDVmlYb1kMx+pOUynqXPCorZIJwk/AoH27iD5SSjCkTUyySqzcyhZthJJPpQyDkxG1Z0ypDKx0yQ0KwFpnRBWairE2S4pEjKYOekYQQEpPL/ooI3Gkabs+n7MaRZT/gQg9k7E2i1cdAVEUGVwMOj8hQ3cyoxHdZXd3z7RPzjadkzkiRSUISU0CIovSVRUKq0hkRgWfrTdGsD8W/QwnBTFeMsax1SgiMKkIUGUkWuRwOI/gQ2aUMQiCkwKWED4nKqGK0lYpapBCZMQRySsxkzVQZFjezHxrYioSLmVqU1i+RBenm9YssiCkipEYLCWScgJPWclhN2Q2W635kNZQbgtL1keizJwmJUgKdJcGH0qKpJEZI3qUq5wc34X+87khWoJUolUkhOJQVj8UWL8tGSIxEJREkzrqBECOVUszbihkVJlhW/Y5GKw5rW7SjI6yT56obyKX1EBUdjdaMMZKNIIfS8pCAXYxc7UZWeiynt5BIJO7YGa1QHFe2LGRC8DRHdtuIIqOyxGrFgZRkDauYGWUmSEGNZCqglZaXplNuT+dcyMCVT/TdhoXWXHtFzAmXy+LmbgLxG7MIKgiUKNeqe14M7+wGUi3RStJQftkWSnFBxN+oQ2UJFdCRuO4GcizOoZPa0tQWkwWnw0BtJPebBi1h5yMGuOo6siymIiOeqa0ZQyTYiPeQYsLfqKhcdyNbPaKyIIaS8NyvFA2K27ZGiqJFNsrMcjVQbDpKdbZSsFBFwnZMEUyFkUXSdZYj92YNtxdTlpvAqo+MYcNEa5ZuIAAjkZBhpLgGJop6VI2mQZH30rAvhLPeEY24OehnrFBMpGKXEzblInsoIsYqvMhsxoGcJVoqjLWcYDEoluMOqyR36xorBWfRI5FcdgNJFOUllwSt1owpkozC+yLp2qRMFJlxSFyELRkYU6LLkWAUVggOrEGKklp1KbAOI/bGDl4hEEIwMYa1iuxCRCpJLRQVxaDmwcGU49mUq86zjWtc3jHTip1PjER6SsEnpjK85zNA5lAoZlLtE64XxGnnwYqiCJWgspJaK0apSEgCN7KXWjBkQTe6ImMsFblSHNEwN4bT9ZZWa46riiQjz1JimjRXnUMpiVKS7TjSmAofIlnDeCO9mBGEGPE+c5E6tFRFOpNAqDVWKo5FQ7qp1gcyq13P3JSiWxZFpaWWmo0pEo1KaCqhsGRqikfEwWSCUJaNpxTdtMQ4QU8oqmhJMVUGKHtwSkVDfaYkzu334BfFMkSEKYnxSPGEaNBkpchkUk7ELOmyxwfowohJxa1WVYYj4G6z4Gy7ohKlNVvIxNXgICdWvSsF1CTZjQlpND4lFJocHDFlbCqO9illVv2Iujk49jlwu1FM0NwTdSnIiMyWgOwlE1naZVOGSGIiJSkJuhSZSUMlBJpS5Dupa+bTCUbXuLRh7caSzEfJgGNIoThD3yiS9SkhZGKiLFOpyq3pu+ADl/B/I3lorcKr0v4CmYVUTBG0sqgGxJCQCLrtyEFtUT6jpGSuNLeEJefMry2XTCvJ3WpGIzRPhh0jgUTmzEduT1temjS0StMqyZfPVlhKb97aebq+Q0tBlzL5psppkLTK8BPf9ypXj5dMhOKiH7gaHSplYkiMorhiBhfpYmSqVFmgAlwj2FIsv2VjmJqafhxYDyPLfsfldoc0iS4EbCyBohM0JGRlGFJZqGLIeAH2ZpBln3Q9P77xXtZaEIUkp3JbM1eGSpX+v5gSPktM0qRNYoZm6z1IaLXklrJkMl84P2euDffqKVNhWHY9Siae+YCMgnvzGXfbllZBIyu+cnaFypqcMmfes3ZFnjClTE4JnUt1qrWaP/qDH+ft3z3loNNcjANnwZXFKAR2SI5taQHa+UBrND0ST+DSFVdVLSQnTctU1fS7gV3vWQ89V32Hl6n0D5buCyqXqQewlWaeFSIKMomcSrX2333f9vzB+Mb72ECpaGWQWTKRZZbkzI8EUWYpTJKoIXOI4Vkqh7yp0Mx1WQP/zdUlrRbctTMmUnPqd8iYOPMdUgruTibcbSa0ytLOJF9eLREhEmPk0gWe9QO9iTRB0YXy/Q2ChVX8xA++yrO3rmgHybXzLGNEocg97GTAIHC5VG4bVdoZQ4xcyq5U2oTg9rRhahT9bsd68Cz7LRfbHT5mVmHkRlIbmVIRcTCKQzQxlmv3kDKE3/u+7fmD8Y330YpMLUuSG3Ni4iVtbblOReu8p9yYV11JZtxNK0QtBHNTk8l89eqKTFH3mQjFxTgyyZIzv8OieDCdcbttsUoztYY3z5bEEHDhprXGueIXkSTrlNCq9EQ3yvCf/6FP8s7rp1SdYOUGNiFgRFHv28bMVICLkT5malVaKV1OXI4OkwRKwlGtyx48+CJxOA5cjB1dTCzdiJLlQAyRUSS0MRxjyDkjXMbJRL4pr+7j7/nxjfdSjgltDVmB8JFZlDSN5SKVkX6HIEdBcp45sI43B9SbfRrgzc0VhMixtdRBsI0JkxUrFzA+cty0zCc1lVK0OfP19QoFuEzxuHGeAYkBOsqcm7nZ5z/z0Vd4++2nDB52LrBLiUpLgo+gyk1DMYRNqJvZkY1zeB8xojgJ3NI1jaoJg2M7jCzHjstxYMiZ9Tggi1VUaRHKAikFTSi3sT5HOk3RjeU/HoMif8Ci9PHjx7z00kvv98v4ruPRo0c8fPjw/X4Z3xO8+eabfPSjH32/X8Z3HfsYfD7s18DvjH38PR/28fedsY+/58d+D/7O+I/F4Acu4U8p8ZWvfIVPfepTPHr0iPl8/n6/pBfKer3mpZde+o5/1pwzm82G+/fvI+VeLeB5sFqtODw85O2332axWLzfL+eFs4/BDxb7NfDbYx9/z5d9/H177OPv+bPfg7893m0MfuBaeqSUPHjwAID5fP49v9h8gz/Iz/ph+IV4L/nGL8xisfjQxB/sY/CDwn4N/PbZx9/zYx9/3z77+Hu+7Pfgb593E4P74+iePXv27NmzZ8+ePd/D7BP+PXv27NmzZ8+ePXu+h/lAJvxVVfG5z32Oqqre75fywvkw/azfLXzYnsmH7ef9buDD9Ew+TD/rdwsfpmfyYfpZv1v4sD2T9+rn/cAN7e7Zs2fPnj179uzZs+f58YGs8O/Zs2fPnj179uzZs+f5sE/49+zZs2fPnj179uz5Hmaf8O/Zs2fPnj179uzZ8z3MPuHfs2fPnj179uzZs+d7mA9cwv+3/tbf4tVXX6Wua378x3+cX/mVX3m/X9Jz4a/9tb+GEOL3fHzyk5/85p8Pw8BP//RPc3x8zHQ65U/+yT/J6enp+/iKP7x8L8bgPv6+e9jH3z7+3k++F+MP9jH43cT3Ygx+EOLvhSX838kD+wf/4B/w2c9+ls997nP82q/9Gj/8wz/MH/tjf4yzs7MX9TLfU37gB36Ap0+ffvPjX/yLf/HNP/uLf/Ev8o/+0T/iF37hF/ilX/olnjx5wp/4E3/ifXy13918pwvG93IM7uPvvWMff9/KPv7eW/Z78Leyj8H3jv0a+K287/GXXwB//+///WytzT//8z+fv/jFL+af+qmfygcHB/n09PR/9us+85nP5J/+6Z/+5n/HGPP9+/fzz/3cz72Il/me8rnPfS7/8A//8H/wz1arVTbG5F/4hV/45ue+9KUvZSB/4QtfeI9e4fcO32n85fy9G4P7+Hvv2Mfft7KPv/eW/R78rexj8L1jvwZ+Kx+E+NPP9/hQ+Bt/42/wUz/1U/y5P/fnAPjbf/tv84//8T/m53/+5/nLf/kv/we/xjnHr/7qr/KX/tJf4vHjx8xmM4QQ/JE/8kf4/Oc/z1/4C3/hRbzU94xxHPnqV7/K3bt3qeuaz3zmM3zuc5/jpZde4vOf/zzeez7zmc+wXq8BuH//Pg8fPuSf/tN/yqc+9anf9/vmnNlsNty/fx8pP3AdWu8L30n8wfd2DL6o+IN9DP777OPvW9nH33vLfg/+VvZ78HvHfg38Vj4Qa+BzOzrcMI5jVkrlf/gP/+Hv+fyf+TN/Jv/xP/7Hv+XvD8OQr6+v85e//OUM5L/39/5eBvYf3+bHo0ePnvej/K7k242/nPcxuI/B58c+/vbx936z34P38fd+sl8DP7gx+Nwr/BcXF8QYuXPnzu/5/J07d/jyl7/8LX//537u5/jrf/2vf/O///Sf/tMA/Bf/mx9l3k4QKAY38mx1DVoyt5ZNPzK4EZlByIhWmsmkZdJUWKlxLuBz5HK54iO3Fiwaw1FT8erBlBHBxm/wA8yaikzm6eU1L00atJa8s+1AaQ5nE+7fWgCCVhucDww+MfrI4B3nrudOVdOPWwbnSVEwEZoAiEoihWJmLZO2IpBwu4HOB8YxoBFMK03V1uSQMEqWr5OglSTkjDWSQUElNFYotDG0TU3VgIiJYUyEkOmHkT/1v/sHzGaz5/0ovyv5duMPfv8Y/L/8rf8Dx9MGoxRJaLKyKJm4XJ0znx/QNFMSYHRDYyVKSkbX8c7Tt/nyV3+LuyfHmPaAs7dfp5ZQJU84f4coBTs/sukTB/MJ88mEmA33T+acPnqbR9sdRmuOJw3Hi5aqMVihcSEzOkc3eHbOc+57bmtD8p4ueFxOzLNFKUknEiJHFrVlPpmQcuZ60+NzZud6dBYsbMV0NsE5TyUhS4WQEiUFmYBWlt5CIyWVUGglqZuGxaImpcBuFwkhMrjAf/2//0f7GOT5xt//6//215kuTphMZxyfHLC7XtMcfoTN9QXTw3u0k0PIHkkEMrvlEy4vz+j6DiETV5eP+Pxvf5F4dcWkqrAC/PICqxVCZXIQtE2DMIZ1cDycL9iulpyPDms0h3XFvK0Q1mAkhJxwPtL1kfXg2MrAbWUJzrEbIyHC3Bq0kQQBKUYaLWmsJsTM4DwOQRccBsFcW5QSxBSR2lBXCq0lIAgxYY0kCdBCYZRESUVjJJOZJiZNP2ZCLOvxn/vr/90+/m54Xnvw//H/9N8gZMbHgBIV7eKILAS79YqDxRGz+QKrLe2kxWjNdnNFcB3Re0YfCWlg2izw61P8sGZ7dcrq7a9gjaQyCu/AVJagFVf9wGtHd7m6eMp1cBipWNQVhwczlNa0lSXGjI/gQqJzHcvgWAhJ1/f0YyAGaJVBSoXLnuATVglaK8lCsB4cMYGLDisEU6OZV4aAQluBMQYlJCJnUo5oI8jKYPRN/CmFrSzzuSIHSTcEYoiMLvK//dz/dx9/NzzPNfC//rP/GZN6AkhG71nvdqQQAPAkYs4l1S0ZFFVlaBuLkYpxjGQ8IUaOqoppZZkYxbwSaGuZIBmSJ0mJI3PVDxxLhZaKPnmI0BrD8eGMrCSNrgkxMXqP854xRrxwzFWFcwNjCOQEE63ICJTWSAlaaYw2ZDLbcSD6jMseCVRCYYXACWiMQStZKvQCIhkrBMIYhBQIqVBKUxlDXUtyCvQ+EmNi7Dx/6r/5j+eBL6Sl59vhr/yVv8JnP/tZnHPcuXOHv/N3/g4/9VM/xSfv3+Xh3ROssWy7gS89fgdERiHpvKd3DuccLjisMOjGMJ3UBB9ZXu6oKo2uNGdh5Lp3ZJX5mJqBEEwWC8ZdxIfExW7gyc7zcFJRGYOoDCiJriSmUvSdY7aYI4TARxhdpnMjm3ViMZ0Q1yNSCqzQzJRmOwaiFVhtqa3BGIVVBpkTqcvkCDknsoTD+YTttmNiNLvoyTkjc0SmTIqwCT0+Gaa2prYanSOz1qKyQBHwMiFzeR+FEO/vg/wu5veLwdPHX0UuGtqqIusJzrRUVtG5a/J6pB/WZGWomwNCyMzbOTkNaJ2ZL47pncfOBQf371Mpidxd062eoQUcHSy47jzNZM704Bg7O+T+vGZ1+oSgBUklgsnIWjGkyPH8ACkELkYG59kNjnGVOJlMuV5vyEowkZIDYRh9JIqMURrbWGSlqZPA1RHhPElrckokDYt5xeo60VhwsWx0ImVEisQoWA49Q9bMq4rFtEJFz3zSkpMG73A5IEwE9jH4nfL7xd/VumfoH7OtK3J8GTlZIHcXXF0+QlqNVJGx30J0HC4OiH7JuH2GG0ba2QHWaG4vJjzdbVmOjip6FlJgpeDwoCE40LZBTiZMJzV3mglut2YcMzlnkhToShOkYj6pEAJ8yHR1xO4cOQ4cT1pWyw0Q0FIxNYYsBE4mUk4YLTBG0SCwvWLtEkIUtQipNG0tGbygrTRCgMiZnBMpZnxO7EJAC8GksizaGpkjs2lNThKRPc4FRNrH3x+E3y/+lBuwJlKTqSpL3RpAoHPDtDE0WiK1ZNLUWKXZbBI+9EgpmR0c0fdr5pMK3zzAhyNQme3Tr1FreHAyZxgSuZoy6ArXOWbHD1muzvHJo7VAVwpjNTEmpm2DlJKYJSFm+tES+y0HyuBSpEZiK8XMapxLdDmTdUYrgbEKKxVBJDqfmGWLIqOUxNiSRNWVRGQBKZFzRMRIyIo+91RaMa1v8oMYmbeWnBWkEU9A5bIJ7+PvO+f3i8HDWc3J4QIrDYPznF4rknd0YyCQiWRSSOSsyIC2iqYykDKrcUBrsJWmSwliwliFMYrWCG7NpnTOs4mB3nmCVCASylhi8GghqSpL01qc90wnDUJIfIiMIRCCZ+V2zG1D14GJASUErZR0IWKMwkiFVCXGlFJkCaMIWCSQkTlTCYEymolVlFASkDM5lfXQB4+UksoIGgVKJKatBBSySwQPqi7v438sBp97wn9ycoJS6lvkhE5PT7l79+63/P2qqqiqCoBPf/rT/Ot//a/LC8uSqZTMK8uBqViNW+JqwxvLNYv5lGljeLZ0dFvPECPXV5cYI6iNxaibxUEkVm4kDgkjJaMQzBvL7dmM2AR+69E5X3t6zdNlT7o7JyFIilL9IuKd5+J6xYPjY7TWSAEqJWQ23J3OaStNrFq8DCU4lAJREWREWUkQietxpJGK4EpgCgEhZ0ZASsmQEml0RBJSivJ9pAIJOkAMgS4OpBjJlWV6cICQAiklWoJCPe9H+F3Ntxt/8PvHoN+tcarHuhqpHWkhkcy4d+81lpfPWF1fUU0WRHZsdwNVNUWbmpOjO1TmiK+9/RVSGrh9+4RKGgYp6G3FXCtOFlNuTQJLGpyecHR0hNUQYySlCFLgc6BLI8vllgfzI5RS1IBUkawED6ZTDiYtKXqMUwgkWkqiEEwlKCUYc2az6zgIEqOgjxkpBEFLggapMmNKBP9vEzEB1FKRtEJvM2MKrONN/Lbg3IDSEi0FWUo86QU+0e8unmf8nZ0+o2Ygjz1v/M5vMLY1P/TRH2abHBHH+Slcri4Zx4Ef/PiPoGtNuzhEqB3bTcfl6SU/+smP869CYLncYMaRJsKR1Zw0E3KdWWaNr1sePHjIiVX87pe+TO8dPmV21jILnt3oOG5qtJYIAUgJNlMLy8GkYewDihElyroklSLhSMIwpEg3Bg6rCtC40JEyJClwJCaUeO1SwCApUQyNLBvXNmf6mIhxJLpAaw3HcYJSGSVBCYnKL+ppfnfyvPbgNAayH9AyoYXCd9eICIdHdwjOs1mvUFWFtRWyqkBopJkgyDjn8D5T1S0pjiStse0Rs8mCwyozrytmVrCrj/BqSlM52sURMUeG4NGyFB9idAyDJ8Y5ADJFdIpUEu5PSiFu3g2M2aGExBpDiA4ZBCjBSKRzgbmu0ULjcocWEq1UuV0S4GUkebBISm0WKq3wwjBER0qJfvSEILBa4pxF6YyQoKQi7Nv2fw/Pcw0UCCoNrZE0ytKPhqAiy92u3EgLQUqeGBMJuO57ttstGkGMAolmE0aMVqScaZWgmrccWIM1BmkVZ5fXPL3u6GPmpakmEHE5IwUIKUgZQkpIEkqAtAqlFd6XKr5VCu8cCJBCIJGEGKgaRRaaMUai76mrBhL4kFAioVRZL1POJKBLHplVKegKsDdrYBaCDIQQ6GNAKUUzaTBao9AgJF7Gd/VsnnuoWmv50R/9UX7xF3/xm59LKfGLv/iL/MRP/MT/7Nd+9rOf5e/+3b8LwJfOTvmNN9/i60+fknFYBds48mh1zXIYGUJmHBPGaoTVtJVmog2NMlRaYq3G2wRDos2S1lpU3fLSw/tUkwmL+ZxtyjztdmAyaEuPpDWKhTK0wiIRTI3lbHnFruvwbiCmEcioEFDKMK0slRFEMmAIUuISpKxRGFRW+DGgomQybVnMKm5Na44rw9DviESSgqwkXgh6cqnihoiOulS6kiPkAR88zx6vWC135JjR8mYD3vNN/iDxB783Bh/+4I+ibn+UQU+ROTJpGiCArKind6hnt+ndyK/861/kX/3Gv+LNx1/k9Td/m8eP3kIkR0Xm5Yev8H2vforbJ/eoJ1OagyM+8tJd5qblcN4yOzrE1RO+cnrN9XpFFxOthAWSaZTYCJWTPHt6znazwbmBmDwQGYMj58y0EtQ2gwgQIkEKkgCQyCzBw/XgwGrmTc20bpjrhlmy7DYedLopKihi1owottEzhoiRFkQmikhUgTH3vP7GBZeXHTEFlE5I8e4Wmw8DzzP+zHTC1ks2QyK4ns3Zkq995UsctAs26x1vvPU2jx+f8qWvvsk/+5XPc3V5Soo9zaTh7sPXOLn9EnWd+PQnP8anXnvAyfGcdjLjpXsnTKuG2bzGHi5guiDGzPXVJViNrQxSZnLyqAgxjJytl+zGkRQdMo6InOm6nhAGapXQJpNlxiiFQhGjwugKo2uImtgnpJJYpWmsotagc4IQcam0Y3Qush49axdwMREoRZGcJSndVF9Hz1uPrrm+HEkuIHMkp33G/+/yvPZgNTuA2QlJNYSup2ka+n7LpJ1h20lpNRCC9eaKzbCDlCBLQFPZiqmxCGNIw4hKisn0hIP7H+HOvQfUbUsznXBw9z53Xv049+89xLkNVhmUlLgc6VMkZ8M4ZpZXK/p+ZHQeN3rc6Oh2W3IOVDKhScQQiaNnLA2JWFszsQ21MPS9wxjDgaqpVIWUpeI6m9ZooVBR4p2nG0d6F+hjIquEtaVNN6RSjQ1h4PU3L7m87MkhoyWI/fr3e3iea+D51YavPznnfLnCqIhSEpxn1w3044gPJdkXWqI0VEretIxpallRa4UnEIPD+ZExB7LWHBwdUlvLtKkZQuJi3eP6gAMyFpQg6UwSiRyhD5HV9pphGMh+QIYeFRwyl3xQmgQykWL65nvgYybljJAChGDXe5SSNFahjC65olLYaUuMCYKk7zyr7cD1bvzm9zJSkmLEBYfLni4MPH66ZLXqiNEjZCr94O+CF9LS89nPfpY/+2f/LJ/+9Kf5zGc+w9/8m3+T3W73zYnt34+f/Mmf5O233+Znf/ZnOe9GzvuBryyvuXVxhpGWVlV87OiQt85X/E4/IBHcMRWHi4qjO0f46Oicw4eIVZnvn97lWb8ihECbBXeqxOr8GZP5IUEIVslxRTn9UVkqpZglEDlSacG8arhOG1ZXa3ZXPRsf8ALuHx0R1wN98BgtSUHifSArh0uJxkoEkejKGmiNZO0cdDBtLQcHE9rKsl5tOJlYAE63W3bOoREc6VLrSjEirEFLIAUudh2LULHdbGknE9pJQ/zgeae973yn8Qe/NwatmfLglU+w3V3ztdd/mzd/5fN84tVPsH79dX7sx/5TfuyH/hDb3ZYnj86Bka9++bcIIXH/5DYPb024vn4G7hP8i3/+PzCZzJirxCx3PL3qOJgfkJJidnCLOy99kuPje7z96/898/mUH/ixz7BeXbI+e8ZctawYcOPA2dlIj8YJRSsjbt1xths5aBT4jHeRyijWXc/hrEGIjI2ZSirkoeWsG5kgqduKo0XDtNE8Ob3iqGpRwDvbnq0LKMqBo67GcqiuNZWG7ALPBs+8Mrz99sh0OmM6bUHub5n+XZ5X/H3fRz/J8eEhbhy4vDjlX/2bLzB/eI+33nqD7//BP8wf/sN/hH7o+Oe//M9wV+e89cXfQVvN/OiYgxPPL/3KL/GffOKHef3xG5hKczBpmaaeVdfTtA0iSV5++TWOP/JDzGZHfPHz/y0ZzR/98f8F/XbN+vwMKyxx0zHGgbP1SJQanyXRB8Bz6hxzI5Ah0YeIVoIOkDIyDo4QgASdUkBkiImpVdw6nDOd1LxzuuSWslhreXK1Y9t7jJRMJwbnRnbdSFWXIk7MiSvnqdfQ7QbatmUyqZDNC36g34U8jz24ms+ZTWc4P7C+PuXt3/l1Tk4esLt8wuL2A05u3SHFwPL0HTaXjyGCo1RafZJsNpeE0GHtBGMzVRpprCch2UUFZLSeUM/vkGXD1dd/h/nBlP/s+3+Efn3BeH1KqyQXriMMktV4jtMNXlbIcUPXjVTnKya1gSQIMRDJRCAEzzqMSARaStq2waWAVJK61ZwcTpm3NadPVsyrFtUmni5HdmPASMHJtKbrRjbB471gUins1NOHTIvk9CzRtDWT1pLVfg/+93lea+AuBvrNjmU/cL5ekwGrJH/41Zd5a3XN6W6HAKYIGqmZnsyIApyPJF0S7FebQ9a7vswFZcFhI7jarG7WQMsYS0+9iwFrZ2gNt2JNrTWzqqaqJKpLpBhZ7jZc7xw+JE5mLd0Y0XrL1GpMUowxMqrEeLMljikgk0Blia2gI6G0wVSKRVvRaM16ueJgPsUCF6HHxUBEEpTEjZ6ARxuwUiKiZIwJa2F93WO0wVaakN/dofOFJPw/+ZM/yfn5OX/1r/5Vnj17xo/8yI/wT/7JP/mWIY7/EH/+z/95fvZnf5ari2vu3T7i7uERd49nPL26RmmFEIraGuaAloLjRcOy65l6y+gTg0uklOlDT64kk6nBZ8VqCPz3v/MOAJ986Egh8M6zFd3G01aJhVWcDQPICDmhSNiq4mCxIMbAruuxUlIrTSJCY5CNIceIkAkhIp2Hk2ZGtqViOuwGYj9CKFdVCsV254gxM2stxIid1eA8i0lD21SklBl7RxUjtanQQuKyY5M8Fs1Z2NG7xC0h8THj8r669e/zB4k/+Lcx+Ie//w+RCWyX7zBszqlrSdO0RJcQOePcgBt7/PaMo7u3kPGIp+dnnF5ecHp5m49//A8hhGQ2O8L7Hm9rHnz6jwPwxr/5Z8ja8tHjl3h4//vJGfz1iuvs+eTJA3be4XhEWxvuHk2JIrDtR1IUyCTpY0I2Bt1aIrlccysYfeThYga1BgHjdmTcDeigUUniCPhtgBDwtUFFSTNrSM5zNGmYNomUEt2mRztojS19hC6ySxEhBZfdyI7ASYJu9Ph9R8/v4XnF37A55/H1U5wPVHbCvYM73Jkeow9ucXhwTFW1xJRIsWd+d8HTJ0/Y7Tra8yseLHcc3bpF3TTU9RSkQFY1dnoIwOXTR2QrmdmWupngomO7u4aZZHrrGBcCPiUWM8HRUYOUifXoGXMiC4O1lsMmkJMhJYeUAoXgqh+5M59CU4GAzWag3w00dblB7WUiDQm16kjOY4Fp2xBSZjG1NI1FZIl3PUrCxFTElNiOjpQTQgq2EfwAR36kGyNB7APw3+d57MEPbr0CKrPZnGGFR8rMwXTKbHqCloYUPMGPXF0+4+WPfpzl2VPSGIhJEJJDKYUj0xoQeLzSxOOPACA3K+q2QTQHZcDRWpSC49d+AFs3dNsrYkxYo1ksFmiZWPURHxw5J9w4cnwwIUXQIiNkJOfMLkaOpg0bIclkus6x2w2YDCsV2caBg62FDOPocMBB25DiwMF8xnRa+qbT0GGkwKqaWkakTGzHSEwSHxPed7SDZ7MzuHdZXf0w8bzWwKvLjtm0YXZYM51P2fQjbW1Ba5q64iCV1pupEVzvBvRYZiFjTMQYGZJDiIa6qck5McTMrz++AODh4QFRZJ5dr+kGT6sltrJ0LqOAlAQxK5RqmTYBKRLrsb85dGgGF2msBF0hRUYKX1q2XeJk2uIVIKDbOYZhJCPpFAwxYLcCP1YEa4nAXCtyhOmkoWlzmZdyA7WSOIAMISZ8DoQo8dEBAjVq5KBx8d2tgS9saPdnfuZn+Jmf+Znv+Ou982y2HbvFBOQBEstUGkLbMOSIsQIjFQ8Xc653HUpKrBH4lHHeY1Xp2RpTxMUyrLMcPT4mtmNgjI63r9c4IlWSOJ85XXfUFcxtRa0sUkrmTUMQCRcDQmYEGh8CCFiPgSomti7SxcgtVTOZVATKFDlVLsoCIRJdQmlVEnof0KOkFbDdDFRSoLWgNhUyKy6GQM4JKYq6gEYzlQ1GCEIcaJVG5tLvPfjwnJ7Y9xZ/0PgDmE1mGKNYzo+wxqBNzXy2ILnAxfKUPnaMQ4/KPZvNNQ+O73C8CCipqOo5xjZ0ruPo+AQpDU074fD4FnU14fT8KWvXQbPAVJa+67m8WtJlST92kCKVtkitmU1aokz4CGmMpBTIMiOFpHeZkBMb7+lC4MRWzGYN8ab/TzRFyWSMiRQBmZEJ+tFDyswUrDYbKqlQWjCzFoVg7B05JVCSlEs7RmMsBsHWjUy0Qaayae68fw5P7HuL5xF/D1/+GArH2fkpj08vGVOk67ZE32OqGjf2dP2Oy9PHcOcW2jYIF8naYCYtd+oTAG7fuUtTtyymEyaNxegpr6fIKCP14oSmXdD1G/ptj2gbfPCk6FGiqIZNZw1SZnZxC2Np9Uk643OmGwdMEqx9ZhsiC6NoJgZ0ib9YG2IIJJlZxcBGOERS9GNAZmiNoOsGhJJoLalrjUayvLrp9ReCBIgMOgsqrdnFTK0Egoz3kS7s4+8/xB80Bq2tSSIhhUEKgxCK1jTEOHJ1fs3oR1L0DNfvcHpWIZMgp0gKmQw4N2LGkTQtB85kLFmfQI5Yu0BoRVA1KXhSylTVDNEsGONIFhJjKqRSzNoJxko2cYnrAzEEQkzsBkdO0MfE1nnGlLjd1LR1jc8D6WYAUskyT3fuR1ZqwCaYjAotBI3SrLsdlcoYq2mMRmU47bYYFJXUSCkQIpEFWAEbN1JpAzEydIluX3P7D/I81kDnI7thoBlNUS/UFRNtSUpyMJ3SVC2CjGLkui8CKjlBQiDQWFXazhyJkCKDh25bkuPRXxMIXO66mxkABR6u+oFWJZSV5JwRItHaiiwTygVMDhBhiGXuMuEJMdFHh8uRY9tSWwskMpnaakiJmOAi7egYOfEVVZQYyrzIrh9RSiG1xBiLFILRDXghUDfFeyElQkmMEGxGsFqBEKScCf59rPA/D0KIrDcdzy5W2NrQbQP3m2O0Uhgt0VEiyHQh0A+B5a4nAWMIpJC4NZkigT6Cj5khRMYYiCExRdKlkTEkKqVRWfLlp0ue7rZUlSRO4cCWQKqs4mLd8bunG0SGurb4FLkzbdm6yAJJzgIpNEZqhMxoFC5EhNJUTU3fDSymlpgyYQyIDKTMmAM+BGRdHjAZcizqFkmUhxNjRiKohMaTymyBElipyvd5lye7Pd8+OXmstsynC46ObrPqBrRStLM5l6tLnl09xRrLrbv3GYXh+Pgei8UJSknm8yPCMPDs8gn37rzC4vCE+eyI6aRFCoWdHbI73XJ+dcZkMsUow+G9j3P/4DbL3YAQNYuj+2gcqqpYx8zs5Ah2G8brK9bjyEIq+pyYCkm8USeTUhABLSUuRKSW1JOK0DsOakvwI8PoSGSSyow50oWAqGuk0JAzMSVyhiQkUhZ1KonASElMiUYbtFboLIqy1D4GXwgntx4yaRS2mdEnjTGas6tzNusly66jmb7D4EaKgJvg+OiIummxVcXh8RHdJnF2esb06Jjjo1scLo7QtcHKmnpxzHJ1weXmmun1JUoojh98HxObUXZKM/fgPcp3NLUi6IY7s/ucX1xyfn5GlzwiKzYxMReGlCVCKKzSJCmwQpRBNyGK0krKzCpV+u5jJqVMSulG+SxgW4swqsyLxMiQEkYJhJDkKBAIjBSEJGgFaKMwN4da9j38L4TdMBR5wKww7QGL4wzKElLk6vqS3W5LZS11O6XrRxaTBVKADBEfEzhBv1tTT6dIVVRUlNZoqammLT46XIyEuEXEiF3cJeopEYlsD1AxolRkUinSdMZMHRCWl2yX53QhIPsydGuzINzEgL6ZX1JaQ4xoJclW4ULgaNoiU8KOEpEgR0gi4nqPtArZqHJ7ECJDSCAVVgliLoOYEoEPHisUjdEQS+ipd5ls7fn2EYAPkU03cLHaYoRlrg0xBlIqlfCUMi6Em9nHonATYiZlwaFtESLS+1LsjTGTfUSIUvgKOZBiLvmUlDxdbrkaRgYLTBRNHYuik9Usdx3nqw6jMk2l2fmExuKI2Fj2YCElUpUYFAhSTEhRkvMxJGa6gpzQoeSvOWdyyoQUyYKb35NSpMuUgV2AlCLi5vDqs8eqGwlPJAKBe5dL4Ac24Y8+MUTHk2eXXK7XaKO4f7AgBM/gI7sh4HzgWb/lej1ytulL9VLCRFs+dm9ByhmfDCGAc5HsI1XKNHVFCjDPgjprUoRf+spjWmtQVtBtPY1SfPKV2wglePOdcz7/G+9QNZK7d1qygIVS7ERkbi2HxoIoTVvdMGCt5XoYkVLRWItwmTsPDji/2jAEhySjSKzdSG1qggSZBOPoGLoRHz0YTUXGh1ySOZW4jJ77dQskJOWAoPN+avdF4dyOXkQqa3n1pY9xtV7hXMfs6A5Pl2dcr5fcvvWAVz7xI0htOKjntPUEqQRh3LLpep58/XWEVFT1jMXsEIHgenlKCB276wve2C7ZLZ/xkVe/j0//0T/F9eqSf/rL/wO1OeDBvduYZ79DVJKrIfLg5U/B9oIr13FxdYVWlnUlWNiG27oiJ0tOmetuZNGWVjerJNOqzIncOzlkebXh7cEhU8ZKyeXY05iGKCUiCTa7kW3XER1FzlOWQ2cKGRczlwy8Vs1AlKt0SQZt3ucn9b2JIGPqCQ9f/j7u3Pso1+dv8//47/6fPL68JF1eFlUxIfn0p15jdnDCyWxOzAltLAfTOU+XF/zO61/m1dc+xmJ2wmyuCA68X2FUy+XFhl3/O+y6Da+9/AP80B/54/huy9nFO9jmmPn8kM0bv46S0KsDPvqpzyC+/iXeWZ1zte0Ro2HbSOYKTowmZ4PzsBsSqpVsBsfgIjlKpIAfun3E6bXmtN+iRKYygs47TFYkCULAdhjpOkeXAlNtMFLgPWUoTcFp5/j4okEohVQSIQRN/MBuY9/VPLs4w2iNNJJ6cY+DOx9htzpnqmuGJOmFpp2dcHh0RN+N2LZBG0WMkV23QwvH6ekjZN0UHa+cqeuG2WSGbDTB9TjfE+KIyonq1kvIZEA3cKSRtsLsHpMVdGbG4YOP0us36HYrrrY7WqXYqcx9W3M8KW2z3gd2w4jUpsyQeE9OCS0EP3H/HuvrDedhhxRgFGzGgVZWeA/KZHZjz2bT40LEVJKUFYMvyZbRcLbtee3wCCET2hiUVIjeva/P6XuZolyo6HvP15+UwkSSgorM4EcGH/A+40KZPxvGUhzIgFCS+9WE4AUiJWTOpAw+eLSMqLpGJINUUMtIkpLfenZBg6GzgoCmbj2vCElUmdPLDV9+85yTY8vD+zOGnJgmTZcjjZLMdFWUn2Kidx5VKcbgiD4iYlHd+UOHd1j1O9axxKDWkiFGGiTk0kY0dg7veoQQaCkIClxM5JARSbAKW16ZHBEIqCyQWTLy7vLAD+xKmRIgIPlE2A4oIXjn7JS7x1MaI/GVRGvN0EeSvtkPTLkWVkoSY2TjemKCtlLUtiZ4DSmz9D1bP+BdJN/cBtfKEJ3i5ZMJWmu6aNC6VDx/7CMPGdaOrffMZjVHk5ZxjPRqRNaWppJIJXGuXPP46Hg2bGi0pdFTjIUY4GA64dFyTQyByigWtsYRIWYcxeAk5fjNz6eYsBIQgpDAjRAmEh0NLkcikT7tq6svCmvmqFpTScE99Sr/1Z1XePK7X0BUcO/ePebzGRbFm19/g7adEGYLqramrsswzo6OEBS/9hu/yptvv8VL917h1XuvcXt6wCsvf4wHD17hnXfeYrvdMPgi/3b3/quIccPTJ+/gpxUfmwAZXm7g7K3fRlrLg6NbaDfy5NmGLg6gDa2tkFqzu9Eb7qPjcuiYWcuirphaQ4gwm07wyxWd81RBcWhbAFJMOARDSngJx23ZQFPKVDdqUC5lXIRwsziFGznObl9hfSF0l7+J9Avq+StMDz/OZH7E//pHv8L/+1/ueOvsnCFEFtMZaozcmU+5e/djCBQpOWIYqJsGFwNfffttlruO44OvMq0bvu+Vj/Px7/shTh6+zLPlKYNz9N1I7B05Sb70P/0qXbfmoJXcU54cwbp3eOOLXyDlyCfu3uXqaslyuaPvHalRmNqgNGghIEZ2LvLm9ZaZqXhpNmGMjjEo5nXNY7EjxMg8JhppiA7IsrSB5HLrdKRLb6t3PfZGhngMiY1zoCYoDClCBFzcFz1eBN12hzaGpqlRtcJg0NoiK8vRyW2aYUCJzDvP3mK7C7x8/wGNKIf/2hjqxQGXl5f0Xc/1dkXfbWjqhtcevMZQL3A5Y+sFjTLEODD2gdlsyvWbr4NKN7rkZYNu+yuutwExjNye3GISE7tu4DoN3FYSaWqEVPgAKiYinif9jqlWvDSbIIQghkhTt2TRkQgYJWmV/KbsRUySIWZGAkeVQUlRbp++EX8xsIqeznm0g1RJpIYx7iv8L4ysyShySETnGYRjeXnN3YO2eMnECDf7kErl34QoNwMGiCHS9yOK0iJdG1VOegTWQ0dEkEIkx6IApLSCUHE0qRBIuiGiNMgs+OjDe4Q+4LMHr7nVNOy6rhivWo1CoJC4mIq0doTV0GOU5nDWIqLAE6mrCVfbDpEyTZFnAUoV38exVPdjKi07gI8eKUW5YUoRl8CPEZAEC6hMeJe6GR/YhB/NjWhoMSCIMfPG02cEbiFNJgqB0hWTmeRQZ2opUY0hG8h55EnXc6w0HYExlhPYa8dzPrqY8a+ePMVLSRYJrKSShuAiOkbuzGpuLSacHEyLgZsQTGYtP/H9D3l8uWHZeRoU56pDxYjLka1PKC+wVnD78ABTVWiabz6otm2Klm/X0WpwCVzwqNpgo8KNAV3XGFETjaJtJHFwJIqroBWKibUc9olIwgFLtyPFhNqLAL8wdD2haVvqZsZ8ljC24qUHL3NxfcliveXs8imnz97g3vQ+7WzG117/Tc6X5xwfTPjxH/hk+R40QE83ZN558pTV49e5KxI//F/8JFopAvD06pK3Ty+5e/djONejxx1HteZo1kDqEQLqCg66K94623G2G1gIgaOn7wLdJHHpPSTPoqo4vnWIaS1aW3IICIoRXIqevuuZa+ijxLlE05SVou9G6qnBGMjS0KqKbjcSlSCOgUYJjmqFuzZ0RJwPLIcBCbR7L4gXgrj+Gmevn6Hnr/Hypy3t4V3uPjjkE/fmrHfXPL7uWXYjX3z0hDsP7rJeL5ktDqjamhQsB0cPmU+OuNht+Po7T3n86DGT5Gi2S+780T/FraphdInXL9/gn7/xz/kv/5c1DI4YOg4PWu4cTuFiC4JizHb9Fqe7gWUXsGPmaRwBTxaGXShqZRMrOJwvaFpdPCFCRgtFU01IsWccR1ojS2+uj0yMRlno+5FG1DRKo6xhgmTpAsEqdCrmNDNl8EPGAV0cOO+LihTjPuF6ETgvUFqglKVpFkAgKA1CM20XNLYhxBEhPFaCYIsfKX4hVUtrbnH+7Jeg0Wy6jnG9YT52rFdPSyvQ4pAsElfrU9559AYvv/QxbtWHhLCj0ZqJtYRU9jcZtrB5xmbdcdGPyJxwNxp1XXSIUSClRhjBrfkC1VqEUrjR4XLR/U8xMY4jxmZIipSKKRIx41xA6oxJmZmosQa6mFAzgwqRWsBCWPzQ4oBV37EbItZomv369wL5hvJS0apPUXB6fY3UiUYrFBlPxGqg1ih90+YiBEIK1t2IVQkRNSlnlBQsJjX3ZzVvXK1YRo9HoIQsJqlYdAuzSjOdthzMS0FMCJhY+PhLCx6vN1wMI63PjAxUSHJMdCREAqUFTTujblukqPFuAJ9orEGmSD84aiWRKaNiMZOFMpSrhAUEQQSsNTjnMdZASlgkk2wZ+0CYK/ouEXcDUmacf3dFtw9uwg/fMBwrrmMis+0d17sdR4sGKxSbnWejtqy6gWnWHMTMfFIzmRxwOGsZh4HWCWoiM6O41VQsTOKHT46pasWj9YavL3dcDwGU4rCu0JXl+PiQ+ycLQCEo3TrTWcvhWNR9VExMRcPa9fggGUTGiESDJHm46neMux5BJFvFKAyVDmz6gbmt0HVDzpl112N1sVF20RXtdJkZYumH7UkYLW9svUE3CtAoH5kJhar0C3BS2PMNgg/4UCbvlVIgJE17wJE0jO4ZO91wsrjFrfuvMpscce/oPqurM06fvcEv//IXuH18n3oiaKOhbSsW1mKX1+x2V/zz//b/ztFsQp5N0CROV1u891it8d6hfE8VDBgJMaIiNI2mUaAHxyAEt0xDHl25BoylCpFVuSm6uuzpNz36xigkhUwzrdmOnmlVM68FOQt2Q6CWglpqRgdelba4PiaCEgwqUldFEkxrRdNYhpjJvWOhNFVVhnf3PH+qWU1dnbBaXvDbv/R/5c5rH6GxkY++/IBna4dPV1hb88mPPeThK59A5Qo/ODbLJbvtBiUEi8WMJ1fn+NExFYKJhrM33uD/c/p/pmkmpEnNVQg8O99wfb3FxIzvtwwu0IkeKzWSWMzYKotZD8TtSB+hyRIpLX0oOttWCbQwoBPX40AKQEz4PBCdpG4UznkOKgW1IgvB4AMqZSTgR0dWCqEqti4hQ8SpMo+iVHGtPJgqXIS+CzRSM2slSe8T/hdBziPyZmg1Q5mrMIacEypHjJKgG7q+IwqPrQ4Z11esuwuSzFTd69Q2s1ov8f2A9Y6ZyrjNkrf/dZEgbu9+BFcvCDfiE8vlBcN2Sdo5dF9jjcXESCJRVwZJxu0GZMhMq6KhDxqfQJOZmjLrttt0jEMAigZ6349Mp6q49poKJQVKCAZX7imVlAxDQihJVVuSKH3ZKUmkECglsUqwmE9Yjx4pDUdVQ1MZ4r6H/4UikkCmXAYmUsa7wDg4mmmDkZpxTHjK4LZ1mZm1NJVFG8FR3TDEiIgZcqZRiiNjmKB5pZnwscZy1fdcdD1dTGirUB6MVRxOaw6nEzwWQ0SISF1X2G4gh4GeHkNJooMGQUIlsLYcAHe7jnEcySkiRWbsR+y0IhOptEGIotPfdwFbTsykXA43UclS91cSgUXKgBTlcDCdtngXiDFTVxarJVvGd/VefrAT/lQeUrqRngwhcbHcMq00J3OLnUmuVmVyxmbBgbTMVY3Khlu1wTQV511HCJGpUhwZTUDTuQGfEif1hNsP50ht2A4ekzNJwvJ6jU4BffuAWdMgFOi6ImrJLnoMcHw4xUhFpdWNe25iMwb6dM3FdY+VGUmiHyWHhwdUTc3RgcSNO1J0jD6yGR2zm0fQmKJFLaUsBiLkcpUYMm4s1YZ1PzJVGh08Ukl8hH7c9w++KAY/oEaBUhopqnKFCBhTcTBbsFtfcXbWs7y+pK1rNqsrus2S7XrN2ekStgErBH6z5rq7JivNkfeE6Hn8+BHPdMWd2wccHM6YzzWXr/9PPN5tuV6dgx/RMaIPW+qmmF9pUYGWOBmptOLB4gBpRipVLLWzyGzGgWEVuViPtEIiADkIjuczmrriWEmGbkfynjHBLmaKfA9UpmJmLVJJxiEwqoQRGpEjuzGz3AWuesesNSghyhV6zHT7GHwh6PkdqtiT1RrrAwd3vo+qnmCPJIM6ZLH4Gtddx8df/X4WB7fx2y3nV8/4+qO3ePPxY5okyf01NgyI5LFS0UrNGAce/e4lxlqOj2fMZhO+b2JZP/oS29WG1eaa5EeG7ZZ7Rw3TtkZIsEYTJeySpxKaV4+mRbdcQRYZR6KPnrjZctVHTChX7knA0aKlriukVnS7Hc4HfIhcdp7ZTYG0UZpKK6SUrHPiGk8lDSKBC8WYcBUCtdYYUWI+5rI27nn+BAFZa7KUhBAQIn1Ta7/SEqUFiYCQsJhOaUzLMJ6zOr/gcndFO+4wOeE31yTn0QIaqxFacHV+yvXmils+cnhwzEsqY1Zvc73rWK4vIXiGreHeoqaqagQRTEWWqjg0W8XxwZStD1hEcUUtf4vNrud6cCTvyDeDu8eLGXVVo5VkHHaQIj5k3tnuONBlxslWhrq2aK1Y9x09ARtL9TaFyE5kljtPazVGa4wxpCxYj3ulvBdFigJJJmfICXIqs4vr9UhrDG1t0DLhUxlfNUKipUIJgRKKqqk4FIL1OBBTopaSiVYoI/F9IgfPQVNzMp8itCYmQXIBF0aW2w2QqOQC07aINKCNASWJMqGE4KSd4mMxx8oCksikJOmHgZ0byCEQYkAAh5MWYyqU1Ax9T04BnyPXcWQWakBQyVwGwoViiAEXIrWOxBhLl0iGdXA0Nz+jAFyKdO9SKe+Dm/AnSvX6psJPLpvKZjuw60YOpxWVVRChVhabNUpKNIJKSBZNRSslox9xEmpZdHn7UKbwt87x4GjOq7eOOV4s2IyOrut56/KK7XqH8p67hxOYtOQUiVmQpUSaMs0tpMBnkNGjkOQk2AYPw8jFqmNWaeSNWsDsGJQyzKaGXg4EX6SepLo54eXIXGnmVYvQkvVuQEjBpNakMdA5z2Y3MrhA3ZTWjSwtEcEY9/3TL4oYPD4YchZolYBENBYhJG3T0rYTYs6srs+YNxXdbkn0O0iO4CKRLSlGxt01Q4p4KdHWkoRkcIFt75nWknsTzcnJEf2zN7i8PGfod4QxYlPm1sQi2ooIxCSQStG0lkordGWpskLggIQPkVXXQ9dzvXGc1HWRKJOCo4MFxhSlF5MHgnLokLFO4HxxtXyoWw7rFiEll2EHUTCzLQnHdhxZbccyx9JohJJFai/DGPYx+CKw7UMq0aGbQw5szfTuD4BsmAAfj5GcOr769lvcu/sqxk4QVRl8Wm/WvPH1NznMkpkRKO+IKQKZlCVDEvQushl7plZwvzEcH00Yl4/ZXVzjxp6+G8nDyPHEkFtBzkVWTkiJrQ2tNEzbCmEm5DQSKM64axfABS42Iw1lgC0rweygRRuNsZocB4z0SB8hJUYh2KXIA6lprUVIWA+eIOCkqhAhk13G+UQXIzYU0yZuLOn36f6LISPJQhYjq+hRRMLNfqNVkYwu0mCZSdMWLXIJ0TuuLp6hVcRmSb5JsJGKEIGsGV25PZ2aM26pyNHxAbE/p19dMwwd4+gRo+ZOraEqM30hCZRUTGrL1BqaWY0VU8btNSl5MpnN6MA5lsOIzomcIlorDuUBSim0rlCiRyTP4CJjcgxRMebI/VnDrKlBSq6HkSRDkd8kkqLDBU83Oib2pnVEiuKFE/YR+KJIN3lgzjdJf5GuoR8C/RioKom2kD1URmOlpKkttTUgBW1dcZAhpJGQBOZmpNeliM+JwUVu1xV3F3Nm0ynOZ4Zx4K3zZ2z6DiHgZNqQ5YRcxi1v3HINtRBoq+l3CSESQgNSFsWgENiOQ2k5CkVFbT5TaKEQWoFxkDwqR/KN5LYjUMuK9sbBug+JnCVWS2KWhJDwPjAmz8RqhCw18RByMTh8F3ygE/4sIQsgU2S0BMXMZfBcbnsmlcRqzcQ0eD+ySZ46Ge5WU+azGcP1mhQ8Pni8FAxZMYmKA6tZx4Q1Alsp6rbFtg1KK/RyhQYqKalEqbZ737MbM1Zq7h8uiGSeXGz42umakwPNQWvRUrG6mdYfiNAltFJUE4OPfFMntaoMk7oiBMF2zAxOsvI77pkKayuSACkz1goOZhOCHUk+sN34Uv0SidKVXa66a7NXSHlRiFw+MgkfPTELTIwIQZFsa6ccntxmu71kt95wcusIQ4ui5603DbfmE5bn5+QYSTHQScmpBB0FU6XYiAiyVCqllNQIjhYHvH21I+Sb/4/I+BhxLrDbDVgheXCwIGVY+sRO1jRWIPD0XeDxplzt2VSuOHMSCKXpvCfE0poxnRj0LBJCJArBsyvPKkceWkNVVSSgqiyzHo6mM7x1RJfY5R0LWw4dIRTli1pJqO37+JS+d9HtfWobyARkNUXqinzTLzyZH9POToC3aSYLhm6gqg5YHD3g4OAplVCczC2b1Y4UIjElegFXBJQPtNaw86HEnshYGdFKk+cTrjYd/qaNTaCIMeOSo9t5Kql56WCBFrD0MDu8hxtW6DyQg2d5E3+jC7hc5F2tMIxelEE2YNFq9ETjfMZHzdWQOR93PKgMdVMRKAZvC91yMp8QXGLcjcjYU0vwPuKTQOniYj4T+zXwRSCjgJSJKeCSQ8WIv5EJdCGiEJjSiQBCMIQOPVVMDxraJ5l7i0OWl1doMolMTJGld8h1QkqFTAERE4LiKWKkZN7W6PW2FNPENxRPRrwPbAeHEYKH8xlaS2JlOTn5BI+//mW8WxHxXGw6AHwKWCFRSqC0wkVBSAFJvvGiSNQh8dLQsN5JVqHnvlZYa0kiY62hkorD6ZQYIqHvcH1kqBVjyqUVN4MSMDH7Hv4XRSLfdC1nbkZyv/lnYyj+MlWtySlhlUJImMzaMrMRIsd1hd/1RcL8RmhiGzw5OFRpugZASokxBmMkkkxVK8JQ9suUM6PriN4zjgEtFLcnU3TOXA09F9eBps1MpxWVlGz6EoMpSLLMZCRSaGKUN0PGAmsURmnqHDnqLeMo2eWOW2qCUZoE1NJirGZe14zaM+YBGQITFJJyy5CyQGZF/S7d7j+wCX++ua74ls/fGE6lkGjbhh+6c4tbtw/4N1/7Kq8cHPKJu3e5NZtilWQIO45NzXnOXIaBwXfMVMORqpBJUQlJpQBGCJGJUlz0HVqUIOqGgd9dL5krwzvrLU1lWFQVbhupUFyvHPNGY/7/7P1Zs6VJdqaHPT5+wx7OEBEZOWdVYS6wm2q2jGSbdCHd6EY/VGa6lJkko2S6EE1Sk2YSKTbRjQaqUIXKKaYz7r2/wcelC9+ZKECkdUGGQCVKZ5nFcE6ciJ15Pt/uy9d61/OOlk41tj/Aznd0VTF2nnE3NC3r2blS645jVMxBM4wbsJndnEAiKa2Iajto7zU5JZTWdH3HZmxXuKw1UKE2A6b0pB98b6Gcw7hGa7BaMNqT0tr+TCk2/cinH/yIqd9xWg58+OHnrA9vuLCen764QnJBG83H/cBdCNzlyJt1YcCwo0NpwZg2XFRyptaABd6EE1bghe44TCu/untg7Hq+fHtg7C1XG8cSMi9ffMwfffIn3B++Yn54g0yReq7AbXxHb2zT+HnPEtqA2xoT1Y4s0XGKK5v9ln2+Y1k1VMMSCuiKQnMx9OScMM4wbgc2a1vfWVu+a8FJVZB+sNvIP+lQbocZLQqDsrv2OZrZSr95wUef/hEhrty+/Yb/7t//t/wn/9G/IJ0e6PPEHzy7ZjtqTo8Tz7XjQTInCrcSiAEulUdphTOtUrnkArliKLwNAYVw3SlSjfzqtmCIvLqfGHvHxdATg/DZR8/57Kf/gl/88s94fPuKdZm5DTMCfNj37IzBWQPeAe1SGEOCbuQYHKdlYfd8JN8tfGQi3ihqbWxqqwz7wUM1OGcpvjIvKzvriDgsCW2bH0l+6nK+lyimYJSgUyEcz8O5vj1HURBrJUti8J7HwwNDbwjLiV4Sf/rRh+yGjuPjgRe+5xQCp5I56MTjuvDMecQI0jWzoVIypWQMMKeAs47N0POYA6dvD4yd5e3tkcEZdkNHioofP/uCuLtis7vGPSSm+Z63cQLg98cdW+Nw3qG9o4SAYUcsCZGB+QinIDx//hHGP8LaCmgpNYOtTrfkX6pgnaXkjjQnLsfujEAUCoBSKP104Xy/ITQnGDA0Og008mFJCucdF96yxBMa6DRcDR1b5xiMIQEbNHOpRKkEK9zHwLXviOcOgtMVndvZPtja3Outpbeeac28ebzjchy4O54QVelcw39e2g1v6z2gcNVgsuYmtH/ni26LM22fVTSpEMBaBa89S4A1aoaxx9hAWQsisJSCUq2467ympIg2bR3npPFnCRoZ6t+zv/nDPqmralVWDPU7uzGBu8eFkis5V47xLf5ry8Ya+r2wNZZnV1c44C+//pKcIhbDh37TWiC58uH1lk+eX7LpPc4YpBTA4zz8r376e4gUcs6cjjNXduBiN3D/MPH29pFXSnhmB673Pf/r/+wn/MXNOw4hc+E6OhxZF9Qpc7lx7DcW3xuKihg7YNDc3kworXm23eKWiLDwwbNn3E2Bt+sJbTxzWLkJj3y6u2zDJ53n+acfoLPwy9evADgtEdB05of9CP8px9XlJVeX14gIIS6oohi2GwBSCqSUsNZx/eJTLuuKjpHj21esdzdc9p5iCv/u5wsNI675wA94Y1ly5MPdlh99eM1m6NBaE2PEnjFc/4vPPqKWikgl5Mx113N9dck8r/zy/oGf30Q+sA5vCsf7N/zbd484pblynkvbE3zFLpWtVey9oR8dSnV4Kt5r3twfEDTPxp4+L2xJPL8auD8eeTdPYA3HJfH6/p4vXlyz7z2+s7z49AUmW/7i6y8BmOaEMx27bvvbekS/26F2YPeIatSJdvC1Moj1hucvfo9x/IBSKy9efo4x8G6d6I3wcucBz13IVAGrDNfKfK/5vL4Y+ezFJdvO4EzDskJjUv9nn35ALVClEkJitJHL3YZlyXxznPjr2yPPjUckcvP6f8dfPRwZLVy45hz51Wnl2dbQdYrBW4zRWFMwxrEfDW9vTlSB3dDh58iliXz4/Jr7Y+TNaUFMk4n98t2Jz663DP2Ad57rF+29+O5wD8DdFAHH1vW/lcfzux6DHaHAlGcyCx2eNUDnG2lOmYqSzFwX9t7jlYPq0cphBgVEprASQkJE4azDWGFPzwdXGz6+vmLsPMa0YVoADPwnH7xAqoC2FNczsOD3zbjom8cDPzse2BmN/MWfUfi3/OXtDVZrtr5j9B1zzNzOEbM17DrD5abHmBFjEoNxTKcZLcKzcUu/ntjmlee7DbcPJ16VE8pZQq68fjjx6bMLhsEzdI5nHz6jlso0nQDh3dI4QX3/tP7eZyikVdq1piX7TSIzLxGRDNrjhqE5JRfQQWGL4dmzViS5eXfHlIWKQluNsZqPGHmx33J5sWFwHU5paq1ordFa86fPP0CkGWCdQmRnPGPXkWLkm8OBLx9mdlbx+dUVv//yir8+PPJ2DoyukHOllMo35ci+73k2jFz2fUP9UNloTQyxkX+Gji5mio5c7kce5sDDGlHaEiRyP098MF7ibMYZw25/AcDpcMIYzVwjSRTo3ywP/CeQLSqqahUcVZqOvwqUWim1sJJIsWDLyFd3J4b+lv3Flny2WUYpLIIS1Zj8Q8fLiyuGzjfmqm63RaXa0IOzzTlXKlQx3B2PHJaVOVVKVawx8SZPXO16ci5EEZSGYoEeylq5vLxkO1g2264h8irU0hHSREqZVFs7ytfEmCGoREyVpYLkgCqFDZ4cMysaK2BLJK2ZU1gQwKqe3nq0etIPvq/ouwHvO0rJ5GJxvnGom5uepVZIsbCEB3bbCx7f/ZzHaeX2VFjvj6whIMYhNWPOJmlOgRo8Hz3b0bk2d2Lsd+241rYcbNPHx6JZkuJwChzWew5rRAkYUZxiQaQ5SC4lIdaQraX2gpLK1bhhP3q2G08/dGA8oWpCbNrHkAunENhqRV8grIq1VNZzpVck0SlFoTDXREjSBJXrkRgzIPT9yNAPGHmqsL6PyLmCsij9HYrr3JeG8xFo0NqSpGK7LZSVojxzsdw8LsR4ajIu1fZBpcBZRecsn1xs2HrXjJU0QEGbii0ap+15+Kw5Rc4LfBMm7qZATIUilZsSeVkGTnHh7bzgDYTekoDRGra9pR88Y+dxzmNsR63wsMBpFXKtrAIbpfERgm588zk3GVBMBZ0hpQRak0VIxlBiYU1tz7O+x9sO9xuazjzF3y86p9raiI1TnnVBG09MjW+uVMVqiLIQlWIuliVXQijwMBPX3Iol5Cb/EQNVMw6eDy73dNaitT7r4c967QLWGEQLqDaIOZXK482RQ5iJUsgi3KyBz2ol18qUMr2y7IzCe0sqlcuu53IcGPoO4x3GQKqasESmKVJqxdpE0BUHhJQJNDpZzYGUazvXJbLGiiAUD9NhIuQFAGc3jK4/yzSe4n1E85FtYH0jGnQ5G2ufc0IUqrb5zFqEVBsl0R41211HiomsBVGNuahFIVWx7XoudgOj1a17b5qsRwHUJsf+frcVYV1XpmViTqm59lbhMVZA0AqiVHSRNltnO6Awur4Rg5xH24bgrtURY2aJiYygksFKpJNmrlVFk2q7aIRU0dkQJZNLIStLqZY6B5a4ttcWy2AcYn4XsJycv+Hn4pacMZ1NV90e9rZ3lCJ4NNtNh/WK28d7JMSGS6oNGZdrJeSCUx1j12GUaf+wardGbZpWC2UbilO3S9OUEu+OE7E2PdegLcUI6xp4Fdq09M47BqPZ1577lEmukmobsqxVCLkga8ChwTjmuHCaTuhaeD44VHCI1jhrqEpR14KgSao58oaYOOTCaVkQpcm50HuLNoY1PRFS3lcY4zDnDop3Hc45jD2vDyy+6+h7z5s3rxi6HzEd1zZYUwrv7h+pteJMs2UvtbKWylIzoxg2fYfR+vuZdGsNxlpyalIFRLBGcEWYpsK8LswxoFBc+A4lsMbM22U9u/w5Bm1Q3cCyzoSSWLOiyxZTKrkEUgBrPApLzJl5XriRwmVncKUN6LlON912FrQz1CpQhFQzUwksy0pWzfBobwxKhMM6/zYf0+9sKGVRStNqXHKu8iukCiLfJfGKkiLWWG7efM3b1695d/vA68cDqhQ6bSlKMEpRER5jYeMV26FZs6vzv6G1xncGiRUtqm22SmFMIZbI7WnhPqyU2mzojVGsqfImrK31jEYlMBkGbUhZiBm8U2fKTkEHQylgtSHkwmEKBKfppKKiUJXCnA9alUsrvqCpBaJkVjJryCCKKSfGrscaxbT+Zki6p/h7hjTqTapQkmC7JuErGhCN1RpvFVRLZy1xXoinE8vhyHR3ANMKGaoqrNZt/YWI9oreObRqjplyXn/GGqRmRHQb0gSkRpYUuQkrj8tKKgVvNKlqYinchBljNVY1wseFcYgtpFrJOZNTIdpMzRWXQKvm0BxLYVkDs9E4rRARMAbrFCVXcKqd16pNisacWGrksC6YIqRa2W/ajMM8P62/9xXndB/4jt+izp9vP8s5h+usJknBCPSdw1jN47ygcitQIA29WhGOKeK1xTmDPhdCQFBKo7RHJJxf+WzipTVREvdhYk2ZQpvxrKqSM0xlbbMiCgzCznasaqWSKdmRixBLJRZBasIphVKGWnKDyqSFvXdtbtW094qqjcuf7fmigqaWylIDa1oRhJSEzjTfgaX8ZnngDzfhFzm3QOR7DEMb4D23tc9DPZ9ebHlcEkNSPN/2XIyeZZkgZVQVcs7EWllKm5p2FnJNmAyohtQUrdHGEEOgnrFPtQqxFB5je5OXWtk7z855kq5Ma+R2mtkPPUqEmgtdsbisuQsrnVIMrk3zrykT88S+a4PBVcEUI7lmlG9ua13vsM5RBSKRohVFgdGGlCqPp5XHdWU0vnU4VCXWyPIb4pie4u8fSmuU0hhjz782/XTLSBqu0xjNt1/+OZt+pBZ1TuIL8xoavx9IIgRpyMKpRD6kb/MctULR6Db1hjGOuGbyGUdQqhBL5hADoQpzLozaMFqHKJjXzN280FsPVailsnEOheMuLWgEbxsVYK0VUmY3tMNVad0uICmSrOVCNLZ3OGfRylBKBmcQAafa1x5OK8cltM3OWlIt5ND8JZ7iHz60OVuIn8sb3zVS5Lvq1nne5/j4mov9C8IyMR+PnI4HpnXBVFq1XhKi2hp8FyNVNzsbI4ISQUSDMljjWFioZyJGrZU1FY4pcIyZKVd6bdgaizGKY0jch9CSpdI03RTQaO5Dxut4LqwYIpFaLZ7WRVW5MdDFGhZV6UvTQnvbLjcUQxRBVOPvp1I5rIGlFAalmatgS6sgn8LyW3pCv9tRq1CrUM7rQSlLrS356KyncxrfCRsq1lhKDei4UJeJaQnY3lJKbVwUBatU7lLEJ0uuFa2kSXarIBqctaRUEBGqVEoVpjVxXBaOUjkWocOwtQZRnmOI3C4LogwFIZTM3joGa5jWxBI1o7MYY4lSCFIY+x7rLKoUYqqIVlArPQ0H662m6koWwTUkDP789x+XhVNKDNWSlCaVDFUI6Snhf7/xNx287wq98msfoTXb3rFIxQjs+o6x84QQsVKJpZyRmYYklalkhpoptVG+tGozoyJtuDarSC3tNYpAqcIqhVNJrCWzMY6NbZ3VU8wcywpS29fXzNZ1oAxLCqzJMjiHtZBypdaA8q6dwUWRcuYUYiMKKYN2bSDXFEguk9Bo0XjVKv2nsDDnRK8taxWMqYgU4m/YZfrBJvyNytOONlXbG0/+1lWvsU//+ccf8Yu3d6RjYmcNO2tJ0lBZMQUecyBXWGrhjogtmneP91xvRwYZQRTVRSQNrEsil4pQWGLg7SFws6znG35hNLWhNovikCsqVx7mhSlERm2/Z0bfpciFNoRo0E6Rq1DSjJHm6NY7yzj2nPLEsWacVgzGYNConOmVZu4dzsDgeyRFwhzIUoglo0zXbpVVvkOoP8V7CIU6O/aZlnwBIk1bjwhat4Tr65//v7ncjQz9hygpkAPeWXIppFJ4iJEgmblmHmuiE8/r44kX48DgNUoJ5AxKWJbEkhagYQhfPczcPJ7Y7/ckMQ0PqxQZRVwTqigeS2ZOlaUUrowC43hgYcyZNRZsqhQFa0qgJobO0/WGHg9RcdQrvXK0nldFScXVih8czhj6viPMkdOUybFV+mzXcwgLtSRqfZKVvZc4V/TVrylW5LuCB21douDVV/+G/if/KdvtBd5ZjGR6YyhUcm6Fi2qESTJ3REzR3Ewrz7aOHoWRdomI0TGvtRlgiRBK5e3hxNvjQvWWgsYbw9Y6BHgXQkt4ihBqYVaVXmmKVrxJESNCZyydd2TgbglsEDrvUa51kpz33OcZJbZ1w0xjzTnrOKimqR07z3GNPCwBLJSiyc5yu66Y0gy6nuIfPkqNSDZwnv0xpuFQnbKMXU/fG6wt7Aws60oyQiJgVMRbg+REjIVsKwmYpLDo5v1xN89cDQLag2pSMOuENVXWNVBrIZTC7WHl9hDIg0G0x4lmpx3OGr5ZD6ypUrQmqwqm0FeHw3KQxjCvVdBodNWc0koqwn4zYpxDlYJYzZpPjHrTiGYatDGoKnjJOOvZdANlXTieVoooIoLuPCFHRCmsfXK/fL/xnexaMAhaNEm1jxVtH3m53/BQhVwLgzUMxpClngu+Ba0VVRqOUxAWVTktEe16cKqh1VEoU4kFSkoUKYScOC2JKQZSKVQxeG24MJaQKm/jqZGkUm1zBrbSqyZ9C2UhSmodo6JQogk5UiXinUOUtBxDayYKo4HmHaypZKyBvgwoFN5pQmyXzowCY8kaFpVwlO8UTv/B+MEm/HBO+qlU/Tf/Ny0Bqxgr7HYD/+pP/yW+//c4EXrtQBm6TgOeu2nhpMEpYYuml54lZr68PbDtO6zOrKmeTQuO7PYD39w98Pp4ZAqRLZZPxh1fHW7YG4sRRajCbjvwZ6++xm8GzCyUkjiSOLLCzvInmwtqitxOCyYI3bDh68NbvD/xoekZtKErwpenzIfXHRe7HZIrJQecU1xdXfKJ9xgUy5J483DiXQ482410OE6S2JuOvffk7inZel+hzpXwFnJOts6fpw2Tj/3IT7/4CbVW/sv/0/+W6f4BLcLoO0Ip3OcTB5PxFS4wjBWmJfLXr47sP/dYHVjSylwyNjzy7MWWt4eZt3PgFCs1VIw1vLq/wayZ2VroPaPruI2BYAyfXH7A4HtqLcxxZiLwP3nxITksZO2ZGbGD5f4xctCVz7xnYxyq2/ANEzZGdrsBozS6CA7FxfMrPu4cvrPMy8rXxyOv08xnlxfsu47HZWVQhrF3yNMcyXsJbdT3aw2+aywJUjJVapM9FOHwq59x3L/g//xf/B958/Y1lMLYjRQRDjG34bZSUUVzmT0TheOiuRxVkzqWSlgr3K3s9o5388LtFDmGSoyJmipv1kc80GXLfaxoHAcjbLY9L/2A0aa1nKdMJvG52aJqompLoEOM5s10xyFXfq+r7K1jKwM3x9i6SGOr7taY6azher/lQ39F18MSEu+WyEEyL7odo+mp5QS6oRz10wzJe4l5nsA7vOsZxgvaCgwYUzCuJcc5Hlnu/pykr/mLf/dfMx+OeGA3OELpAMtjXpFacVWxo1Xtv32c2PgOVYUlJlJKdIeE3zteryvTkoihEqeFGhOvpwWlK1VZivJsfEcZekzJfPjiQ/p+hJoxYUbmzO8/uyCHhYUOq7cob3mYZiaT+bHTXPQDF9uRd6eJGDOqs1gLQRKZwufba3TnGLqOZZm5XSYWNM+3G3S1LHltnhT2TCp7ivcSWjfZoZyLSoIhIUBukkYj9F7z089+wq/sa3IpaKWoWuOVRyeDp1AoSGmdSAGOy8Kb+wPumUMMkCIpADMMfuAhBk7zyrpESomUmDgCjsoxJWoRBrHczwGDJmlF1ZBSxZYJrxwvTE9aK4eykitoZ7k5HMgGLkzHxlgsilp0I/rpHhEIOZFr5flui78a8RTmELhfW7I/mh4CJAM9ikFrivsnruEvuskh/oduLkorNkPHi/2GV/eveTk4anEo37XK1GnCWsMn18/55Zu/JqTMM+V41nUE0/FmXvhsWrAYum7ko6srtDWkMtN7y0kVHlXms4tryrzwh7sd05qZa2XJiTF7dNXcHRc8bbDoO0qsmQuz7VhTZdMPXG0v2GxGcl7Zjz27vm/eASmTlebLwxEJNzzfbRjOmrJRG0KEBKwlUU3F+449W8pY8I+hfW2F+fjUzn5v8f+1j6u/81GTnSU9Yh7e4WqmHztAkeYVYwyf757x5u5blprwWJ7bjqDhXTrxcBxQasO46fl83J+lZBXvLQ+HR25D4I+GSwiaTwbFOx2YlbAaGL//r9CsjXKNNopuf8Hh/p6HkImhcLF1XOx2jIOn7GeGztObVs8YjObzzQv+/N3Km2Pi5eiwViFWMYyOOsNCZA2pUV62Gzama+jPGLjc7Ljoek7xSVb2PkJ9N7x0/ui7aIm/OkscCzEXvvrZ/5PHx5vm4eE8FE2Jmb3WfK0yRYRRa557h2B5UzL9aeKq92yHnottIy3lvNB5yzIv3JeFbbWMWvMjOtZa0MaSnMLEwBIrFYurQmegKgWjI4ZCNoZcM95ourFnO47ENfLjS02vXdN1S8U7z5+9DoQlsANGq+gcbEdNCpWwanJWFDEUrbFZ05vEqRSu+4HrfiCmJ6fT9xHOOdwwYq3HfF/4GPF+wGhHrZEUC05fcXj4kqEU/DhijEHHBDHSaUtQUKh0SvGJ37D6ym2MXM6RD3THxWZguNyhKMRY0QlOKRMQroYROPAjBo4ho53CewMZQBiGEac9Bt26BRtH4ZE5ZpRApzTGW3bjyDz3fDYO9EqhqfRK8eH1Bf/m9T3fPiy86DS9V2w6h+8csVTWsDCniNKa62Fgz8iaj6S40l9cshu2TPGp4PG+opFzznr688W+Wfy1un/vHPthw/39PZ6C1xrreoyy1BCYafr4N6UQtWAErmvDqD7kxGVY0Gqg7zoud422VEqhU3DQleyEvR3IGT5BE2ppMyPWUgqY4oA2w/RdHGpi9BVs12ZLrMY4yziOxBAZRsfODw0pXAtlgV/N95iHG/auozOWwVkGY6BGAppUCloUW9OzxbN2BUiMdmCw7ndAw/9rCLq/G8YqLi47fvz5MwTho48/5P7tO0I8kbIgkoixDWp8bAdqTTgBlObZduQa4f6wcgrC5R6GoUNRqaXitebTzcCLzrG3FjX0dP3A3WlhXxodI6yRDzdbXpRKEvU9CVVoOsVv1oldZ/lgf8GzZ1uc0pShp+sUvWtovM4oPn92xW7yHJYVp3sG39FbRayGNSRCXTktEZMVn223dAoe18QkFR8jcjZoeIr3E40OoP5WztVW5Hea6krOgcPhht5UepWpJZJFsKYyrxkxwkvTIVgcjbDzwW7gc71jXjOxzFwW2PYNz1lKwdqOj68uebZNXJcO4wrjMOLmQD1PlJ+OiY3r2EphyAlzVnaXBUpc+UVYuPCaF3bDha9otXBpK7oGrOlbt0IKe9vzh9sLpqXinMK5phesKxzijKRmdGfE8Pm4w1J4DIVoFUcq1Ex5WoXvL6SeqRTnUOosNdMoMjkvPD4eyOHIVipzBoqgtRBiYnSWj23rNiGKThn6TjNomE6RkgoFxTgOUJpBlxLhyjs8gkltQG3vtzyGjLKtNf56nugUdAnQhWyaLKjUSpTCr+Z7ds5ypbaMWmFrYFAJnw3W66adlkpvPV9s9iwhUHKgYNG5I0eaFCllDiFgq+IPNhc4VSmlkM7ghlQKIT5Jet5HGGPpTIfVFnvu4vWbgc5bisooCQwmU01Ch8CohJATpWgScFdmrvXAXjezKqOgN4qtH+mcZjmt3IlGW0XXtxJGKQVvFM87TxGwpeLNyK733M0RbdoO/O5xxVdNKQk1T6gYESUULSzrzJvDzM47dvueXZeBCasyOi3guibfAUbv+MPNh6SSUCEgUTDGkiLEnKhSOK0BElz7ka2BuWgGt0GjiLnpvZ/i/Ubj4fD9zwgoA7uN49MXO5a84ozFIpQaSBKoFJay4k3HYAy2CFpgMBqtLbbz5+5nm5kbnKMaqDVCqQzK4rymw/DCaZwRTnNGG4NouF8mroeOwxrwqs3iVYEgkIviUCMb67gYOi52W6xVrIOjswplKxlBEK6GLShDDpGaCpmCc5ZaDGtZKdWwrgWVNTvT0RshJEUCUi4sGab1dyLhl1/7PedsS7jYDHx0fc3Ly+eQItv9FdPjgRgnUgycpokYMrGDl4PDDq5RfjBoZ7FaOIREzYnD6cQvU+L5ZU8phXUNqFghVW7mI85oPttteH5xQa5t8CK6iPcOrw1iIKbMvCaOObJTnv1FjwOowsPjAW80sxQ68Wdny0Ym6FA8A7RADoG7ZW0bDBULDLo2BjeG3jb43FZ7jAKpilAr6amd/R5D/dov6vsKg5w/H8OJh9tfsSwTu6sLOutZZCXFxBIyj6cF3TteDpZOWRSKJBasZqstD7ElL8d54edvKh8MHimVKSYkJlTK3MWMRbHdjFzvxjbdL+BNwIVAZ31zbi6V4xx4mCODg+dXWxyKmjJv393hreK0Bobe4jqN1aCLICWxtRaxiWVaOeZCFsgGtn1PDTNZmlvv4DxIZpSKsR2pZh5T0yc+xT98fEdwqrUitVKlYrRtcyRU0npiun/DxYsPqdMdXjuiqqw5M8fCaV0pZuCyM6hqqNL2EjHgFRxqQSXhNAe+qY9sOkOpmVzAVLAFShHmmnixbUUQ0aoN06K4mWd23rMdLCIwrZlDXvFG8WzXN/fHWrh/PDJ2MIeINl27+OqG2dMiXHiNK4olQ4yJd2XiTVwZrIfQ2tvKnIfVqSgVuMRRsvCQItPy1GF6P3Em2YkgVLT2dL5vhoFUyBFZJ7SydM6itFBrk8keY+YxrLjBcNU5tLdnUopBa4M3mmNJ1Bo5TTMxJvpeU3Kj6a1rIqQEImRVebYdeLEf0dpQRWGVZyoJP1g2naHWyikEHmLAKvj48gKHIufC2/t7OmtYw4o3A51SGK0QKqUmtk4z5abvXnJhqpl3pWJth56mRu8ztjmgKth0jo2BqoRTzqTwdAa/v6jU74d0z3Guw236jovtht0wkMpE7zpyWKlnB95jDkw54JTm0jcCD1VAK5RYrLGEmqi1MK2BkCvj4NrHMbHGRKqFVSkywqfDSG8aTz9TUUYRUqb3HaOGUtq6jyHQW8vFMKBVW2fH5djWT62IcgjNFRgqCsO2G5hypVQIRVjnwF28JeZIrzr0GVLTO4vWwqgqujooilgquf5ma/CHm/CLIM1162+FUvDB1Z7Pnj9n1+04hLdUgb4bqVlIsZBTpqTCQ1354vkzds4Amqw8Sy4YW8i0Cm5KkV8eTwh7AE4hssY27HhaJrabgee542LYI2hyLTB4OCjG3lGlMM2KFDMY2JpmPR9CZppX3k33dN5xqLkNEFlH5xyi2+sb1waQTodGNlhS5m2J9EZz1Vm6vmPoOgbbHtWgPb2GYyossSVnT/GeQn3/E98jUs4V/1Izp8Mt7776C2oVlDL0Q8+YIkWEZW1V92Nc+WK/58JpFJpVdZxixmnNiAUlhJz59nZBbVqV6z4EUqykVDmkRO8dL5JjvxmxxiFK43uLORTGocOIYUqZmhIxRy67gR9d7AmpcpxWXh0fGIzlrkQussf5DaN3KKUpuQBCrYnjcWZaI0utPKjKRxfXEOaWbA0de29BLINKuGJ5CJFUK8jT0Nr7igZsEkotlJzaji0tUTk93HDz7S/ZX7/gsJ7o+67VjNbYKClaOJbIy8ExKo0SQ9aOObcqamcrTmtiytwtB15sOwByVYRYCCETEhSVCTlzsRlQztADG2+pUrgYOjqniLEQEYoU9sbyxX5LLsK8FN7MBzZOcV8yWbc9bzjjj3MuGCMNsCfCGhOHvLIsmgs/4nLBakXnFdaBEoU1mr1WHGJhDpX5N6xuPcXfL7RuElMUiGqyhJZwJ5QkiDP5dKAbNyjTHOFRQlkCdc10xjCXwOe7PRvTKFNRNFIF4wxVNYZ5CCs308L+vP5CyExrYA6BgoBtSNlN77HGAYZN1/P28YHdzqMF5jVScmQOK8/7nk+vLokxcZhmHk8To22EFrTGuY7Otr23lARaSDGeB4UTp1A4hQXXXzDOoXlXaIXTliLQa431wqEKqVTi09D4ewuR8+yc/O1EUGvNfjNwtd3irCfXqWGGrcMoQyVCbNCApWY+dAO91o2CKM1jyRiNLg18EHPidl24qgMAS0zEmEilkJQgWqEZGbqWu2UE5z2P04T3FivCEhKhVIyGwWlebDaEXFjiyu060yl/pgUpjPZnGZCiasGc8csoTS6FJQcOshJz5cpmeusYOoe3tnUjjMIrx1SFSP27357/0fjBJvyqNqah/FqVXynQBj558YzPX36ANoaSIvc379h5x+guccayhgA7eLxd6bxn02mMVmTjcVGwtrK1zdjmLgZmNfOwtEPjFBt5IpbCbVgwg+ftPGF0x64b2HSOqjTDUTF6xeu7wOMhsKaC7hptp+ZIlUqSZlqUsvDVwyNv3Yl/5hXPzIBC47VnFeExJKaYyALKeDoRQki8FsHWwHOl2PZtM2yT5m3GAQvmqbj6jxB/+1alFIR14uHtN7z95c8Yhp7T4cAwOsbugv3s6Y1GLkf+/NUtfecZfasqdcbgosIBQ1HkUrlPiRAqd2dpwmnO6Npwno8loZXhblkxRrMbNYOz9DJQ3cpgHG8eVh5OK0ss6M7SG4MqFdVIwEw1Emrhy9OBYXKMtkdtRpQCq4RoK/fzwjElCmCsxZXCzeMt3jvWErgywtXgQEHRijlkRBm8seinCv97i7/V55Qmqyi1skwH3r35iq9++TOGy0vWmJp8YePZL4FeAwz8m8cHnO3ZGYNRhuQdNtJcG70hFcWhFGaJrLFx0+eSW9EjFeYsOF25OU4479h7y2Atylrypsd7x/EYCWsbiutMW/vuzHBfS2nukbVy8K317KxFhnaVtgLFah6WTIiFORbmVDFKcTwtDEOH5MJGCwOtACRZULqQEZIU2is9xT90eKdwriX+1jYqT6mhzY/EmTrdU6YHXN8TYuDF9QWKHdO8MPiWWvz85p5h8OytouTCKTc5musMPhlyrhxK4agStp4T/jVCKTjTzAB7adppXyrWCs5qrDXsvWY0lseHiWlaiTljtcIrg1QhUVhy5HFaOQDi4bRmrLXshg6NwmtNwnOKK15VqEIJhbpm7ue3aL9nSomdCWy7lhwuMUPX9j1fBJ7qHe8tRNTfPX7RZ0O2i+3A5X7EKo01hqyEy4sLrG6XyPGhrcFfPrRzrDeKkpuvTLUaazW2WGoplFKIkjjmtgfmkFAiaK2QUuiVRXKm6ogyrTtgxJJ9xFt4PCTmkCi14F1779RSqGcowhQyS81kA10IWGXQXdfQ3a4QM2SpSBF0FYwIujTUdlWVmQRWMeBBQc35TCiqreP2T914S0zDaSENzwmqITEtfPDsko9evGBwDvY7asmtXWwVc4kczzbdv//sJcM4UKwi5MpyjAQiYzak1Jz9RuP46fMPGTsPwP3hkZoLDxI45oXjQ2ApPfMx8KMXz/jg6oJaDBf7LUYb9iNY4zisK7eHBz7oNvzq7QMnIqUKpmpMLVhTIUGPZ2OG1v45HAl8d5BbRJem74maznuMVSxKKNrgTfvvex1OZDKkii2cOd1P8f7ibwmoW7VBwfz4LdP911itubi84pu/+hnbfsBUxZyFm1Y459PrfZsR0Q2rdXeYiUqxN5qpNLznqC1/+uwZz7tWXfjW3CNFWErlbQ38YjqgVM/9EvjJlWZ72ZOo7MaBUg1dn9iKpZjCuxD4yIy8PSbehBNTikgVHJHOWzoDQ2cZvSOXwt3hCP5MhDn7XijAWMHoga7z5BwwzmK6ttZuDgEM6AI2C1KeNPzvJc7ZvjojOLU25BzJuXD37lvu336NqpV+2BCXBSeCBoIIxzPV4se7Pdt+A0ZYc+Z4mAlKse8gRciq4g38eNh/vwfe3B/pjWLuNG/UiWVNVFOIt8IX9YIP9xsisOk8GYhAOP+IgNGOd8eFmxQ4pTbh4dDEEnjAYpViazS1wmkt5NyGImOCmP7m/dYZjVKw6srgLOP5/XEXThznTCoVntbeewttmru4MR6jPU3iU3DOwVKAit5t8F1gysKaE1ZDSkII7bl8ttux6TqwmrkE3pyOWOO4xhFTJVVBW8tPxkt2Z8PxN4MhGs9aCo9l5e0S2NweubMTLy/2PN9rSqmM44DB0/ewVo1eJkqKGKM4nR75NiwclkiltPVXodMwas9OD5RamOYTxoDRiilmllBYk+Ctw3hL1zsKQu8No2nDno91ZQ4Zp2zrgDzFewutK+psUMl3lX6twSS2+5GrZ1ds+g53jIAhpEzVbU+JNSEivBxHOtfk1DEGbg8nbD8wekOpzffBa8Pn49X3edZRjuRSWGvhSOEUV9RSGU+O57stl1tNJDL41qncbBRVK2IAS0YXzzKvPKTAKWdyFfzZK8J0lt5XNr6VsyNQYkO+LzmSUpMxVlH00eBNs97qlMafE/t3a5Pdaq3Q4r6XGf+H4geb8AOIPm/mZ0Pcf/Ef/5h//pPf5w8/+oRO9biaeL4fv/sSUqwosfQfdax5YZ4Xvnr3gDHNYOE4C1uvOVboVeUUE0sFP/Y832w5Hk9YI3Sd45kf+GP1AWXJPB9HPr7e8fU88a/fvOWy6/ifvvwIYwsvrveEIHTHmSkXXs8rxlR61yGpoES46EZWIlfF8NdffsuXrsk/XvQ7fnF/g4hgsUhpRkvVZ553I69PC1vV4ZbK1+EdN3XmJ/sXeDdwt7ZkLj3Zev+jhSDksvLLv/rvefWX/y9Ob3+F1BUXZj7eORRCiMLgHZ9cXVLKwjzBN3czIpUiwlo0nz275P6mEVWOMbFmGIYBdolpDlQRBmfZOsOnZcsXZeBiZ3m53fDNaeG/+dk7eqf5zz/4GN8VXux2bIctfllhOnFXEjEuiGj6anFoLsaB1/M9Y3H81Zev+Guj8c5z6Tt+9e6EOM0gGqcUsRSChb0VHtfAi96zKYpv35y4DSc+u7hGqcyCsFBY1JOG+n1ErfJ9VV9rC1Z4d/MNMUZe/+qvuHv1FYrAxmZe7g05W+YlYrTiajtiqmHOK98+nEiqtjq4aD579oL54ZGiKsc1EFNlGEbYGUKIhCWy6Qx97/lUei7HHX1nuRo67nLlZ+/uMKrwz7Z7Omv59IM9sQpTKjwrimU+cLsEtqrjqtPoHtCaqTiYC19+fcfXRuOdoweK0SSB3ho0niklDqVAAdMbLp2nL5rXdxOTWrnUWy6GDlwjSq3xidLzfkIARythB3KGZzvP6fgGmxc65zCm0JP5YG9IBWLIWKO5vtqhi6GayC/fPbBIQTvHxXjBCNzPc0McLoG1VMZNj2w3zPOCiLBxht5Z4lz502d7xCpG77mPkV98+w3OGP549wzTwcVuQ7cZGcOWi9ORtUZ+eTwyaMtHXU83GLT2zCVgq+ZXb97yjdFsnGdjPNgD2nnisjKnTKiKQVtMhZorvRkpq/DlPHEissNjjKbfb9HOUU9PTuPvL+y5kt2qH1UrPv7oguvtwMeXV4xKY2tmt9/jciCjSRmkWnZjI4+F9cQv7u8oGUzVeAxGDPO8YIwmpEooEd1lnu+2xBAbvEApnLEM1fHZvqfrtnijOObEq3cLtio+vrqi15a+14yuZ5ciS2yy3Zuw0FvHNZaaKso7pFH0+cXNI06d2BvHzkEphmOOhNR8AwrglceOhkxFo5iXwjwfmchcDhs6DEtYSSmT829W+PhBJ/zfz0yqdgN/eXnN5eYSyZllfgArSClowHUd3lWsMQzjQM0Dfzn9ikNKhJixSrHXHVoKb0Nkqw1aabzXaK2JufC4Bjra4I52jkvnOC2Zv3y847YshCKoLAyuLQQKPEzNbvkU241y11vezDMqZQat2VqLKpV5LWzzysZ1zVq5FO6nA3SKPLcpOaUqIpmYMsd4YoewZcBJk35Q4M1pZhgMUgpWYH3K9/9xQgHSKgR/8Rf/DYdXP0etJ7wWQpno1oTqWptwqzrGzpDF8ouHwG0K5FLwSnFhO0ypvIqZUWuM9nSDRqwh5ULIgkim6lb52jrLHDO/fDxxuwaW0m74O2MwplALHCSxpswaZpa0MjjDQxRiSfTGMlhNLZljyAyx4KzDaAMCj2HGd44iQtGtYJprxeTKtKyMrqfvBqQolnVlFeGwRhRCTIkiQn3Kt95LfOf70D5oG/rp9Mi/+e//a+r9t9g4YZQip0hYEsYKnROM8uyGnpor968OvIsrFcVgLJdeY23lXgtb7eg6AZPJqpBzIUukUIm0wcqLzuN14cvldDaQg7XCpTOUArUWYtXEnFjiymPJkIR368KjSuy048I5BqfIa2FDIZ3dW6NAUYrDUrBDM/SqVRqlohiEjFs0rrdNZ1syK8LBR6gKs1SotRnKPcU/eGg0qp5blWhc54hhZllmBtockjaWeT1R1gDOYaxmVI6h8yiBX75+5JAjgmJQBVRgxRELiFYY5/G2kpUilialXVUlKIXXhn3viLVyM6+oZSHUNjC+0w4xlVQCs1TWEJjjzKIKHs6DjAllOwZtcUrQqVCloFKhZmEuGe0SSwJxA2tthk5Vl0aAioEOhRk8WmkSQkVYDKhUmO4esFpRfkMk4lP8/xaKNv9RRYEUhqGZQUYqUwwYFLY1y3G6oqxFa0vnBV3hl8sJKQaFYIxqJB8KsbSelSiNtTT9fC7kUpgloLVFicaUQi2Kd2nCZYgFatVsjEPrSiZxWmsjK+ZM1BUPLFKIWegxDM5gzzOBawnoNo/ObISUAecJsZyRyxqkYo2i2AqxMmjBGE3RBouw1oQplaQqWP03M4b/gfgBJ/xnLOe5uo8BakHnTA7CWivGKUopbPumhRJpqC1jFEYp1pTJRShSsVYzeI1G2GjFXBKCwojBWc0onqF3SKINQNbK1mpWScwlkY6Fveu59gODNRyXEwAPU3MFLKrivOb52FOVYo0JrUAZjW62waDOtsmiqLlwFxb6jW9MV6MJqjKnAqEQbWbrehRCzoVUM9443h5P9Emz0Q5vGjXjKd5T/LqA+rtvc0n0qnCfAmldGm6kJPyZU63OP4zSKOXIAlLb0GXVBquFJS4MWrFKoZQK5+RqI43/nHMjodRc0AinHJnJTDkzWM/edwzGMqV20MylkFIh5ow2cNn3II7HZUWkooxglFClHbJFKYw0A6eHmLjYDYAmAotkQq6QKylktr7Zi4dSWFLCdY7bdUVqYTsMDF0PTxXW9xPfz4u3wbVaBVUq8XSgNzBuB6RUcimoquFMvbGAaE21UDFQOc9rwGCE0zRTUuJRGhiuKgVGUUQwWmGtISuAwug1JWemlJnXSmctG+cYlGbO7bkf10zOGZGEcYpNb3hRekI5o2KV4JUmJsHV5kipKxRpyV2toMU0CppSZKMx+XyAG4uoRiRbc0F7w2OMrY1uHZ011Kf1935Cn89eJSitcM4xH25QknG+kXk0mnkqjXwCTYImrUCHai7zRppcsFOazsCaE4ZCyJUoQlEKJQptLJ1vkook0kwuvaWkwilnpICzlt42P9Jac+vcr4kYI6VmjDdsrOVjEWKuaFFkKXgMsRQcze1eiSKnxF2t4AxOF6y1GBwpt31VpGLO9eUiQiwVZx0PYcFUhXeOwVjkCVrw3kO+dzoSlGoSK1UrOUYSGmvAeodCA20YXBtNVRUlGqtbwu+UwmlBdMNoxiJEhKrBSZP3aK2xpe1HUBmNwRjDKQSMAqc8ndZoIJ3P4ClUUiqIVLQ1DNbwQm9YU2MMVdr7ogBGDEpasSIiHBFGpREEdf61SJvXLFXoVLvwpNKco51zPIaF0TWJmTUa/Ruav/2AE/6/CaUALdwfHsjPJqrtKVZTRDVUndWgBcntUERnGs6pufXqM+wnUdkoxfO+48tpYi4ZpDJkzfMenu0GpkWzhEioGVc1k2RGY8hFMLShS5RwWGcUcFpj6zA4zcZ3XG4GBjdwWiOnFJqODMVgHNZaRBpWsdTKY4xsO4+zhqgNS61EBVRF1JVsLYtUai6UWnDO87iuFDH0mw7jPPZJwvqPEnI2QdJa89HLj3l8+yX3xwdEa5R27XBU6kwTEESapZ82CosioshSmXNLsp51jlc5MMd2udw4jdI9u96yBENKiVAz1MwiGWc0sbTWntWNOjWlgoKmUy0VrWHoLRed56L33HnP4zoTS2uze21Q2lLRVASpwiFlrkVwRpPPG19UbbApIBRrWamkWkgoetfx5nTCSOa6u+Ly4hKzht/uw/kdDXX+WaThWznTyJ7vrzDF4FQghYCg0aqtiaZz/RtqtXMOvxrKORGrtRKXhaFWblOmKNVQxbTkrlcWRDNJq/h7q8korChSETBgdUuCQm3txcOSKSXT24aPvfSKwXoOMXNKrT2tG4GBKAoLGKXQSphrZtQOhz5X/YUMOBGyCKbvyQihVCLglGbOCa8UfuvYdj1Vu3/8h/P/D6H4fl/TRmOMYUmZ0WmcsxirMGdCmW4l0uYZcSZLoRTOGfxqzsOXbQbK6Fa9jKUSayVrhVMWZxTD2JGK5jEmYs0YpckUpNIqubRiXpFKPa/xaVmJuQ359toyDh3j0LOuhcdlYcmBDtsQ1xW0aslfoXLMwmChE8E7R1JyllS0/EErgyhaJxOF1445HemMYfQDQz+Sw1Ob/f3H31TfljViNOhSqFGRtUZ0I0ihDFJbtaCdxI1EZoyB2i4Los8ADWdIuaHNs4ChFTy8bWCDqRSy1IZEN4Y6TShj0K4JjbJIU14Acw5UqXjdQBa9t7zsLFMoZ+l1RqqiotBYIJ0p/LBS8TljdHv/iEBBiLWCAqMthfZaIpXeOZaccFrR23Ph95+8pEfare67e4sCvnlzQ/jkU5Tt0J2hao3V6qz1NygjTRZTBI3jervheAqUKsQivJ4WvthvuNj07CvksLDWQq7C2Gkut12brp4VJmqKJLK2vHQGZw1zFW7SyoXq2I8bEKg6NzqFWK5dh1Oe3b7jeiu8ejzw7eORaDR743GmDRuJErKCaBWiNFopbIFBFNkaDp1m1uB0s1wOJZNLZkdzbdv6jr3t2BhPedJPv79QnG+bLapUrOv55Ed/zM3br0jLEa8UWgPzPUYEpTVKCbUWcq5sB81dsCCVuSSO88RPdjt225FjhFoDpRR6Vdh0iuut50E3FFhIhQUw3nJhDJ1ynGrhIQaU6bmyjWqxpAdUKex6z8b3eIFu7BmcQx0Ub04n0I5L2+MEVBGqKJJWJFMptVW9qAVTBWeEe1WZHGyNQaQ0+/FxoBqDoNhax951XLqBczn4Kf6B4zskZ62VnCLGWPZXL/jsx7/P8d0vWI+3aCdoM1C0RpMRo1BodG1Vpf3G8bBoahJCgruceHHZceE74qyYSm1VIxE6W7nuem6nxLIIaxWOAqUaLoyj94ZZ4JjbIXrhHaCoS0SoWOXYOodXmv2+4yJUXs0LN6FJwYZeI7Gx1q1WOKMoIeN6g/ZQc6NS5FwoWQimgvWkENpFwBlMas3ejTNc+J6rzQ5n/W/5Sf1uhvruyqkVxjTWfekGOpeR2jqASKHrOsrcKqvWaIpqZ7cGLrYDxymz5IYZTjnxcjdgnCOZ5gadRHAOrC5c9b6ZZ1I5BiGdfUE2yrLxhlmEUy5Y56jnActFJqIUtHJ0quGGx3FgdEKicpyaW+lFP5JDQApoZ3DWYkNGJ9Beg9G4YvBVsxJo45egJINWOOcRgd71bAxcWs/WDBzN0xn8vkKQvy1t1PDwOBGfB4o2FA21OqzrWlIOrcovjbhkqXTecIqt25QBXYVno0LMec6yNhOsTmk6q9j2nmRAJ82UakMiV0OnGhVKoBXjlMH45s4bwkwmoXSjlCkKne/orIGlcr9kyrnolnIrkBmjcc5QjUZlsGcCoxawCDMrAx1JaBcVabz9JInetKLLoBy96sj8Zmvwh5vwn/uDzXgGNIo//exjnFYcDkfmqTmm7XrLyg5nWkJWpTFaofDR1QYtkVI0ay48zAde7jYc54Uvri65XgeO64LRhpfXF+z2zxmHO67DyhoSx2Xh461hXSObfiCmQkyJseu43F1Qq2G/2dFZTW8MKWX+4uYtP7q6JuTMHBZqCXhpG9NdCdymzKANz/uOl1fX7MyAUolDTOii6LNjzgtLDGjZtGqurhQlrCHxnz//lFgqN8eZr+6OnNJTdfX9xXcCHc7X7sIy31Jy4E/+9D/lJz/+KQ833/Df/Vf/Bb4kkilQNcL5Elo0V5cXpFTRdSBJ4SEf+Xy34TBnPh0uOZmVKa4Yrfnkgwsurq4Zb265XhRLNDysCbPb8zgvXPVb1pSZYqQ3ipe7faOl9COdrgxGEbPiF+9ueQFkgUNcWFJgm1Qb+l0m3uVAJ5rnuuej7RW7scMWISTB4zAoTvpETc35N1QhpMgcFqzR/NHwjKIgrMLX+Z776Wlo7f2ENFfZFIlpRUVFKROiApcvPofLjzk8vuLtuy9Z4gmnOkRa+1fOldmXV3tKLiyhFTaqJHam41AqH13vWUNhWRJGaa6uRj68fsF4f8uLoJli5m5OWGuZaInOkJuEaNcpNpsBwfP7psdrofOaLMLX94+8xJMEShbqnFmM8GLsua+J1yngBC6V52rY8snQEWIlGfDG4q3lHTNJGW5v7tEocskUydi954/9QFSG+7uFd/cLa3lKuN5LKI9WDqmF03RiWRa++PwFAwlFxNSMWg3Hh6+oIaJNy7OkCFIrULgYNsQrIeXmQ1NLYfQdc8xc7rZsYyKHhFaaq+sLXuwvuX1zw0XO9FoxJ8Vm3GCMYtP3xFSJqbIbHeO4p1D5IzfgrcJaRViFbx7uKaUgGBIVqzWmVHaj5SEW7kh0Gq6c57nzUBLLHPE9DM7AZmCdpNGnYiLHRJZKouK94ye6Yy4KiYWjnLh9qvC/t6gi1HO13miNMZo/+Oia66HDSqGmJgs8eQ14rFLoclZ0aEFnzXa3A6VIqVArKFUxphlc9X2HK4WcE0Zrtvst2/0Vh4d3jOtK5xSpNul3xyW98818NWe8txjtUbXwo+1zvFV4Azkbvjw8cJnb5SBlg+CopuJxzFSCE3pj2doOD5QcOSwLw9DTGcdcDGteOcYM3qFEUbWm6IKdK590O4ryWIQlztwdTr/R9/OHm/D/D8RfvX1H0orBgleV/WD5n//xTxnHjrSuUCtaaUCTYuCvX9+xzhNSm35+6wcqMOfCL7/8lqEzbEeH1sI8zZAfqDRNvlHC3hnEGB4wbDvPrDJrStyHhQ9qoYYDvhvxxhNK5hdv3vLtOpEzeO+wxvHR/pLOGLwIHwPf3h9IWXBimfMKZgDT06tWRZ288HZdmHNlJmPRZFWbWQOALTymE8YLl7o5aD7F+4pfq1wrhbaecfOC4/2fEZaFuGaWeGDoLIPpyOt6bjPLWYeXeH37yHSaGrpSG3q/oQAlJ/7sq28YOsvF2GFEODzOkCGlQK2CAXamYDsDdGy8R5TimCP3JD6vC2Vasc7irCeUys/f3PH1emIlsfUdO9M6Tp0R9t2Wl+z5q7e3pDXSo3gkUYoHo9hXT1KVRy08TgKYNqGkmqQkAZ6K6QpLrBALNVSWp4T/vUSKmdI1J8gqFSFycfEBKSzEMJPTSq8T/vW3bHdb0rwi56HGUjUF+OZ+YT4tlFJQSmGtxnRQbio/v3nXZpucxYgiTz0HeyJGqAWcVK49aNs0rDtnuVsCh5zJwfBhgTkcsNbivSVX4evbE1/lmYCjN4LThZc7T2c7dp3ncoT8uoEJNJqcA4EOvIZccQKD1o22qWE1uVWaNShlKKWSx4axEyq1FHJYf9uP6ncySm6aZqXa5dGOlqEfKIuQUkAJOOMwRMb9wLqc9z8FUpqp35v7B6bTTExN5z/0HizEWPj23RusaAZjMVqxfzxyyLSLndVopTGqtIHKse1/kyrEkjgWeB4TIRwaJtR2xAzfPBx4NT3yuDo2vsNoy5Ub8Z2w2faMmx7enqixzcrNJdNZ6LVC1YwWGExLi7y3rPG7ZLNp9q0xMDq6AnPOxDWwPhm/vb/4O7Oohcqr44kM+GZaz6bzfPziGWNnSSki+m/cm2qp3B+OxLiw5gIoNl2H6QRi5NXphNaCNwpdNfPkMLmgS8Vpg1KCLrkVwmy7cBCFWDVLFfZ1hpCwrsfQkYpwNx+ZSiAem+eI1YYrY7FG01nL6D03pyMlZ1KJJFrX0pjz6xmhM4Y+A1ohpSIorFKMxmE7hel88znJ3xm//VOX9Cj5W1xwEKyvDB4+3G7QFJJkxu0WSiBnoRaoZDKRkhWXw4apwjQHjjkzi/A4LaRceHExsOl6rHUo2uZWfDxTRwSq4L1HG8djEIqqKAPj4PEWRl1InWMNCylGQhVONTE6QzhX0Tpt0Ch649HnlsvVsGkPuibeTmubwq7C6Af6rqOuM+pR6H4t2bRaYZShZLhdJ+7WwJUd6Z1mjk+bzXuLX5P0KBFEKVCWv/zrX7CzFqvgcHrV+OU1EVM+D+G2fSqKcOV7fB+ZlsQxVw4yc39s7eePLnd03qCMboxgCio3gkQuQlUwDB5re44hIKqgFWx9z4vO0muDGj2nJXDKhVg0c64MriNKwRrLoB2aplusZ5rJM+8p2hBL5nA88sL2gKF3BmcMIUEqGas1WTL1LFvaKssgmoc58Fgz176jUwr7GxICnuLvFzHN5OwoJVNKwvkBYx1IRtVC5we8/4hv879ubencEvV22WzEh0Flkm1a1ZCbUdXx3UqKwvV+xFuD0eq8/iDHRJFIkYrSisFajHVMMZNUwRrNhe/oektvwDjLlBJzLcQK9yEz6o7HHOncSG8tSgrWgCpt3unDTY/kSqqVb9fEs1RwzjA4izIKVTLLQ6DXnnL2E/DaMGiLLpV1FZZS2kBlbdXjp/iHDyHRZuEqWSUcYIxlzStlOWKqgDVYI9RUySE1ySqctcjC3jlwnpICS8zMeeG4RkLMXHQdG+9w5/0PdFu3VZAzjWzoLNb0RFa0UhijGXvPZhzZbNqfPSyh8ddFcQoJiyNrsNY1E0IqXhmIGQ1c9R7tCqUmvpwWvnCXWCVYB9o7JoHbOHNltojTjRJjFJh2iYmpNDpeFfR5LuEp3m80kVdF02aUlILLfqSzTac/Dh5EqCVTa2m/r026unWWQzaI5Db4ivCQKrY2ClmnFfZ8qeWcV1YarALRdLbHaU9MqZm/Kt0uG04zakPtFFPKLLUiAuFsoJm0MBhDpw0GjTKaesaob51HGUOukVfTiQ/sFudsI+gZQ5XKQy3snG+dNADjUM5Tc2atmVI5m3Sdh21+g/gBJ/yAahgl5zUYIZLprMG6NgU9ug6jhLSu1JIQNFIrJa6sRTEvM7W2pMkph6swTzNFKqL0maBSMQqkGI7L3L550twFle8oVTilTCiF3jj2XcfozkxYEbQxiGiqJJIUeuUYtaIH9Jmu4XuDMR0xBLIJTCUzlcRDSNweD/TG8Gg0gcopNvynNx4RIdfahpGMJarKxbjBaEuHh1oZ7FOF//1FWwu5JEJYqCXyOD3y6tUb5nFgP/SNSCGVsM7UGtqUvShyKqy1sswBoyybwWJrxUrmVCNRaiPm1DMNwipIlYeytg2ttsPVWocgnGJhJeCVZusN2860XkIVnG3axVALUTI729ORMKUND1elGLynU46UVqqCWSqnkjnmwutpZqcN97YRfKaciVLwRlNVG+7VCjqtMdpyvekYqwEMFMGbpzX4PkI7j3UeYx3aOoyxKKUxzrFOR+I6U9OCxCMlRWrJZ1pZuzBKVSxrc3Xc9YZehEVBSILyGeeaTXsuFW9Mo63HRMnt4GoOq5YqmlATsYK1hiujGLxBaUHpirWGikJqMw7sbRsKt6WipDmrDtbiVDNlKkoRpBJqoWrF/RoYs0KMaS7OuR2eXqsmz5RWzS+0YbveG6xoShFiqnT6h3uM/VMOa5ouH6Q52BpNrYUQjpADRoOtFSmFuEyUHFDn4fFam6nW47RgjGG/GehKaVXxmDHa4owDpRCt6KwFhJgyORVqEYw1WOeQajms5TzXptg4w9a2Wow6D1/WKoRUKQKd81iVcdJQ1ihF13uMgZQyhUIQaZIzgYc14ERaUlYrcxXWs+mSUQ3jaKtGqHilGHqLS4WYNSkLnX6i9LyvUKohxr6rfCvFeVC2ghE6b9k4jwbyulByRKt2LqaUKdUwrSvGWra6/V1BcSqZgmqOt2flrjYGXdr+SDl3t0yDacQqTXZtNEY0nVP0rpF6slJoo6iiyLUSS8YZh6ZgzrffqiqddWjpyCWQVcMPx1pJAo8l4ZWQKujUqvZTzjil6apq7sKm7YJWafrOkVNpC1jaHvybxA94pxQUCmMUvjNkKUwxcQyRvndsh57PrreoEhsaSdWz7L8gOVNS5f54xLuO3dgqCX2F21q4z83CXThvCrVZJx/iwqh7rLGgLQVHiJG7dWHUFjdYnGvgpyRCKAWtm262krGi6K3l0micNG50FhDVhj1jTCwlcZcCjymy1MKr06FhPkUItVJra3V75xo1wxicaQipXWf45PKSZV1Z1kpMiY1/Glh7byFNmnM63fPqzc/Zec2//dUv+ObtG6bdlnqxYy+FUiIprm1TUrp1mnIm58LN8cjVZsvQeTql6HJBKcvdcuAUEoMxWAMpCzsUtzWxs5ZOOzSeSkfMM/drokM1prlRVMkksYRSwZhWAdEZo4WNMWwQdC2NrKI1OwHnHTkHllK4i20NRhSvl4kJw6oaHUBEcNrQeY/VQq+b43URoes9n15tiTHzEDJLymzdD3gb+ScczvVY1zXaiSiqFESgG7bc377mcPsNcnoH60zOqe2BZ4ZzLZlcNA/zysWwZewsaIUvsNjKaS1nbGFFnSkVKheSCJLb4JvSBtGeNWSOKWOUZWfAaXACGSEjKGuhglDorcIaTV8rtmRyBpTGeIXpHSlnTrnwmBKxVrTW3MfIlCpBawqKXApIcxe2tjlM1lrJUtl1nqtt31xSlybBENf9th/V72R8l0RowJ8Z+yknijSZl5IVkx7IKZJiaOvv7O9RqxBz4e1p5sXFjnHw9CK4mJmJrGcakz7To4pwRrsqaha0Uo1+ZgZirtzPGW8LF13rLJW8krImVsE5SynN6dco6Jyhr2BqIdem5ZcOnOvIGaY8c4rNQ0SL5mZdMVJQybTBTxG8tmfqGnTWYM6wg2HwXGwGyho4rhmFsHVPlKj3FY3uWlG6GewChNS8N+YUuRgsz7dD2+/iegZg6pZk50rOwu0682J3wegMUiu5KKoyrCkSBZQ08lMVsKVSqqBqe02lTcsDU+AhJpxp3kqdMlArRdoa1Kbhj8lQETplsSKYM5FRaCQoYx1VImvNnHIkl4pRhmNJdLpSU8GIhizoqqhFqGg6Y3BKIVLwtmM/dAQVibEx0DbdP/GEX2toxQLVNoNYmefEv339FX+sP+Ljq5Gr7YikleoMSjvKWim5oozBJU1tT4wlVtYSQUNvNHOKeIR93+OV4X6aGHEkMnqrW1VBa+aUmINwWAMXO9/aLGFFKcWVNExcXFZSFnItXNie0Xu8aTKdWiohFw7zAtUiNSJrIs2RVBODU9zFwpwjHk2v2oXhed8RjWHTKz7f7YlZeH2c+LAbueg7Ss4oV+i0atzRp3h/IZVXb37G//1f/2/4n/3JH/D/+K/+r3z57oEvPnjOKI9s6wmVKpgecYoUKyUnFA0/mKoiK8VcC0WEnDKmFqY54HThYrfBacO7xxN7GrZQ+QHtPFkb1gwpwKkU9sqjinBMiVOAq62mWMthDqw5U6Ry7Td0pjJYRwVSqsRYOOml+UXkQloD0xI41YxFSFr4pmZ60YzK0BnLhR+xfUdP5rPtlrUI35xWPh4u2AxbSp4YNfRekZ4KXO8nSisAtNJHq7ZWEcbNNWuJPNx/iX/4hrqmVsi0lpIVJSsobe5iEmGgJVWU1q3ZGM23p0ixhmcbx+AbbnGdVobdgNZNP402LKJ4jPAwB55JJWvNvcCDUrwwO1CWNRWWnImp0Kl2GA6mUimEWFhT8wbYioacyDkzp8wKlFKpGt6ljFaKHkUvigtr2dgObwqfjD25Vm7WzIthy+U4Ms0TVWu8U+1C+hTvJWqtOKfpx4EErCmxe/YZZblBHX5FOb1CpQimR2mh1ErJuXkj5EI44zdVzK3zlAu+73h9uGdfOjabnsFoHpeFQSm2O4sxDm0UYg1r1SxSCTWzNw6RwsOaUUHxAk0xlpIT85pY1sJoDZ0SBqOpQKyZkBKPAtBefw2RKUaqEiCTMKy1ILXgqmGwnk/GDV23wdXEh5sNRYT7ENhtt2z8yCkIRhdGq+l5unD+Y0WtDVf57rAweIe9UOw7B2mhGI3SHTknpFbcOacTo0AqJTUD0yytiHVfAiKWoevxSnNYF8QqnFdo47DaNixsaQqPtRQGq5EiTKmyUNFDpdAhBmJKpJTZOt8096bJgUsVUqmc5pVNL0Ag5URIiSIVrzRiFGuBWs9VfWP4QI10HrRSfNiPiIKHHNn4Jr8twVCoaGMw/je7dP5gE36U+t70Q6rQLlSV5Rj4jz54yb/60Wd4vTAHg89wWAsSC+ZsnDDliXHcsN1uOK2BECPjdwdDbHrTG31Em8bmHUfDYTb43gKG+2Pkm7t3GGP4UDy2CLu95WrbIwJv709kNMuSqFXT2Y7Prq6pRAKeUgNGZ1yqHOYZex6aO+TAXQocS2FjLIOGne2oGUIuhFL4ousx48Dne8/VfksWxYvxgm3nMdZyOV7w7XrLkp+G1f4xIhT49jDzv/8v/y+ktTA9nvjg+TU/8mBz4qgdxsLjvKKyYFEo5zhOK91uwHeeOWZiLuxcG9AptRJL4W6aUUZRamHXddzNiWF0iDbcHle+evfAZujYZyEvifF6y/P9BhH45uYA2jLNgVSFznu+uNo1QoVpLH8vmSSJd3PgKrc1eKyFQ8mcUmJjLR7NoDW1KoJAlsofdCOj73jRw37bUbXm+X7LrhsxBjbjhscQGv+aJ0nP+4iYV0IwlJLJJdHpDts7vPX8+OMfsQuveX3352hTsdnwmBI1tzaytpZQCt47fOepcj5MTCtDnUiwZoyqzK7RmPbbgYcl8MHliMLwOBe+uTnQibA9G3rtN5b9YBCB1/cnvHfczitrEnrj+MnlSCytPZ5SwpRAToEvj498QRuim1LhlAuLCD0CWthAQzACxVo+6jd4rflksFzvRkRbnicYxx6rDcNoeAyPrCWi9VPR432EwSA1NdkhXfO+rOB9h5sXTLlDm4nZeDJwmldEBCsNOTiFwGB6NkPHWoSYM70BqJxCBFPRuuKSIZTKB5cbDseF588vqVrxuETeHQ+MxtInIRm4vOy53nbfr7+uc0zrSoiCwfHJfkMhInhSSnQlUVXkIazYqRBD4m498ZgLWmt6moOppxGmRAlVFa7tyNhZnncj+76jaM2FwGh6jIHdbsMUEqGE1qZ4ivcW35U7UIBXOCBT+PGLZ/zJR8/pdCBmBdYzhwldavP6MEIOhZ0fcNaxpEyQij8beB1CIruEpuCwJKm8GAfuY+VyZxDVir0Pc0Qb3V43w9XouOo9AtzOEWMyac3NGFBrXmw2LKUi4km1YmheO/O8QCkoFTmukenMzv9OjWO0QqpqXVap7DDs2fJy5xmHniLCGBODHfFo7GC5LRMpx7872/w/Gj/YhN+Ypt//0ctL/pf/8R/yr/74X3J79475NKFL5Ge/eIczht0AQULTWqEopZJiQUX4aHeNskJXK7cx8au7E7kErj+64lJ51pSIOTMMljlGTCy8vZvp+sKmN/zJx5f86mHiGBNprlhZ8CJcX19jykzIK1NssgmbI6IShjbsa2olxUSMiVEr5mnhISYeUsZj+FCZNgQcIWSQLBRAnCWIYE8PzOMV6hgYu57rzUDMM6kYun6L9wM308Krx8ff9qP63Q6l+ekf/Es+/+Azvvl3/we++vqeH9k/Y72/4799d8dgNOO2JeCjcYjKpJxYY8SUwo93l1hrWFTkXU781f2JUgovnj/jUlliyIRccBvFXCo+w5evJnxvGTrNn3yw4VfHyEPJ2EmhZMKL4sMPrwDIMbDkQgRSSXxzOGFiAu/ogBgTJRZ2zhHjwttYmWptHH1tqRrGBFG3AXBFwfbNzOTm9IA3W/JqGTvNzhnWdcKYgc22ZxdHXj0+8svHw2/1Ef2uRq0RGDBao1LizS/+b9x+e8tXX/2Kw/070nrE1cJmM5JyxRtN1opy7jKZUvnJdovtDCEW7pfMt9NCtpUPNwMXrieUxFoS1jnmCPfzyoJj22sGo/li0/FXj488LIU5hKYbve759MUl7949EklkpagWgqp8OUd8Lgy2dTodwkZptn7geJq5XQIHClYUl0WjtGJMEbTjkDNJN7MwYzpiDBz9gFuETQcXVpHWSBkN47BhlwrL45FvHp7W3/uIaX3g6uqSi03HXkfq3c/ZXnzB23/3FxwfX1PiESM9Tprx2qgtgpBrZgkJFQo/vtrSW8sSCncx8/W0EEh8vr3i2WCpSpMwbFTHcT5wc1y4D8K+79j2jk+3nncPkSOFKc3IKWO18OGzC8zNgRACp1BZU8Uo4fWsoax4L3gKSQKpZrZiuLk5cFMyShl2SlEoKDGMywrOUEttBoYYkta8nh/QXFDPmulea0KYsLan73u2FyProfD67vjbflS/s6GdQnt4fjXwz370If/8sz9iOh45rI8YqXz17QNWw7AdkBLxWiM4SikscSWGwuVug7VtLq5E4XZeSSrzcthx4R3fT6poxTGu3E+JZU0MfU/fOT7YOU5z4Zgri0Tul4aJf7bfwCECiWNJhFSx1fC2RkQi3gwoajPRjAkjwsPxxKIL1lk2WhFywZRCIOFxlLME1xhNQfNQDgz5khIT3lm6oSekgGHADQM+Z6Zj4O1x+Y2+nz/YhH+/6/jk2Y6ffvIxv/fsY3I4UNYTvbFQFdSKmHOLJzlCXtsEdxHWNTCvKxdXQucskjs2vvLRDnTZ0o1ja5ukQEgJKQrnNC8//5TXb7+lpoavK6XgK6ylEkvCJGGMHVfKnzWNlW3vqLUNyonAFAIYhav6TMyAagyPS+AoK8YpLl1PV4S388yRjFSDMpZ8dpvsayWh2Q4Dm26glMrb4z3v5pkvRHi2t/SdY+w7zNNZ995CpCK1MB3v+fqv/5yvfvYXvHn9jjKfUKm5+VWjqBVC1axLRCsFVbHEylzg2hq8c+QMO1/5fNdu8MPQ45QiuVb5ryJo59hsCg9zwddWUc25YFIhl0pUlUPWHGPlRbaMrkdbYd8XcnPqRqFYaqIUhdEN0aiNQnWG0zFzjAGlDfu+wwl8e3hsh26F6oQqkGtbt9b2XI0bem+JOfPtYeYmRH5PKzrv2HSefdfzVqbf9qP6nYySCyUFpocb3nz5l9x9+e/56usvictMWhYoGeU0KVfWoslBoc7rIOTCEmE3WJzVpNRcc6+2Hqmm0U/02WioWERg1zvQhvslYhX0vUUk04tFq8JSBRcKu7VSsmHoe0QJo6/NA+VMxVjJJHGo0mYDxBpcZ7lfZladcGLZWIOx8CYsLCVhrSLbtl6FivGgxXG1Gdg4S0W4WxK3p4WPZc9Ln+k9dL5hHJ/iHz760XO5GxlUIT3eMN3dcHw4cry753C4p+bA1ltU74k4YsgopahZMyUIaPbWYIzH6tzOYLVt9XfrqKZ13N3ZKXrsRy6y4m6JJNfoeTUXtC5YLDVnYqgsKVNEY/oNHW0OqtQzr10p5toMLmMVam1kH2c9YV1AKYzWDNZQqbyaJwpCD4hq4rkMFK2xMrIfBgbvKFV4WGYO68rHrmL9/4e9Pwm2PcvOOsHfbv/NOec2r3F/7h6dFEokoUqsCtJKKA3KyrDEKAZM0EhjhsAAGRNGoJGGjMQMA6sBhsGYSRlYDSoxVFWGVRaCgqiIkCK8fd3tTvNv9t5rrxrsEw6ZpLI8Ej1XKPwtMzfzcI933/V79tvNWt/3+wK9D4wuYN9Set5YbcfA9eXA+4+veHbxmDWfWuaId2iuSG0p9EaFgmedEw22oeSiJBGMNzjXUVwhBuXRxlBQvHVYYz7n21TAWMtF33NYEkEEo4GSm7oEHCJNolsqiHHYELDG8yRGqmsPRkEQwzndvOn3rWs0tFIyaiteDcEGvDO8XE6sVIItBOtwQFGls6A4hr7dN6VWjqcTx2Xm/eBx3uOdI4bmz/oi9RN74f+FD97lm08u+cbjx4w+cjycMJoouWJFGkbLKs4bOmN4sV/QKo15HzpsrixSiMG1A8TAJkakKLvQ0tEMTec658xcHFe7S7aHPZImjvPCmlYQxRQlaeFUYL8kbh+OWGvJJTJ0EWvaxey0JkSkjeBLGxs551BjUGCqFTEWsbA4w6TCpQtkY1qUyTlkolQFDDH0RO94SCuvDgdeLZmvX8C6Lnjj2HYdw1vD0Bur0+nAw/1zXn3yXZ7/7v/Ay09eUNOBUmoj19BwhvaM9Xp+nDAK2+AZY88qwiqVLjZ5mneGjfXMRbnsIgbDgkFqZVkLC5UQIo+HHjHCcU4s64oTaYdfVZYsPEyJ27sj3jaiwBAjHUrOzYhZMSRtjwSHNna0KqLKUguc/1k1lqkqV8FQDYhpaYQWiz2nl3ZdJDrDcVl5dTxxXxv7fJpbWNjYdW+N42+o7m4/4nBTeXjxGS8/+i77V89Jp1vW3LwgVisxWIypeKu8OCyUIvTBse07UhWyGqKxWNsOhl00SA7seg8GUhE0wVxamncfLV4NUpTjtJLWDNJkkkULa60c5sL9w4JzjrUUxugwNPTnVBoOLxmhqACK9RY1hnr2i2iuqHdUB8tSibRHcD2fvApYawDH0EWChUPO3K4rdznzrFTWc1jT4AO9fSspexPV2wWbXlPWmfTwitvXt3hXmU8ry3LCVKE6MCbigNvjjNRGTRrCcDZgm5bObSvOO3bOslRl6NqeUaSyijCXmc4KY+e5m1aWnNkvkHOi1IYGXUUwSdifHA8PM8FYaoEuWgxQRMml9WtTySAVayD6gHUWnEFpBCkxgLEkGu3HWoOoabQpY3G24jBtWu8sc17ZryvHVKilsq4JZwx9DHRvoQVvrD54csHTyw1Pdls23rPOJ6xpebr5/NAyxgLt8n5YVkQq0XmGc1NW5GzApclmbHB40ZbfAGeilLBIZqS2aeSykkphSZkkBclCQalVWKpyypZuWtrdr2rDD7vmESkpI7VibW7kMgze+0b4tu2sTVXw5kf47gZJaMQg0xakgjsHf3rbHgspCYd5YU65QQzWFYsSnCd+QR/TT+xK/eMfPOPdix2Xw9hwcUsm2MqUV4JWgjftB2IqnYfDupJz5moYuBx7pAiHZaH3niotAtwYQzFCdKa95EvTtS55xtnIupzYdR33aeJ+mtph5j1WFDHKSTKvTxMqynuXlxQNVNrXqijpjPMyeaWWQnSOLgQqSnC2vRRVmVwhoyzAY9eBU5YqLFKhQjmzp6tAKpnjMnM/rcxSsVjWNROCYwyty/q23kx98oN/x93rD7n/7Pvk20847meuNraZDbV1BoxppGpn4H5ZkCTYzcjTzYZ1TRyWhaHzjZ2uBTVNv9/7RoHIJZNFOKwLISlXF56nl9fcTAdePhxYU+Yq2DNqzDAV4fVpIqjyzvWGLEqoNLQsDeeVq2WRTKmV0To6787Jl6DGIKVyJFOtJRuLNZ7oDLOpFAQL7UAERCtJYMqZY85kazAKy7IyDm3kudkMf1gf0U91ffT93yEfD8x3d+TjPQ/7A7uozEXIIgTzI3WrECw8zDOntXA99Lyz21BkZamVUWl4QdsyHwqeMYZ2Aqpyol34H3LhYjMQvCfnwpJTmwz8qHlkYanC7bzS3ex5fLGjaEWqw5pG2Mk1kRVqTmgtRO/pY0D13PzIBqnKWgV1BrW2pWOeL19C626JnnX52qZOSykcJJEtWJRlLcQYGHxk179df2+idHrF4bhi1xnyyvFhzzDAujbWuTet4aEKjsJhmphT4XIYeDJukdooIjU0rCpn1rnDsIntAnRaE8eUuU8zAWXXDVirLLlhriULgzMUFRZt1BU3LQwcuN4MSG0XNtNAYkhtJsnTuqJVGWNk8G39WaugLbxtkYq6Zs4MKozWc5LKOYLnnEEAWVs2ypwTU2nscwTymlozJASG/q1p903V159ccj32bGMkWCUtmT5acmpEsXaLdlQ1GGCSTFoL2wAXw0DwQs6COsFUaVHQFpCm/jDAWgpTyRzLSmebIdZZQ67CKSVKFUKFatrvaUTZr01Nctn11HMzzRjTQjVrbb+nbZ6W4BzR++ZvcRZVS65CNg1/7LzHqbJ1gVSFomfa2jlMK5eCQ1ly4pRyS7NWKClhnSc6Txe+2D3wJ/bC/3S7ozcOpwbnKjkXUlmQDMF5jHGoOE6HlaoK2sZxplZcTZg0czNlLrtIqBVfG/YtRkdw0tIbEVbJ7GVmKIFPPvwO7/bXpDVzLIUuBLoYqNMRxXOfMrfzkXVaef/qKReDR2ShVKVUSxHLQ030p9wOrT5C1/jCVZVBDEmbVnsi45znZOASz75m1lKoFebQwhkejrcYDLfLylSEpRSKyXgGwOKDZxzfHnZvqv6f/5f/M5JO9N5zOQyN8FAVVYe1BncO5nqYJpz3dNaTTIuWr7mQpwN3rFyNjlAFL4W1GjqvWBSjoFVIZeGUZwbfMZYVudix1szyAK7r6INHlhV1lmMtPKSVVRLvXlxxtfWkpa1BUUtCWFDSaSGp4seOEkLTKKqyM54p16b7D8IYAxPKBZ5FhVLbYf56uQHg5i5hrWWfE8VAEcNaKzFEzHkz2w79H+rn9NNa3/l//N9RWdh0kUfbC+6qfk58sPVs9qrKNAnWOUwwmAxGBWpClgRWEHUYMkYFKR7nwCIYNWhtMfGHtLTOmO8p5ciUBVHLNga2zvD84chqKqsK+5IoufBk23MxOFJShHZ4KcqCsB4yqsp24+h6i6JYdYRqcaZNM1NRNt5Ra+XSex5qQxMX4F5aoOD94UTvHYucQ+3UkE0miEO1ZbTs3u6Bb6RuP/oB+XSk94bH11tqVXKplCIEDL1rHclpXjDWYq1tIW5aqWVGlonkLHXw2JqgJJJ1RCKWdF5/iVxW5nnmzjhsjVjbsiFygW3sGK2lzkec7RAK+yKYhwOPtiObbWSehZpBDaxkBMvDNGFro03FvnVyrRr8uZu6SmWVhtRMyTAQOOlKroJWuNUVUC4f7gimndlzEapalroS8FArwVnG4e36e1O1i5EIn5t216ZXRAqEc/cba5jT3B51JuDMj3oZ7Rw2RqnGo0ag0ffx0dG5NhnKYqiqVFFM1yFB8cFxKo2RP/pI7xR3UtRZVAvLkilaedIPuBAoIi0DSpsXM6fMXhMOx7br8b5lngRVOgnY87Q0qbILjpQK1lbq2ViszjQ8J3B3ONF5x1yaYsCYpgqozjJYQ2ddCx77AvUTe+G/ur7go1cv4OGObx2v+OzmBbeibOPARa/ElJBcEFV+7/ktf/qP/yydtRyXhef7AxcXW74hlcFVYjDErkOXSvWN6+tM4GFKvDqeOFXhnsSSCj/Y37P1gV3siNHw8d09WQzv9z2EjpmMCYZhdGw3I5+8aq8uqYUsC8/iyIv1SJ5X3JqpS2YulX3N/GA6sTEW72jhXH5EbOX5MpMM9MYSz7rGQ5r5cL9n5wPHUpg1ceEDV+OIVCF0ilXPrtv+IX9SP70VrOAePyFNM68+e8laLN+7u8W5yFUX2TmLWxKHVPiv/+z/gW3/O8z7ew5z5sO7PZe7kXfb0cBm7NmMG9wipLURWLwJjUQxJU5SGbzhs+PCv/83v83WBa76novNwIefvcRa+CD2WMzniLBuE7m6iHzySjnOmVwKSy5EC3e1kudEyIU5J5Iq+7nwvXVhpMngOmMxweKscp9XlnOohwueFZjTxOvJczn0JKnMObMzgafnjn7sWnBYrz+x28gf6dpsOkq/Y50mPv34I35we+BQLZvOso0dnbO4dcJ5x8//yf+WX/S/x3J6YE6JT+4Wdrvm/1GpbLrIGJV9KszSQAHeW6YkHNfECuAsv7uccNYQrbKxSj/A85s91hveIdD5EXWQKYwXA+Nm5NOXR+Y1UUQ4LYnRee7ryrJmqghuTWRneZ5mnqeVC7FYDMVDCB5rLZ/mgvOO4F3TpcYRKBxrRQpMa2E5tmCxR5sBBDrf1l9nvph+9W39eBW1kH3HfpqY7z7k0/2M2MAwtFybmAtMK95ZHv3Mz/O+fUFeFua18MPbA1e7EWQlzULfBbZjYF4qMxG3SLvELMrpVMgzLIPnu/M9EUNnAtvg2QyRj+9vsNbzjvdE21GBRYQ4Duy2I1O6Y8orUoUkBUfFe8vDvJKPCUkTqrAXy2eS6Cx40zr5a4Ld0PO6FsQbbLWIVdZiSClzssK2c9RSkTlTK1yPzwBw0YBArG/3vzdVF9sNr04nyv0Dj04TN8cTxEA0kegt3hbsrKyq7NcjH1w+wnhPKZX9KbO72CJrwmQYTKTzvqUy+4G5VKKBqawc60pFebXO/HA6EoCIozcN5b5fZ6wTthhM9FTjkWKhi2w3Hbd3R5bcOv2JyrgZOB0qc1lJkpnTgnOWacq8cplgLG2+0KS0MXpmFLpAry04TGqTls3SknZVBFsFdZUuRlwVXLCUagj6xZpuP7Er9dWnLwgp4VTJdcUT6RC8q2zHyGXfYUT4watb7qVy/3DEW6Eo9HHH1nuyJG5OGS0FFUWd57rzOO8oKVNr0z89HiJf323YT0IIlojBVMtSwAk467jNK523OGOZZ+E7H37C159cM50KuSpYcM41JCKWKSiiBZMazunpOHJTWtcL2zRd26HnaxdbUOVuXrid1xZwYx0gHFNlXtsEYyQwGMt//x8+5BfffcqzR5HoYPMFzRpv68ev333+Eief4UthGyxiO7xYgjUM3rPrPQFhOsL/9bf/b3ygC7VkCoaxbzi3eVp5mAX8JTEEMntiB94PLHNlXisqymU38LWrDcdVibbincE5j1Sh2Dbeu80rQwjYaFhy4bufvODrpwuOGapWnKtYsdSacdZy6g0HFVgqQeF60/PEQcqJUhWP5ZHr+Jmr9mh8va7sU2IRQYCHVFh75XZOJBFG54jO899/5/f4xfee8kHcsXGwhLemtTdRL29uKMuKlsJoLd7Atu/YxcCjsWMMDtHM3bHwne9+HzPtSWmm1soQezbOs0gipZZrYq3FEBmdo/OVqTYmdcDwyDuuho67eeXxuG2kQW1eD2uPSIZ7hMFYoguU6vjdFze8f5UopelNrbEsroUQxuBIXskoU824DE96j1hDKm0sPmLoXeTd7YgD9ikzVSFZRdLKnBY61/FQFQU2XSAEx7/6zqf84rOnvBcjMcCmf7sHvon6+NUdaVoIVbjsWq5I5wLOOa7GwC56pCqfnFbuf/hDekmk3BLvd7Fj4xyFjnltBBMLUC3j0GSGa6axx51lO/a8u+s4rR0xWLxt4VttatTqIImtbZc2Mcr3Pn3O1588Yi0tXAsczhmQFWsjhEIWYVoLDsv14FE8y9o04N47MIZvX1yCsxzWxCnNzCWRgVkSD5LZT83H4qzhoov820+f842nj3ly9jdturfr703Vy8MRNBGMINKaoR0dzlW2fdPpaxVe3dyzXzOb+cTZJssmDg2BDa0pWwSpTd2x6To6IpMspCzYrPRErrqeNWWCt2cfUZPPLEjzPFGINeCtQ23m07tbHq9bjrmgevZ9mI6VFWct1TlEK1oyPlnGMfAOlikLGEMMnsH1PD5z9OeSyEXIVTmSOUwLo7OccsIqLXsJy/c++YT3Hz3iyjk6A8MXPIN/Yi/833v5issYeTR2iBWSK+SlcpLE2A3sosVbCH7gvSeX7OeF4BTvA14qJcMhQ06VMXgudoFujEipzLlSZCWZivWBbddxOe64GiwvH/YsOTfahCqLFcazj9tURW3TIb4+TCRpHahaLb0LXA2OvaxYaxhdh9ZKBnZd64pF7xirxzoDHraqPBku8AiXfc/1sHIzNSzUIxxHyc1sKUIRZTKe7WB4WFa2syfGwFLfXrbeVH14c89V8Dzum+nrLp1YpHKqM310bIJtrnpnCfPK0ULrXRqyVNZl5SQGFWFIC6NXnoyO4ySsS6WURDUN0XUZO66GDZcd3JyOrLliSjM9Sq10P2IJmDaUdEReThNzLmQfMNbSGdhYy4EWHz7YAFrJauiDx/tIZzJb588GScsVhsuzJGfsIqdSeMiJhzkDgfs1gXI2IAuDK2yA22nh8tQhsWPOfzifz097fbI/0UvlMjhwwmQzvvY8LIkuGLoQ8aYZIl/fvqYzYGvzk2AtUiuTVFIqGGe46D3jBvYLzBUk1yaH9I7eeZ4OA1ddT9FKqZVSYcnC9KO1RCOqOFXEWJ4fZuZUkNhjjSWcyVLHXNoF3XiowqqV0XmG6OikMmDBgrGGC+d4Z4gY4LKPTFI4SuKYDRTLvaxw7oRhwFfLzlTuTxObwdLHQH4L6Xkj9dH+wAg8iQEXDKuHcDbEztkxOIfD4XEsdeVuns5p8xE1sNRKqhWjsLOeXeeJ0TNlSLmwlEzWjLWW0bvP979DSpRaSAq5ClUsnZy/KRVyNVhjeJ1OlNcG6XyTiwl0NjMJWOfZhoFqStPyd54YHC4XegzWOLzzRGO4GnY4o1yEyFwCx7TysCp2LZxKJlQLtVKozKYloh+mE6MzdO7t+nuT9erhgYuhYxci3hgITSO/iNDXSq+1NVFDYGtGTilhrSFYh+ZMzo6FdtGNHja+5ZJkbUbsXApg8S6cm7ADm65jXldSVQRFpCJiCfzIV1SpalHruVkXxChrBqQSMIyxARMAeizVGIIxbHtPCAFZzqFvDqI1hFq46jYYAmOMpFKYc4YVxHrmIp9vgen8LVxZxzFnuuQJzram8xeon9gLfzXKjHCUQpcL1rs2sgOyCFkKOEMXI490YH86sLMWp8LDOmEwHKSQp5UUHWIMFz4gksmipLSyCb6lNKZMFUOphYdlRXLB0saGh1KY0WYssw5rHQFDMY5qDLuxZ1qFNRUwHaor6mDr2gLtrONy3PD8uOdYCt4YLkygd46BdmgHzaTczBqrlGby9W106UxDSBUVMspDWvlkPrDbRq5D/Bwp9bb+4MuYwlyVQ2nJd6ZCNc10mIuQkmBDs2z3CFOpbJzBouzTitXKXCreOx6mCZFM7w1LrtTimHNi23k6b9CloBWSNNJJyoKphSKNm68qNBaK4tQSsGR1qDXsukDS9j1Z28bSOMPGeDyG6BqG82FZWaTiLAzWEYwneOhd65iVc2L0nApqLCH2ZNM6bb4qyVSqNRyK8HyauN5usLYlUL+tP/hSVVYVptrGy0MYSEVZirAUz1oUnMU7SyiJpSija5ehQ0mYFdYMoQp7C6sUvApFA8Z7Us50zmI7z7KsWJq86+7UjOQopKzM2h4S0KLno7EEa1uKdDVsQ2h7VC505z3SuTYu9wS8NWy7wH5JpAqhKtFaOmfpHXSumT+NKrMoeVW0GrxpKc7WNNhBroqq4UihzBObpeORcVR52/R4E+Vo2ua1Cqk4gmnY6CSVKQuDE4JVvAGvcKpKsAZrlKUkKoqKMkRPUpiKIq6SajNm55oZg6VzhmVu+19FWxOjlPNnXlkxWCyiQi5KQNuFjpam2wdPzpW1FLpgmznSWIL3qGum8Ouh47AmkoBBCRZ6a3HnM9hoRjCItq9jqsNYh1fwNBRjRrFaOYli5xPbGPFdQ9q+rTdT3jqKtnOxPzcmUqlIUdbU0rqtAesdI4E5VawaXIW1Zo4lUKriXEAsZFpOWqlCVaHWSucczhjmnKmirLVwSpkiFdFmmk1VUKOoKoIhGMVWA8aDGsboWXOT1RrzH8dSvXMY087gyz5wLE3irUbp1BLVolIJNmIM5NLMwrNkoOKcxTqLVUOulYTgjOVUBbsubILH2Yj5gtFbP7EX/tBHMsJJhGFVggsIC8E7qrZQhXxmm47V8EqVjTZs0j6nRriplXVe2S+G49lwE5zF2kpKicuxJwbDzcOJeS7czAdu5wUvSodhKolTEQqVaAzRKYM9H77jyKNtx9Vu5PVx4mY/4X2kl0I2JzbBMzhP9J5hjOSHZrg4msQmODauw2FZS0JUuJtnXp5O3Mwz1kZMjFygDNaRXeXBJOYqLEW4SxNLfYQzjmjethfeVEVnWKvwsGZGE+hsADLOWCi1IbuqoKJ4SaylhQwZoxzXAqV153sNzKXysKxcB49zFgdMKXO9CcToeX6YWVLiZk7sS5P5kDJTXpkMLFoJFSKVHs9gLCEMPNn2PNr0PKyJ23nBesdWI6svDM4wGEfnPLuh4+50ImkzDI/esfURRchSKSrcrQsvTxN3y0rsN9SuY2eEaBw5VHzJZAsnaVOAqVSuAGfennhvogLKTOUgyqYGLsKGl2UBmnnylArJNWBB7yxTbtQGYwz7ZSVJkwKipsm0tOJLYdMHNtsdS8lcdo6dWj7bryxFOMjC62mFUvHaiGEZZalt2hiwbGiTrSFELoaBd4aBk2TuasUT2BqoLPTW0FlL7zy7IfDysJCrIWtD0vWu4TSTNLnHVAsPa+JhyRgbwVl23pwfF9r2YgN7rcwlM+dK7RTD2wfnm6itcyySOZ274j2evZ5zHrJwMCveGhSHOZsJnbNgKlMqzFkZDAzBc8yFYy5sisM62+SvtbLtAkbheJhYU2Ivmf2aoCimKrkWioMF09aJKr0oTpUxDFwMPZf9wL4uPGjCuoFOM9REsLTJk3MMoeNmXsm1OTo7A+GcbCpVKDWzXxdu5pmHacHTkb3hkXM4YxshqIGGmEUhZ9ZaURT3Nmn3jdUQI1mFuWQGa+ltYLYFU2DNGVQItnXRnaE90ozBoI2qJIVQARuafEwqQ8ntIk0jPA3eUw3cnxLznHkoR5b1HKJ0bqQlJ4gxiCqx1oZCxrCJHVvv2Ywd+3XhMNdzcnMjnQXr8M4QnGtpv/PMUiveaEN1V0NWSKViTGFKKw/rzD4nOmup1rILHiuWlUJRaY9iFWLOlKoY06TmX6R+Yi/8N4dE38EQPa4aHA6hMFhLTSsPJZFQNi5gc2JrHClDzUqHZTErujYndbUWa4XrCNAoEPtaWXMBYyjBMhfhlDMJAeMwWKYAXi0dDc3ZqyGoctDMt4eOR8OOYGEXHDp2hBC4dDuWdcZjGlIzryRVrpzjm+PA3ZoogBrHqVq+//xThhh4mRamc25ALu3B8WTs2PmepVbKeuL13R2/9Ogx1jm21mG0vTjf1pupTw8JH+BpF/AmkMpKTpkY2yFxWpV1VXosbl2wWBYs0Rg21bIYRamYlFkVtl3k6aZJIyYqUoW82qb1s+G8BgvJNra/estqHL4qj2wPJREwRBvR2POoj1zGkWigN4adc4TgGeOGY0p4q8w5sZ9npFRGLO8OHfuSyRiwliTwew97YhFe1IUJwUeLlaZHvA4dQ3RkBZ89Hx73fLPf4hyMzp5jkt5qWN9EvTotYOAytmGyiJC14KNpF5QpI8DoHesKBCiuohUokEPBukrKnrUqQ4RvXDf5lnWWE4KWpo/XMwXi9XEma2twWG2fq7eGGNpNr6d5nFaFZ2PPpgtYFZxUehyxD3Q1cshCBEop3KaZUirOKZfO8GAUtS1JfZHA84eZwVvuJDNrJXSGlZY9cR0DG+NZBTCZF+nAIx+JBAb7o0P+7ZzzTdSr0wm8chkixkZSzlTXGg4pZW7SgsEw+siprNhgEGtZKs3X4RQbDbkUTlnwFt7pe0DAKA+5sOhZq289CXh9mMFYOmPwDqqxRCpiBV8FU2gZEabyzasLxhjafusdOkRCb4myYZkatmfNieOykoplFmUInpyBs/TSWcurh1sKcLcuLFKwziMYovPsnCG6QDIGp47Pjnu+5neMxjNYjzlz1d/Wm6mHecX4ytY5nCqzCCKC845UE+uqQPNlSplZ1UOwOIRMwawTwQ9kSSyasQYe2QGkIt42Bn8u5ym1QSjMUqjeYaVNNkPw+HMH3aDUWllrJhnDk6EjBo8zls55JHRYa9k4x7ysrWsvwiyF5ECkSczhjOim0lnLi4cbnPecaiJVobP27FkQolii80TvQA0v5pmvbzYMMtCZHktAv+CU/Sf2wm8RDkvC5MxlbbpRLxVSYbWBakNjAHeOtMKBI53vGF1kQ2YC9s7xXuzItTAEx+WjKwCO+wPVG+7mBcmF/bryyDrKSUhFSXYlWkPE8diBCMyxfdicF4ZzleAch+nE8+nE3bpwlTNfu37Kk90FVSv7nDiUgpTCJIXeeb4xRqrCy3nm4KThmCZ46iNPXBt9floLl7bj+XHm5Ct98GyD593rDX/qWz/byBu2BU8sRf6Xfoxv67+gdt5xKpmDTOyrQUQgK86OrB6ya4dVtIFpDRzJgGPbbXj0aMv94Z6XKXNN685vXcfVo8v2xacHwuS5WxbWktmnytMUcGLZnw4UbcZbQ+RdhA449QFrHb0fiP0FyAHnLLfTxMvlxH3ObJeVbz1xXI+NDzxJ5aAJVzITlU7gKR7NcJsXDkFJqYAU3okDz1wkq/KirDxzW17OK2GFzRDZbTq+YTv+5NNniAjWegrKpG/X4Juo4JWTFE5JmfAUSVAtiKF2HudaN8tZC6xnjr1l5z2XW3hVVg4Jrq2iCJ3reOf6EQD305Fa4W7JFCncl0LshBg9d6eFIjDgqNZyXUEsaG8aGrqANY09vosd67qyXzL7Iiy18uxiy4W3aK2N8a8tvnmfwNnKkxAwFQ6LUOzCXVImKzxygdFassKdVJ7FwIv9ijOZXR950vdIEv7ku1cAxDhgrKO8lZS9kQq2+cgeNLNxpaECncWI4n3EWos1hs5ZSqk81EaOu/CWqwh3KxxSwYQKVPp+4PrREwDm6QHrAg9LSxpftHINdLuO23khF9jgMNFzkTLJK+o9NVdqakFwIhXnPMc18TAvHNaVkDPPrq/YSUDVsZrKtC6YxqEiYvHW41CmlMk4RgezNwxUGhsKbp3ySAwfpSPeGi76kethJNrKLz16hkiTaqoqIm+n7G+qvGnZHwcpBGmSsBWIAtF32DNaswNOOCQpqpbOBXZBmKVSKBQRqq3EvmN3sQMgpQOrt+zXxCyZ4pQiFucGZjk1OSwWEWkekggSPSoVI6U16qTigHlZmdbMXDJLl3kSt1xvBlSVRQtZGkoUHBEB/NkbB0cqEUhyZMSzwVJQbsl0BF7JiSCW0fdcdCPRWn7x0TtkQPFkKpkvZqT7ib3wV610tmMXO3ZDRGrlJk08cgZnCpVmkBwZWMuBnQtE67gYBr726D2MJH7nk085A044Hle+++FLvvXsHT6+uefFkrC1MjrH490WI5VjLCwlYaqj9x3vdj2305EHVoJ0ZBVWTQRr+eTmyPEId8uehGCc5VVZmW8+5r/5mV8gOMfruwde3t3RecO711fcTwv5nJIWnWVjLN3jKzbe8e7FjqGL7JeVF9/7EICVwvPjzDYEfvbqkv/mydeZ1yMvHtaGszOGaVr+UD+nn+YqxuBDYPSeizFQiuUHMvG4TAwpYqtHDaQ+MFEZ8PhqcEZ50lseMXJ6uSK+mX/ujyv/w4ev+blnl3zvsz23MmPE0NvAO7uOUAovSmaSAmq5sh3v9SO3y4ljVZy6Rrw4TXTTnl3oWJZb7pYjC4I6S3ZCvrnhf/8z3yQ4x93+yM3DHmeED5zl1SGzpIYgC9bSG8v26oLOVZ5ud4y+47Ss3H/yCd45TsvEbRZ2KfJtLvhjVx+wrolP9yeGvqOLHbW87bC+iZqkUXIuvOdx75il4/lpZls9nopxpnWW4siaMr40zakZHI92gQsJfHhzpJg2gznNid/55IGffe+ST+8XXq4zUoTeWp5udqS1cHNauS9tWnXpI49dx20uQMUujkWan+jCL9wcHXkVXqWZ1VSi95CUu8M9P/P+Y5w13J1WbvYLtlYejx0P80qSitoKQVmqZTc4PnCGZ7sNQwhMucDLA5vxgpv1BfuUOFH4ejT83DuPAOX1MjOUisGyn9c/5E/qp7MOJRGi47rreDw4khQ+nAsbDDE4vDct9ygGZF3xVILAtut473LLkzXx/Zd3ZFsoathPie999poPHl/yvRd7HmoBrXTO8ij2rIe5pe6mmdlaqut4VDwPRVkl0XUdCcNqBOdgXTOv5cDNdCJrI6t457i7u+fnvvYezlpuD0duHo503mJd5SFnTrXJ4qL19M6z6XseO8v1o8f0zrGsie8+fw1ERAw3KTHj2MWRb+yegFTu5hMxdKgqh8P8h/xJ/fTWfZoZO8cmBDoXERFOdcUhVAVXTAupOmN8B1vxxjDEwLNhx6rKD16+BO9Ra5hy5sP9nqfbDR/dzSQjKIr3jgsbmdJMAeYlYQ2IDYzON+9JboqPimVGsCJsSuH+kDnKykpBndIXy72c+PrTd7DGcppnjqcJA2ydZU4wnZHy3lp6HG4ceOzaozIEzyln8svXGDpmSdxJM7iPoeeduKFKZT8veOdQWir6F6mf2Av/iCcai6/K7byySKKrFlPAUPBqCJ2DXJirMIaeaC3eKSEYUMtsDM5U5EfM3SIc0syrJTH0HleViGWIkWUW+lix80o5B8DMptL1ketkULXcn80bFoNIxtpzsE0tZAURQ8yRf/fh7/Fos2H0He9dXwEJyoLRCtawAKtWdsbxtasL5rngbMTbgLOZSRKXtuOuZNZaGNSRtZEGrMJUFhCPtW20/7beTEWjLXZdK6/XhSkrozEt9bYUQImxQ2omlULfdfizhjAayMaRRHHWtqRJmlZvnzI3aWWMHXiDt5ah86RaCZ3Fp5ZwmxFmkxmHHlML6jypFpJWXMkgBru1GNv4v1kFkUpf4d9+9CmPxpFNCDy92JJzJqiiJmOdJ6uQjBDxvLfdMC8zzlisa1Ki+1K4GCp3pbBKpa/CWoXOG1DPopWcErEqUt52WN9EDS7gjCJqeJ5ykyACDtBVMKr0faDWzEQhhkhnLdHB6Nt6mkXJVqnnZOgkwjHNvDgt+OhwAby1dNFAMkRr0WpYqZyqcKnKs6tHFJlB4WZZWdLKArgCdIVdMPTWU51jVsGlyr/79BXXY6QPHVfbEXKhj7BfZ4KxFGNIKnhR3t/uOC0rDouzDuMMB830sjDVBitYtbIUaT8TW1hqZZlXrLGsb0llb6RGb886d+HlPDfDf8sXZ00Jo8LYdZCFZDIbE5sB0jXDrElC9mCraVpjbTLaU8rclcwmdhjTcJd9tMyp+QAKShbBkNlEz3W8INcZwZBkpVBAKqecuAyOiz6S1SNUkiZU4D989gmX/YbOB65323ZR8yduSyJaj9RK0srGKE82I8e5NNO6c5jg2JMYfSQvYHFtWloTH9hroJ47xxmH+TyV/G39wVdP2+9yrTzoipwlzNYYRAUw9M5S60rOhd45Ao6oLdPDSKUah5om36lII0SlzKkI2+jBKAYIzuFok/VCY+E727CxQTzOt4jbrEKugnPKSTO99URnsSagVErJTKXyw1e3XHSBznsuxgGplZILx1SJziP6H4O6ngwdJTXJkTUGY9ujYqQNVdsdQkk108eBfJY3BW2Bd/kLrsGf3Au/7wi+JTfep3Tu+AMopoKrBlNh0YT1Fmeg954+tA9QLWz7AZMz1WSwltidxyg0zbO1jfNbRLhJC7MV8lmyU40ymxaF3HnPXAWpUKph0sLOCrfrCeMNVEupgqMdqC+PR6oIH1w/4vHFhlICr/YLC5VsYEGZasE7w+gd6lunztB8IoWKsRY10Pm2gRZTMd5w8zBxlEzR3BLXyttx4puqwfj2ytfKbSpQDdEYjD13tmiTqFwyzjqstXTe0Xv3OT3pahwpkknaDraha679bPSsPT6vwSK8qplFCqW2jUyNsphGvuiNYwXEGqqFSQqjd9xLxgSPk+bud8aSauH1aWodhN2Wi34kWMtxXlhVKdoenLOWFvphQIz7fP1VYK6VYhS1Bu8M1oIYwRjlfs0sKCUnTEpofnvhfxM1+ojR2vanktGzrwLbPilzVhiuJWMMdM4y2HN4n2kX/LGPJG1x7OacNC5qWM+0HWc9wRiKVh40kYxSDZ+TR8QYMErwnloVnCEb2EvBOuUuVXoX0DO61TrLIVdKXqnA003gemhEs2IaphHTPACTKL5UemMo1rX0c210okmEIuVsSmu56AUIznJMwik1+SXGIG8pPW+kNr5rOnqUh9xM3xvvMNrMjrkYiheqUZyx9D4y+EDvA+3khkfjhmlZAGmBasFTjUExBGPPEapKqZX7mljO+5OoUoBkIXjotOOQE2Lamsy1cFKBkriMEVMrkxTUtofhaVkQMTzZbLnejBgxTCZgmFHTqDuJiqHiDQTraTZOe97/hI0FMYo1LbG3qmKscj+vLfU01xaEmN423d5U9T7gbftMliqoQjQWYy1Vy/kCrmjOqDZnRrSG6CzmvAfu+g1F8ufrtHOubXBW235KW+OpFk41s6ptk1JM09m7dgn3Ykm1UrVSqZSqzFLYm5WN7zEYVi1glKUm1jRTtfJ4bJlLtRb2ZUVsxmJRpeE7tdLbwGIFNbT9FyVVYevanyNrLMaAmorxlmlpzeBVFaphLl9sDf5Ys/i/83f+Ttt8/5O/fuEXfuHzf78sC3/1r/5VHj9+zHa75Vd/9Vd58eLFj/NbfF59iMQQqc4wqbQ/dI4zv9lh1FJz5VQTXQgYB13w9L5FDFdreGezpfMRtRaCpR8CzniG4PBYSlWmXDieZj5Z9twtE0kFY5ur2lpHdZ6x74hdwIWAGseiwkkrL+eZLvZcDCOb2PGo71FTcT40I6NVYnDEMHAUWM6X/VQb53pfK4gy+oB3oFSUinMG4w0b59jGQPSWTOtIfLx/4CFl7vPCbTpxO0//q36+fxTry1x/AIPriCZS1TFpY+YaazDOYL3HOEuSwlwKMQScswyhPToroEZ572JLH9s4kWDYjI2bO/g2oZFamVNhf5r4NC88LImltkdnsA5rPQKEEM7R9RbjHCeEk1VucqGLPZfDwGXXcTn0VAsuONS278EaQ/CeU23TrkWFqQqzCKeSybkQvcdi0NpMSfb8oumDpQ8OZxsTO4nw2fHISQv3aeXVPPNq+eqMtL/MNbhxns54VA1LqaiCw6LOYIMFa1nFcBQhOEc0rdsV3LlDheGd3UB/JkOFaBl6h7WBLji8NXhjqQrHNfFJmThKY0RHZ+i9xXvLnFtKJNZivUe941AKk2ZerwnBU7XhMTvnyRhiF6lnZF2gNU6mrGQMc1VOpXDKmZMIUjK99zhjUFVUK1Wh0ohX/jxpExS1lVenheNSuE+Jm3XhbvnqyBq/1PXnOwbX4YxHOO89xtCuQg3ZOeXCSTLeeLwP9CHSufY4zEZ5Nu6IoTHOY/T0fdsnN97jbNtvUhH2S+ZVmTlIQlC8cWfEq2WuiRACzjucD+ADa1VmA/cpYWyT8jjnGGIPxp3lNm0PC8a2/cv4RnyiMiPMprLXZtrsg8Od12utTQcezme4dQbXbluIybyYJo555X5ZuJ1mHr5CkrIv/Qy2gd5Ggm0haU4drTXQGh5V2/qZRDCmZSR5b/H+R6BKw+NhJDqHs5bgHX1s6d59sG1aXyFL5ZhW7mTlsM6otsmnt6blJgXXck+ixwXXlBpVSUV5KBnnHM57cJ4+dOBtMxIb09ajDUTvEXWosySjLFQWU1koWIEYPMZ69HwOGwVrGwlKUTCgxlBRDvPCKol9mbjPJ47pDUl6fumXfol//s//+X/8Av4/fom/8Tf+Bv/sn/0z/uk//adcXl7y1/7aX+Mv/+W/zL/8l//yx/1tCLaxv6W2DzA6wymB1zOZQRXJghgIBGx0qG2v8MZJt2wCnEKjiKiDVQvH9cj7m5FN8Hx0f+D1YSJUZXbCrlrseaPZOs+zboMCf+zxBWs1/LubV5zKC4IESoLHw4b/6sljuuCZSxsFfbi/QVd4ut2w7TpSyRgFkiOoJ8mCVSGqYc0g5UeTB98S1rIw4qgBwmoJOLTCaV65Pxy4WTNzzoipqG2Yqa9SfVnrD2hrSiquWDrr6F1gqYnORgbTSDZrEaorWDz9pieEiJrAopbkLEEF79shKa5h5o5r4uv9SN9Ffng4cDuf6KSQg6dTiD4yGseF9TztGtXnG5c7tFZ+9zCxPlSKXSlJeLId+LnLC3znWKjEavnB6ztAeDps2MWOUpuGW4pnHAaOmilrheZBBhqLX7WhztaUuAjt5xqldRuMVI7TyqvjkZfzTJbCXBqqTt+uwc///g90D2ziHbyzjD6yrZbFK71puFWrhlQKp2C4wDUzomuHUVUloWyD45QCYgXnDdYIpQhPxsBF7LhZV26XhZoKhywMVIKF0XkuQuBRFwHl/d2AVENMntVU5mkFdVwGzzeuNnjnmEuh84Hn9UiMgW2MDMFTFLQ0c3DX9RyXmamsZCmobRH1XRdaUGEWSlEuYmyRTrYlZQqFKc3cTgdeHmeONbGWglSFr1iH/8tafz+aZAbruDgnya814Uwg1gpaKaKI8WSbsK4HTe2fqUdVMV7YduewSWdJVglr4rrv6XvL68PMYV7QUElGcVkZTKD3kcsYuXZt//vaZuCD7cgn88oP9weUhFO4tJ7Hw4D3jrVWuhC4M0dWYBc8m9C1PUoLaU14H1jKxCQJrfAj3kAISkVYUyWnwtb1ODGtyWIstSr7OXE4JqZp5VAXWmZru3N8lerLPINDtRgFsZbOdXQWJl3pqgHhnMRcSN5RKezcBmMdgpIUKBZrV8booVaqhaQCBS5cT7CWw7KypkKioNVQRVrjzllG59i4CBjeu96iVfnkuGc+7PGiBOvZ+cjF2GGtYSue0VourGUqlk10DM6QRBDbQlSbRn9uNCBVbAVI+BBxOGqp1CIMtqMUR6KFKUqtnNbMNCXmUkhSyDRJUMlfDJzxY1/4vfc8e/bsP/vnDw8P/P2///f5R//oH/Hn/tyfA+Af/IN/wC/+4i/y27/92/zpP/2nf6zfZ5/27HxgsI4xjDjv+DP/1bf4//7wE+ZlBWMY+45JVvZOeIzl9rTnh3e3TGr44GLkwjk+vj8Clc5bbpPAuOU6boHM4+DpdwPqHN+2lq7v+N3lxPNp5vuHO/4/ty9JwFX8OTZDz4ByZSI6wP/p2z9LxFNdxFi46IWUlGdxS/KV0ffcPEx8f37dNg9A5hWrwmg81sFDTqzrBE6oS0v/G+j43+6e8vG0P3OrC5ex49lmy/PbA6/nI8/6Dc5UrDVtpPMVqi9r/QHs84kr1/E4BC7wGOP4b7/9c/yHzz5lTpkQDLshMKXCwcJYldtp4qO8J0nl3bEjWstHhwNald45Xs17LoaRR2MHFJ56xzBsqFZ4Blxvej6cVu5S4eM08f/+6Abxhl/132TjPbUIVmHXDfyFDz4APMO2EVO2pbCq8M7YsUqhQ7m9O3A/rQzR0wHTYcaqcGUiwVkOxnA6LegIkirWWTbG8V/HHS+nystpJWnlKkYuQ89+v3AzJ97tR8ZQsEYpXzEN9Ze1Bg+6EKJjUM9G2tTvV771Pt95/pq0Zpw1XDjLuiTWWFA8kxRu9sJhrVx3kTF6HpaMIGiG/VK5vobrfgCFXpUrDHEz8E12dB18vCTui/CqFP7D6xfUqvyl7l0G6ynzQl0L72x6/o/vv0NfO+ibN+kKx1oSz2IgASMwHWc+mxeib8Pkw3TEqeWx6XEeDmuilBkfHXnNWNNY/99Uz6uUmVIzCW+dI1jLy/2Jm1zopVFcYnSo+y/9RP9o1Ze1/u7LxBADwTj66hhN4Je+/Q3+w2evmFPCK+ys40QFPN555lJ4fZiZHu550rV9aRYBaVrsOWWury7BO7QURluxYySEjnfWhe11z4slsU+FF+uJ7x5mpCpDfJ9d6MlpQWRl7AN/5oP38bSHCMaycYaCNC8f7dE6LwufTfft5wbs54mohsduhLOJc10TALWefSQK186yTzPTnCgKF7HjehN5dTrxOhW+NmwQBy52GPmJVUa/kfoyz+AbZjocHY5LPJ3p+KUP3uGHL29YUsYB0RjaSrP00bCazH6eKYcjFz9ag0VAKg5hKko3bIjOISrU0ILaRnoeFegvPK/niYeU+WRaWOoD3je55Bg8pjZssQ+eP/3sHaCD9iZgo6AJrF2xvqVM3x72TDnhfGw0oXXGAVcuYGmBiKcijKRmSLaWHrhAua0zpQhFFB88IRherYlX04HHcWA4733pC6Kxf+yV+t3vfpf333+fvu/5lV/5FX7zN3+Tb3zjG/zrf/2vyTnz3/13/93n/99f+IVf4Bvf+Ab/6l/9q9/3w17XlXX9j+OI/X7fvrHqWJLQDx3v764pBjrnefZky2kNrKXp7d/VjoMpPD9Mn4d/9N4xTTPj6PBayFLZJ+FUhY0N3BfhYV0ZoiVuAvvjihGYa8ImZaiGxVomaQlp/+b5a8ahYz+tHNfC6HteHk7s4ob7+R6p0oweqpxOEz88HnhvGDlI4WZZ+Jof+NrjJxwc5KVhmpKxqEQ+urvDPDR+sXWW4AxI4U6EGCw1G1Qra8nczCvJwu9Nex67yM4Hylesu/oHvf7g91+DfQktG6GPfOtixyJK54RvXGw4pkwqQhXlqVUOfuVmPlJrowa4AHdl4bF3WAPZwF1JfLwm/jfR8/pYOeSVrbd0veXmmKEWbDZ4hdEFUnTYM33l//XyNdsYWthSETZj5D5lRleR0jOnlel0RIGche/t73jqPceceZ0Sz+LAzz3a4KMhLpUkwmodtuv49HjCnCbUgw8tuVVQJgdjdNRcUanMS+IzFsQIPzisPO06diG0LutXqL6sPbCWyiKFixD5YLchYeg8fP1iw8O8skpGtXIRPZMTXh0nnD/Ld1yLlB8piBNyVdZSeUiFbrS4BLd5pfMW33luTjMjFmYI3jEax2ogtEEQ370/MbqOh7SylIwPLdWyRqGulYSyViWlzKmsfLI/8U7sOZbCTUq8G3u+dbEh4plrZqalOau1vDiumFPGesUHi3WOyQvL1LwwKm1sf0iZG5OQznMvhZ1xRDV8QSLdT019Wetv9JaiwhAc7487vHd45/j6xZZDSixF0CpcEJmccF9OLLkgCtF59ghXQKZSLBSprHNhHFvo5LRkonV0Uflk3dOLZZlmehvIzjCL4vD01vJ8XrkXx+s1cUyZq64l545+YM0TWSpZDQmwufDxfOLKOaZcuM+Zixj41tAxWUsWJWcBY9h2PS8OJ8zxhLUOb5v0wzlHsUJnA6tkchXKKrwwBZzyvenAk67jAsj5qyNphC/5DMa3LjiOq26DcZVA5NFmw9S1z0VF8BKAxCk3BKfUirWWqUi7FJ/piKsqc0o4F/FFKCJ0oUkVX68novHMUhlsQIJBjMFmg3OO58d7uhi4T4ljyWxDx/2a6LwjHxZSFZI21UXVyov5yMXZ/3mQwrXAbuzxq6MYIVkFNQyu4+Z+z60B9b7RpgwU71jTSsCyUMgVcoF9OoCzfJonLsUx4ChfEM/+Y134f/mXf5l/+A//IT//8z/PZ599xm/8xm/wZ//sn+Xf/tt/y/Pnz4kxcnV19T/6Ne+++y7Pnz//fb/mb/7mb/Ibv/Eb/9k/11pZEVYjDGOg7zYYClebgTF2HJeV+/mEdx0+T6RaGjfVWtQqdymh4gnGErxlYwOPz6Mn1wUClVIL05J4vU58MO6o2nSy1jTTx8WZdX2UzDrDKa0sUggl8DufvOJqOLJPUzMsuYCUFo5znzKhTnAORGou8MJuHBBal8M6y889fcr379vPpkhtqETneK8fccCjODB7RyqVl/NCcZWvbS84nRbe6Tuiddyevjr61Tex/uD3X4OlFhKVVQM+Rt7pO6RUhtjhvGdaEw+nBR8ar/c+C961A8pW4VgFo4XOKp2Bnfc8sz1gCdHToxQpnHLitiTe60YmETJnqkUt7GwzYM7nxOc5FZIoITu+e3tgdErZHxERtBSqaaP0k1Q6W6muxX57DAUYug4RZc0JYw0/e7Hjezev4Jz2V9eW2vresMPkyiPX0eFIUnmdMquFn73YMa+Zp8NADI67r5CG9UvdA1UbW99aYt9xPfRorWz7gHOOU1rZzxNDFymycKuCr43uE6xlWhPBGCQ3c1vEMsbAvFQ2IRBqACq5CLMou2hZihBQas2otKBDxfCQCkdTOaXMUoSti/zg4cTYzS275Py9FimIViYt3JeEMYZN5xBbMMDYRXSFSTJYwwcXOz497BtMIVe0KNFYHncbqheurKf0jlWE+zUjCt/YjiSUax8J1rPPX50b/5e5/ryxFKNgLH0MXG031FIZY4f3ntOa2E8zzluiVO7PIW7eAAL7ZcbHDlMzHqUzhsddoKSK7zzeBURb4OWchSchMlMxVfAKnbFsg8Xg2S+ZYz7ycM4tqZ3nB4c9WzOzaCajKBasx5zzaY4IxsHOeTa+O68/h1fPLAU1yjeuLvne69eg2ljtZwnd43GLFOGRi2x8o+TdrQtYeHp9wf6g7Hygd550nhB8FerLPoOdqSgGYxUXDJtxQBDGPhLEM6XEsSz0zrFWw5yXhmw3BqOGeVmxvaWYglrFG9Myl0QYvEOsodTWAFuysus8RRtG2wK9NZjQAtYmEaZFm+9NlBqUD097tn5mypmiihqDnrFNaxVWNTinXDj7eSL9tuvI0vZRNYYnF1s+urkHhZJXtDRQx3UY8TguzkFepVb2y4JaeNwN7GVlawMemL8gvOXHuvD/xb/4Fz//+z/xJ/4Ev/zLv8w3v/lN/sk/+ScMw/DjfKnP62/9rb/Fr//6r3/+v/f7PV//+tepVanOUK1BLXShjYQ7H7mfJu6mlWkpjeRTFO88WhXB4Gvrkh5zZhcCmWZCfBIic8poLqRaSXNiXhcWyWQLc2rm4IsQiM6yF6U4mGvmeH4NqqnMKbHPmVkyWgXUcLCZ3jbDsHeBWZVoobMWVeVYVrZ9T4yRXRWyKqKZfWporyyFijKGiHeRb18HvvtwQLXRBE5acMbwjc2O2wKgTCUz169O6NGbWH/w+6/BnAVxTSKs0Nz90jStd8vCzTS3DcU5oGKtp1F3Gg0gCuxl5tLHRswBdi5yyAXxbaOpubDkQlKF4DiUlYBj4wzBGmoxpAprLSwJSq2oaX/A1zxx2TUGdilCrRBi07x661mq4i30rvkN9lnYdB2d27CrAxkl5cRJmkxo1tKMkT4w7CJfuzJ859XctLq1MtVGYflgs2FPk9UdS+HwBQkBPw31Ze6BRZpUBm1knt5bVCveWUoSplJZigKCreCdw9jmuVAFUw37XHCqpPPXGrvAPgsmNJJZKvXzrqyxhpMqG1F6Z7j2Lc07i2GRQtW2/jCNbPZKZjoxmGpYVMkog28z5t4Himnj9tFaFGFWoQsNYbfTiKAUqZzOHpOJgqJsXWAMga9tOj7KmZXKosJshGA9z/qe43mCPalwlLd74JtYf4sIOI+zHusc0Tu0KM455nVlPy/MueBQRCoGB7X56wztXH4widEailSMc2z6tv9V20Kr1jM4QGtjks+50eeis1y4hjlMFU5rxpCRWgimrcOXy8RqI9UIpbbL1tiNAAwunrGZFW8NSQunauliZOMcO9rkYSqJSTLGWrI2atDoLH3o+OAq8LoWtLq2T5bCJngedT0mNaLKqWSOb/e/N3YGryp4At44rDV4FzFUoncsqfnNchGwmXxu2Bp7tpWfARSHXIhqKKp4AxfWcZLMqo34VESYc2nnJ3AshWAdLjjGatCcydoIjFBBOeOLK7frjEhhrY3aYzB09ux/+xFww5i2ZhFWEfoYGfFsK5SqLCWz0PawohXVihqPt55nmw0P00JBzlSgzOA8V12Pru2/dwXKm5L0/Kd1dXXFH/tjf4zvfe97/Pk//+dJKXF/f/8/euG9ePHif1bv9aPquo7urLP6T0upOOMwxjbDQ10xdsQovDie+OT+gVCgiyuRQB/DOXYZBvV0VrmviYLhQdrocSfCmgoPTC0BbU6sa8JFQ6qVfc48jQPbvmu811S4JTOXwlIq4UzAmPPSJA9i2JlAqoW5ZMLYaAFDDeTamKrRGHLJPJ8nfmG74ck4Ypzjfpr59x9+3BarttGpsY3J7o3nZx5v+J27e6aSySqoU4w1XIeeHBY+mU4czti6r2r9Qaw/+P3XYM2Ctc04mYuQSmE8GylfHk58/LDHC8ToGG2g84FchForIQY6cXyUJop1HEtGqQxemNbEnRZsVVypiCgWQ3GGowrvOMOj2J8vZIW7JC3KWxTvDME7UhVqLfQaCdrQhKsIxpmGknWRVFZUBW8NWTKvT5bd0PFk2OCs4z6v/PuPXzSuv2gzM5kmSYrG88515N/cKHOpDVdr2gNiFzwlFJ6vC/c5c1q/Ogfe/7Te5B5YSpsY2QpSGs3mR0Er+yVxc1opWRAtbKxldJGCoFWxRhms55Ukdtaw1tomR7btdblkvFZSKcxZqEA1hpNCrJXHMWKjJTNzXytJCkUa8aTzlqKFE8qcLRvXcHVZlV10RGuxdEy1NEvZGbN4UxLvDCOXocNZyzEVvvfqngXFqFKoONOSULsQeO+i56PbAzkVsgjVQN85LmMz+L5YV/ZSWL7CSadvcv2d1symbxr+yvmxdyZp3h5PvNwfsc7ipOUnxBDIRRvowDfIwbEuRNszqZIqXOE45Zm19TeYS2IqGUOTEc7SLujXfWDrIOfCUoW1FMz513jvKFU5ScZ6y2gUU1sn2BohOoel55BqkxPVTKor6kfe7wO7LuKcY58z33n5krkkXIgY64nBM3ae0UUebR2vjgfWpX3vAnjnGdSRfOAhZ6ZSmPJXp8P/P603fQbPWdj5iDcWBUTAu4pRw2le2J8aZjUVaQjps4rDqmK1nZeHJAQXyLUFE1ZnWCVRlkLfd60Tf0ZaG1HWLNjOMcaI1/ZYnXKmnDOYgvONi18rszRlibfNXKxacaHijMETyUaQKhSFZIS9ZN7pey66iLWOw5r5vdvP2tmLaXMqa3DGQTU8243cTQulGooa1BjCGf/drZ5DTWSF8gWv8v9FEZnH45Hvf//7vPfee/ypP/WnCCHwL/7Fv/j833/nO9/hww8/5Fd+5Vd+7K/tqxBqQUsmpYwUYZ8SU0pYagsAii1aWFyL2ba1MPjK5cZTnSWGDn+miKQqHM9hxPncyRdvWYJjxeMKWBvZdlsuxi1Xuy3PLnZY45oxpCqdQo9puC48SxUmFLzDOcPLwx5x7bW4psy0Zg5r4iSVT48T92uilMLt3T0//PQF0RgeDxFcJougRTFFmKaZT27u8LXQq2FQy0Ycg3g+vD9wOwlVHZdx5Nnm4r/kI/wjXW9y/QF4rUTaAXZcVqZS2BfYl4zVxul3zkHoEBfxpeIpRGfYhIgLsA0bvCpUIWnlQQuuVkxuXN9Z4Y5KMmCtZRM7LvsNm37Lpr/k3c0l3liM2PZAUEPA0WOowO104JAK1bSY+4fjgnWWnAu1VpLAMVcmqXw2TZySIlV4dTzwey9vGIwyYsmczbfn7/V+OvHx8wesVDqFEcOGRo368OHEtGaCWq7DwLPu7Rp8E2vQ1opVRbV1wotaMpZcKk6bjKwlxtCwmbVSk2BypUNxTjBwJt+0y/0+zVip5LUiRUhZWQqkahouMXo20RN9JPiOwYU2iaqVnCtSFUebXC4op7I2JB4NIP3R/YmSwPueTh2lwH0Rjrnw4jSTaqZSuTkt/OB2T+9ad7/USi71zN7PnKbEZy/3bR2L4BR6HIP13M4rOWVG63gnjrzbbf+gPs4/cvUm15+oUmshl8SaMnMR5iKkIk0+6x0Eg5w7qpoLiJwzcZpscRMb89yqYqqynPclkSbbqdpoKsYEwHNhe65Cx8527GzPk7ijimKCQ3xFzrIIdw4yfD3NzEVx1WOK49P9iVIsx7RArpRVOC5CqoZ9WShnMsrr44kfvLoh0qS0tSaspQUt1cI0zXx2+xpZBS0ZtPn0Ome5nVckCV21XLmBJ/3b/e9NncFahVSFKReWZUbKzH5NHFfFaluD6j0GT2i7ELXWNmX3lhBh6yK4xt1Xbez8Kg3HqrWFEioOZyNg2QTPlQ3sTGAMkW0cW3YODatetAVwtdnqOYwwFzwWj+PlPDOXSqBJglRhykKRyr0sFGlqkdvpwCen11jX9r0sgmpD3qpW1vXE8/s7cimsZ19CoO31D3NbywHHzvdchf4L/Tx/rA7/3/ybf5O/9Jf+Et/85jf59NNP+dt/+2/jnOPXfu3XuLy85K/8lb/Cr//6r/Po0SMuLi7463/9r/Mrv/Ir/6vc2RjXgrWmxMev75Cq3E73RDKSC5vafuCzq3gqIiumttCO21QYCDhZidFz7SL7mnmeV0bv+Pb4GIPhtSqjUa66nk/WGecs/RCJLuKc5fKdLQp8TGBygjMNCbrWglDIqRJHi7GwqkFj4NU54jjYNvYJ1nAErsWyTAs/XBIK9DEg2fB47PjwRln92vIFTODhtPBwWMFacgWpTQ5SEBYSdoB1bQE5j+N//ir+aa0vdf0BpnMYb1lr4fnpiDGWdb0HIK+ZkaavTmLBQRMfCGsRbo6wi54dLVWvaNNF3+VEFwPfHkcM8Hqe6TM86jp+737fwrkut/Shw1q46CMW4XcPJ1apOFUCbYNabSGnTDgHxKxW0Wi5mRORFtLUnRnVR4THGEpa+cG8gsLOB0ywPI6ej45HHhaLVUNfPQ+T8Nl8T42GXBVRsNawUFjIGGe4LRmH4/HwxTabn4b6MtegcxYbDLMWPj6cqGcJBKUyp9wMZ9aQxLI6eKiFqk3yIBi8GAapbIPHG8dUKndTgT7wzdgOyZIWBqM83Qy8PLOc+z5iXNvDfv76iiqVF8mxcYKvBlvbJW/AsC9wKhWoCBXnLQcKcnyg0oLaemNY8Oww5FT4ZBa0wsZZFuP42ei5SYWjtHyVII7bdeGz44yxhqRKqQavnvuUuYkLxhrmUrEomzO68atQX+b662PA2YZ+vT1NWFWWc6r2tCaoikkweIe38KIuZC04Ncyp4F0l0rHtO3xJzLlwSAVwvBdje+jZgIuWq+h4Ma84Z9kNkd45rLO8N/TMCJMPHKcTpSQsij9n/nYuM5XMidLIfSEy1YoDqq1E0wgvJ83E5DiWwnR/D1XZOItI5I/vOm7qgvhAMIFYKjdyYrqbIUayMVRjCM5wj7AhYYJhLhAULv1XBxP1ZZ/Bvu8w1pGBB1XqmpuGhROndWU9m1VjbHLqo6xIbY0Or5auBKyrdLQQzaJCSgUXHY/GLd5VxAjiDBtr+WxdGF1PDBFjWv7Cs4stUgp3zpKlotoC2gzgyOAMaxEmLVRg4z1SLcULWivRWYKPHFPGYDikxP1pxmkj952IfHvseSEtINYb8BUe1sSaCs51pJrJRgnWskplcWBCg9e4qmzsF7vK/1gX/o8//phf+7Vf4+bmhqdPn/Jn/syf4bd/+7d5+vQpAH/37/5drLX86q/+Kuu68hf+wl/g7/29v/fj/Bafl9m0UWLEcRl6dij7InyyzJhSCLSOqHGWyTl2/UiWipSKmwUfbQtJcD3RerYkLo0yVsdF10bcdlFElUWEwXV0wG6zYdsP7QVXhd3mkouUebQbmeeVh9PMYgoVwZ7NHkpLR9uGFtm97SO9Wo458yo3zFIW4UIyfTEYbYf5O7sNtQobt3JVwQRL3zmcGO4mYa2K1UYecs7Q2zaQMcaANvzYxfBfNKT5I1Vf5voDcGdjdDSWnXNcOcOnUvlsmTEoHoOtFhsrK5VNP5CrUkrrZnmA2B6PnYddtTg17OKGvvOYXAjWsFhlJjPYSBdhuxnZ9QNaBckTY9dzOSXC4Fhy4bAmJifUqkht+mY9w5rG0HjUF94zuMihFF6llT56XtWVrQRisXDu6D4dB5TCUFsXxDtL7x1iLVNqI1XR2njcrmVUQADTuryjc1zFr86B92WuwTB0BOsIatgBW6ec1srNNJOl+ZK8tsh15yyXYySvDikVk1tQ3BB7vFU6FGM93lkG57gee0ounIIlWyG5jKueZFeuNxt2MYI2bfaTYYtywph2wEylUXmWM4fc0Hwlzhl2wZNyxgfPgG+TVWmJzqUKowi2GKgta+X9ocMbyzGvQMU6Q+c9vYvcMzPTpEbeGZwFYytI2/MUR3CWjf3qyBq/zPV30bWwK6+WzsDgLKc18zIvpNySn60xOCyC4cJGVgK1tgTlWDzXVwPBd2hyeJuIaEsk7wK1JkxV8jmEcnBtdr7ZDGxibJ68Urjue0RWuq5nMZapJJKFeubkmyarxlroI6gVxFU6XDPv1ozYyomVrQz0OIwBZ5Sr6DCmcDh5oOI8ONcREO7jQqFQLXhn8BUokAAMGO/onCd+Qf30T0N92WfwhXN477AKvihbZ7ll4TZNVFGsAedAvIWU2fUDVZVaBRXF1srOBbwJZOvJtjQPgHHE2OxRrjiMKItkBmfxUtl0kT62BHGplYu+YyrCpXrmnDmVjHNgxOIMqAVqxaEEZ1nLylw6gvEUERYpqIGpZq6cYM/5IVYMT2JPRRhybd+zsU3WEx0nqTRhevMfQJN3NgyoobOG4YwM/SL1Y134//E//sf/i/++73t+67d+i9/6rd/6cb7s/2xtu3bp9jh813EEsi+gjT9vncUEwyknLruxjYrVkLQySyYITFV5EiojhkjrVjhxfHKaULUckiBV6Zxj8I6am9HDqJKrcLO/I5XCQxGugyecF9+6JmwIPHt88bmGT6vQjYFNHPGqzKtwSM3M8e2LHT/z6AkBw/P9A+Z8ITsVoUhmjxCdxVbIKZO8cqcJOQ8uN97zbLvhm0+uscby0f09P/voEU82my/8Qf801Je5/qAZbKtrRhznPVNVkuesNW7+EqtwTCcu+p6lVHJVclXmWumLYUJ47Acu4sAGpUrGmspn80QQOOWCiOK842nv24A5pTM9oPD6cKIUOFXhQhuL3FvLmhI2Rr7+qGfJhSm18WQwll3vcUnZ58T92fT4zuj55qNrOjwv9wegoT+n2kaFk6k4o22qJlBc5r7mlu6n7c/Ik6HnWxdXRO/5+HTgetxy3fd4+epo+L/MNbhx9nwxMfgYmM6POlVtTQBrsF6ZqjaajgrGmEYCk4wlsHGeTQj0wVC0NQtUlR+eJsjCqbSulFPPo+jJph2unE1oD3OCM/Xpumupq1kz92nBOcfXHl9zN8+ccgKaWX3nPYPrWhppzmTgg7EFJ3mUF/uJKtB5zyxgyJQfJSDVlugssXCwbXTeRtmGRzHywdWAJ/DpuvBBN3AdI7xdf5/XH+T6G0wzVoPBWsdca8NHG0MwFpwB16Y92xBYEEJtYYSnWrDeckqJK2e5CJ7iLEtNUJQP5wlfLUdpgVuRcEb8Qi2CuHY2308TKQsP08LGR6K1ZGd5yCveWt7dXHM3TSw5U7VhC7fq2zRCMvvUPB7Pxo4PHl/QYbmZJ0SVwUcWhSrKWhRjWw6EMYLFMRfBWNoDxhgu+54PthfgHc+XA1f9wHXs4QsSUn4a6ss+gwfOybPG4INjsRVjDdFbxIChXY6hELxFzwnxBVg0E6yhr5UYDYNtGN+1Nmni7ZoIzjeZmhbG4NjgkXMCNNVAVU7zTKqFtQidcXQuUIxhn1c66xg6zykLuQhG29cebYtNXErhmBKlCu9sBr65ucIBN+tElcpgHVpbkm4ylaIKWnHV0HlLztqM63Im93SRd3YXBGN5dZq5CD1Xw3AO7/r/Xz+xiRHOOJxRtCqHspJrpUjC1touWpYm5akV7+Awt3GJ0aZ9dVQWrczatMa1KlPN+OrJ0SC1Igass6iB3lqya5KH4i2LFF4cDhhjeLUsZBUChhWo1oIatn3H/tRSz9qhKETMWe9YyLWeY5uFb15dMaXE7TJRUm7/DS6Q8kq1EDCIVKYsKMoiFW12c6xzbLvI+7tLigr388TW91zHgcpXi8P/ZVZwFnVKLoWHtHJfMquWJgeEz7tE1Eaq2KdMpcmqvSg4WLXlLox4jBoOueAoFO8o2jSAGIMozaQmlrTMDUmrysvTQnCe25xIVDzNdFm1PUwvu66hOmulUFlQRuc4lYaQzbUd2SlXvrnZksTwsM6k1JBgITjWVRFrcAq5VlYRaqkkVZz9ESTG0ofAO5stzsFDXth6x85Zin51Hp1fZg3OY2x7QE5SmNaKJME1Bsrnf6kBOKc+12b9cqo4KqsKqVp67zEK9zmjpbJ6Szmbdb21iMJFMBT1SBZWhazK7bKiVblZExjwOHJV0BY7fz307PMK0vbehkdsa3TR5lsRDEUrz8YtSTJ3YSWZCs4Sgm08f9sulqU2VC0irFqxZyO5t60p82zcULE81MLWO7bBkfjqUHq+zOqMI6OsKjzkxGQqudZzt9FSqRSjDTrglVRzeyCY1iTBWRapTGVh67uGd80ZX5R0NnqLaYxzaxzRW0qhhcopFJTbZYFquF8WcqhE28y9RhvAausj90yf77tLqdiS2uRUCmsVcq0sIry32VJy5phhlvbnJnrPKZXPf33RgoiACeRSMUHbg9g6hhB5Mm4oDk5lYcDQmfN94G29kfI4RCFrZSrCooqqYLEY24y8as5rzhtWaWew0tapsU17v1IYaJPoSRqRxzmHajtLfzQk7F0gq5JKweOoFR6WmWoNp5RRowTnz7cuQ7CwCR1zmWkEdsMi0u4GxZ0bgEKWyloq7/Y71rxysAuLVappuTertH1ObVOdpDMZr2qTbpuzMbjznkf9FlOFvVsJ1hDOv+6L/Tx/QiuVwvb8Ad6sJ1ZgA1g1GGuwCrHUNmartBegsfSmhX4M3mJr5ZRXOg2spfLZcmRrAu9dPOaUM1EtplqmWhhLWwzH+QQIizZjGRaO60yqiWgcRh3OeyzaXNopN3yZgZIzi57QlJu54jyG+XQ64WmvzIsx8KCFUy28G7bMy8wmBFS0PVBKxaxKrRZxSrAO61s3pVaHdXDZDeRFmKYFvkL6wS+7VgyjKmsuvFozxVlGoDf2TH2uBGOa3rSCORNMOjUEaegwl5VDXqEashg+OU3svOX9qyvmqnitlKI7A9XKAAEAAElEQVTMtbBTg1Y4zDPQqCoPa8L4wrFkFi04DFYNzlq8qZjSjHCzFtQZTghWCqecCbZp/lDl9bTgVInecDEEbqqwl8S137JKZRDXOgkqTKVN0n5EDWiPU4dxDozDerjsetKycpKCcV+dkfaXWcY6glOSJG7Ph47Phq2zoK3zqNK6j7W2Dqe3loBvJlcHd7VRnq60o6jhk2miy/De4wtOohhtHqRZM9fGglQOS20PUqPc5RUKPKSZrBmPx6gjOod3Bi214YrPU4dVC/e1IjXjtH1vosrLdQZVOu+5GD37tVCMsutco/+4gtjWHJlLgVVaLgpK8G26aoJFjaMLgesQKCVzpGK+YmnjX1Ypjco018xdXnHV41AG47G0y1YpAgWyzYgR8IZoTMuCMI5FDQ9pRSuUCq9OE6OxvLO7ZNaE5SzLsQY1iprKcRaqtPXwkBMewySJrBVrLM4aOuepVTClUmqTHVrjSLUyyYnRWowxWAtUeJ7mJoEIgcu+R9eEqDJ2nqSe6B3VtUfMWjPlfBFUKs62wDHvPMYGgofrMLIsK0dRnH17Br+pErU4lKVWDkvzeGArg/F4a6hGGz1HQRzt761tKExtIWoVy7EksJ6qsM8rRj1Phh6piVAVL5YqFfEKtXJaV5DGsHjIK9Z1TFJYqfiS8cYQrMcbIaij1kqtgjurTKacUHq8s3jToBg384pVw+Asl10Hpu3Zg/cIQhSPNbU9UkthKqUFD1pDxBGtA+vQagh4Nl1gXROntRLehIb/y6yb/QkzNknLWtqFInqP75pTvvMGY4GHA26u/O++9QExBJZp5fb2HrGWR5NjTRPGtTG41kpwSl8a+UFEKdL007Nv3fub04knaaTznpoyL9LEB10kDB1rEZZUiKbhkiK1aRtt00MPsSVWBlGMtWc0U+viPkxHNrstvXN8lDOfHE4cl5kn4zWPrOVkMktVrAqlZP5/7P1ZrG3bed+J/UY/51zdbk9/e/akZVmir205xRRsJw5iICjHBfjJNgzEgGHBCaLEBgQEppAGzqMRwEGQBwPJkxE/+KWAclJFK1LKVkGNHUuiRF6Stz/n7H12t9rZjDYPc19GLFrQpXgPeUmuH7Afzt577TPXnN8a4xtf8/96AjPpaLRiZjWVMSQ5Nq45rXnSbyj9joWzP7yH9GPO9eAJFFIsFCVHtSajaDCj/KUe9aJXm3Eo1hdfvcvEOdqd59mzNdIaFqWw8ZFejlq+OUsoGl0yKmV0SBASPhe2WTAQOEtwWjKN1CQ/8Gzb88BaXOPoY6TrPYjC/abGIRBqFCGwQnKoDM/6FpMKpYwlIR/Y4LLtmc2m1FIxpMD7mx0hdJw0cxptxmhHBmSkTYlOR6bFMrGKhTMsrEEZTS4eLQWPh56Sy6iCsOcj56JvWWhJSqN6kkoFI804CVSUsYZfSZ71HjR8+u4hlbPEIbK72gHgfaANnmUciEVAAnnbDxSNJodIChEvElsxStDd+MiBHdeewXuuupYJgkYaQh4juUYpjk2ND5GcuLWbghFjFqG+dZKM1JQ0ZmIHv+OgqZkozbJ4lsOATh6rKxqjiVlQimSQiTaVcRCh1DghqbWiqgzaGERJ1E5wvgrsfMLtgx7PhZvBMzUSA0yMZRSkk9hQxl4LoWmS4CINDF7wuVdPcU4zdJHldQ94jC9sUqZNgZTG3o2iCroUlBDjwMBUCAWu0gBDZucTB8lRG0nvOzYRrFYcWcc6BFbRM8Vy1GiUHguoUxqzrrPGctZ2TOFWQFmQkcQEbdsxn00xtiLHzGrw2M0WrRXTqiKU0U+QUpNDT1ajMpSTmsY6XF0h3HjNWgg2KZDjQPMhna093zvb4JkqhVXidt4NgMSWcV9TUlOU4WrYIYCXTk6orMX7yGq5RcZImzKtKrS38z6s0egox0MfkBOQRtGBM9/igK2PLHTAKs0mJUgt5nYAVh8SmxiobOaeceicIOWxoVeOzvx5KRRGSWULZDVmajfDDc1kjsoGkQKd91x3kYl2TM3YHyJSISdJjAlPpsZQq1GhrEaRVSIATmouU8syBhr54fbgj62lTo3kuuvIMTOToxKNvnVuOxLdkJB9ojGagcT9R3eZTmZcXtxwdnXD0rfMlWa98wwlExW3Db6ZX3v8FFdpFtbQSI0sjqP5jIt2y2WITAEtNBudWflC5zOvOcFrh6cobfj3z57wdB3YDi0/de8Oh1WF1YqDuuY333/K716dM3fNOOUyRyqr+e2bFZuzSyofoSTmWvBkaHmWAi/Ympvo6QvU0mGQeAvb3vOwmZFi4f/z1rv8N996FwNYq4lK0IlMd/2TUz/4g6aOgeswkMsY0QZQCXqR0VIjsyJFicqjgtJLD+5xeDDn/HzFe09vWHYDcwS70BF8IRUBRhJz5jcvWqbO0miFMwqdBHcOa9atofctKChKsFGZDZk2DbzkNZ+cH6APNL9z/YwbH3nbt/z0nVOOqgoJ2FL492fXfENcc1pbFOPCMVGSr99saddrdBwbfxoheNx53vHXvGpqViUQhKKxDdNOkFC0yfNwOqOUwq8/Puc/PD6nTxltFeI2Ld//BOvwP08aqVj5gSEl1AdOhYQujwOuBIxqKICKkk+9fJ/D+YJnlxt+4+qbLPPAXGnaYSwvDEALIA2/fbHEOUElxbimZMVp42hTwevAzFq0KKy3nss01jQ3UvKp+ZSJ1nxttWLjC9DyycWMWo1R+IWz/N7ZJe+EDmtGLWmBwCjJVzdb2GxRKTOUwC5H3hgKSnnu2LFHphTBFMOUwpVMdBTu1DWkxDeeXfCNZzcQQVlBVmODetjb33PBKsl16MZ+kNso9oyKZAQTIcg5cz148JmBwKO791jM5pxdLHn78e/TqUijala7SCoepKAoSVSF31ldUxvFzBisVIiQ+OzBlLWD693A3FqEhHXcjiVjKBYaPrU4RCvF166v6NrMWVzy6uECpw1GaQ7chG9eX/L+dolRCiMFCMHCKr7a3tCsNxSV6HJkGyMXQIPjQGqSSRRtqXVNLQQxJgKR08mCFDO/9/5jfjcXBiIT49BKE8qo277n+WBquEk9vY8YNZZOzW1DyhknBTlG1jGhkeDhwdEJk6Ziud5ws1yyJeCUYQgdOwpZCELOHFDxftsCMLWa2mhUcbzSTGh9h0ZQa40oYyZrMwyAYFEpXp3NUUrz9mbF2kNqEi/ND9C369zCWb51veLcb8e5AAVUEjin+VbbYduOkjJ9ivQlswFcCswwdEQiAiEMTo3DHwTQaE2IiTeuL/na5QXD7XVbpciycB52H+p+fmwd/k0aKLrgpMTmzC6DyRkLSC0IUjEUQSNgmyOXlzf0q5bVaksbE0s/ECycHE5vG2szpWhE8ry2WBCFwJZCLUbFgM73LLuOVesRcc3MDmgluWstGaisZZc83rcoQKnM8bTi7d2Os94zN5rZtmXlezSSIXustsy0I8XMm5dXqGqMiJgiiFmwC4lDawmMU9yGNKq9pOw5iwNOSN7f7ZClEFLmKgdm0jBJIMljk57f1/A/L5JMaCcRISOHgV4UVDVBpYxShZASfQw0UrMNnsdnl+xWHat1xxATHQNBSe5MGlqb2KRx+p6L8Mi5W4ULsFrSVAbvI9d+4HoYCLEw0RatJCeVQ2SorWUbA8kPVAhCyhxVjse+46pkKhRsWtZhoJSCj4lK32oV58y7/ZjtmpQx85SLoouRA2PGqbsx4SnEBCEHrmOPRXLW7RB5tNFLIo3VuCRQKZNL2pdUPCe6lAhCIii4mBlyxtuxGawoSUGQ8tjPtMqB86trhrZnte5JtxO4vYjcqd1Y6pALDslMqFH7OY8zRSolqJykS2Pa+bL3bLsBLcfmt6lSWMayh030tMNA6RKDzVijuAiJSkrqXNjcdGxFpGSJD4JaCJySBJl5su1wamz41GLMVrYEToseJ+1Gj88CIww5RK5ipLGGp31PiYnWF65kxwyD9hKt8thXx97+ngctniALqkgqKUi5kGUeG6ulHBsb4xhFX+XEk2eXrLY7Vuse+P9nXR40EwYiQ8yEfnQ6JkZQlEAjqZFMjWHjI892nmddx4UaDxwCqIwCNEYruhhIfmwQL0Rq1bDse7T01FrT9R7vA7pAKhnFqGCSS2G1GehNgjBWeUspAYGxGhJ03pNSRMmC7yI3KXKoFKt2N9ZgU9jgaTC0IVGVUQ7Zl73D/7yIPgCZD3S5pBqzhT2MAwZLIaWENbDycHG9ZLXT7LqecVC0hARHpiIwimrEPJY+HtgxQ6kZS2Qrqdl0PcvYc973aKlwagys1OrWVVaSXYmUEMZyNgVVNGQNfSl03rMJHW32FEahBFUEGo0sist2oFGSnPMoaztqe46lSinjQ2C4LaP1PtCWzEIpVnHAp7FHbysDMyy7MErRAuMk9Q/Bx9bhXyiLlx80CCkqCevkqQAbx9P8ZKqplKDvE0/Or2iUpu897eDZDAFfYDJVbFNkEyKVFNRakGThdNoQh0AJmUY5LvwaKSUawc5HIqCNoq4sF11PErCNYwpGF8FR7UhC8LjtWd42SF7lzEXfU8o4HGcQGSEyOz8wEHFJMBRByLfNkTFyaCuOmgYjYd1H1j6zDGPzUxFjz4Jh1IhVwlC0QQgxNqQwNlPueT7MrWWTIj4lRAGLYJsDJhdUEmijaazCSkNfIu+fL7nSW4Yh0A2eZU5oW5hYyy5FdjHhjCALiEVxr3GUPGr1Gim5bjtyKhAF2xgJsSCMZG4tyyFQJHQ50oeIyHBqLVjDs6Gn9RGDIA6eZRiQWtORIAuckHRlbMKVEYIadY2HkslkTozjsHbYQdKmTFcE6z4TMmODaBqHLVVCIIVGoNAfKBkAUuxr+J8HU6PYlrGh1kpISZHUrZRwGRUeGqsQSnMdO945u+FCbvFDou0GVngGbbjrDEOf2IaEMhJUQQrNcWOJPkLOWGVYDgPptmdlKKMUoZWaqZYsSySXzC4UckxkUTgQBq0VN9HT5UQvJTonfB6nMg85orRCSkWfEn1M5AJJjHWtRUDOgspp5lYTc6GN4zTMVojb6a5jOVMZVeyo81gqiRizAYVC/gmeNv48adStNGaBSip8LoRRhBqdBAbJ3BmSLmxK4L1nS5za0PvAOnR0PuNN4dQ6Qii0MeK0GSeSCjiux9IackHfrn8xZXxMDDFTGcXUWJoo2THaQZ9HIQKRM4e1xQrJhe9BSFIpzBX0hFEK+9Z2ZBknsXYFRM5wW9ohy6imPsFxWEt0yPSZ26moeWwMZTxYxww+jt9zQpIF31ZXkXt//7mhtSIU0Ihxkj1+1M0vhVA0DsFUSqxSdDrwbL1EKUGIiS4M9HEsH5tqRYwFn8uYrRKQyRw1bnS+Exgl2IR+HDiXCn2MoKExlmIEXS4gbkUzbm1oYhTSCJZhIOWxpNGKgr8VcIm3ogUKMR44SiKkMkrKIlCyUBI0VjPNmiQLIt7uvWrs0UspI7Ui3Q790ozldEnEbwvCftgd+GPr8BcxSiwlEp0AIQVDSSRApUIlQZvbTQE4Xy2ppYEsbjdIw8xUdHEc+a7EeHM7MU7kTaUQSyGV0fEeYkEJRW0NXRzHeU9RSDk+tK33owpACMRYuFMUtTYsTCIxNhLfpJYuJRopMWIcszwQSbcnVB8TlTQYOUrjqQJ3p1PuLuZUykHe0fkdEjC3+tpdGeVGtZQ0CG4Yu76napSZkh9Wj2nP98w4Tl2MEl+Mi04qkVLkmG1KGYwikslCcrXtUbfzv2MepbWmyjKkfGuTgkpCIBEZy4DIY8SiC4kuj42PTo9650NKOC3RjAM/2jiWLvRxVJI4Eg4nFVMUKY8Njp0cI05O6rHl9gM7p4wNQGQUGoWgkMlKclxXHM+n1J1j2Q/koUeJ0QaRBU8GIVFKUQPrnMkiYyVUQpHT3uF/Hvg0LvCxjLWdSit6EkLK2+c9yhMjRru5XI9ShyWOs0UyGWMUfRrrRyWCSgjaEjEFmjLWycdS6EKmC+NaopXCp3FTtUKN0yJDJMZEvFUdC6VwIiRWSmxOMPr4tBSGyOiQUwhlVO8RjMGoWDJOjo2XGVBI5pXleNqglWbVezY+4gVoIYg50+cIYlTVaFC3SjECKwVajPr8ez56YhwV8QSjUoiRmkEWFGp0big4IxkYM/HLtkUXcTsfZFTSMVLi8zgzRCIQKuNjHg9reVThSznThkB3O9TLKoW/PeCJAqpIRI4MIeLTKNvqU8EqgxGSRmqElDiliLKQyWQpxrW15FGuk4wUhSFGnFRoIeC2Zn/hHMeNw3rLKgS2MSKlRwtxm/Ucp/E6o3FA9OkDibZRnnSfYXpuhAxIhVBjz5IpGn8rBiBuA01aCgoSqwXrvhvtDEFCUG59p5gLuXAbEb+VzyYhhEVKQU6jGp+/HeRVS4Mvo2Ii5VZ1inHieUqjgk7IGS3F7QCucSirlaNIgbwVUouMfmAp48FZAX2KGPSYYRLj+js3jpmuKL2mDMMos60SJo0lwDGO11/dDhnM6QOdIG5lcj/cHvyxdfiXJSGFJItRN7X+QDozj05MzpkujTVcAej6Hq/BKouxhlNrOJ3MeH97Q600R0aREzzNARMKF5sOI8bhSJvoqaUhpsSkcsQgGGIk5cwujSnLZTcaUqTQxsQLyjLXlgcNKCEJwI4B0UJj5LflwyIZZzXRR5YxcewsU6WJUkLJPDg65Gg+I5eKZZeRYkejNa2PeBG5ih6L5EA4QLBOAzLBrHJM1Nipvuf5cN4NaDsePNtSaMpYNxiKIuUxjVaIpBRJGVICkRKyFLRR3EFx6GqetTsmSlJriwSelETKgcs2Y6VCC0n0EVcZQkpjRGHwY0NkHntIYiqsW49QH8yaiLzoFE4K7luHAAYKQcCNHyXjlJTjZ6WMC5MuhW3JmFxohKKWhq2UHM0bjmYTlKro0wbRtVRa4IIgqcy2jCO8G6UAQTt4tJTUxjBTmrCXRXwuPN32aDM2XmcECz0OAzRq1BnPOROEwKdwK0k4HiBlkUgpmeFYaMt13yKRHDuDloJ3Y48pmdIyNsNJSH3AaE1ImaayyNuUtciFjoKMglhGbfQhjxkGU1mkEBxrjRKSVARPQ6aLBaNH1aqUM33ONEpijWCIAqsUtVKk2430ZFJxNGswxpJkxy7tMGF0FvuUuAkBIxVTaxAI2q5HilGBo1aStC+peC7c7HpcZUZ5zZyZKYWWCVMMJQZGUVdJKGl0/EOgYNBC0ejxFHZgK66H7TgETmlaIj0RmSU3XY+Vo3vmB4/VY2Bj6gxtlviU6eL4v+RUaEsk3coVJgS2rrG+8KAyKKVISnCV/O0groISY1AllFHD01FYxUijNFbqMZJbEsczx6KaoUwh9B3bbo2UAi0yXfS0KVNry3FVIYTgSbdGKTkOZVQSmfYO//NiExKVM0gKIUcmaPqScUojEWOWUMKQMlYLtj6ihcYphTUSCyyU5rrr0VJiJYQ80BVGxR4fqIxCa8HgI7pIYspMraMnMqRwq7ijKGIsq0xpdPYjYJxDxnENNFKSgXM/YJRmKAEo3z7YZhjnQKTAkR2z5LlIIHFgJ0yqilg0PkKQkZDACMGQx+yoVYaFqUDARbtGIXGloJCYDxnj/9g5/OW2Hlj4Qm0s0gqij1gfOJ7XrDuPT+OpW2dDkwoLFJtgMHncVLDj3/nm9TkxFR64KQthWOeOeZFcdh7v4W5TczypaKoKJSXn1zf42420D4mhDexSpLKW9TBQhERrxVxpvviFT/D0vcfIXrHpBm58j8wFHxJJKIYUKQViKWzJ1EjaYeBpSFRiHKB0Mq1woqZtBzZtx7LruBo6uuK5DgNOinFjL5k1gUoZTtCEDNFnupQo8Tvv257vnw/uZRwiE1dhrCZSUIPnQNWsyeQYiTlhMoiQqKVkUOPUSSuhMpoCvHO9QchMXVWYItn5QKXkqAAkC3cby3HVYJVlagvvXq8JJRJCZtsnZIn0jPKa6xC/LTVXa8WXvvBJvvHW+4S20PnELkUSY7R2LiHmSIyFmAVRJSbSsuojKIFTESVgbg1TY+l2nq5PrPqBZ21HmzLLGKniOEnVy0TQAictp1ER5LiZbnOm3Dat7W3wo+GD+5hiYmYsVqhRk3nI3KkbYhBEIl5nMoo0FG51YeFWr7kxilIK719vkFJwWGl0gc0QmCnDNkR2MuCkZaEMplbMnOHxcjNKHYZE6yObONaNVohRWva2+beWip997T7vPL1h6Mc1OdzOP+mGQCM0fY5kMUagbnxESslm8MgIrZIoBAtdURtLu92xjZJVP3Ddb0khsQlhnGbNaGtrMlNTMy2CPmV88JQoSMN33rc93x8f3EefEi5qdB5rkbd54LCuWfeBVDxSSVIaG25zgJ6C1RmlBE4oCoWz5YaYEjOnUVIQvWCqLQOFLias1cwrNx4CpeTJzYYeiKkQYh5FAW7tL+fy7fk2jav46Vc/wZtvvUeOPTFEhk6SZWHd9iys5SYEQsqILOlyQhpD2ydU9FQyIYVg7gyuWLre06eEHzr8rqVPibb1GKOosiTHzOXQMTcGLW5t0icGmcghfsd92/P9820b9ANagMqjDPFWJ2a1JPeBiEArjdKS0PdkmelCwKiC0KDHYeE8GyI+9DRCgxajAmKp6NLYpyIZp+oaa5BS8my5pg39qIWfxh6BlAYaZ8i3h9AhFZyVfPb+I955+gxCxPtR0nooHZsuM1WFbfDkAkqOMymEkgx+lF9HjZUfU2PR2eC7TOwjwzCwHnp6H/A+Ya2iygIfA898wFkDSaAoDEMghIT3H24PFuVjZqXvv/8+L7zwwg/7Mn7keO+993j06NEP+zJ+LHjzzTd57bXXftiX8SPH3gY/GvZr4B+Pvf19NOzt74/H3v4+OvZ78B+PP8oGP3YOf86Zr3/963zuc5/jvffeYz6f/7Av6bmyXq954YUX/tjvtZTCZrPhwYMHt6oDe75flsslh4eHvPvuuywWix/25Tx39jb48WK/Bn5v7O3vo2Vvf98be/v76Nnvwd8bH9YGP3YlPVJKHj58CMB8Pv+xX2w+4Pt5rz8JH4gfJB98YBaLxU+M/cHeBj8u7NfA7529/X107O3ve2dvfx8t+z34e+fD2OD+OLpnz549e/bs2bNnz48xe4d/z549e/bs2bNnz54fYz6WDr9zji9/+cs4537Yl/Lc+Ul6rz8q/KQ9k5+09/ujwE/SM/lJeq8/KvwkPZOfpPf6o8JP2jP5Qb3fj13T7p49e/bs2bNnz549ez46PpYR/j179uzZs2fPnj179nw07B3+PXv27NmzZ8+ePXt+jNk7/Hv27NmzZ8+ePXv2/Bizd/j37NmzZ8+ePXv27PkxZu/w79mzZ8+ePXv27NnzY8xzc/j/6T/9p7z88stUVcWf+TN/hl//9V9/rq/7uPNLv/RLCCG+4+szn/nMt3/e9z0///M/z/HxMdPplL/21/4a5+fnP8Qr/tHm+7GjH0cb3NvfD5a9/X0ne/v7wbPfg7+TvQ3+YNmvgd/Jx8L+ynPgn//zf16steWf/bN/Vr761a+Wv/N3/k45ODgo5+fnz+V1Pwp8+ctfLp///OfL06dPv/11cXHx7Z//3b/7d8sLL7xQvvKVr5Tf/M3fLH/2z/7Z8nM/93M/xCv+0eX7saMfVxvc298Pjr39fTd7+/vBst+Dv5u9Df7g2K+B383Hwf6ei8P/+uuvl5//+Z//9r9TSuXBgwflH//jf/xcXvejwJe//OXyJ//kn/yP/my5XBZjTPkX/+JffPt7v//7v1+A8mu/9ms/oCv88eH7saMfVxvc298Pjr39fTd7+/vBst+Dv5u9Df7g2K+B383Hwf70R5svAO89v/Vbv8Uv/uIvfvt7Ukr+0l/6S/zar/3ad/3+MAwMw4D3nt/8zd/k7//9v8+bb77J8fExQgi+9KUv8au/+qv8vb/39z7qS/2BMgwDb7zxBvfu3aOqKl5//XW+/OUv88ILL/Crv/qrhBB4/fXXWa/XADx48IBHjx7xy7/8y3zuc5/7Q/9uKYXNZsODBw+Qct+S8b3aH/xk2ODzsj/Y2+AfZG9//3H29veDY78H/8fZ78E/GPZr4H+cj8Ua+JEdHW55/PhxAcq//bf/9ju+/w/+wT8or7/++nf9/pe//OUC7L++z6/33nvvo36UP5J8r/ZXyt4G9zb40bG3v739/bDZ78F7+/thsl8DP742+JFH+L9XfvEXf5Ff+IVf4OnTp3zmM5/hX/7Lf8lf/at/lV/6P/wvkE6TSkFLzaSecjQ/whqLUIqYIsOwxSlFSomUMyVHKImSIeaEBOLuhuBbdssLrt99i3mlEBlCTNjakazlOiXu6YrQrVn5gtWKubMs5hXWGJy1hCHSDQOtj4QEu9JzbCu6vqf3kRQLlVZYJZHOIErGKIXRhkRh2baIIhiSRwKVVFRKETMYI7HWIJWk5EJKCYnATSucVkgpkUJSWU1da2LJ9H0gxkLvM3/7f/tfMJvNftiP8keWP8wG/8p//rPUVU3MhU3Xs15v6XtPQRBFoYiMoiCyQFKwE8NkUmNR+E1EmkIrBl5sahbWMa81x1OLxSByZEgZV1n6kvjmzYpPNVOMlqxSxCnFoq44mM1p6holMzkm+ljofKLvOy6GlpenMwbfsvOeEDK6KCotaeYNPiSMltRG42Nm2W2RaFa7lpIzs8pwZ1Gz6yJSS5x1aGUQwBA8SoJtpigpkAK0llR1g2s0pMgwRFJKdG3gf/q/+n/sbfCPyR9mf6//5c8iFMSSCCnTh0jsEzlkQk5kClIIEBkFGKWorcUahZISYyRXu45PHi04qiyzWnMwq6hRaCXYtZ7KOoKAd1ZLHlQVWkiGEqmVYdFUzBdTrHU4IOWED+N19DnifWSuIIXAsm1ZD57KWCqjOVzMiTmilcRpzTBEbnYtjdFc9Ft8jkyN46XpguuuJaXCbFLjrKUAu74jkbh/dIQQCgEoBW62YNJkcir0fSSGRNcH/vP/9d7+/rj8Yfb3f/6//O+ZzOdkIaAUJpMZ18tzhiHiSyKLghKKaeWwWrNu16yWNyyvL1nfXHN4eMgqRcLZe5jikSRKt2MiNJNGc7HacThfUM3mXEQ48Tt22x1DKUys42hSMz9sUNZRK00cEn1ItCESkoecabQg+IFd7+mGiBAKT+LocIEkURmNNZq2H7jedEyU5cluQ8iBhbW8Optz0Qb6OHA0a6icIaXCxvd4kXj19BglDSVlpIDJdMr82FBCYr0JhFgYQuJvfPm/3Nvf98EfZoP/6f/ksyAkIUFICR8GQFByYecHYk4orTBCkDWoUKiNxWqFlQprDBfthpfnUw4rx6TWzGpDbRW1MlxtdzTOUYTkW9crXq0qhIEhJabGsmgqJtMGoy1GSXIsDEOi95G+BGIJzJVmt+sZYiBTUEpTyOhGY9DU1mKMYug9QxsQUrD0G/qYcEXxoLZc367nE+uo9OiWb4eB4iQPFws0FoRAKZg0DfXMkNO49sUwroUfZg38yB3+k5MTlFLf1V18fn7OvXv3vuv3nXM456iqCqUUbdsCYEpE+QClYKsJtdFMnQIlyCUTsifGjoNmgVKWISa83yFR1G7KZrsh50hzfJeUehCR1dnbGAWnBzO6waOmc5gtqKRi0geunm3xKWK0xNaGqraEEJlNauRU0ntP13sGn8l9ZlpXFFHQSqEKOK3oQ8EoiZISrRXGGKxSRJEZfERnC7kgAKMVRkkqq0AIyIVcMjFkfEpkBdkoGmuxlUOVyGxSkUmIHPAlg4kACCE+6kf5I8n3an/wh9vgo9mCu6eHCKW4alueXF0Tuo6bdqAlkUVGl4LOElESRWsqq5EZtilgjKBuLOd9z6r33CsVJwuLKZkHxwfsfGSXM1ftjouu45E2TE2FV1BZSVNbmokj58zRbIoQgphg8Im2q9ktE7NJTZGRoiSiErgCnY9UxqDNuNhM64osIF1HfJ+YVobBB1IuTOqaTKSuFRSJKIKSM0OIxFLIqsfK0UaddpgSmU0rVBbsRCD4hKwSsLdB+Gjt7xNHx0wmliwKbYjcDB2+G1iterYhEMnjWiMKSghSyVTGYoQkDBEhJdoqLqOn3UXuFMfJokKWxGunp1xvWrYps+4HVkPg1GhEbfEBnAJrNfOmQmjLvDIA5AQ+FPoQud4uOaoc6+2GOiWkUtjKsg0BqSVWaCprmFhLqTJFASHROINIAq0U09riRSKnjJZldAoLDF3PxvecNFOUECgl0Mqgkmc+qSg5o0pPEBFJAfb29wEf1R58ffYOflOjjMW4mtopYr/GD9DGgUTGWcesrgjRM4Seod9SYqCqalarJWU+ocwmSBpU6An9Dqfg03cPmWmDXByhFseULNEX7xL7HbsElQRrFE2jKWgW0ylyJgip4EOiDwPrzZZ5bdlsoRRwWlOk5r3tGoXAGMV8WjOf1GzaHoEgDJmpM/QJlJE0znBoNN4LnJYYMpTEbudZ+p579QSNRwlJ5TQyBBaTipIEcRgYSkCSgb39fcBHugaeHlNVFbFAFwLLdgMRVtsWSmaIEqs0tVUUIwgiUBuD1ZpSCkYqrNPcDJ4hJY6EYz41aCV47c4Rk8qyC5GLrmcbPQVNNpogBcVKnLNMmxqAxWSO4HYNjInOe262S2aVI8SI0AWlBVIqrjqPoeCs5mA6YV5XdP1A6zpaH+ikJXuPLpJZZRFS4HPESIksiThE+t3AroucaE1RAa01UmiIkfmkpmSJLJ4gIupDroEfecGZtZaf/dmf5Stf+cq3v5dz5itf+Qp/7s/9uT/ydb/yK78CQEqRtF1SlleI5Q3r6zPOnrzN1eqCq+sLri8vWa3XDMNAPwz4kpF2QtUc4lyNlJrFYkIzbWimR8znpxzNZ8ybhum04vhoxuL4Dou7L/HSS5/m9PgULzJ9DsQSKSUTY2S9aUk5gxA4rZk6w8RJ7k3nLJqaSmusUhilUErThTI+NKPwFHbeE3NBI+ljJKVCKeOtLxSikPQFUh4fmJaS2hlqpylASplhCGx2PavdQEoRCSipUUoj96MUvoM/rv39wdd+YIOVFJw6ywuzCZ88PuKFoyNemc0RQyT2njQk8jAe3mQRXF6vefvxMx4/u2ZIgZAy22Fg2Q08udlysx44qqfcOzzg8HjBw7vHbGLit59c8q1nSyoliWX84EcyRUApidXyhpwFShqsktRGMK0Urx4e0TQ1VhkUEonEWkcXEkNJCClACGIeDwoawxASIUVSjuScKEiylgxFAmMkX0pB5SzW6DGCXAoxJLabgXbZEmMEkTHKYLQFrZ7jE/3R4qO0v4WuePngkM+e3OHzR3d5eX7IK4sFldBIIdFS44RmohxOGFa7yLPVjst1SxczkUJRhU3xnG9bNjvPias4rGtq63hwtGAXPL/9+Jyvnl0yVwKhwBPJpDHDoySGNB4etEZrg9UKpwR3pzV11SCUxlaW6aRGa8NlCGNmVilyzOy2PVs/UFnNkBIlKyphmWhL0ZIkBL5keh/wPiAETCqL1Y5cMjkn+iFws2rZrdeE0FMYs1LGGIw0z/WZ/qjxUe3BN+dPWb37Ftt33qR79pT11QV0O5Q0kATFJ0QqpFhYrlaIJLHKMplMOTw6xfvAxfp9ihEI11C5GQ+nC+4tpszqik/cP6Y5OOJaT9hkWFSWJKDPaQxmiYKVElsyQmSkAqPAqUItBaezCbWriCiSkAilCUJwEQKqFKwxCKXpIizbgBOGPkQskgPrOLT1uL4ZiVSKlDMxZjSSQ1cz15YUE8l7+q7nZtWx2WwZukDOYKTGKYuR+/XvD/JRroGNqHg4XfDJo2M+fXzMo4MDHi6m6FxQCSwaJwy1q6ikpfOJm23LatvSh0DIEWrocuK6HeiHxP264bSZ0tQVrxwf06XM7z674K3NkplTCASplNEnEwJjNE5KhAClFdoqnJVMrOLudMa0qnDWYLRGS0Um8cz32KKptEUphS+FtR+IBYIPSAQTa1k4ixASpxwIgVYSoyRaSQ6bhqk0KARSZELwLFcdN+st3ncUIkpLrDFo+eFi98+lpOcXfuEX+Ft/62/xxS9+kddff51/8k/+Cbvdjr/9t//2H/m6v/k3/yYAGcVQBDoXqjAgS8N2u+XFB6/QDZ4hZ1TKxKRICibWYaXECIlAUYqhcY7zy3O0rnFVw+HdB9zVCYNHSUm/OCDMjpBacb65pioNgkAXI9vB01SGzgeeXFxwZ3GCkWJcAGLC3l6zkxAVxAQmSbTOeAFWakQB7zOXq56Zg6kyCCnIFASFaVVx1rbYJIlZIApICdZIlNIoBSkkogSlBNEL3n5vxeFhjaCgKKjyPJ7gjzZ/XPv74LUf2ODbV0tCTjw6PuDeyTGNk+xUZtUO7ETEWIlCk5UikrBWURmNkYoYoDGGs75FB2i0pqodxdS88tJDwAOwjoEnyy0yCbxWHLmar1/dMKTArLJMg+Pps2tKFjy4d4faWcp4YqQqBSUlTinaHOlDwMkZWit6H1jUBqUsfRZc3aw5dIZZXVFqR0iJUjI+dmy7nsYaYh7L3QSghCCWgi0QiicjaaSkjZ53v/mEu8cTrBlLQPQ+svUdfFT29+7yhpAjDw/m3DuacxU2lHVmPfR4ym30vOLByYL3r26YOk8lBFpqglBYo8ldwhqDnSrc3CLrCZ998T52SGRV2L79jLObHi0kQjt0lqz6QCqZea64lzPn6xWTrmNRzzFaUkoEAkZJUJkiEloWRIFNhEly9D6PR1BR6ELkYhj46dMjejegrCTlPNpYSngfkErS9gPrdkBLyeG04shadrsWpRRaKawyhJB4681Ljo6nVEahhEKI9Jyf6I8eH8Ue7I5foISBEgdcKWMYHYepKkg9sct02xXfeuM3QNZYZ6iEwhmLqgtHx8fopHjx7ou0uy15veTg6IjPP5hDyigl2cgDXHKEvqXzEZsNq9wSfWQ2aO6EA55cX3LYD8ynU5wSkCJhyNQ6MuBIeJARsqQbCge2ZsgZUzQhK/oQOes6Pjs/YPCeNkPIGV8KXmkYIloKrjc9fUhoKTicVhwkzXY3oISg0pJJpRhy4nd//31euHuIVQqtYG9+381HtQaeLZf0uedkOuXudI6VhjYFdj4TtcAaxcI5Tg5nPL5aMq00TklUEfi+EEQhq4ixGusUk6ljNj3glQd3sAxkZdm9+5TzVYcQILRDxcxlv6HPkUmw3CuFs6sb1PaGk/kJTltKzqQUb9dAQAlkBkqm6zJWGXIS9B6kzQg8T7YbPjM/ogwDqlQMMZEBWTds2xVaSlbtQEwZJSQLV3EAIATeFwQSpxUxtHzrGwOndxdURqOlQOr8oZ7Lc3H4//pf/+tcXFzwj/7RP+Ls7Iyf/umf5l/9q3/F3bt3/8jXvfvuu/zDf/gPUdWco5N7ZN+zWl9y8d7bnJze5+z3foeXPvlpXv3kp4kx8N77bzGsryl2glaGVAr9MLBZLknDKVU9QwiBZMf9RgGKzifIkoxAyAIlwuBxVvOzd18jB08JA3NbccMOB1zcPMULA8JRx8JNu8EBB5XFFIHPGc+4mW1ShC5iEFgU1lm8AqkSzaziYFZRacH5kzX35zMU8Gwz0MaELnBoJDd+IHqYaEWlRoeqJdH4xJMnPXVdMWkc2H104b/LH9f+PnjtBzZ4llvOz1u+/uyCk8n7SGVRJP7KFz/Pf3hyzptXN0QhOFSSpq6ZndyjyMJu6Fmvd0yV4k8c3+f9pzeElKiN4aXjmuvNDU0zRwjwBbIsaKuYzxtQ8DOnp1TasqgnHFQNp0cHzGvNxc1TrtYdQ595MJ9w3fdUWnFn4lhYi0GTs6dpDB1w0Xew2SJjxlhDh8M4gzJwdzplYhrOn57x4ukhJHhyfcO27zFScjJtyN6zGrZYq7HKIKUgJ49F8fTpDlcnptMK1D7C+gf5qOzv0u+4vu54e7Pi7k2DkZqI5H/4hc/xH87OeGu5JAwd5goW1vLowUOQiS4M7HYDc2W5s3jA0+UNSSZmC80LE8fm+oaqqRFoPIlIQCBomoqoNV+cGIyUTKsaozTJJySep+17nK13tH3iwXxO2yc2DLw4qdFS0RcwZO7PDYMIrGJgqjRzo1EUNimzqCcMZJqmonGWZ5c33D06Ig09lymTpUBISVQKHwOxwNyO2aZSMst1i9YJ3w+oyjGdNFTa/pH39SeNj2IPFgeOyeSYm7On/N43v075xu/yF770P+K93/8NfDWBZk4Wmk+89jO8/+bXuf7GezSLimreEC8L0Q/cu/+At37nDSZHCx4sZhz21zy9WDGbTxEp82T1Ld7dddTKYJXg9PiYVycvkX2HygGKGmMjsee9iw1Xnaf1mQNpSQRuUuJRVWOUJQg40AmDI7jMTdoybHuapLgbFS2ZxcGUmczUtcUZzePza+bOYZH0HrIYM1sAQ8xEVThsHK6yZCXZtgMaeO/xClEp5rOKidnb33+Xj2oNvJYD63XiYhM4m3QYlbHO8Re/8Gl+9+KSd1drVrmgl1vmxvLy4SFFJoYQ8LuAMZqHesLl9YYgEu5AcTzRbNa3a2DyhH6gtAEhJc5NUU3ki7VBZkGjatStm1xjeX/5lMt1S98l7kymDDpwMyTuu4ZKKDKCWa05sTM2dPRskX1P0xruYtmkgLGW6byibhyywNn5irmdUjvLTnaEEEefVUqcC6y6gYmrcUoS88DVtuNk3nD+5Abp7O0a+OFceVE+CBd+TFiv1ywWC/5v//f/K1IGNutznl28x9nVNZ979dNYpTi+c4/p/IAQPG+88Xs8vHefZ+fvU4pAKkuREqUUpyd3CEMPRFQZUHELwPbp+0jraO4+ojq6Czlz9v/9N4jZfIyWrq6J7ZbTxYyL5YZaFW7anpAVoMkxMm00AmiEIKXEzkdaH7i7mDAoRRGw3fbsdp6mqvB1JsWEQnPgLAurWHeeO4cTss+0wxhVG+sMPT4FQKKlQCsBUrBNmUpluj6htcY6C0ry9/+P/zWr1Yr5fP5DfHI/Pnxgg5/4S69y4GruT6bcmU+4uNlwPJ/wmYf3+K23H/PG2SVaCF6YWXYpMDMOnxI+RHJIxMLoEKdMyJmJU7x8UIOAL7z0CF8C//ob7/Dr7z6lVor/5X/vZ7nc9cjox8bH+YwHpycsV2ukyLy3XbLZDRRfmGjNiw/u4lOmTokUIpvBs+p7Ht05oJOZQuHyesfVzY6jWY2Z1KSUaL1n5hzHk4boA3eOFuSY2QwDKZfb6EhLKYWkFLJkjBqbJnc+oLVi8KOTaKxGSMXf+t/8l3sb/Ij4wP5e/suvMHGWu9WUF+oFXdczn9S8dHrIv3//jG9d3qCF4GHtWA+ew8qQbpt7Q0lEITiyFblEIlBZzaPF6Jx8/sF9ejnwq996j3/37gWN1Pz8n/9TXO8GjElUSnDQNDy6c2e0v5x5b7Vk03pEFkybUVDAI1A5IigECqvgeWU6J7vxENi1HettS58TBwczhId1N9BUmuNphQ+B04NDuK2JjSlRSiF4T+g8KImUoJVACkFbCg4YSmDdJ4wxzKuK/9n/bm9/HxUf2N9f+Rv/fV559AIieVbX7xOy5D/54s+xfO9tNkLjtSPFwPLsLQ7uPuT87XcYhoGqqjk9vcvx/Ufk7ZLWD8QYcVZyZ14BkJaX9NITqopBKvp1xyPvkbaGFIi+xxnJozunrJZrlBK8tbxhiAWDRhfBC/dOuPEd/W4HOZOBTQi8NJnDRIGA3bZntW4JIdMcT2iQXLYtjTOcTBraXc/94xOy9/icyUWQU6HbjgINKIWWt70yRtKVQC0l2+3AMo89DCf1hP/5/+nf7O3vI+QDG/zc/+A15lXNaVNzZ1azGzwvzRYcHy747SdnvH11jRKCw0rSBzisHEJIQsoM0TOIyBxJSoJQEpWR3Js3AHzywSG7HPn1t5/we+8/o5Gav/uf/CxKW7p2SUmFWT3hhfunLFc7pMg83l6z6xIiSCotOb13yHLw+M0OkQtZwGroeWU2R001QsCmG1jtOlLK1NWUWkpu4oAzkkNr8D7y4OgeKQ70cXT2FbDcLCm+EFXGCI0WkHJgM0SOJhWb3rOMgcZVnFQz/sYv/Rd/pA3+0FV6/jAmTY3WNTFs0Vohs+RockCWmfVqyc3NNSkG+ptnLBtHJuNDROXCZLZAa00umVQyGUFSFdY5rDR0VxuUczhdU4oi+IRSGtEcUnzP6GhLpJQsZg1WFJYpIPsMIdD6QGUFOWf6DLsQ8DlyYh1NVVFKoQC1s+RUSMDZ0ONFYBEMKiZkNBglaFuPFqCsxGmLBM77Hokgh0TREqRCSkGNpA0eLcYzZ46RrvtYndd+rCgCuhJZRU8zOPoBDqoJlMLpfAZCoSQcu8LXHl8gncCiSQmCyCgt0AJ2OTGkTN8l2pDx3rP2hVb0vHW9xIeIKYKSEuerHY0pKK0QQiK1ZDadgCyYvmNixq6NEBMlJEJKY3/H0OFL5n4zYdI0yBQoQJwAWSCV4JvbFTvpabpCChEnBFNraHcdUkmMNTTGIoXgabeGInFFoIREiTHy6mxhvfFYrdBSIqKg9+GH/KR+PPG5IHJkFQeaviN2mZdOHSlGppXh3sEULQT3G83m2QBaIFDImCklYYxCKckuZIaY2QyR692OTKYNhSUdb16vGULCKUEIiat1S9MU9KRCqzF7OKnrsWejb5kVgc6ShAJRMMDSD4Sc0FJy7Cqms5rutiep1G7Ui+s6vnZzjY8RlyUnVFQKKiXZtD21kdhmVGPJMXF+eU4UgqkxSAlCAkJQlcJy26Ip1FKiEQy9/6E9ox9nHty5z4N7D1gtL3nyrLCYHjC3U9rJFJsFUhoi4Ls1zy40UgtkGKOcaEllFLHSNMcnhJDwQ8dNGDg5OGHbBs52V8TYk3ImrHfcNY5Nu6WIgYmSzKoGKQVN06C1pOlaDBFVFDEXhhAQqXDTemJJNFZzWjccHs5Yp54CVJWjFMlq0/G1qxVGF4pPnKSKmVRYAcvthkpLTOXQ2pJj5nqzJEvFgdUoUSgSihLUxbDa9QxhVFJzeQzs7Xk+hFToSSyzhyGRg8ROLF0OVFZxMmtQQnBUS95b9WhrkQUKgVAUjRaoLNmkjiElhqIoO8+2HVgPA6vU8/5qgy8ZRyGERFs8XfA0ymCMBimY1A4k1EONSBGhxn630HtEjNz0PYXCxNqxv3M+pSsJKFRGkGtJ1w28u9tw4DQ+R4TQZCkxRbLtO6SIKGdwxo3l4OtrpFTU2mAFlFzIaBoLy7YnF2ikxFLY9u2Hup8fW4dfKYGxhrqZc3hwF8oEKQ2mklw/O2Oz2eCMpmoaElBP56jBAxJtK0SOLK8vUMZSlEEISSmKlCXFzYkKhgiy9+QQMfNT9OQYYQcEErolSgYmVUXRDTM3p1+t6G5W9KXQ9h4vCqZIUikIIXBagRQYBDFnrJbgNEMsLGzFJmeUL+SUSSljpaDvBpzToCxJCGJOJMBIRZYQi4AMOhViKigkViukEORcyCH+kJ/Ujy9CCXzKLLsBmQRDl8ilcLPZkHLAGTnW7KXAtvVM6rHRUKRCGwP3p3Nqq1kOnj4mYi6s+kQOHnO9ZlN6uj7SKIMTmq+d3fDO5Zq6lgQks/nYLGmrisdX17z53oqpVRzPKlofWO86dmWUR+xTAimorAGpcEIQY2RqLXIKXfDMdUMqBdMHZC6InCml0A8e7QxKa7IYJW2TFMjbRt6QChHQEnIe7dsphRSjjGyOH65+cM/3RskQQmadB0QAGRR9jIQQiCGiBYiS2cVIFyMzYbGVJRbBsO65N5ngrCaFsTxh8IkheorMLNyO69QThsJEGayQfP3p9XjgnAuKlhyIUfXBOsvjqyXferyiVoWDieOmz5zWBpQk5kIpAiMVMzuqQ9mUyTkjtEI6Q4iemarY9h3RJ3xO5JwBQd91OF2jlCQLQSiZLEBaDUpRyORSxuaS2/iG0wbGn7Dz+zXwefDC3QfcP71P7Wp6n1jM5hhrmRyccHF2Tus75tMJR6f36UTF4kgTfSKksdkxbje0qceYHqUdWSrW247FPJMxLHcBoQRGKTKanVCs/AAVKKcolUEbg1QWUc95cfaQq/MnXJy/x3KIaK1ASVIBUSRGaGa3TZIKQ4gBoxSyEnSdZ6EbYvHs+kyMhZIKRgs2uxY3m4CUJApDHLPtxtlbVUDIjGvfqKSgqStxq3xeaIf9gfN5UUohlMwmDvhO4LCsY0AOAz4EFAIhIchC0BmUQEuBz9B3nrsHDUVBHApDyvgIAU8XBtQmsfQ9ORZm2uKk4htn1wQlibnldNYwnc0QSmErydn1ireerFEiM20MPhcQiXI76EoicHLsKdDGoJIgxIQBJsoSSSwmEisKXRdIsSCMwEpN8B7rBEIKIpkQIzEWnBQIocglkUohC4kQikKisppMJpHZ+u5D3c+PrcOf8xiZr5oFDx9OeeFFyZPH73I8n+ER9KUwqRsO77yKVmMXdU7xVq+6EPtr3n/3TY7uPEBVNUVIdhQoAxM3YQg7ut5TisLpQnX/U8ybKSFHwuKIsr3EXH6LohS9O+Hk7n3W9h3a/vcZYmI3RHZ14ZFWHOsKIQQ5ZfoQsNbS50jOESsFRsOrd+5ws91wMbQoGOuxQr59r5CTYOc9fuhGBQ4lSUrR+oQIGR0KN33g1eMZMUdyHpvk9hX8z5EiKEnQDoGuGxC+8Hi7wpFY9j2b3hNCIpSem+WAqRSLmaLPiU3f84XZfVAF3UpkEJSU8TkxNaPCg+4McyE4qEAUwX/11cfoDKoS7JKgmU/5jBg3ta++/YR//etv8omXFvz0F064KS11a9kqz5F1PKxnWCVJKdP1nqpxDH1PShGrBLlo/sKLL3G9WvPe8AzN2FTch0ijFKmMn7l2u6PvB7QctYxjLGz7BGRMFLQ+8MrEERR4H8mpUPLe4X8elJRJKNoU8cqjULxxaZgbw6ob2HQ9IQXeloKu9zRWc3hQUYxktwscndSkKlMPihAKQWRKBm3ASss0FqyRZJlJSfD/fuN9LJLKa3qraA5nvGYtlMLX33nGL//6W9w9sbz28pwn20B9eAdqTa0sU2NpjCGKgB/G+RJ+6MgxQoxYKfnLr36C1WrLb7z/FJkLWmhiTEg1apzHlGiHjm7XoqWhahxdHxn6AGSUluScOJrUVNZytd2wGwa6YZ9heh4sqoraNhy+eJfXXv4sfdjQbi85PL3Pv/v6G5xdXvC5T36G+6/9CcxkwUwXUvSs1yuenT2jvVry2F/RD+8ynx9hrWHbLrleC3Tn2V2vODi4w/H8hL5uWaWAkQ0727K0iUkl+FRdA5J+/iKfeuln+Npv/zd87a1v8s5yS10U7qBhUTlqKWn0eCDe7DrMpGboB0gRckFK+B9/4lWWq5bfePcxmoIRmiIKhISUmpQEu7Zlvd5gMiymius2EWIYyyykIqXAyWSKs/Bss2XTe4a479p9XpRYCDGRMgQp6E3hrYsrFkqz2vXsfKAYwUVKeGAbd8xqx5ADl5crXp0f0JmeShqigC4GttueaiKobM0kFRoM0kAUhV/5xrtYYVDzwoMYsJMJnzQWtORbj9/kl//dmxwdaF5+Yc46Zv7UyR2aScNxVeOEpNaG3vfITmMnjsHH2zUwUWLkS594leVqx29t3meIBWqF0mqUkRWGmASrfsdmu6H4gq3GMlqfPeIDQYYkOKynVI3ifLtlM3i6Dxn0+Ng6/CGCTRKFoihIUqKamlwMx0enVE1NSpmr6w3OOo6mU4yuMWRy7KCuUc7ShpZuu6HrB5RM3Ds4QB8vyELQzI+pm5o8LKmqmqPpCb/2m/9POt9yWBkekCAlbLpi+bTFp4HZfMFpTFz3G/wQiVYj9SinufORLo0lG483W2qjOJ1MSBlSTExNxRUdUMZoVsp/QFQzknMghIi9bYLsew+35UFtzmzw2LrCb3YgBFIK9pO8nx85jWU5iUTsA6TM44srXjs9xCnFIAWlQNuP0nSPL5c8Xa9RUjFRlqapePrsDFKi0oraqNsDWuJssyEBQ4qUnHFCozIUJA+PpoSYefdii/qcAgpf+vxrDNc9WWdEL3mhntO2nq2MnBRN4xzaGra7jq3v8Vrw1tUNldE8WMxZ2LHxe1ZNRgk7UTB2VHGRQkCC6CM+eKL3TJXCasW2a0edcyHoEzxLAw+Zkb0nlEKUiaD2G97zoABC5lEiLiVETjzr11T2GGM0VdKUkClEMpm3rpa8u1phpKBpLHpWcTNckErEGYmRjnklgcLjzYaYIiGMUsHyVuY3Js2innBx3fO76YIvvfgKCMGXfvoVdtuO3g9MVMXnTw4ByeAjgsgM0Fqx855r4ZlpeHozXsvhtGHR1CTU2NxuFCoXZkazTQkvYPCZSCLcHh5TztgIz7Y7Us5oJUEWOhWZJ0vfeWrlqBrHVu4d/udBXc2ZVjOsm5BFATVQOKBC8flPf57Dgyds2hvevHqX+XzBwk5xjUQqQT2bk8qSm7Mr1tuei8sltbMc1JrZ/btcNwqvYZs64vqCq5tnfPHVz/Po/kN++T/8Co/7FeJkgTw8AaDxT7h+rEhpx/0Hj5jaZ4gkIAQkCaMNhcJVu6MYzdw5LtseqxQnkymPXMOQEnXtmFcalTNWKbp2AAy7mFFqzDpJYGAMpg2hZwhprOF3gJL4wZNTYWYtM2fZ9nv7e17ICHSZJKEYQVaSa+WZcjvDSClKgW5IxBB4J3WgoMSMcZLkJNt1S74NOhhnORQaCDxdb4gljmo5qWC0QkpDzpJj67je9rzx7Iq/+Okxl/jFn/oM/dDT9h1TU3FvZvEerJOUWNAOhClc9C2H3rBwhqvNDi0FR9OG+5UjAVVdc1hpVClUStF1/ejfCkAGcg6YVOjSgMTSdp5OjHN9JhJAjb1aLSxkzaKu2YkPZ4MfW4c/y7FEQQgDUmJTYjY7RKbAvFngrGPTrVExAQNXl8sx/WwtVVWR4o6biytc07ILgaHvqPJA2lwiTx6xOJmghGC3vuL98/d4ePKQrrthuLn49qAhGCc8mthht894tu05awfKbuAmdUjAY9nEPJZIaMnhfMqisWilGEKEIphbQ06ZGAeUluOArVyQt3IAfgg4a3DKUnQa66pToJpZVMjoIsil4ENhwHLT3bANaRxGU/bR1eeFshKlBSBIAiJwuelpTItSmZgyvmRmswapNNYotJIUMQ5fOzpccHlxjWAsYaiM4sVFzaeOD/nXb7/P1TCghrE+WVkJSlIpyWElSCVxYBKjxLNgcTDjS6+/yteePuOt6yVSFGbW0eeBFsXSB3QuCC24Mz9gdjDDCEHbduSUmUxn5JQIvmNe6TF6HMbmb6UkvQ8IZzFCgdGouqIbtkxmDTEkNGCkBB9JlWK1jKwHT8kF9iU9z5EMJVPymEm52vbUYj2WbKVMyjCXGislzVwha0GQGVkk9+cL2os16xDofKBWilemM14+nfLfPjnjrIukCEIKtJVEmWlC5sAJ5m7CC0dz5G1EoWka/sLPvMIb59e8ebOmDFvu6YaEJ0nJ9dCyyZ66cZwcHXA0a3BZsO07SoF5VZGTpx9ajowmp0IsUNkxk7Tqeoyw2CKwwpCsZJM8R8dzBh9wBSZS8d52wyb2SAXLmIilQNjb3/NgM2zwscNEBSWjcubo4C4TPeFw8YCDd7/Bf/vvf5WXD1/g9M4jfvt3/w1daKmbiuPFnJmWpG5cI6QRGCmpk4Cn77KO4Kzl8bOnbHZbpk1NamCdLpnqMRgxNZpwGxKTw5LN+bt88/1Lvnp+Q4mBzy4O8L7DSMnNkMhF4JqKh3eOmM5m6JLZdT0pJma1g5TZtR13rKPczsNxzuKA1a6jygGnNYeTKV01cOMjJ0ezcZChEMyk4q2bNS1ggUvvx3kTaS9L/LxIjFPEEYKsBNqMaoXXKaBzJCbPEDLOGqoEE1chKkmgIKdiXAPbFesh4kNiYjQvzie8fHzAr7/3hPNtRxZQbEEZBU5SRclhY2gqx8PDKeN/X5g1iT//U49443zJN262+G7L52cNXbeGlFlliYgB5RQnR3c4mDWULOjadrTB6YScMl3bcuAaRM5Qxs9BTIlt21Eli9USXRlyiGzSwOHBlMr31FKwsJb3V2uUPSSQeLZbk3PEfEgb/Ng6/FJIUAUKyKwBhVIJckYATlvsZIEnobHU9ZbN5pr1+prry4TsrtE6s92u2XUDhMBMF2JOvPFv/1+cHB1w8PBVgpvStS0w0HWewQ+Iksgm4x1YpcgpYrWiRE+7XpPSbdf0KOyJjwkQLGaWWit2QyTEcSJbKJGdD0wmDTlkFk6PI5Ll2PTrb9PRPhayEEjrSFpASiilvt2x7RAcUXN9vWIImVmlaZwi+n109XkhpBgn10kBSoJM9MNA23Ucz2qMMfRdoG07ln3HPV0zNxVGG4RS1BqqiaZKEiEFM224Z2sWxvLFO8c0zYR3b5a8dXXDJmbqSYXIAVU0p9OGu4sZ282O2XwCCOazKe5myZAzPiYO1IRaFbQ0Y519ihxNHEYp+ran7zMhQiGx3W5YqDklRg6qGsrYJ5PIRB/HTJG4nRiJRinLKLIoxl4ZAUbA0bRh22XaoXDgKhqn6fc1rM+H20atksa1pCToVWKXA7V11GhC7+l7z7rreXB4wtS5W1sdZ4IoxgngQggWVnNv5pg4eHU+50+/8IAnqw1vXy9ZxUStHE2lOZnWvHRywMPDA/p+lAAGQdPUBAlPui2rGJjUhmIyC1chhCIAU6loFAx9z3aI+FQwJbNabTk6PqAkmNmKGBMpJbq2xzmDKAWnNNYYsIUhJ7o2YZTCGKgoOCVY+IrlsGVH5ngyYW4d3bCv4X8eTCcztNaE4On7HufsWDOtNdm3bFbXPHt8xc/8xZ/j4cMXWZ9/g8unT8g7T5EruiQ5cA1SRFxVceAsRyS2mw1dH/jMZMbRtOKdnOiyobaTsT660tyfzHnh8IAQM0ZLckoYo+lz4slux5AjJ41FAXcmM7Ia9/aZlmgUu82WZdtDztRScHW95s7pIZJC4wylCASCdhhQUtJoQ6UNdeVQypB6SYwDISRcLjRa4YxmUTUstzt2KXMymzKra9p9hP/5cbv2IcdtOGvwKrGTmSOh0VnQdS270LMdek7uHbKQDm0UciZBj/MenNY4KTiwltO6worCg4OGP/HwPhebDe+sV1yHiJWG2sBiWvHC4ZyHiwO6zlPXFSKBcxVtTjxeLwk58KhxeO85qWoQgpBhhqNSmW27YddtISWMUFyt1tw7PgQSE2sQZSzlHeIwKj5KOc4bMQZlK1LU9H2PD5FKGiZWY52hricEEpfDhsNJw9Q6tu3woW7nx9bhJwN/wJcNpaCKBGFRMiOFphRJCgElNMJOUGpDN3ScP7tCdksmZNabluwDDqiFQmrFs+srNu2GByFwdHjIQ50oy6d0bcu2bdmmQMme5nhG7SpkTpTbbu1IxgnJvaMZKUUqpcYa/AwxZm5WW7YpEvpRNQgBJ7MG6yxaQOl7Ykz4mLjoPNPbKX0uRZwxYA2tDyQKIuZR3eA2zb3sE5WQWCNxamyY3Mb9Zve8yClTYGxKLWNEKIbM5aplajWNkygRSQEQ44fpdDpHW8P5dku/63jpcEGlBEPITKRiYQ3WGGIprPuOO5OKB4uHSFfhkyQOPc82S9YpMI+RlDIIjSBjXYVyFmUlCyt4dHrAED1VgYIgC0kfE5fL1ajMMvRshoFM4bXTA4ytkFJSypYUBnwMvLXtOL3Vka6MpraWYgVDDHSpUCvwIRByQYjCdeuRBJwArRShFFb7Q+dzoaSxWzDfRvdLKcQ+c5V2TA8k96cz7k5n/O5bTykUTqoZlRBs/cCGyMa3vHg4R0uJj4mpkcxqxcxW7Fjjd1tmtebPvPIAXTX4VCAUhjzwbNcSRWY+cTSTA6DHVI66tixqQ5M1j07n+BiZaUNGEsp4QLm6tb9N27HzA0jBi4sDXOWQUhG8p+RI5wNvbJd8whyBABsjVmuUGlPW2o1D7G5CzzZGaiTXbRgnUwqBFQqKwO8zTM+Fw/kJlZvQ9x2d32EM5CwZvEdIwfHhEZ948SWG2LG8OSPvelzMtCFyHjrmSnNoJMMQKF0i52EcfqQ116sVfes5nja8/ugubjbnlEi/XhKGwOM4MAAH0wlH1RyRMsVU1M5xWBukNDw6OQKfqJUmUgg5Ywpc36y4igPrXUvrA1IqXjk8pKqrMYjGihQCfSi8tdvwwnSUMRyFpQRICClijMZKw03Y0XWe6ZC5WHcgxiFI5FHZqt0fOJ8bWRSkKAgBiEIaIkUq1vTMZMW80hyXhovVDpUlU62YKEWIsPaehet48XCBMztSyky1ZlJpZrVjdRmIYsO8trx+8AKqmRBCJPqBLndcbDtiFhxO5zSzGWQwpmJRVdxrKhCOO4sFfgjUQpKBWIBUuF4uWefEbtvSfrAGHh1iqoqJNIjdmux7usHzezdLXmpmAEwqh1YaKQVeJoQWNM6x6jtCn4ipcL0bmGgFOY8x8VQYwofbgz/WDn9OeaxVB1JOlDQu7EoqhISSJTFEpB7VJJTS5JS4Xl4xLZ4pmdK3yJhQSkIyDCnRhcgueKbmnBPtOTk+pO83DOsVKXla71FEHh6MsmDk0dlTSjGpLJOiOGhqYhkjpKWMTmE/DPTDjk3yyCLxIVOE5GihRuWAylFlT5IBESJdHDCqIlKoEdRag5bsfBrLk5QmxUxKhZQybR+Y1BaUQjBqze43u+dHTgVRMvlWpkFkSLGwjp5t57HKoM0Yea2kQQiFVBqlDVJKRCkcVzVhGPB67NanZDofbsvMBl45mvOJu8ccHh+x9YJuu+VXv7Vh3XesvSdTKEJSUhxl5qzhZN4wlZK6UviNIsaA0mNPx7b3bHvPKsYxpR08WQiKUkipkM5R+Y4sMhnP1nfUCDyFB01DU1UgBe1mRRaC2jq6VIhxIKXITd8xFwbnHIXCEDN+f+h8LpSUR1GQXMbSKaAMmd3g2ZpAbgqTiSZr0FYzpEyOmS4Goh5rkI8qix/sOK9BMcpvxnHMe+g6Pn1ywCfuHHLv9C5tgH478DtPH/Pe+pptGPjsvbsIIUmpQBFMnePhfIYG5rXlal2IsaCNwCpB53s6v2TTJzJp1JWWBnEyqqfgFJXTKDxRZrxM9CWNnxcxThjXSiNiQYqEs5Zy25xM9Gx9ZKblKNKQBV0Y1/M9Hz1VNUNrB6If+z18Ty6FEAec1hwdn/Lqa69ytb0i+DXKGKrZjG67YXOz5vhwSiMzriR89JQiKcoSS8Wq99z0PSfThlePFty/d4cuFa5jT46R83VLmxJ/4sFdBIKcBTHD1FleOJhQCcnxZMoy9YQ8StAardl1Hbsbz7X3xBhpY0Rqi7IGdatuV5Km6IhQEY9nGz1SShpRoW6drQIoKZnWNasYid1APwR2g2dSaZTQ+FSIQ9hH+J8j5XbCcymjPyhuFVA7keicYWo0VaUQG4kzhhALOwI+FdqS0aJw3DhiCPiYqLTAqrFH6GbwbELg8PSIV08PuXfnHt2Q2O7W/M7T93j3ZkU7JL7wICIQow+aBQtX8fLBHGRhbh3XQyLmhNUaLRWbtqPzK1qZiENiOwxjxtVYpNI4p8lxLP2NOdDGno2vKWQmQmCMGQN4EqQSzCZTdikR/DBWGPQ91o2Z/JgyXfIMH1Ia+2Pr8KeUiCXdlvSMQ1d2cUxbRCExZEieTb9m5hzy9mAgkZTQcXcxwa9WKJHJqpDIrENiFVtkHqebjnHRsbbQSItoplS7lhABKfBlnNgWfaLrI04o7s+muKKIWcDsEFESRhSK73m2Ggd7hRJRUnIbByCmRMrjCWxSS7SQDFGyGiy7IbEpmVNtsNaRVaFyheQTi0mD0ZqkBsoQ2OqEFpqQC14KpFA0+ymnz480lpSJzFiGJcRYMwxsO4+zYBtNLolZrglC8qztmJfE6bzmZDYh7zpEHLM1sRRucuDaDxTAKIFREqM1dVVRVZathKmxbIeeUDKhRMIwkGJP30cmSvLa8QE2G86Xa946azmuBSfzGmskq924IkZTELeqAdZoCoIYAihwduwZ0EnxqKtZtpmbEnhgDJV1JDJSSmbOcjSfszMWv9sS2i1KFRSKKG4XYAGTDznlb8/3SC4gCuRRXecPZj23beDp9Yau7wg645ThGzcX1EoxtZbT2ZSH0xnt+gabM6oUbJGUBO/vVqRUqPWYKdRKUDlF5Wa0ZY1hPMSmLChkYurpO48fBhySR/MFKhfWq5ZvnG04qg2n8wbnFJe7Wz3okDFGsTCWqatRQpHCWHPfTByyjjQx8YV0xLofpRkbN2VSNRSZcVnQdz11PeFOEXgpSO2Oibm9JWi6NEb+ct7XUD8PRhXxgkSiiqJvO6Z4RBEU6bDNnIM7dzjbnKGL4OS1V+m7Lf7xe0yWl7w0n3F1eUklJQZwQhJj4a3NhlAyE6MxEkROWEBaA9OGWikcElMUMSbafkfwgXbX4yS8eDhH+kwfEm9uOhqRub+YUBvFk8txDzZDQQLH1jFtGnIuJD/OJpk4i64zVcy81k053/mxdMwZaucoQlBVDaHtaeqK+1IQ9I603TFtNBqDMYrIB9roe54XIhVKzLeemkSoAnLcg3uV2cmEip4goKoMTzcdRgpqZzhaTLg3m5O2a2SI6JjRSEQsvL+7IQETZTBCImXGmIIzDbpkFBJZQAK5JPquJcQePwwY4M58xiA8XdvxrfMrpo3i/nzGRCpuutFPdbYgyBwYw8RUyCJIwY+BO6NQVmMrw+eGAy63glgCWmucsaRSmKgaHz1103BPKfx2TdiuaPQokICU+AyUxIcdn/ux3aljTIg07nF9KVSVo1uvAbA5EknEviN1HcuUWNQ1fb/D5IFPHx9zUCsuth1zk1gPkUEUWhN5vBt4IGu0uh0mlDPDMIDwKA0+ZyprOWgcXd/z1q7FKsPVTYvRUDtNzIWHDx5A8zLX1++Tuhs67zlLoxbqp2ZzJloTYqKPmTSMaj8hZrSraaNh03sODw1qPUDsGPXOE5KCIqGsJedMbTSxFPqUOWksURpU9qSSoUi0+Ng+wh99fELosWlMjKdJhJSUAj5lQihMkqXJFghIVbgzdbx6eszJfMLCOm52HTNr6IvA54RXkm921zy0M/ocQYux3jBFPBFjwTaOu3rGnWlN13Y8Pb/kcH7AxdUKbSR1bUk+4YC3z27gwYS5rFECzuJogz99csrEGHyIdD7jO0iTSPAZqydso2HbW44PFc51zNoOm8chdIlx2t9B3ZBzxBmNtBWlD9ydSBpl6VIay41y+Y7Suz0fHTmP2vMljfJ036YUYikMOdOlzNBlpg6yydyfz3n18IS7xwvqWnF1FdjcOjpZSHSRPMuR42mDT5HKGGqlKDEi0hplB0pJ3GkcR/OK3g+8/eQcJRRn1zcYXaidofcJreHdy2vkyQHH0wqKZBnHSNMXFgtqa3F27GdZtzvE3BG9xzhDmyZsO8Xp8SHT1pNIiJwJw0DRoIgc1hOIgsZW6CrSDYkHiwOSD7R4hjRK9n3YdPae7w0NiDKW8gkh2Ow2nNzOTqAErBYcTw946cEnOT46JeeOq7ffRpmak0f3kbchuIHEmJ8UaDIXwnPcjGWEzoxqK37oCYzBikopXpnNWUwqur7n66sNh67iybNrhBW42tBHeOHF+7yzK0xzTy0lIhfWKSKAP3l4iNP6dnCSYrvpMEcNO5/J2rHbZFbbyMnJQ+a2pY0dMkn8kBB6VE+ZzyaUXKiNRdnMTkZOGonWBj8EBiCUTPyQztae752SC2QJCYpIFBR5GIO1aSrIWiB9ZjesyVOHAV46PubloxOO5xNmt02uO5kY8PikcMXwxHvuNA2STGMNtbKkIZAYBQEmVvHyYsrUOXZ9z8XVW8wnU65ulmircfVoA5VW3AwBZwwia6RUqHr0GR64BhHKKIxhLX4YW9B7n0nSsdkmNrvE8fExTd3Rth06aUIfKSrSWMuBrckx4bRG2posPSeNBluD9/SMe8D6QwoXfGy9RV8KfS4oIXACutUSrRQxJbyPSDJSKJKVKDzbXSRtW5oEi9kUrRJvdh1rHygItBKYJPmEmXB0MOXBYkFTabQZ9fPRYy395w+PRlUBKZFG4YctddMQfeSt6zVnFx0Tp3BWMqT3eXe9hVJQBTZtRGvJV6+ueaGZcG/a8HDeIJTGWYWzYzNlKYW5Mdg+MXOBu7Mpl5uOp22L0JpSCmfLDQ8Wza3yi8JMJxwUzeXmCimhu81ifzANc89Hj98mZBlrp4sao4gKQfSFVTuQ23EQl3cF7RR1ENgkmdkpL957EQE8fnzGs/WWWCJag9GaT6kZ949mPDy9x6S2GCMZUkKo8Vn/p594hZIzIQTWqw0nkymL+YwUIm9e33B2cclUwJ96eJf/7E+/xjvbNcuQWKWBSz+ggK+89R6vNg2vHh3wwuGCpDSVzhhtGdpuLPeYNtC1LKwkz+Y8W6643q6RyhB8xxu7c149OWFiDM4YZndPmZbCdr3CobjseroAqOqH+JR+fMkxjdJQoXx74NSYcoLNtiP7SJnWKJOICuaDxEbFvJrw8r27CJW5vLjgREFXAkWAEBrHwEsHc166d8S0qjBakVIEFEZp/uwnXyKnQoiR7WYHLrGYzehrxdtXN1y2LYe14/Mnp/xnf/rTPNmsOYs7dsvM+WbgyCm+8uQpn57XvHpwwOnskHriUDpTVzXdpociOZjOkG3PEYmhlpwvbzi/KQht0Frz5uVTXjs+RQLGaCanh8xxtLslUwyX255tTtRur038PMhS0fuem5tnPHv2mHv3XgJqZC50bT/KUdcTDhZHbLcbLp6+xZM3vgHbDS/fP8ZZeHx+xpF19KRxMrOSHBjJi6d3efnuMY0byx+7lLGAVpKfun9KiYlQMtshjVmoBkwjebrZslp6JlJy8tTxclV41kfeGTy7kLjsPCdK8V+dnfG5g4bXDuacNAcs1BSlYSIku80Wg+TuwYJm6AkMdLOKx1dL3r2I4wDDyvB7l8/47NEpGpjUFYf3Tpj6gB9aaAzrIdEngdP7DNNzpdxG+WMBmcaeJil4qq/ZJM2xNLjKopSkCRI8aKl4cHqKxnB2dsaxMXRmHCRZcqaRktfu3OXRySG11Wg5NoajFEbBTz14QEqJkCKrtsUpy3TW0PYdT9Zrljc9lRDMj0/58689YjN41jnwZNPyraslLzYT/uvLJ3xq2vDybMFcNzS6GmUwrKRrOxpjmZ80mLCjAP3xhGfLJe9ctfQ5clBPOd9t+OTd+xilccZw+PA+E+/Zbtag7aj0E0Hw4fbgj63DH3wkxQRakXKhi5HMeMFjdjuTShql6QCbFbskCD6guxXBB/pSiIlxNDsSKxTTqeb+QUNtDcaM6WzQEAUQMDKPwzhEoZTC1sN1t2J9e3jYhkQXE8MQiaWwbDvIhZkxVJUh58JC/f/Y+9MnybL0vBP7nf0u7h5rblXVXV2N7gYgggNiOKTGbGQiNZRMNv/0mMm0mYkzGBIisRC91ppbRHi4+13Org/HqwB+moKEJLqheMyyLCuqMjMy7olz3/Oe9/k9js60l5ZWGmkNsYBfAselMXyN1HSqorIkrKlFSOdCygFCwtQWK51rwRmJkpV5XjgtbRxEKoezGlmfNpsPpby05D6+7e4nyEm0QiwXUoZcJVkniInjUvjl63coqbm92cKamUtCaoWOFVUqWit2o+Gj6yvG3mBs83cIpZoxiYzRilobEtYaxeHxxOv7CV8Ld5Pnblp5pPCzUMgpsV9XpJLsnOW6cxxDxYaVHCq5KqS1SKUISPy0Mk8LqZRGEhKNorKugpArMRdyquzDQqmVnCJTFUQknYgs88KyrkCFKumNafiEJ/39a6mAPBf7lb9V9dMCuCuRTJXtRnRJ8Hl8QAvF1cZilGTOtfGnqyHkwpQLP77a8PJ6x6ZzaGXan0EFAjLX1vGXggCsQnC3n/n6/nj+lCozhfk08+lFJFfJIbQsh5vOIaXkePRc9R2jG9DGUbVEWkHIEj8n7k4rPiWMklwZiSGzrhAyxCKoMTPFtv5qrSwlE0VFeMU388xAuzLPpWK1Jj/1PD6IHvbvcVqQc2YYBvp+wCDIUpBiRpaEqhWhBBfDyL/95a/55a+/wJSEUhlbC14meqlwRRJK4pQyP95d8epmx6glSkqElijFeTSmII2mKoXKBZNX7k8Lv37YIyQ8xMzdEpiQhBCIKO5OMxLBqBTPth3LHHk5Dly6Ldp0ZAXOCpYomWbP+0fPEiNGK16MjiEJ/FrJua23kgvzHBmEhFoJJaGLYiqRXz+85+p8vlR6pLeGdf1+hJQn/d1VS21YYlGoVGoRDWZQgbVQdCV3AsiENbNfYZkiMRRG17MxgkVGuipxpaX2zqrw08sLXmx39KZhqfnuFZaRub13i5bICLYK3p5Wvpm+IKbAlBJrKiwxw67tv/d+IadGRbsdOhYKz7qOwQ1IY6lafLcHzqvn/rgScsJq2GlFR8avklwFzlhUVZzSgu0MqlRKzUQpOKXKF/t39OeZfak6jDTfOwvnt7bgTyVRaYEzMcQWUSwbrrMIBbUia6STiiIL/jgTl4n5NOEPB2SVICRKSewZr/gYA04reuNQjUMIQrbQGQ2pFOTZIFJpRuFY4N20cggeXwpGKVStxJw5lYhQ7XOSUnClHHOMZ3MnpNzIAdnn1kHLbX5/LZFT8KxKYmQjcAipsEagcnuwVYhWR1WIuVBDZF5WBII1VUYjEaKl8z7pw6jmNp8pvq21SqXE0syU5ywFSmUrJSEmRAErNbWUNn6TCqkUrKwop0i18LCuWGXoe4dSZ+ynEGfTuaIUgRLtArye0x3nUPj8eCAKwRQT8vw5hZg45kgW7epdFri2A7KuTGt7ceVciKWc0wqbOVIKQQqJNS4sSrGxklgSUhicE9Ramas5z0oDNeNTJNTMOntqLswpYXWHUjDHpxfeB9EZRwd/U/OL+p9/TAjJzmpCyMgqEAJCDrx/PGI1PIbARkmsVG1drgsbM3LRDUg0VImQEiErQlpqCd8Z5YQEKRUhFV6fDgQJ4Wxco0IIkfer5xgb2lBKSScV+9JmYOecmUthWytxTeRzuqkQ4EMzzPles6Oe4Qei3WhqyRwqg+2RSqJq41XHVJm9Z5WeEgqGZgROT6bxD6Kvvvw5lMTgOq6vL5EyI2iADEpm9UemODP5hWdXz5mOR2pNZDJv9g/spOHOe261o9OKguSbeWGnOrada3Q9mj9PC4m0hhQj2ihKra1zuYIPmXfTShQtyV6Utu7nkPl6OfJuXVBVsFWNYT6XVjfsvWeMhr5U0jIzr7I1V7Qi+ZVl9igJt0rjQ6ZQsVZjjCLEyFg6rNGkVCkF1hAIMXNfKrlEdoPFFJjW+R/6Uf3j1rejjTRPSVNbH6SKqDCoBkmJqVCVIObI++mAV5J9CFyg6KSkVsG7deW5bZ45cW5WCXHeB7Wk1jaqKkVtIzpaUoH7aWLOof1/ZyrPmhLfhJW9Dw3XjsRpwxQ9g1RMMTLnxKZW1nWl5ozUCgSEEJimyCQF150993YUzml6VVHLzImCz6nVvamiaqLGwgnwp5aurrRgCb/rWE7axlJKS64tpSESUfK7TUIIQV8LUQh8CpSwkvzKtES0UBTquSAXpFrYp8CYLKUIiqyIKii1mTG1VqRYKCSotd0q+MbQP6bEnAtOKTbKkHLmEBOnkkG0EbMEXCgDuTLHwJqaYzzGwloSSUY6PWCkJsiML55QNUqBRaCMohOSkgS1tKS4KgVaSlKpnOaVJQZ6JUlSkKvAp8T8VPB/MNVSqeK7naatwVjPZt7zQa1UXg2Od2da0vUwcNF3TPOCzg2/KktGaIXPlfvV05uOWCrq/OuFgCor8ly81FzbwTOXVuSkyttlIVcYjeZ55ygp8ehXjiWSS0tjXVFcu5GiPZMUSNUCQ1r3NxEDjEPfrOS5EH3Aa0WVGlEkylisUUDBJ8tc24vOnDfQ0xrJodGG5lTIRFQpzP6p4P8gqi30rU3xVCrnDkD97sMIIXg19tzXlRJh21uG3rLmzBo9D34lK8XWGGKtzCVx8InSTolU1Qp7kEhliSmSc0JQSbUFxvlaeAgroVY22nCtW1DM/bLw5jCxLwkpFbkILrRD13ZoDCkRU0PJxRhZSmDTdxjdeNPz6pu/oJ4jDpWhc5rOalKu9KadbjptCKWwXxrms4hEDZXe5GYEfaL0fBA9Hu5Z5xM3Vze8evWKljdKu4msmXU5cv/wBevhgBEFrQS7sacmzxpWlKw8LAHjFLUKYqXtgYsn50KlIAXtll0KlLaEEMilAJVcMnNIrCFzCpk1B0aluLSOmuFu9XxxOHJXGhVvFYXr3mKqbBkPweNjR04VHzylFMaxjck6q0klsaTMpDUxF5CS3hnGzrI/VIxqCeO9c4RauDtNpFJbZk4RCB/QIrLMT+/gD6Wavy32ayOWnQt+UcXZ20RrdA0dhykwEdn2js3oiCROvnLwEakKVRpyraRcOYRIqhGRFQrdCn8hkMqS4trGhmrLdvClHQaPMTKHyEXn2FrFnDMP0fP6MDGRiblgUDwXGlkqUlZ8CPiYSKWyxEiKgWEzoiUo0SZXlpzRQtLpgtIO5wzGCFKKmBRbaKeWhJSYl0DKBS9gTpBKQKv0u1/wK9HCYiqVVNqGnoTGCIFSpRViRSLjAbhEVaBGZM04ZQg1ssSIVJK1FHzJBCpTzRyXlbHvMEIiBAgSxhhShDUkSknEkHk4eN4tK7MRCKm5MYpLpXj0iddrQgrB8i02U1Z2xuKk5p30bGnjRCm1tLjH1ZOcxlkDQqNkpChJTBnbgVDffi4Vk9scWZGGrtMclpW309wOQDRW/5QSspRWfD7pw+jbQv884lViewl9+/GaKyrDH766pdb3LCFyNfRcb3qEhpgi67noIRZ8TSw1cyye+9OJq3GkR7c/o0YwBu890RdEyYTgef84sw8r+zUha+Vl5/jhZmQOkS+WiUFKpiUwp4TXmSvp0FW15GZnWsBbbnOPj4un1opIoo26KUlWsK8rF2qDUaIFcCEZpKZYAM1gHAe/8P5wRCuFwxGFJKQV9S3F6El/76pUxLf4hdrGCwrlXHAJigCU4GfPr/m12PNQAhdjz81mw+Asx+PCtEaqDvjceOSD0RyJvHs8sOl7us61tV0UVhZWn4lrpNJudd6dJh7iymOMdGhuesurwXFaAn95eMSfKvciIUQiq0o3GDbVIAQ4JDJB9KWNLAZPTgVrOqxx9H07OB/XE6NQSNPmcNU5mNAoRS5wMfbcrzNf3e8JMdNJg9GOY03EknF/cx//pL9HWTeQckRqg9YDtTYyjaIVQ2uYeb//mvrujioK202PKoG0QBEw+4VS4DFG1pjRUnDZWU4x8/bxxOgMrlosth1ec2b1iWVaGr44Jb46HNkHzzEErBA8GzpedJaHeeXzaWZaM4fcUumyqvRacaEc6MSoFLpATq1ZuIZ20Oj6ns52jcRQKwsBKQTGajprcFpTBGghKbWyHQfu5pnPHx5Q2uCkxqmROa3Iklvt8aQPoppao6Oem2LlPPglaUbeEgoiwmcfXfGbd49ID7e7Lc8uL9i4jikfiUlwqoVQIhbBlTW8DQvPHh+56B191wMNkmBFR4iREiO5ZE5+5c3hxBQT+xgQsbJxihfGcl8zXy8zfs3sWVrib1VspGSrNYMViAikij/fsK8xEimI3CZDrNNUD0sKaNVjtMQZiZSQdeFSDggajvZumfnV3QNaNbqatIajX5Cpouv38zH91hb8y7IgtEBIgTobai/7lmZmtEaISvYHig9cXg/86Z/+P1j2RzZSse0ds5esRKSRpFIgFnQx3JfM1/sTP+4chsoaE37NqMOJYeh5u0QeloV58TAnfK18c2oUncloroxhQOFl5tnYkXULnFEF5iWilOR/M16w+IjP4HFIJTkuE18tJ26dYTAapOUYIq5mpLLkWph8JObIq4sLfvissc6XZeUwTfgcudAjIJlOJwZnuewM3dPL7sPpPLtPgRLPHHTaTKFSAu0U48XI/+5P/luG8T9weBGw0qK0ZesMBy25kZJjWIgpEXwhevgynfihu2erB6IMLH7m5D1a77kYBu6mmdf3B949PnJcJwDe5bkV76d2xffTix1fv77jD15e42XlVDMhrvzi7T232w2fjVd4v7B/nMlRUU3P63d7vlCSQQl6q5Bacn9aGQfH9rbDF3g4zaQU+Onz53TDFVIX/DLz+H5lzYVLOjLw6Gd2TnPTD/TyCQ37ISTOQJRvZ/cFnDM/QGpAgus1//pP/hn/7q9+zpspoIWkd5ZdZ4GeP1KOJXnezEce/JEgC8cS2RXBTz/+qIEJ5kCMC+HBcjkMvDmc+OZ+z920MJvK/bJwpPKQPKdj4sTAP795xv/17Tte4dhXWGpmX1bUsXIlNP9084z364l3x5nZV6QZOByObAfHa/8OSeXCaAKJ57srLob2Qnv7/oBC8E8//ohuuELpTPQra/Q863qS1hzCjLGgq+TKGrbDk2n8Q+jxuOeHn3zG5e6KnBM5J3oyoDj5E4f1hFQ9f/jpH7EoyV+8/Qui92y15co5tJbcjiOn6LlfFt76hf2UCSQ+3o/85NUtRcASAqdl4av7R15cb3jwidfvD7w/TjzIyNslsBJJuTATiXLDH93e8Ge/+Io/GEZkMRwpyAo+ZrabjudXF7yZTrxbEqFmTGd4t5+42oz86rhQCwxSkHPk+spyO16SU+S4rEyL59PbK3rXYZ1mXVbW2fOx22JtxzfzQraBrgqu+p7Npf2HflT/aFXE+V6z1haACd91/Mnt9jopzf/+n/xz/uLLX/Lm9oQWmq21XGhFtJqfDTuyqjysM2/mmf0popXk0vUM1mFTIaWVGAJLvuNmt+FxmtkfW6P1N+HA/bw25n2NxLV5+/7w6or/+Ksv+SebDYdTYKoFSWFaPB9tR66t4U2eeLcsrElSrWW6f+BqO/I6zBRgKw0iJi6eXbIZR47e83B3QlT4vVcvMcOAAoJfWFfPK91hbM87vyJV4cJaLp1jsN9vDf7WFvypJEotaKGR5068Ui1aW8uCJFNqog7X3L/+DWMRDLsepwQ1JrIq3PYb3uYjS2pd2Quj0VnwdVjYnCaebUa2fcfFpp2iYlroteQAIARu0+FPK7d9R8yZ3gishhphKRXvwVrZWMJKkI1GhYRXEDuJsRJlDcPYc5j2/Hjo6bVCC0FB0HVb/vLhG9bjwigFnZZcDj2XzhA9eAIlF7Q2jMPIDg1UooCtFQxOE5+6Cx9ctaHQm75lfgvonOZy0/Plwz22Ji57hzUDVhlSDAgf2CnJo0gc4kpMiedWAZrXy8zm+MAzLtmOAx/vtkitSd5jFfTOsBu3WGM4+hO/r3acYmHnNNvecvSJmAXz7NFB0meDAPYUtngOXlGKBGfoB8vtZmCeNDfbK/qhwxhDLgXz+J6/fHigAhutGJxle3XBdhjIuZCyJ+eI1ILN0LGjZ0qnNuO6HdiNHWF5wiJ+CH1X7/9tw+55HdZacUZy0Tt+9c0Dtiae9z3f0tnWNTDPKztriAKShCglndZssXyxHLmaZ6SSbPqO3fY5UmViCJQSkCXTK4keNCUXNlnxGAOvXM8PN5u2H1rHlepYomAumQKcSmLs4XVcyErRKU3Xd1xfbpjSkdvtyCcvbtrsfU7cPd7zzh84eEfOkVErnm9Gxl0PIVPON2QxVXJuXSyL5N3pkY/GAa0sh7T+F30u//+iT198ymeffIZQmni+ZbcoqIX377/ii69+QU0ry6trXn/1l7yyBjGMUAXr4cQaVgZrGWThHZkMPO8sip63y8LueOLZduBiHNhuLptnzkcgIUVmcJJ+3KDUgRgF+znwsev44WYglpWNbTfjV0LT19b7jaLyLnjc3FOzwjjLuBnZbS95d7jnYuh4sesQohJr4tFnpnnieLpD68rGGm6HkZ3rmDxkAlOMLFSylKQE1q+8nyduupFoDA/r00jPh1KtbfT6b2b32810m3evWG247jo+f/0alQLPuoGu61AIpsPEfPI82zpibCPRc8n0VqOU4H2Yeb4uINvY1s31FVVBivk7f94gDR8PF+3QERJ3S+WFG3m13XAshV4KTqeVUSq0bTdCU8x8GR6R8wapFMZ2dMPI7WbHX68HtrsNH7nnKCnw2fPu8ZGHMvPmzYztBJd9x7NhRzdYSs74HDgsM8c1EpOg1syOwpfLgV5YjFL4/DuO5ZQIRBGIXNGyFRTlbDpEKioJQSQDx/sHBpnJOVNyQ3pOMaGlpKMZJJCVjdBop3G95jD78xBsxXWSmiU5AinRC4GyFi01g1QoWzn4jJUSVQV368JNp3hcZ8baYc5ozEpiIvFw9PRasrOOja7o7BG5oHJGKnXuElcGXfmkG1tEcspIAaYKUoAQGpXIh4Cs8LIfscBj9EgsSE1M4J+Sdj+cCtQzran9CwjKOYURbrYdP/vohuNxj8qSXgsoMykJ1iJ4FxZeSItNoEtFCsm1cRhp6I3m7fFIyJlXJLruCnI+j98kOg03oyX1lttsGZ3j7rRitEJK+Or+yEfjwNt5ZaMNF9qcrz0LgcoSV5yVPNtafnC9bYEew4jrJH2vUVJRkuTlxS1GdczrRF0TQmj0KAk5E0Mh5pXH6UT2medmw+A0x/vC0J83mlA4LE8vvA+nwncUAUAgqGcu+kXf83svrpmXAyXD1glCjPiSORT46nSi9iOFjBWCC6XYCs2tsejO8Pp0YvKel9sdfdchREsq18ZwsduwLZVqFC/MwIUTfHWY2HUdO+t4czrxexcjf31/4Ep1XGiHUKA7MElxzAGlJbfbLZ9cXWOMQQ8CbSq9NW2cLFc+un7Odp7ZzytfrRNBi3aTGwuTP1EF3B8nFp+47Dt6CZ/vAypJYqjsc2QJTwfOD6Gr22fNVxQ9lG+/xi0E7otvXvPl11/xo9tLHk97/MPERlZKWttcfA18vTZ0oRSNFDUayUYrPhu3qM7w5jBzWjMfRUHf9dTazLaySnZjxzhY0IorY9howxcPR7a9QSnL14eZT7qBXx6PXHc918qcPQSaRGXvF5RWXOx6Xt30KBFRvUHIgjY0I0Ju++MqNft14s06c0wFKQ2bEFkXD2u74QoZrvoRlSMPpqBkK53mEIlPY7X/ZSXbPoioXI0dP3t5yzxPFJ+5GB2yFpaYOLLwJq1cRNXqJCHotGKQkh+OWzZG8fr+kftp4fnFlu3YQZHk3AiQzrYQrJ7MpbUMVvDm8cTWWKxQvDmc+Mnmgp8f7xllz6XUGCW4uDJIKqec6bXhdtzy6uoarSt6MHRa0FmLlAKV4ZPra3wM3MeJN+tEyIVOdlwOhdVH1uC5mw/4WrnZ7XCq8vbg2bkekQW+RPz3TN76rS34RXOSUUt7UMMwUIREaQGikPxKnPZIU6gloKnk3GLl73xkXgNd77iyukV603wBWiiMaRSIkguHxbPkzJVx5JzxsRBiZomZIhKpFj7bbNnYCkKSczNChgobbdj2jpILxyVyFz2jVDwbe4wASuFhPtGdGe6iNpOdlN9i8Ao7Y5qpMmaOa+IQM9ZlYpUwR6wQaK0ZXOvgdrXNK4acmyHuewYuPOnvrlJK21hqO4AiGjhFCBh6w+XFhovtBXE54oQix3Yjc4yRr1fPYV3Z7a65sopBdpQqGJRBoHFOcswVmTPTNPNFgZuxo+RMCJV5iRx9YKktZO6fX16w6duFekiJVGG3RtZquXT9dybKt+vC1lie7S5airSQHKcZdaY7KiW+o0oJLRDKcSsLByrzunAKiXl/5JvjkaOvDFIgyWhlWgCSElyNAzZ6Uq7cxYXT8tRh/RASf+uf0OhhnK+4nZOMvaY3hkjEKoGumUrllBJfTivHEFDjhq2U9IMjJAWxslGC3jpMTohUOJ0mfvMGXmw35NTMZ4cYOKyBKFoWyqeX1/S2BRZK0SAFm2JAaW6sI6XK/bpylxZeWMfLq4FQagtDOh7QWqGLQEqNlI2eJqWmKs0FgpwKO+2oNXOYA3/++RseU8LpRumx2tLbDiPgakwIlSALlpTw+cm0+yE0dD0Pj3ccj48IIXh524y7h2lPqCvKSIzUJL/Q9YY6Z0pOTN7z+WnisAZqP3JhJKOSLNFQUmKsGS0sVSk0sCwrv353z42z5JQ5hsD9sjCFQGxHXP7lq5d0z9pBUQpBLYZcPLLTXHcdIWce1pXX88qzrufl5UCslVIyD/vHNiGQGtxAqkY/U6qR+mSniUWz8YqcC8d15a9f33FKnpbpDIPr6ZxGFLiNIyauUCS+ZsL37K4+6f8LVRqeVwDnIr/W5uHsrGLoNFZWSgkoq9AIyIkQFt7OE1MIlDKw0QqjOnzSkBo1xxWwsaBkYllWvni757rvyDkz+8DDsnJKiYRAS8HHF9dsrGtBv7nwDNAIaqfYKseSE3u/ch89z2zHq+sdlIIoicPhAUTBIVBCIhVIJTBStb1Ra2af2ORILbBfVuKb9zz4hZQzlExve9zYoWVlWyKqRJaYGhzhjOn8X9NvbcGPOHdXASEUXdezpIxWUIsnzAeWxwe2lz1SQd9plKiEkik5YiVMOfFqMzDIdhMehEQWhdQVdQ6w8THxfg6oTfumXXxm9plTDATRcBhGSnqnKUhShcFJ9pPHWYXRgmmNHGtmSZFrY/h4M5JK5rgG3hyOjEo2pGdSqGIw8mywyAWlGmWiVlhj4bRmSogkZehiZGsNo9R0DdJOpyWqSvY+EVKFp5TJD6ZSCqJ+a6b+z70Slxc9t9cbrHP49YAyEq0MolbWWsnxhKuCQ/L83sbhhKWWFmaTi8JasLn93jEl3j8e0bWtwdknDkvgfp44lgCmFVkXQ0+qEFJmcJb7xwlrR6yUHGbPwXtCrgza8unVRaNbzJ6vpz1WwlwKo9cYnc840IoQCu001hh8DG2e1p94TAv3a+aTbsPFoNkOGmPaur0YO8wMD0tiiZFYv99m86S/mxqT5/yS429T+GE7OHaja6QoIbFO0itL7wReSVgWds5QROGy0zhhiDEx+YBUit5Ieu2IqTDnzJvHA660P2FJreB6O81EKhtn0EKw3Q5UAbkUnHEc1hO7rkPUyv28kgMc1syrUfHR9oJHHzhNE19PRzpnyakwx0yXS7uWFxIhBdoYtFLsjGGNzVz+7v2ex1J43jmuR4vRBq0lpcJusEh6jktsgXU8dVg/hJbpyP70wOJXxn7EWkcqkW/ef0mtns3gUKIV/eacnJu05lgqkolro4m1cNV1jKpl6+wXj5ZgpaRzioLA58y7xxPSNS/GwXvezzP380pEMpzHZne78bz+YHAD+/mRn2x6qIV389LW8ey5MQMvtiMHHzhOK8fHI71R5JA4es3YZbRUSNG6IEI36t8gBWuunILn4XHmQGaUcNs7BtdhtICqueh6EJUlFnwpSPG0/j6Y/rMMEokQZ0KeqOz6gV1nSMkjrMZ2mk51yJpYcsSguLaWtSSeDx1OCnJqxb1UDXu+0xohJTkV3j5OqNjeZce1+Z7u1hWEZtdbtBTs+oFSKiklxr5jWlc+G3pySoR5YloTD8vKlXHcbrcs68zxNLHfPzQCnpJMIWK7iJO6nWFQDdGtJKM0rCVxWBfe+CNv14VBKS6NZbQCowUVwaZziNh+nmvh+96x/9YW/OXMXpZKYmzjLZuUUVIS5on1cM90OLAbN2A0z6431FTZzSvD+W/15/dHrNVsbcPErVmQMThVyKoQauVUoGrFUluXyMdIiplcICm4UAohMlTT0s6kpBiDD63gn+aVaY7tGkZJnNOY5jDA58zDsnIoEm8jp5BAKQaaF9QARUmmEBC14KQgZMGjLwQ8gzUsKSN9wJ0PCZKC1RoXQcqW2vakD6NaGta1nqGI1FZ4SQGvbi/45MUlVldyZ9BatNEFIXk+LVybAYA/ffc1tttyoQXkzJoEUSk6o3G5kHJmKi3sbTqPZx1Wj08ByAgB19aQayLFiDE9Xd+RSiT4iHWau/tH9seV4Cud0DjlUBVKiZzWmYfHFSNgrxKzj/xECi5oIUlOG1Yqp7RSKRhRkTUx58waA7oThNSILRva90ipqgWECI3QgifL7ofS3z5k/udFxYvdhle7LbIWnDD0TvDi+garLVfLxM62MaD/9/tHfno1spWSpBOdURStUVqRs0SpClWTgYfzTc2cIzGlZqy1jp3RqFqhJpSyGO3O1KcD1lre3R94czpxip6Lrm8vtiwQNbNk30YfVSXGxHJf0Fqzo0cKgTOKUCtLat3hmAPHlDiUxN5HPjY9KQpiLghSQ9gKiVAGoyrinI33pL9//ebzX7IZN3z87GNevHiF1prH+YG/+sWfE8ORjdaIUhk2l0zLHc+fXaMQXJ5mLnXzm/3Zu3cMw5YLJQlGUrVEaY3WHTkHfK5kFIMy7H3b/5LPiFyxSrKxlpvRYmUGMkoajFYUKbg7ZJw1fHl/4JvDxNEnLo1DKUkNkRozp3XhcZ55PvTMJTPvC6O2iB6UEPTKscrKkiJTjswpstR6Ti7PvOgHRDXUKrEAQjBLSUW1WzWp2m38kz6IqjxjYAFkoX47oQ08H3tebHoQBa0d1mqur64xsjJOA6N0APwv77+hGy/YaUEOEqcA5yil3ZYjoShFlZbDt3tgCKRU0UU1n4AxyFKopaClwjpHrpX3y8SgDd88nPjm8cQxBNw5TDOEyOoD+3nmtCw82w5EBPNjaeCZziGkwukOn2dSSYScWFNgroljKhx85HqwCKGAijl7adZYKLlgqqITmqK/X/rgb23BTwZdwWqN7nrk+epDKklePHVZcBakSuAjixTYCqoKdFHUWvm9Tce2swgl8T5wmFeEK2gca6hEUTBG8NHQM7S1QU0Nt5hTZSVzovDF3QmtFm42I9ebASEzO2cBS5GVVQt0AZvbKfTd8chjjC1YphQMuY16qNbRH5T8btEmH1BS8rgEQmyBS1YIHDAoR5EJZzRb1zoo3/jMnEPrrOh2c/CkD6lv56dFo1BLkLLy7PKCj2+fsx07zHJiK7eEuSC0pFRNVm2M7LNh5LLrcapymGa+fnhEOMuz3Y4YI7EUqtY870cG114cyQuih/kcSAPw8/07bNG8vLzm+eU1Wjguuw3ITBgGfIFJwGAquML7/YGv/cTDvBJzotOtuzDnFWMN4zC0PIskKfNCrZX389I8Iwh2ufGAlRDElBAVNmcSwPs58FWYUAs4adDmiZLyIVS/nVU997C/q2sFXI4dH99ccLMZGHLEuZ7FRyoFQcHhqFR+PDh2Y4dSgmUq7A8B7TQDijW0DAdhNJfDwNBKGsT0yEEHsqhcDR3HnPjN/oB63HNzseN6d4kQhsuhB2HZdoXHkHEV+t6hs+Dh+MBD9JwWT0yNoX+lN5RcsUrT/y2qhA8BYyp/nVpugBZwqywrmaLaFXivzHfr76t3J45qJdLY6ZinqN0PoWcffcqr58/Z9ANSSnJO/Plf/Cn/lz/7t/zXP/6Un7z6COc9zO/xPjDVic7aNgN9tp783mZgHDuElIRJcDwmdClYAmvM5FLQVnAxGrautQ6+fl9Yc6CowtWgeZMjv94foEzcbjY8226oSnI7DAjheOkg9pIsTmysZlCOx/3Km7iwX1dCyrxZFq6GHRrF1o5c2I62sUdO3tMpzdfe8+A9g7DscDyEPWq8ZDAdo3VY2dbZPHtmlcm5trA79VTwfygVckNwfqvznlglDL3l9uKCm+2WHR6lOub1hNOSEANHP0Gt/P7Qc9V1DdGeYD8v6ByxzhCAnAtaws5ZlGvP2KfKQQVil7m2Gk/hm/09SghutxdcjRekXLgdNyipeLHbkktBTmC0Y1CSw/7AvT8xpUhWmruQeKk3FCqDc4xDawrm5DmFwCAM/ync8+BnBmW4VjtW19j8225g2w/Y8x44pwzKcjydmGZPCb/jBb/WCmENUrfu0rIsYBPT+3vS8R2yejZW49LMrasgBasvZAHqXL2/HAZ+fTfhU0YLzWBGXA3NsEvisDR05nZX6DYDD/NKqRGjC4MQpCK5UY7rK8fGGu7WzP/y+g6VE79/c4lWsNuOuHFgGwKnZSWEzF3wDFJzqySRQlES5xR5iXz+5oHXSrG1hp0SJGAFllw4lkyg0CnLDoOwFodhXQN/fXzPROIHlzt61aE2HWjFMj3NT38oidLm3RFQREFm+MEnWy6vR169eE7vdvS95tX4ogXBAeuyUpYVlQtY2O4G/v27d41ykSo6CJ5bwf79HikFx9mzpsJwtUPf7jgcTtRa6XX71rQi8UM7MNie3Wbgq3nlP/71r+iz4I9/8BFW97y67bneXfByWrl7PLH4wC/CkSvd84l1ZJVRSrFSOB0X/uef/4bLceR22LGhssSFu1w5rYVDKCy1cGFHXg2OUgoSwzJnfhnvKVpx0Xf89OKG1+LAHANPN9r/JdQK/48+GpG94PbygitzwfNh4OqiGcuKgBgKKQiMHVnywqAk//6L96w5I0qlR3FjK+8fjgiZ2c+BOVc2lyMfXV2yfzhQROGjTYdUPdMUGDO83F6hTeXuuPCrN1+Alvzhi+c4q/n4+S3Pri85zBNvHg4Y4IvjiWvbceMsi04tFwLAwr/9zeeUXLh2lpej5atpIinDtK6sIVCk5PZyy59sm9l8zfDNYeX9MqN6MKqjyx0P656T95j6VPB/CH3+xc/5v/8//0dev3nDkj2fv37Nj/7JDZ99csNOKdLhyOXg+OTZlhsHKsPqI0EqLjc7QvGMo+HP3t6zxISukq1y3FjH8bRQa+JhiawFrnyibkce9gd8KbwcBz6xO+bF89lguNhtUUrxMHv+3RdvqTXx2c0l1iWe3w5sdx2fTJfspxWjKr8+nbiyjhs3ssjcMk+0wAfP/+3Xv6RUuO06Pt52/OL4CNJwCIFjCqyq8NHlJS+3DoRijoXlfuLt/gQWLoYNlznz5frAMUbcb28Z9TsvZRTSKoQGYQAJu02Hy5XLoWdnBp4Pl9xe91gCJWRijBRruLra4UPAAf/x9XuWmhC10mXJjZIcjzO1Fh58YK6Vi93Ki+2G/eGIEJlPtz1FbHg4LdxYx8dXt1RZmXzmP73bk2Lkk9sdCsur6xt22x0vJ89xOiJy5G5euNps2ZTCFBJDP9DpwpIK/6/Pf0PNlQtjuR4cX86nRrdaIyFkPIUXl4qf7W5Yl8DjceZxXVC2fZ9td5dYZMPKk3D2d7zgr0BJhaKaSc0YDSSogVozkma8iSVRckTSYaRm2wuGXkOWfPPwHh9Ti0mWmRw9npYkqoRGWwGlUmrllCMxZ2aRmqlCKkwBITLv1oX7EFlyJYvKzlpyhZIzuUqWGFmCJ5R27XiInlkkNlLRS9lmXjFMOZNyu4qRuSCVIJkW5BVzoZRCoWAUBBLJz2zN0CLIhUAqxSEnBIlpP1MT8ESo+GAqALUN9LQ56ko/KKwzxOxZlgO9dMQxojNoM+C6HqUM43hBqZlffv01YW0BSk5JrFOspZKkxAHKarSpRJHxIVBr5eA9EomSGlMlPmdmv/AQA6eY0cDlpscpjcyFxzVwWmZO68xJRFCV4xKJOnNhHDtjEVVgjGJVnilEHsuKigJvQOjKvGRqFS1KHBisYtWFdQmMypyDdgIBRVwLTkgOPrfE4Pp0y/RBVIB2k9sM/0CvFZlCSgs+HkkBqhftUGd6nCnonaAbNCU7/urnJ1CVUQsMFQqspbAPgcEJXKfQVSAr5JSxtnAfEhrLTlvoEvOUWUrAHzKnnNG94UY7OqWQJfNw8pzWlZQi201HionTKUHybLRlY87RWDnwJnrW4tFVsqbE1z6hdEtiFVVRsqQm6IviUWbmZWUnOwatUEKQqiTlyIg574mS8uTZ/SD6n/7s3/Hm/VuO08TjPBFK5KN54H1+z9gFNttLLvQVwYOMgao7jNHspKAfHCkP/OWvvqCkyoWyOCURFR7WQKgZKSSds1gktUpSyggLi08oYRmVwnaWk18Z8sh+9hxjAa3YWY1SkpILb+aZ0+LJOTH0ba9KOfO4eAZtuOwdWRRyhm/WlblEXJX4EPj1lLm2fUtg1R0k8LmgcuWhBE4xce1GBq3IJZGT5P16wlRBTQWbQZSnjseH0neBpFIgdWu+bbUBFUnRsy4nUuipvt2IKimRzqGNoR8GSor88suvqSXTC4lREg3MMbPUjJGCrrMYBLpKcsooITjWilaarekQpZKSZymVeVlYMyAUF85gVatL3+w9p3UmxtDGta0hzBMP80JvNNtOU8jkUHm7njjGFVNhIrOeMtd9TwwZoSu5FKaUSGvgnYgcvGdjegZjQAhKrSx5BtmTqwChqOL7lfK/xQX/3+KuSolSitPpRA6hRbP3BiUgxtAS8wQIUZAStNBUIShFYqRCCDAStKzkkqgl44UilUo5/0i1sfRlVlQhUEpwoSQdhc+XACSs1AxKY6VsnFYqk1+ZUyLWhNKSTglu6VnPhBchJJ1QrcgX4jxbXZhzYVIwKkuqFalkSxfOjUoQyfRJU2Uink0ZRigeVo+VglIlWraT75M+jATfGif5boTaWsPtxRYtKus6EXRmMZKdUghZochGgOggp4a/7IRGIem1pLOaOSQKhbkUfG0YTZ0L8TzDr4QkV4GSkmutkTHyeg3UkjFCM2iHEjD7GYDHxXP0Hp8Twih2g+ajDGsILUxSVozUlFoYrKXmikiVafUcKtxog1USLQRZQqkga2W/eGSt2FpJpRBrwhXFu9PEzrRD6Og65FO9/2FUGwu6/bw9x1oqV84hcuY0z0y9ZRssbtTtWWeBQGKNokqB1BpTK062H6VUjj6SBCwFshAU2XwYuWaUkg0qUNoh47rrUKlwv87ELCiVtk5yZPbNKvZwWpliQCm47jt6LfjBdscaI0pKtNYUUfGxEnymxEyomcdaqELywg1sjCJae6aQVlKuLDURSyHUDLVALYxm4BhntBRcdD0X/YAPTwvwQ+irN295v78j5sQaA1iB1IqtdZACy3TCDz0+Rpy2zVtBK5ikaiQwLRSShAEcgkxlCYlEaQ07CalU9Pm5K61xuXKG0XHTW+5q5G5ZOcVIrRItFClnYmonvYfDwhQi2gg2pkE6Pt7tWHxES4kxklQrqy/4VKgBYm3o2iAyF8oyak12LWlxyYlYIkstKK0pwBQjoXp2suewLnRFMmrDVTe2vJMnfRAJKRDyb4p+oQTayHMjtLCsM/O64L3Dja4Z7HJFILBatD1QSYxSGCHaoVMLTmfseZKSeK7/KoUqFdYYbKzUXEEXno8Dx6Vyf1o4hQUlNU7BWhPL0sbQ3u1PzME3gk7Xc9FveJVzO7zKVtuVVEjn5GcSxFp4zJEkCzf9iHXte6YIsCJSZWsAYwxCSEIqLCUxFo2PGVjZaM1l1yG+Zyn/21su1maapDbmNAimZaaWgjMaayy1VGr0oPS52Dq3wRCtyDcakwr122JbVlStFAmhFEJpmC5q+++d00gP/vz7bIxCpEyMpaHwdG3r6dztBTh5z5ITUgl6bdgY6KzlkBJrTNRSsVqzrhElJEoUKG306EihK6UFukqBQiEK5AqZikJASUQKsVYGFFPwVCHY9SNj1xHjEyHlQ0tUKFREhZAqu75DUFn9infQpQHhNFJCyo3bL0SjpzhlsLod5BQKqyTZKGSpTBGWkgml0quCoB0IpFAcQ1s7W605es8SM6JmjG4d+BgTS2zjXPu1vfAQkp2zXI0do9uwn2Ymv5JqxmpJjZnOGIi5hWoJOJTEtezoTSvmSq6kXPA54GNhdJpSaR+riUFX1hCxFEbXs3X93yC6n/T3qpb/8K1ZvDbDoI984jZQ24FtDpEISG0Rsj2/er4RqFXgjGb28TvDeS6tcO46TSrgayZx3n8kGGmopaVNlFToe0Nylm/mE0JZTG1kk2NOjGcU3H5emHOk7wwSydYpPrtsybk+ZRAglaIgEUlQUyVTyUKQq0Ii2RhDdgJFuxGdc0KU2gAIuXCKmZwKm26gnA+fl93A0HVM61OL/0PocTo15K4AoSXSCa6eXfGD4YpytydEj0+RLCrC9FASVXyLoK5IYHSGY2hz9OJ8m65qpRgBQuJLIlDYioqSglE5DJI1n2lQWjMYzRePE1nQQAGiMuXMVddGdw9nfOKoLEpIRqf5gdY8zitzjORSMVKy1IrI9bv1JzTkc0en15pcFUWAiYIlJ4QQDNZBFpxiZMmene2JKSNz5WLruNyMhPxU8H8oCSHOP5p5V2pBUJXt0KNLJubIEgMJiTAWQaHkTK3lW9QGzlhOMlBrodRClWfrj1BUpQglE0pGy2bC7juLFBBLaTSebkOOkV/NM6FGBgW6CI4pMNrW9NgvM6fgGZzmWu8Yuw5rJIfFM4dESqWNvsqKqhIylCqa50/J1hg2klphc/aGJAFWGTZaoxKEEFhSy3gSSbCWlQvXsetHUvldH+kphVzOhUlKCAlRQN85ZIKaGsfedh1hlggqSmqaVbK9ALpecbeUxnHNFYrgZmupgA4gCKw5o5XAqcJF71gUPPrMWiq5CFJR7KSlV5JFVPYlUoDn57CttRZ8LvRC4YTASUHXOVxyPCwrj+tKzgVrFHNqplyjFYNRKF2xVVDLeRFWUKWyitb9yKISyJRaUO293x5YrQxCs1WWY36qtj6YhAApzgVUOzDe7yfW1dPLyiISk1fcXBuE1s1Yqc5UgVyRKjM6Q5ECHysxRLIQPNsOZBx6CaTYuMGdgAun2W4G/BLJ+5asF2Jl8omhSkarKFqylISMBWs3gOCYH5myZ2MsG2fpheBiu+Wi6/n68MjrwwGZoVeKlDJIcFozOk0SzRyeUqZKcCKz1swhRnZyxEmDKpKaKzoLsohcn/F5o7QMUnMK/h/yKf2jVSNDle/cukLCfvUNWSwrSRR8rWjnENIB8XzZWSAXpKxsXKPo+NKaFTFHnm8cqndMoSJiJNbCqCUX2nE5KI7ryn5p5LGjz2QhWH3CSUXSkJWgonC2dbdmIo/JQxJnL4th3Fi6wfD+eOL9aWGQjo023ClIQeKU4qLrSL1mqw2GRt0xppBj4ZgCV7ojRKj1nKpeCjlHtsKdw3EqpQjKt+nXT/p7VYoRozUoEFZgR8XPfvoZz2rHYyrk00yWEu16akgIkRBGU5WklIhOYJ0mP8CaMkciuWZ+cLmjWE1ItY32yMrGNcLd7cawzpKHkFlK5X5K+Cx4DAudNggqmUzvDFa19beQecwBosCWTELQ9z1aazjO3B9XjFFse8GbQwsnHJ3hdhzIVnFlO6ySyJQQtL7hFAs765BZkFJpXdkqqRFGFAiFKIKSKzk9vYM/lM45q6AFQiuklhxypCqB1C0HpNSKdhohHJQFIdsILaUdOp1VhARLygiZyKLwrN/Qq5Y2H0pBCMFOG0YluOodR6U4hECqlclHQinMTDhtoTbimEDi+vYuzKZyDIFSYWsVVYY2sz903D1OvH+c0cbS6YI8KFKBzhqebUZ019FrhamVtUqorfm2pMKl6ZFUUk2UnCFnqmqNkKQEQihKEfjw/cCcv7UFf6a0l1qJHE6PBDxXvUaJQteNGAZKPPHu7Z4yZ4ypyJZMQ5WtI7nbjqQkiDEDFSkySgrmUhnGDqU13keUElxveq6vLjnsH+m788suRqx1zGQ21tKnTMqZ7aDQQ08CfmgMVlacgpQlrw+P3GLbqFAs5FCZVWKnzl9qozFWs+sdN1ISjjMZhULRG0GnDF/HExSNDQ3DWUgkAt4rXliNEAZVMqd54u3pKeX0Q6ldJzaakpIa5wT/4p98xI9eXqFLwVRwQrDMMz0JpTUU1QhMEnJKbLaWj/OW1adGpFAJpMKXzPbqkqGPpCWglOTyesPl1Q3Hh0d+3HcsPvD+OPHiektdM9tz6IcSsBs0aujJWfMHrzTOCDpjqFHzxftveK5GYo2t05EFIa88HzYEsSA7Q98ZroaOV2oHAYQO7JeMxbIRgq+WO7xdufUaSSGLQlGQteS2SLTs6VDM68rn9/t/4Cf1j1Pib82SCSXQPfzxz57z2asbnDR0QjEawTIfWQFBPBtPFFIqMp6Ly55Xy4Y1l3brKRJKKQ6+MvQ9tUrmeaGUzPbjDdvtDv/wjq1YCTlxjCtWGQY9cuEskuYlurrYwDBQSuZPfvAJVguMgpQUd9PEJbAUzxITS8g8LA/YuTCiMN1ApxWXneGiUyjVc/QBXaFHkqrAl8R9KugEIMhCUlVlngKExFZaOllYlgO/fn//D/OA/pHr3/x3/wJhJV/v3/Grt58zbCxf/oef493Ip8+fcfPxR6hceXz/ll5JbC5kCkWAlJrgI5cXF3waKsfgqVKwcw4FvJ1najdgKrAsrD5w+8OPuN5tePv+PZfOM6TIu+OCtQOvNpdcW0tMhVzh+W7ADjtKKfxvP7MYDUZJUoLXhwPDmplL5mHx7FdPnk5cY+mERndbBqe56hwvdgMht0RToyrOSE5ZsMRIToUe14K+NC3oLWdsLnx20aOM5XFa+c394z/wk/rHK20cuhOIQSK2iqoqf2gHfnh1iRUSJyWmdyzzjAKICzVlhJRYZyFnLoYNP3smOCwzuVYuXIfPnnsfyZ1u1dfabhE/2liG2xfk/T1dDPgYeXN8RCvHpd4w2p559fjsebbdkFVPzoV/8cNPsUqipCQlyd10zybDGhP7aWHvZxKBT3eXXPaWq6Gjs4qxM+yM4ZgLi/coJXBWMVdJIvJmPtCrESkU1RqMFQybDYSZH242KFk5TQe+vD99v6/nB31a/z9IloytFaMEqpOwZrJzqNwTa6LIghB9Mz7uLHFZG1MTCUlRCrx+OLDOCzEVhFRsOoezkofjzC8eH7FVMQiNkoIpddiDJ6d2jS4pDIDTBb1zDMpxWhKPq8cngSoFPy1IJ9DSULLk3TTzdl05+EInJUjBZnBYARfDwG634euHAykm1tkTpUQBFshkEAqtFH3UZCmJMSIqaC0YXIeWkk1nzmmrGR8Tkafr7A+lNtHZkpGNATT81ds73h6m1iE3ilebgX/1yT9jGBTrtFJraHP/qRJL4cvXjyzrxLxGlBA82zmGQbF/WPjzdw/0Ei61QkrJMFkkihRWai0YVbgaQNFjtzAozWlOHNfIKUu2AcL0QD84rHCUVHl7uOcXpwPvpoi1Gqskz3cDSil23cBmt+H1wwPBR04l0PUSVtj2HVLMSFHoteam7wkhkWkjZFpLOucYlGHcbgilspSCLwL3LdP2SX+vEuI7Imy7OXKKn7/e8+g9o1ZsjOblbsv/8PErhm5kPZ2oNYMoZBLFw93B87guLCEileJiNOycZe+P/Ok394xCca2b0fFwaoVLWVcMBZTCFcWgND+52dBZzdFn5nj2Fcwz87yy245Ia4i1cv+w5z8dHnDWYISmk5rbzQDVoWzrhP5if+TdtLKGiDEDW9VGKh5TRGvJjdtQThKH5V08kWtl1JqrvkMIwdX1BQLLsnrmEBDfk1DxpL+bfvL7P2VOC8eyoB8Ut9cb7ph4/fBIHCA62CrLx4PhwjmWaW43m99eSdXK8Ri4m088LgtKKMxWcHPRIebEf/j6SwYpuTEGaub9/QMyZfIyfRe4udMKpwvbqxGrDfuTZ1ojoJnnR+bjwvZiQEvLGjLv7k78p/kerSROdgxa89FuaIVUUtxS+fXpwBIid8c2+3bZdzirOZ4CtQhu7ZauaECx5HYrf6kdQzcgS+bq9pL7NRNOjQCYeLph+lBSHYheIK1AIShIvgkrp2++ZECx1YZX2y2/90cfsXVwmponSZxx1gXYz4nH44n7+UCqFd9veb5xlOT5i69e02vJVWfIVTKdZg5qj5+m9h4XBackW6W43PZorXhEcKwSUw3z9Mg8T9jrK6wZSBUeHo/88v17hFNYpeil5uXYI9UlF86xsxu+Ohx4vy7c+YlrZbjZbrHWcnc6IWrlRT+wC4Wa4T4HCpVLa7m0W6oQXN3eEIpiOS3MoSDN7/gMv6jnzpZoNJ5vlVKkrAtZgLQaRQRRSKWx7huzOuFrZdSGICNr9qQUiQLenxK5Cl7YEStBiYoUom00urTZ0gICSW8VzlrCFEE1Q3BnHcNg6IxGdJJjDBxipmTJvDRD0GqaiWlQCislVUkIEQlstTobijO/PB74YT+AEWgl0LoZdg/ZcyV7lDSNwy0LkUIukZAb5YXc+LF5fRqn+GD6NvFDVqqCnAVxjSSt+dHljq0x5JrZ9pZaCilWSoZCK7hqrWx7hffgUyZX0KviN6d31Cj50TjQKVA0n4pMmZwaLSenNou9cZYqDWEOFFERUjRTkdEoWdh0bUb24D25CA6TRyzgu8QgOzbG4qRAIL6L3x61ZZCSSOKv7ic+6zvWpDFCYowi1MKheEZl2HYGJVrew+MSOZSVobfsZ09nWgpKeUp7/iCq9TyPLwDdpntSaaSvj2+2XDlDKYVtbyGvpNz2wEql1EwtkU5KhFLMxRNiYi2FL+fARmv+q9srbM7I1JKXc47UGihaUjIoUbjsJU4YPKCUQmcwJQMRi+ZqUMxpZT6ulFI5+YCIEGVi03f0uqX0Kmkoue1Vz4aO284ipeDnh5mfXThkLmzOgTW+CE4l0nWWW+Fa2J3RZKtZ4so2Jjz5u6vv8LT+Poi00by5v+d+PXB1uUNpg48rykg2WrPVzUu3NYaaEz6eR18AyKSS6TuJspKwClIu6HXl8+nIZTfy3zx7hsqJmhNCSGqtSJkoUlFSxohCPzqE1MxFI4VEK/mdj6lTkuHCMqfAQwjEXDmltv6osBkVG9PewUYrTqXtf5edxXQOReWvDkd+Xwg6pdjZZjxeM3wxe152G0ySQEUoSVaSg4g4XziGQicUVoNITz66D6UsWg1YRTPgVlmJBaqAV9sdl9pQZWHoe0gTOUPKAiEyObd3aS8VD8CaKrFUZl3487s9g3P88fOXEBMlxkZ+zBlZK1Iocm3ezcveYXXHvLZ9RkrVgrOMoFPgtgNr9KyHRCmC0xIotYJPdOPAxjisUmAEx6V14rWAW+fINfHn+0f+mbEMVuOMIlVJQXEqR27shut6zmERklXAzIrzso3DKYkxBuLv+EiPMRZjDOqcIOasAyQhLPQCrBKIsrQiOAQoGSFbom5OmVIK+yVgteN60KSayVIwxYLRCqc1EhCi0pk2hrHmQE2VUkCqFvmeq+SUMkJklFSMtl2ja62JSmCLJBXBmipL8PRaU2pGIxBVQJUM1qCrxudAVoJUKzlXUhW8jwEjBVoYdAKfM8eU6E1hkOU8HtLCZzqpW6GHIPpMzW22/0kfVkK0OcJaCj5Eau2RUrDpNZ2zaFkJ8wI5tgNaKcToKaXysKwYZbjZKSoCpRtKU2roraGFy7eDpEQQQyCn2vj3UiDtQCiFxyUgQ8ZqzabT9FYjlaAWia4aKg1FN69YpdG14mjIuIJg07sWfuMzQXhSLcSYWXzki5wYVcQqhRKSKSf2PqCsaQmn54OPVG3kzErJ1ioQklQK9qnD9UFUakVKgdACYQScx6qqrhQh6Izmwmq0gOAXSokgBLVUgveUkng3e/rO8UJpYi6AZJ88EoUVuo0rSNGKKCHxIRNTw3cqpbDaEnxln9rIg6iCwWh6LZG0GVJTQJRGPqnAYAxTie2KPZ/X39ghjSHGhE6B+O3LNxf+0/0DnZRcDQ6lCgefeDMvaGkZpMBI0YgaZ2RebyWqtH00arDmyTT5IfTV27e8fvOGh/s9qQROfsbYwkXn2K8n9gfNx5sLlL0gLjM1e5QQ1CJYQyKlzNv5hNOOj3aGVBqYYF6h15aNlZSsKNXQWY1GsPhWNAkkUkqkdpy85+ATvWtNt41VdLqglaSiMZRGQMmJKgo755iyR9cG7Ei17X/SOGL0+JIanKBAzIX/eLdnYw3Puh4t203T3RoYbTP7KiolV0KOSCvYOo2VgpwyIRecfNr/PpRKLWTau5dUEaKSgSgUsRSMElz0DkUmhxlRAloISm6BfqXA3WHFGcPL3Y5cwemO5AWdcWysJiEoiLYGRUvILaUZfqXUGG2ZQ+IUCqZmhJCM1mI1aAVKaGKt5FrJJRNTYOsGDnFGybaPp1LYmB4jNSlG1rRQs2g4Yin484cHrpzhwrXa4pQCb9YFI/o2UnwmNwaRUEYyOEMHBB8ppWC/5xb421vwO4V1FqklVRb6rifXVqhI63Aqw3rA50gK7UgvhWxf9NTMvu+nmU+21+x6RyEzpYTsKkFApCGutZCUqkipUGRC5naSEkIilGP1iX2MKCQbJXCiGXVKabOEWimEEHiRyTWxNY6SwNTWgS9FMCIw1hJCM0ROKZJzRSvFQwpYoTC1XVnFlFqSnBLIUtrBRgqEbDi0TdeMSqccqDmz+Z6Ryk/6u0vU+l2Od7shzPgsWVNm71dud4YfPNtRSyKEFWRBVAk1U3wgpcKb48JHmw23o0GcD5xXdcPRz/hasaKh64rQ5BSJNZJSw5BJqSmix8cT75eAM4pLAYORyFoau5p2OFYVQgqknBl6h8kJWws5RqKQbPoe13fk0mK7pxgosaBF5ZvJ04nAxnUoBEuK1NxOObk2trGQgKzc2I6LvmfUkikWfMqNi/ykv38JEBqkAalpN00aoiq89ys3neGPLnbUlEgpgKznJkMmx0jKma9PR3569YzrQVNKZQkZlxSPy8rjGrFCYKSiVIHJBR8yNdEC57QB0THFifslsDGV3uhWaJVKkrmNu4nWMEk0+kmnddvHciHkSMmC0TmG7YAQC0HCoWTIbf1/czrR6fMtgpAcfcSnwhozxujWkKkVHyIXTnMxdgTfbqGsEVx0T0nPH0J//td/zeNxz2k+cSoLRcHVrsNoxdfHAxsqP3UG0kAMHiFK28tKoYS2/3358MhPrp5xs2ljY6dYkFqTS+UUGzZTGUtWCpUS05rQgBIKpCGLnlPwPM4RKTVOtu5oKYGoLCAbTvt8sVBEobea5AMiF2JOeFnYZNhtBlZReDNNnHzzu1gp+M3jTGcjpUisShxSbASr0kzoTktSTWQfueo7bocOHyMP80qugq192v8+lKponpBagZhRtH1myop3nLg2ij/YbRB5JUWPFAWqavlKayCmwuvHA59ebdltt+caUWGsYomFJeZWUFuNMJpcGg1H1G9xoAahDJN/ZAqZQQra4G2l5tLWrVDos1E4Ukg10duepXoEhZACvkqGvmc7bPDryv1pZg6RKiqXneUX9wemaACLUYJDCiypsKSMEwKjBKIWSslcuJ7rcSDlzH0IKFEYv2fa+G9twV9kBQlKq4Y8rJV1OSG7HdVAiXv0dNfIJ0AVmnx2zOeYWGtjVvuakVlQcsHHgFGFL31gKzXPnMYKeJhXNkpxIS1KSqqUCGnIxeHPxdGt7igxs48RMQsUmowkkPEpseZmqtSijVxAxeeEL5H9qXA1VkiJsLYghdCmj5BKEZLAh9R+rZK8GnquugGzFm4HSxSV+5hxVrDrO07HCUmmtxKnnuanP5QqrctOo2g1wpJU3C0r7iT55Hbk2W5DXheSVAhtqDGRc27o1ZzJohIR+ASlRGa/oHXHl9PEy9TxajvgjOThdKAXhd32AmMUQiqE0m1WPkvmGLjoekop3E0rQnhebDqEVtSSWWNhCZnrTY/TFktAycoSAmuoPNTKlYBSEjkHfGksdtlJ+mLxIfJ4vm0yUvDZdstWd+yc4fl2wxIj3zweGJzk6mrg8a4SY8vE6IanQ+eHkNDAOWFSGtGyPxQc8kLnIdaOm40lx4WqJEJ3lBjIOUGRkNseWIpsxLGaCCWwM4Y/f7hnqIIfDiOjUrydF0qsbLYGp1uokVCaUDVJWHIujIMg18TdlBACrjpDP3aksDLHzDFkDn5lVJbnqo3pnHzk6AM+r/xQvKTWxBwSc8yYKhmR6M1ALooltTE4jeJH2wtudIcR8HIz4kvmzXFiayyb8YK931NqodOa7db+Qz+qf5T6j3/2V7jBIHuBsAKpKpMP+EPB7hT2UvNsYxBxISpHMYIQMjV5NJmAQBZNLpkl6zaiViI7I/mf7u95JhWv+h5F5avDiQstuZAS3TmKFBTRDpa6anKescJQU+bgAyBwXWU7djzOCycfWVNirgFdHS/tiBCCOSWmGIkPe34I1Jo4rJ699xghkBJ+PA6cqHgiPkcqgk+2G55bTZcLzzcDa8m8Pklu+i1Od/gQSKXdMlyZpwPnh1ILQZXtCrG24CofI3OqdIMk7TbcbCw1BgqmEaJiJid/Jja2CYl1TQgpUFqgSmZrJD9/2LOVihtnkBLeHk4YIXgutxjTI5VGSEWpCikdlSODsfgQeFgWBDD0PZdDTwora8pMKRNEpdSVa9ujkKyxhWrmWvhYCGoNPIaZk2+j39pIfn+3I1RJTJmQMlVUXnQj19bgtOJq64gpcX9auHCajR14PE7UIrBK4brf8Rl+ow1VVTIJSztBK6XpzEg3fYU5foFc7rDAUSvmOaJqRdPCkQ6zZ7sd6ZwipkjIidau1ZzmI8F4pOgYhSXmzDA47hbP88sBpORx9dzPe2w1mCqQRXAxWIbLtozeH45YOzCtniU1jOYnV9vz3JjFF4+KEZMyq4eJhaOP7FfPmiogQTdslAU8mUgLDbvWW3YYri5gN/QUoRhjQ5wpBf3QcYyJFJsv4EkfSN+yf2nPX5iKVI0g9a/+4DP+D7//CaOreC8ISTKtsaVF0tbgvAZeDFtuxoE5RNZYsGhQiXfLiSWvFJW5NJZjDDy/3PIY4dmlolB5mCbeHT2DUvSqjV9cbQ3bQVMrfP1+wVnLunrmVJDK8NmzZ4S8UOuGGCOZRBJt3enDkaOfeDvNzLlilAIUV4NhL+AQAqfUkK8v+45Lu+GjS8X1xUBMlcEY+qFHKcW43bCPLV78qb/1YSRVK/SllchBogTIvt0c/h9//0f8m09fsekz0QsWFOs8t2KfgrHgE7wYtgzGsKTAklYUiSlZfrUccVVSgJeuo4jKdmiFzHZnKEWzPwW+Or7F1cqaE0cneb7reXU1UGrl568PDCjmaaGUSmcdf3B7C0DBEeICaqVKgY+Jgz+yPx7YLwvxzPqfgmco4G0hloJWBm0tWggGa3mxs1zvNuQq2LgR69pY3GZ7xfvZE8MC6mkX/BBKNZN9QSmBGRVZNHRvIfNvfvgj/k+fvKIXMycvURoejzOqVqyoKCXwU+LF9pJN13NcPUv0bAxMKfGr+z3f6HZb+sJ15FLYDj2nJbC52pCAu+PK64cHXKq8W46YmvjoduT2dkuplb/48sAKnI4LKYN1lk+2F5Al2jnmeUGEhM2ZqSQe/MTDfuJhWkmiIqVkOgRkAd0p7mPEKM2V61DKMVjNC2fZDIZRCLphwDkL1rBRG76aFkKIjPq3toz6nVfVjaYvSvlucNRIRRaJ//5nP+Jf//gjehfw5277Oi/NOF5BKk0OKx/dXLLRcFoz07QyqoL3lX+/f8tGKH48bLjtOnwtvNoMnJaVZ7ueVCuHeWVeA6pW3vsTQkSe73qeX19SKnzxPnDyE9O6EFPFKsdPn92Ss0QpzRwjUgak8Kze8zDtuXtYeBcCUghsrYSQcAhUhvd+pkjBpu+w0KAb25GLcaQK2A4RpRVZadzQk9eFNZbvnXb/W7tSVUk4LZGqIuZ77P4rdttb7r78S14f7ilxwQiNqZE1ZzopqKWN5oSw4H3go+0FndYspbDPhfvFcxKJH292XLj2V09FYDvHg594fUxMATadobPwqpfcHQt3oXBKK0uKvLzoeH694/X9giUyh8yaC1pWXh8C5IyzDX9XUyKGhCHy+hg51tKuJVUl5IxJgkBCKktcAxWwwlKpPGSPzT3SV5ypbMw5oc1KdtuRNWXePyZe76d/2Af1j1jGCbSVvLwd+W/+4Af8D//yv+N4PDBNDxADv/j8EWMql5uRFDNaSSRt1nieVo4+8OrqGVIIQvLEZeKdLxyJ/NfXL7ntuxb+QsXZkffzka/2j7zfb7geO3aD5tPLjnfHyNFXDnXlmBOf5JFX17fAAiHwuLTrP60yX3BAUbEWDLTD7urphOCrhz0PaW6BH6Wy5IgW8PlDoDMCkQqd0vSdYaXyeXhHF56jFsnGWV5eO5aUKEUzXih2MXC/P/LN49Ma/BDSO0V3YXh1MfInL17yf/6nf8zhGJhOJ2T2/PrLFSc1uwtPzAktOhSKkFeO88LdFPn46jlGQ0qB/bLy1Rx5XO/411c/ZNDtijiVlsT8fs78cn7kWYg8H3ZcOsfPbi756uHA22Xi8THxGAOfXGz45NkzlDqhwoLPkRVYC9RZEHzAOosDFh+ZV4+Wmb98/SXv58TtMCJlC64pVP7arwxVs6aMVoFNilgMR7+gh+eoNbOxhuvRsqRIyZlx1/GiXHG/N7z5nki6J/3dZAaJ6AWfPb/kv//Z7/Evf/SHLIvg7fuvEKcT/+EvvsFZzW4zEnNi0JZaM35dORxW3p5WPn3+ks4JYso8HBZ+/nomkPnXrz7isjPkkPExM8qOd3Pi8+ORtz5zO47sOs1PLnveHmceDpEwSWZV+YGEH9ze4tQRERJrUaw14ULgcFC8Xxa2vcFSmUPm5BNaVf7D4x37NXM7jHQKphxIWvBlmNlGwxoKnW4z2iZlYnjEXb8gR43TkkHAPC301jBsBj69veXuceL1w+Ef+lH9o1VeVmqofHSx5b/97Ef8qz/8Ix72M6fTPTJnfvHFAaPhaqPOe6BCCEgkpjXy/hT49NkFUhdmf+AwHfnFcSXYxL959kN2TrQRtCK4lIY304nP55mXEW6GHRvnGHvBu+PE0UMuiYjnpdC8ur4BviAEOKRATOCKRM+JZZq42O4QKbMGzyGs6BT5n7+655gyn2wvcUowR88xRr48Lmw7RakwSEcqhYcYiHhcLxFRt3XXSfyaKTkzjJaXacPdHl4/fj807G9twS+cQVuFzBNxec/h7j3p/h3zdOJ4OFBjZOwMtlfkLDnFxucppRKyJOcW6a60QSVwprATMGLpnUPIZqhV5xQ3JwZ88qw+0EmF0oZc2hdWVagxEaUghJZg2XUOIwQvlCR/l65aOZZMIiJzbsYPAShF8pFIZtSKrVIsSfDlfGrzaKVgFCgEmUwBahaMVuGsoNTMcQkcfeIH8hJrwRmHUZ4nRs+H07AxvLwa+P1PnvFf/eBjyAtLeMRqyeIzOSWsdPhSiVkSltBwYBnWUFnWjFAFYw0qOWwuXNrIlp7RdSjVuraqQqySzTiSk2Z/WolWIbCUkLBFtdGiWKlakrJBCse2c2gMHxt3TvhtIUWTL0glWoJDrQgJxhjW4KlSs1ONnDKnxC8PB96mhQ2GC+vQqtEJqgCy5qLv6Zwi1cThtPD64cCPPn6BNlsG13GyK0t+olR8CG22ho9utvzBzS1//OIjZBTk5UgvFYcp4HPAbnpiEqxZEnxASqBkUpKkIJCqJY6r5Ohc5gWKS6O42m5QAlIOhBgoOXO1HUEK3q+RRUd2xpJyM98qYUg+40Ul9hIpHFf9gKTyka3k0kxrsTaTmpKGWBJVCpwxSGnIITBaw83QY5TCLZK/mu55HxcGYXluO6yUlJLR2pFrS7UenSKXxN1p4f5w4kcvHdpUnNYYLUj1af19CG16zavbkX/y/Dm/t31GOE487g+YlDn6yFojt1ZRSmVOEj97tASyaKSRKjBKtVsbk9iOiR8phQduxg1GSkJNFBJZCK5GBbXwdlnpjWY0khA8MWacNoAgZUXKBiENu36LJmOtJuVCLZWcCwiBkB2hrFQFfWfaxMC6sO0kN6PFSMX9Kvnq+MA+BLBw63qMbOm/vbNEJMPQM9hmNn+YFt6dZvq+wzqHMRqpFesTOOODaSM1L7Y9P332nJ/cPif5lbQ80mvJYZ7xKXG97fClsiYIfkWfQ0xzEaScyapglcWagbEvCGUosnLdbdBSEEQiikwVgtvdlqoU+8Xj0oyzhbSshJzRtZJzIhVDxSL1wGW3QxDpbdf2wFJJyYMQSGnxzCChNwa0wsWF3lluh7YGpRB8vSy8Tx6q47npsVIypxUDrAF6N9BrQ02F/bry/njix05iikMphdCKpX4/UtlvbcFPmklHT10PhMe33N8/IMRKSJVlWVsn3YCrBiMk996Tc2pJt8qhDcRacVIjZcUYw2gEKWVG1wGCmDOJ5rTXtXDRa+awsqaIDrDGwBIaGaLUyhozxyXyePRooQkp02uDkIWYM6E2hn9K6RxhX1FKUqVoeKksyKmgdZuT9rW0ufBascq0lEoh+fZ2RluFUoLVR/azZ46FGAurD0gpcJ3BfU+zxpP+7vrZx7d88mzLp8+uuOw7TqcDskRqlfiUkbkFuRlpkQbeP55IJWOlotMdxibWFLHGoqXGaYNTipgkm3MsfC2FmDJL8Gx7wdXY8XBcWEPgtLZgOB9aqNyaE1MUHBfP6TihhCakRvgRVEJMTL7hyFIslBqppWDOWFvJOU6cNtfolCIi0ELilGQwFiMllII44/WctWglmZaVt4cj76YTP8i3+GVtKYbGYJ9Mux9EP3t2zac3l3x6ccXO9pyOM9RAzopp9ciaEGJACI2WktfLnlwynVJsdUdvBaEknNBIaXDaIisEKemtRCAQ0hBLIaSEVvBi6LlbPUvw7IVg8hNLbF3PUAJzihx84HicsMIQU6azClHBh8waAiVByi2aXkjR0LIC1KQY9Rm/CAxaU0QzRm6VZmdsuw0rGXce0+mMQSnJtHre7o88nCY+eZZYlgVRBUa1+dsn/f3rD55f84OrHT8aLxlQPO4PBH8kZ8kSEkY0UIaUEqvh9cMjpbQcj40b2CRIpdLJVvQ7YzEIQobRuQanAHzNrLF1Z2/HnjfLwuQ9DwhOfmaNmSpgSZHDItgfF47DRCdUewdbDbqtv4P3yFqaH6QUrJCMViOEQguJ0ZJSClVInNIgBUoItsawM7qtcxqdB86HZSE4hsg3x4n7eeGzuCKmDKJR855iID6cfnJzyQ+udvzg6qrRl04navakIpjX9qyFbCQbIyXvpoVcCr2xbE2HcwGfIp3ukFLSWYXTjozCWY1AkHPFl8ISI4PR3HQj76Y7puCxEk5+ZvK5eUIpTD5wnBZOxxmrDD5VBqOAwhoie+/JpbCkSCgZKRrVrtSKk4rROGppnkCnNEYb/j/s/UmsZ1mWlwt+uz3Nv7mNte4e4e6ZGS8yqKSoB5SUpAQlCiEhVGJCjnLMEBiQYsIIcpRDRskMwQghGDMD1aR4JHoF4gHZxMvo3MPd3Mxu++/OObtbuwb7RvAQL0sekObRuK3QlTzMzO81v2fds9dea/2+n9KwMpaNdiilmB9MPQG8dRhtOITIy/2R29ORr+ZLTqcAyjzk4E/5Dn/avWJ/u0A4QZrZH44MPhKzoZTS1Niqomqzkt/HpVEcnOd8PRBNYS6FkUa50VphtXl4IbVv6oRwypl9jvhSOd96tKlMJZJCIeaELoIypvF5pXIXAvZec+5XLAW6hiJHgCTtH6aSqLXSGUNvW4FVNeisiLkV+RiF1xYRYaUNVmsERaVdLoCGDVOVOWX2S6RWS5bCEgTrLUNnORvfCobeVPzx95/x9HzF+WrEasNhmhgczLF1k6oCYypGKYyFU4qclsC66zhbnzPWyDEEVn5E1YpVCmU8JQmDbXSnOSWiZI5h4tJ51sOINZo5ZTgtxNymTCKNAHAqibt5Yn0Dq9WKUDK+NgfqqiCVJu48hYUiid4oRmsQBEtDJIZSkFpRtD1pI5Unncdqw8OdlQfLVlLJ5GKYQuT2NHOShryd54D1lt47tuPw43xMP7PxS4+f8Gyz5bwbMcowLTPOCcelUKQ80MQMtWqsgkOcOYbIeTfwaLuh95ndNNN3zQ5ePXwYo+l1m0hSNbPSLKUQJXLeremMIubIXREOcaYWyFpREIJkDvPM1c0dm27z0Nj4wXtLGu1M4G6eqLWw9Yax80iteBRaW04xkaXl18p6ziXxju9xylAUeAP+oeBKuRB0ZgqR/WnmGDIimeNcGNyAd57BvxXtvon4vzx5zON+xYUbMBXmecGZRnJCKsa2CbkgdAamGNgvgfNh5PFqQ58y9/OJcdW1/etGe8XURr5RSlHQkCvLHEnZMPY9XiuWmLjJMKVmZBgkk5JgpHKn4ZWCy2HNLJpaVfNkkErJ7Qtdzwc88KjrGKxDasMHe6U5LZFoBLRm9XDRfNZ1GBQZ8Nr+sNiaHvjshyVwtyycSiaVRDwl1uOawRm2/dv8e1Px9SePeLbdcLFa02nNfUgNRrEUirR3mWrMbJyGKUZOIbHp4bxb463lOM+MbmwQDlVxTpNwONu2QgpQU+EUF4Lr2PRrjFLEkDlUxUEyMSVKbS7gSyrsT0dutWXsBsoDN1+jQBVqUY0SOR/QCFtrGVx7Bzo0rmoOc8Qag3OGbdexdponzmEqFGk5+ANtSMyFich+mbmeT0whEaNwzJH1amRwnm3/+eAtP7EF//XH36GEidHAo/XYeOJVyOnBndaAFuEQJpRqrrQhtcNB1UhZJoruqEOk1oRIotT2IGpt7rRVCiUnlmVGxg5n2wOYkxBLuxj0pnKYpbnp6ib+qYcjF48928FQSqY18xUVA1ZxOx3QVXPeN2dSasVVRTKaUoRZClnD5eiZ5tiEb6UwV6FqzeqhiL/bzwxOcYqRlAvKGLJKUAy2GlbOcj68LfjfVDzerhmsodOW3gwcJCBhJkcYrcJZi1DZL/vG2lWZWRVsLRhdsCVyVzKXNSISEUlUbaCjMfJp3a1SEjFlQjac256+c9wvkRwz235E1cjrKTD6AXTllDOf3u35xf6M7WAbDUgqVZrV+Ay8PN2hq+Zi9PTDg3GHaWO/utDy2FSedSN3UnnsRl4tE8ecscZysW0vkNf318R+xSnkdlEQTUkZjMNWxeAcF+Pqx/WIfqbj3KzRSaM8eK+ZJqghU6Jm2/f0tnma7qaWfyKKVDRLgpILU1q4Op04Ww3kEjjFE8tcOB8HOgyqKkQlbC3UmJmy4WIwbJxnHxORQu87XK28Ph7olcWLIcfC1f2B7fMtq7WjRNp7UGWcq+QKv3N/xYX2DHqDHhtWs9OaYuA+RQ6iccpyph3Gd5w7x3WKBITOuibUAz69uuHRamyYT63IWpGTIgLOVkbvebxZ/5if1M9mnOkVqmhA4XzrQpqacGI46xy9bwCLwzRhjAFliBimkklpYjeduAoHHp0NbTqUFmIsbL3D1gacsDVjapt+z7myVXDeWe5qm7wP2tE7xSd3E1szMBpDLsInd3vONmds+455Xh7O9YpzFmsqL25fsTaOodNc2A5qbbz80rr/pyQYZVhj0abjUjtezIFQYTtoRudQwHdev+JCN7AHqmCtpooQacSfVdfxeL39sT6nn+U4H9aI0mQFRluUmAf4L1z0PYO1WNX0PrU2Q66kINSM5IV5OrLXhbNxQ0rtnK3e4WzTvCnAloyt6cGw1bO1wpnxLCmTcqEzHZve82kIrH1PpxWlCrfTnk1/xnYwjdpUpJ3BRpOw/MH+mjPvsONIr8yDIWJlLpG7EFDGslY9o7ZcGM/WOK6WwFIqG99zsRoB+Pjmho2uhJIIObSVuZS5nye63rPuOx5tx8/1/fyJLfg7hF03cjVPHD7+jE9OE1oPdL4V4U5X7qeAtYYnH/4iz8InRLuQBT7bBzabkRgTJSbWzrIyhv2cUb4jxogxmvtp4XoKRBFeHhKf3N3hnMFbQ2cdq27g1f0dxikcD4QVHIspjKuBcWV48XpmjgWpQiwLxmhs0exyYCmJOQZGZ7iOmXsSHlAVJIIxGozmtqRmsKMaCvIwL3gtHKjNZbVWigbFxMX4pBktKEUpUMvbefabisePn/HtV5/wyc01H67v+PZhhymKjVthLWgS15Io1fFiOvDB5QVfGUakCK/3B87OL3kyzXTJMLqOQRtOobLq1swIBrg+LbzYHQmS+WhRfPOjj1g5jxscloozM9dTZk3BCHhlMFiSqwxbz3bb8cmrA1Nsa2RLjJhO00+GT5Y9txH2p47R9Xw0BSZap6uIkKrQmYAYxe/Nd3hMG52XBPuJ0VvutCXnIyEmYooYWzjbbpAiuA6SVIp6u8T6JuLZ08d8dHPN9asrlvsjH+1uuRw3KO/x2jLFwm7ek4vm+/t7LtcDW6txGm5i5PGTS7adp8bENEdyrKycZbu9ZCmtw/5qWrg+nYgVvrePfOv2Ix73I9YbFJUNllOMPF0PxFTxtmmrooVh61mvVnx6dc8pCCEU7vYHtmPHu0PPJ6eJFzcTq3vLc9fxMgaI0gS+uZCKsLKajbZ8vOx5PJyx1Zo5ZyZga4RJEmU5kXPlWAo3MnO29SQp+K60jq78xB5jP9Xx9MkFB+24Op64/r1v8tH+yMWwofNgjGIXE+l2piD8qT///0Dd/69sw4wXzc0sfPD8OU/2HctpYT8vpFToO89mOONmTjhdeHWauHqgPB3vCv/h1TVPxzXWKHqveGc98sndnufbEVUMo/N01pAQ/Gh4tN7y8WfCvARiFg4pcOEV7/crvns48eL0mu7qmsfjwPEY0QZm1abxVSqKynPveZkj29V/cdq9DgEfhe3acjKFUAtzLVynxPn2EisCXZvYh5x/3I/qZzYeP3rKRzcvubn/hHDzio/mE1sGOreiWrhNM8vdPTlX9nHicj2y1ZoOza4I7z9/lxiOlPnI/bxwiplVVjzdnHOaZrQu3B5n7ueFTOGzJfK7n71i069xGpwSzn3PfkpsOqhktLJUZZgE/GhYb0c+fXXHKRRSEk5xYfTNM+fjm3u+dX3L2DmejD37OXI+eBaVWXLkZr8A8O5mw00MXHYjWmuiLkw5oUVjteJEZZFKKHAlJ862G7bbDcZDTpUYfspXel7e3zHFgM4Zr2xz8zQaY4TzcWDtLKVmXi6Rjz7+HoNE5pgAxeW4oqcDEvNciLE0R0llGY3B4llSIeeKElgZz8Z7DiGy6R3WKIzWeFOoHnKsZCrWWjpribXy0dU974WxYRhV+/OG1kHw3mLJlCocYmIOhdFZejoO0ji/a+sY+o7RqIYWnSOxFsTAUjTHeWaNZYkZVRWravG2499/9wVff3aJ36ywDobubcH/puKzm9fkHDAIKUyMAWw3oFXmYrVi7DbElPj4fscxJuYQH7CciiebDR1QjOGYEjy4PhZp6FgDhAglgUWh+45312dcn45snUZj0BgGa7g63XOgUEvhXI+sXY+Q+O6rl3w1XhCWtuagkNZpo7DuLL1Y9jHy0TIxhIULN/LIaPaSEW3pnWXjHM/6FbXC1eHQ3EyN4aZEXh739EZzfSqYAhvt0NXzv3znO3zjyTmXdoPTlq17u8P/JuLV61csaUIjFGW58Bb74M3Q9ZbBWZagud0tRBK5OOYgGFVYmQ5bCgXICQZnGR0glqkIHYFlhmmOpCKY3vH+ZsXxdGTwPYKgKqy04y4E5lIQBT3gisWg+fann/KVx4+Zp4iu0Js2cVhZw3l03GjDMWVeLwtHFXln3XM2jHy2hLbLai2j7fhgs0KXTJBKyIVZGa5L5Xv3e752dsYuNQfhvlM8Uz3/79//Nl9/9oivXJ4zGMNqeOt0+ibiuy+u2acJK5l3XdeoYsBSCk/HkU1niDHy6f3M7/xvv8/9/ZHTMtM5y9gPlDKTc6FWw9p1bLyHhxUggPulcgqAGAal+MqjFdd7Td/bhzVcA1hizGSEijAo01YPc+VbL14RHkf2IeG8ZTsOTPcJEM6958xHQiicUibvj7y7GnnkV7xcAlVX1tahnOYXxjbNDLWyxMxUW3Pue9Oe9+ua1IYcWKV41nn+P9/8A772zmO+otdstCV9znWKt/Gjx4u7K0JcsEBBcWEGFIakAuf9it71TF3Hpzc7IokQhYVMZwuj90gphGmmVMvGNKR102lEMpCWwilDUY7eDzzdeM5xWNc68kYp1tZzPV0BjodNr2bWJbR3YNwynwKlVLSCzji63nAxr7jvhZu4sA+ZGE88GjzPugGVHSOKwRpqqfz85YaSC4ImxcwcAicpHPKRjbFMoSJFsKrwxDn+7cd/wPuXT3g69AzacP4534E/sQX/p8cJJ4VLq7GuIlGhgSVnliKMTuGMxlXYh0hSBVGCU/oBsySEVnYzVEXnDP1gmIMhJ2EprSvZGY2yhsernvNxTZZIlkKpcEyZlCrdQzdMqUJRGlGVl8eZJSWiNAyUN9BrSyoRgNFYslSUUqyVZugcx5TpS9td7JTC5MLz9RotcGYdoRYmEfZL4gQci6BNE1EeS0aLYmVgHwKDs41H+7a58MbiDz57wdZZnnQOdNNmDMBtSPhc6Duw1uHo2I4rXs8nrCjWvqMAkmACqii62nbpx6HjBOSsWcqCMjB4j1jNk9WKi3EkLDNTzMQiHFLmIJmVaKhgVSarhaQL37tPnObMIgVTFb22eKcIuXGJt75vzoK58Nj2nI+eQxD6JE3AZCwKeG/dViLOOv/Aa4+kA1zlJnxP0kRNqVaUKM5j5maJDL4JRNPbHHwj8d3dnl4rHnmL04VZKmUpzKowOP2wcthEsGeu52aaQRTbTlFrIkXDoWgcFUul95btduBUKiU5EpHReXrnUM7waOi5HDr2c2RJCamVY6rMkjBYjGoeFEdZqEVTl0KQG/ZzxOq2BrFZrQlUZqNxxnLuFdorzq3h2XoEKlchoo1l9B21Cu9ttuTaNAQpZ5aUUcfIfWcJAlWrh18v9BW6leKUMvOSwEJObwv+NxGfHI90CGtvsE6Rl4KUBiyIfQZncMbRdYly2nF3mhu0wLimI4qZQ4KhVnotTXO2XrPPkJdCLsLKOtbWoCysOoe/OOcQmomRVGkeIrWd5wChJJSqze18B1MqzKnSW8+Z94zGNDY/it53PFJQpHBuLM9XI6EokB+c51B15el6SxUhKCFJw4R2S+amWwgPBpmtpqgMxoKr3IfEWcxk22qSt/Fm4sX1DSun2XYW6zU5CiRIKRO7VtRvOk/fey71httppio4V30zfJsDp6wwNOOuvjNcrkaWrFlEEWpi1XdsjcFozVnn2T5esZuPnFImVZhSZl8yKjfdWzVC1YZSK7sUSC+EQ2pY9cE6zoaesGRyVZx5j1KVlIUz2/Nk5amiyalpQx2aUw08Wa8oRSO1kHJiWiz5sPD904Lrm4ZLV1C50mmQlLk/zWycxTjdjFw/R/zEFvyuNvMEaXa0jJ1nTpBzZUmZyWl6FFa34vkozabdKk1AMUtzLOu0aUKLoiipid1yLaSaGJzGKsc+JpRSqFpZihByI51EqUQBXRSoShTBSEapikhbZxicJlUhiNAbg1YGAwwPvEVrDGedZS6VHNo0wGmFU4oq8tAVU+0lloSQBEQx2IZOBIgIS830Yjkh3MyBte9YOdMES2/jjcSoNZom1EE7VmPPnDJFYImJyf3AVluxcp67pTnVKtUEvB7LVALOdEBbMKy5kkyBCqkket9cnW+mQMmZqjT3U2R6EDbGnJlTEzzWWkkiUAVdFUpZqlZsuo4QE3OKDN0KrQu2whpN7y2uV7yzWnOMC5k2BbMo/INAaPQd0ES/QTJTylAVZ92IqwZ0GyeeaqGriiCKuzlw0Rdsxw+7Hm/jjzbOfOtGaWPQ2rPuNKcpkRGmkDAKrG6Xt8E59g+Fh9TKKYSGd6uwNR7BEKvilFW7jApILXROUaQ2ke1oCUW4Ok4sOVNLJaXCVGsrpKSgqRjdzL90be6p26FjyYkpR9arc4SM0plN59m6ymgcl6uenAunkBlUM5HrUSyq0nmLq4YaCscSuQsJKTAoS6cNBSHXRjXrlafoyn4KnPqMVe7tO/ANxdZpENDKYLVl0/XcniK5wGEJaMUP0YJLzA8owtYQWyRjgiJIpasQq4IsqBApGDSglLByilLhVZh4MnhirlxPS3vPlkqqQlSwsh1LieRSEdUcWEWACtvBkbKwXwJPhqH1biusjGFlOjqjeNoPzKkyR6F35qETq5hKprMWKUKsiSln7kOkYlgZy9p6Sq1MORFqpldQimKaIvOQcRg+JxHxbfx3xNpZtAKUorOWoYN9yCSBKbRVaK8VzllGOm6XBamVJIUpZazOzLWyUgqlDEk0+yWjqsYZjbXNr6bUxM0UOHcXBBGupoljTD9Ebc4FLrRjkUxWFdtoMZiqQWvOVj1TDA30okdSKqSSGI1m1D221zxerTnlTEiVzli0bsCZUgud7UDBlIUpJ26WhVIrnVhW1mOUYqmJiXbpTKkwzYG4XiNeAz/lWM71A683VBBlWXvDMSaUwJITu1AJRiNUrIJc5UEIqZiomFIoJeJkYKltDGmy4LSglUJqZuUs/cMu/5ILx7iwL4WSCjU/cPSNZlEKRSHVgpGKRTE4z7qzXI6eQ8rcLwltFVo5TGrmj0ZBZw3rvuPuOJHlgdajVUsypUlFUAVOpbALid2SMDzsfJtGvzhSCaah7KaSsSEyJWlmSW/PujcWT4YVh5KZpeXg+WC5nw54Y5hD5KYWnLUUlam1YIzFaYUo4S5OVBFqLlSnHljNikEqfa/plSaXxOjbiPrTXWgUkpJ5vTs1XwdgDgtVGyYDUoVS20XRoLnsNzzeOC5WA9fHPdeHI953GG+o04yVwspYVp3n8WbF9esTD7TNJnxHUTAsRdCqMKfEfgnczRGplrNxxVpritFondinBFIJFZYQCVmgV7i3W2VvJN7pe3ZVKChEOS56z93hBtGK/bKwlIS3jXyyVKHvOqoIuRRu5oUsmq5TVOObmDIJhxLpnWNQbR9VAbkkXu/v+crY8fJ44sVxIUtFixBigL5nZfTD9FJhadOmje25GCxnq6HteR9OGKMwOKwOrJyhr4qNdVysVnz3+oY5wVo7vFZYBQbDMUVc1cwhc3sKfDbNKHH00tbFskg7xLUAlrkUVIiNYAXot1zONxKPO8chJTKVimXTWa5OCxXF3bxwyonROVCKmxjw3lIKxCrcpJkqoB/E14soDrFwkCMr39Mrg1aCVhBy5NX+yM+NK66PM1dzo5OV0t5J43qg8x2zZFKppFpxVrHqPI9WHeerjuvDwu0htIZbBSsVq6HTho2zPNqM/OdX95Ri2HQd3tRGRImaY0gohFOOXJ9mXk8zq3HFqAyXQ0dMglCJqiKqErNQlkSJFdzDz8PbeCPxZBjY5UCuFassGw/XNSBVsZ8XphxwzqAwzFJwzkJugu+beUbp5iaO0VSl2ztwmdk42K57jK7onJnDwqf7A+/6npfTxMtpIpRElkLIwqof6XXHQiFXIUl771z0AxfrFWcrx83hwM1+etBjVmKJjA+0nbX3PN0M/MfrHUobNr5DKUFUodeGKRRcFaa4cHOaeHWacLbjzPSc+9YwlFo41opoTc6ZoRRAo5XFms83ZfqJLfivUgYlbJQh1UqIIFpwurnUhqngFOAhhEQ2uq3wlEyqguDotWYJiVAaY/qdVQ8CzjuOuRIpoFQzM8qamyWCbnuoGo03BtGF2AFJEaVSpKBR/Nxm1ZCGqt0QRw3egfKG2yU1qpAUQs6UWplLwOpG8tFaY43BY7naBYwR7lImiDy4xLeqbN05vHIMtaAy3C0Ll87SK4VTFYOgP6el8tv40eOzaaKaysYYUm4UnUjGOM1tnMhzpjeOrnPcnA541xO0IZTCkiPVw5OuY1lOHGPGOs16XJES9H5FDoUkqnUvtGXOmU/293jrGY3F1DbpEpqTKSYzUwi54Cu8u7lk6y1eaTa2p/bgHHjluNod6FQhC9yXhKjErix0pqOi6Zxh1Xtg4LuvX+M72MdMyMLoHIfQrMzPRo+zmq1k/LLw4njiSa/ZYBl0K/bT2w7rG4mbY2TRQm8U0WimormdI8PKMYdIXSq9bY2RF/sD7z++QGuYSttbVtbyFTpiyZxS0xRtBsMUAtvNijoLS8wsMWNEk3Nhn1pXqqCQ2lYe70QIZCqZUxYOCUy1vLs2rHybRK60J/uKNgVRikUEkaYPSDGTlOJqmRiNpzcdvTV0RnFWNH/w6SvWY88SEyUXzq3js5gZsXjb0xvBVUOfmyFOL4rLwTA6sKatTb6NP/q43gWCSYxOc8qWECuH2jj7u3khzplVZ6nO8M3dHT9/ftaaUrHpNtgKz7sBQTiERNHCdtVTSKxcx/UsHFMmpsxae0xujPOt74i6klPhTPfcl0ioiYpwzJldCRil+JPvvMva9zgFK6eR0WI92NIRyqkJH1NlDplJFJ+GHc/1hh6LUxqnFSu/5ndeXjH0GvVwlj8dB25E8N5jNTivcLZnXTp28xHn4cw5nDFUbRD7FlrwpuLuMJFdwXjHKVRSqcwiDBp2YSEsjeqljebjuzuebzZorTilyHU4gVF8ZdyAblo6QbjYGCqRUhzzkiEnksCma+ard9OR824gSXPvdd6xUFhKJKlEzIldFiqGDy8fsfYOqxzrboBNM7msdUVRO+YsxJI4ZSEpxfWy51G3YTRtHU6pjq2u/MGLzxicpqqKp/mhvFgy3oNIwlvDpndg4XBaGDrHxeAYHyAz+aedw28rHCVTSsaLYpb2Q6WA3husabvwxmhOVqBasM1cw5eCzIHsLU4JUOi85/HFGQDTNKOM5rBEYhaktm/DYA37XFAi2AqpFBQZ7y04gylCLkKDkWVGM7DkyCkXJqlITJyPPdvOIWJZaiRKwpXSHAC1xVOpIuyKUHRmlMq9LnhpXVeAoh1GNJ9OJ5TRbLqOd1YbRq35xngOgO8HqjZk3u4PvqlQwG6emDQoDceQyGi6mDlza7S3KAVGF3YmoqxBG4Ovhl4sqmhKbp0A21XWK8eHF08BWKaJzlt2ITKFRAgCFjoMi6mIUXQYrLd4Tiwxs3K6eTMkgVyBhDcbYg6E3C6MS5x5tj1n4wxSFIlKVnBaoBRDIdM7i6C4OgVKCYxG851pYaUtXmtyFSKZUTTfvLnBdY7HqxUfbC/YaMuf/MpXANC6J6NY3s6030gEInNOzAFiKOzqQrbQq8rjcYV7eMkHIiEvqCooZehdj31ACEoxHOORpRS2q5H/6XnLP5kmjt7xOiTuHlB1oRguuo6XEphzxhvD0/MzTqdbXseJS2dQoglZMKYgRLw54xAW9mFmjomqDI8velbFUGQEBK2FnFuOTCWy1IyOqvU1HNii+fT+DnShkRMrIVZGP/AHx2tKFZ6MK94/u+BCT/z803eBCMaTqiaUt37jbyKyZELNlKIwaeFlbKZGulSer9b0zlJp2qan4wrJFaPbJOBCCrY4JGuu0oFYhcfbLb/4/KsA3N++Zm0M10thFyvaaE5FM3jPVcyti+80G+vZnwIv5xOPe4tWmiUUOq2JktBm5OpwYjc1U05RgYvthu00UESoPJznWfPYjGQTmEtAAi3/rMZg2C8LAaEASim87whofn+3w2h4Oqx4d3vG1lk+vHiMLRFxphVzYf4xPqWf7UipEEjkWqDA67gw6tbpfXfc4oyiKph04RTWQFsrW/cdW/WD8rZjd9oTJXC2XvHh43Z+7W7v8QZ2S2WKTaAbcGz8mlgFbSydtthY2ccjdwTOe0tFkaXibGUKkfNxYB8mTksgJCHVme245vm4bT8vupF2AFbWsZSFpRhU0GipFJvp0FwnIZT84MOksHgi8NF8QmvNk3HNB2dPOfqJr7/zbvtPM5ogwi58vnfgT2zBP6eFznnOvOWyd+QML2KzeS+1oqUpokffs/WJ/SKUrBh7x1c3G4oUvn21xw+WUmE/Z75zdeArj1a8uD+yS7nRKZRi02kO85GYFce0gFQGZVlpy5EKcaHve2KtzCU1t8BYeS0TV3khSduZjiFBzLz/7lO00ewOM3e7E4rCMzMwxybAVLXtp3rbozx8YDWPVyO9NSwx8a2bHSUb5lSYQiAVYWsc741rsE1EkpZAEuHudPpxP6qf2bjbH3DecNl1PLKOrdJ8637mqBvebbDNaXLbrzmVhWOEVOByNfA/vXMBUfhPn7zAd5qcK/f3gW/Kaz54+ojv3e3Z58hUMlorHp+N3B1nKh03hx3eWC5szxpDLEDMYHxDb9aCeMVdCJxev+BVnFmkMCjHu8OW+7sdv/gLP4fRhvv9idvdAUgMXWWehZfLiVIrG+256DzGe37JjDx5vGHsB6ZQ+J3vfIzC8WqeebXsyVJ4PnR87fwCD1zNAaMiOVduD8uP+Un9bMZuSfTesO00j3rNk7LiW2UmoaiSsGRQmm5Yk8bCUhqh+tEw8I2LS2yJ/NvP2vSmUjlMke99duDZow2f3Jw4PpDNBm14ulpzfToQas/V6R5nddNN5UCPYy4zVTsUCq2EqitXx4nd8in3EilVMVrHuzpzdzjx9a+9h9aa+/s9t3f3OKN53g0cc+Z1DiipPNKO592K0nner5bLixV95ziFyH/4zvdReO7SgVQKTgIXKvD8bAVE7vcL3ldSzVzvdj/uR/UzGcc0o41l5S3PRs921PzO7YlZF7ZKfqgxG4eeSwK2aGxt4u8PLzYQM//21RWWBtOYpsg3P3vN87MN/+mzHUJlyQmjFe8MZ3y8O7BUxUEWrDF01lNKpquOJQaqhYqhGk1RlWVKfBRvuEpt33llHWe1cHO/45e+9gHGGF5e3/Ly9Q3OGt73Iy8PC4ccECVsveO9oQe3xqnE+WbL4DxTjPyH11dYMRzzkShwqIGgJ97dbICZ61OkGyyihOP89sL5pmIm0RXDqAwXvWJrej7aRRYdsLbilQUUox14PCYSzXH38TDwc+fnSBH+l+98TG8q2hnqkvnos3uePhr57H5PFOEYMyKFi9Hz6f0O7zw3+YTDMqqOCHi/ZZpPmNxgKdkbjKqUXPj05o4X045YCyvneaffcHN3xy/+3IcYY/j06oYX19ecjz3P/MDVMXCsrYbYWMdjP7BabREijzbnDL5nTpFvvnjJNGeuYoRamHWkDgvPNgMxRm6O9/Sub0aHx89XB/7EFvwK1VBMIlyFSC5NmFCVIUlFU+msZs6FY6yM+mH8phSds8QsJANZhKKgVogps58Xrk6JofMoJxhVGb1hlxLVKmKU5gJpFWPXscZhJKCNJZVKFUXWlVPN6FrZWI1SDipMYSFE4TtXV5z1PU5ptqNHpGBF2uhSGTKVUitUeHK2Zj5FjNJYbTCmMlMYjIMHZKOqlSiZ0awwVOYUyDpTUVT11tf7TYVIE10sOfPZdGRJlVoLqcIppCYY6zuOErmbApt+xaAVozH03lNrJFSNPOydNmF25RATL04zm96xMhatKoPXzFSMFkoRjhLQSjG4nkvrSaaNCu9DZJIMTnNMiUvvWCnD2lk6Z0k5kKXw+x9/wsVmxegcjzd9mwzEyrLMnDlPLA/e3krx3uMLwjTjtcMahzGwqMJGDwydo+SKqYrjknj2aEsG5iVgrAcMyrzNwTcRVYRUFAep5CLE2gzWUs5cx8pgFOdDxxwmbsPCpRuppdKLYuMNOWiM1egKpRaE1kGaYuL1MnMxDNhOoargLSAaJYkglVNsKMxxNfKoH1lZ8MpzmyKH2jpSr+YT76w3bLTBW8voPc5ojtPM73//+zxarRiM5enZBl2F4DVyXLiUJnjrtCaWwjtnG5bjjFcKbwzRGFKF0RrOqidT8VoTVKK3FwBESZRFEKVBv8XCvokQBVkK91HIqqBrpZZCVIbvn05sbOT5MLCUyn6JPO839BhGa1k711YPjcHopjsKJTMtkf0wcZsizzcDfTVtzdYZrKFN81Ol1NRcb23PedcxVOhdx22MpBLojeGz5cT752dcaI9SjZLnMNydTvz773yXx5sNgza8c75tJl+mcBUSZzQhqNeWOSu+crliPp7olaG3liRCyYXRd2xcz1KEqjQBwVkLVEINyIMZnKi3O/xvKpZSiLUQ0KSQ225FgVSFF9PMxlieDgMhBXZz5HIc8VrRGc3gNTHA4DzOgUhFkhBi4jAvvAhHnq63bI1CSqHrOvpQ0FhiESYiySgubceF1lg1sLKGu7iwlMzgHZ8uR7663nDue4RKZw1aC8uc+L0X3+dyXOMNfPD4DGc1KVj2QXAYjFI4FKrCxXrNdDzilWmr5GIxSjjrPFU1rxtjNKeUebQ6o9aKVE16MBsT/VOO5Ry0wRlNAaacqUXT+9apqtIEjFI1MWYUil4bvFYNNagUKFiPHsqDDbhuZiFV2sqC0W3VQqlWfM8UQoVUm945K0XSFQO4h2WbqqAoRSzCqSZqKWy8R2tFElDWcMxCPiVyaZ22s657GFEvZBRKa6iVKBWRTI9CtPqhuEmARQrrTiNLm2JAbX9nZ5iWJjCeVX0wCXm7TvGmolcGrzWFyk0IFNEMtlGYqgg5ZaIxFK2pCkytjNqwMu2HuSi4WK0IZaFQ0dpgTcN5lVwwtW/YVSVIFSYSCUOsQhLB50zsaBQCpVEPNXpWEFOhNwlNZdDNBTNVIdfKKUTyHJgk8d75Ge9sNpRsuClCBjpjUUqYS+FUMr21VNsIU6oqhMokhW0H2uhmOKch1ox1lvtp4bQEMAW0YY7xx/ykfjZj6x1FQRRhiYWQA9Z0aCoZIVZNlkp48PawSjM4w9Y5jIKk4dF6YAmRJBVrFNYBFVQVrNZYPCKJJScClVNpfOpQhVPJZGkj8lFbjNJ4q1FVMZUCCMeSeNKPdM2nnpQLu1RYYiDmwntn57yz3UJOXNeM0oaV8Q1zqCr7LHyoLeIa7UXV5gqdEKyz6KxQCFVVRAvGVaYpMcdIqiC0Q/Bt/NHHmffMpRHo7mOCLFjAaliKNGpIsRTRIAqNYnSGlTM/lLG+s15zSgsxZ5wxeN/yR2kwtqEGSxGmlB5odK05EnPBoBDXSHx9bV483mi00RxLxmrNfQpceN98dmhn5z4n0j4QSuG97ZbnqxUilaUEjLP0RVAPQvD7kvlQgbNtXQgaKEOksuocd0sj6mnTwCDGVA6nSCiFKVZQqlHN3sYbibWzFFrdN2dpoAjdQBehJBbJLDkTaqvjjFaMzjFah36QVjzfrjnlSEoJrzXOaTSKLIJSGu8URSuCCKKbS29GEatgalvJMVo9uPqqtk4ucMwZauU+Wja2a8hOmiPufU5wWggl885my7PtlkrlJu6xzuIUD7lfmCTjjaa4hgb9AS62KFgPHZNkiiooXYkIyijCkohZWEpAoDVoPkf8SFfTv/f3/l7DV/4fPr7xjW/88PeXZeGv//W/zqNHj1iv1/zqr/4qr169+lG+xA9jZVwrTLQmt4YQSivQTflPaQjNlDNea6yC3hg6/YM7jObpqsc5izENweQ6jdWO3ummzqaSS+UYE/sqnHK7QTplcEpTK+QHEovWGmU01SgWadixXcmI0RSlyEroek/UFdGWUCq1Qm8snW27WEVpglIEBQuVXU0QMoNpmMR2axNyFpRV5AcrZnno8IkW7paZU87cx8BtmNjHL8/+4BeZf9DGbSvjsEojaKw1eKfpjaE3bfJyDJGcM95ZKIKjCR01rTh/93zNuvP01jE4i++a9mRlNFYZKpoolV2I3EnkNgWyUig0qjaiUwZ667HWoq2lKM0+JJaSuFlmrPVgLIsI1mtOWdrefm4cYe86Rr9iEUXRul1mVevi38aFmjOdc1hlmgu0CEkq6HbIZSpZCZkCGq73Bw7Lws3pyNVxz810+B99tD818UXm4KOuY+0sVmkqGilgtKLTmtFpnKEhhKXSm4a63HSOs8FTAdHwbLWidw7nTPvwCqsra6tRtXGlS1XchMCBwlUKGNM67VobtLLkWumdp/OW0Ts6ZzmmjLaWQ4o432Nc11aNaiVpjbaeWYSMxrsB7zum3C6cVemWn1K4zZmaKp13WGNQQK31h3+HORfmmvgBK6aoxO6wcJgDN8vC6zBxO3951hq/yPx74nu21rc9Zgy5NO+btTWcdxZnFIccEcAbi6LSmfZ+LCKg4J3NmrXvGJyj7yx9b/DKsvHt/VZRhFK5mmf2krktC0q1ybapYLVGTKPidcaw9pbeW/ZS0BpupgmlLMZ4stIUC8UqvPPEWsgIzjmcdxyStJ+jCkGEY07c54WaMoNz6AcPnx+AOQZnCJKpWlpjUIRSM/fHiTkl7pbI1bxws3x5Vhq/6DP42TDyqOtZWY/HUku7fI3WsekszsAhRWLKGKPRGnrnGJ1vL0AqT7cjvWumqb03+L7VgxvtHy4Fqq1HL1PDnqcJrQ1OW5xqyM9qDKP39M6z8h29s5xyoErhZjqhjcF5T9UaeajxrDGE0i4PnR/xduAQM0rR6EEagirtclCEofc4a/gBkUdEYa1hlkSuCaFQlFBIHE8zp2Xm9nTi5jSxmz9fDv7IHf5f+qVf4l/+y3/5Xz6B/S+f4m/9rb/Fv/gX/4J//s//OWdnZ/yNv/E3+Kt/9a/yr//1v/5RvwxeG0RpnIKtt4xFc5RMXzW21nawpEzBQSqUQVNVc0dr+l7HxmlSfnDZ1YqsKnMubHtP7w37JXIKgUgh41hKYGVsO1Ct4dK1/7b3t1uiEvy8EKWSU2oObMZz0a0euquJjbWMUjkAZ94wWEeuUGuk1opzHft0YsqRlAuCopSC7zpKNeQoxBgZsJS5oaUsjb1+iolpWtjHwClWIplCRfKXixDwReUfwNp0VNVIIOveA7CUQK88vdYkEfYxoosnFcF1BmM0pcIiQgK63tDnjmJAVCWpCiGyXvWMvWE3Je5OM3uZiVmzjwvnY4+vmpV2PO48CvjGO88pCN+8vuFwFRDb8nSwhncuzzBaEfLC+WDwYribAs/HDZe+I+eEqZUUC103cD3dcx8nTjFTssJkMGNPNRBzpITIGZ4aYU6JVAWD5RiFu+nAflrYlcgs0qYV6ctFivqictBVg66C15qVcmTlWVzAV7DKEGrhNgfWw0iOEegoZFJtwq8KuFIZbXMsrRpCLSx5acZ9thKScEyJV2ECHIc08/7ZeaOYKM3jcQDg6882ZLF87/6e2+uIzortOGBz4dl6RectURJrZxmnmbvTzLYbufADOWekZpY5EWIi1sxUEseUmDPoHLGr9rMWSkJy4bEZccAsCa2b0c0ildtj4lgShxBZjEa0pnzJKFFfVP7ZWtFF6ESz8h3BCkECK6XJtXLIhbsUuBgMi0SUHqlSiUXIWpN0aX4KXpNUI5DEnJlz5KLz9BpOMXOMgZfhhDWWfYi8N6yxGqxVnHXt2X7t8hHKWj7aH7i9u6Uzmo112NKmWH3fU6icWcfK9FxNE49WHZd936ZJtTLPgRgzc87MJTHXgtQ2qPTeUqoQYmQJMw7NEjLHFOiVxQGnBK+PM0tN7HJgqQpBU8vbM/gH8Ud9Bo/GUUzC60pfHZ3yzBLoELzRnJRwHTJnxpNLZsBgRZGLEKqQScRa2IwdJ62RWpvQOioueoPTilSEJWVulhPWdNxMR94/P8drg9OGTdfO/g8fnVOV4nu7HTe3iZVPWKVZVc+j9Yqh9+Ra6FWltwv7ZeJyXHHhN+TUUPDLEpiXxKIVSRWmGglZUXJm3Y0YUeScSXPGxsqkFq6WE2trWGEJIbE7BaZ55iYeEdUaM/I5wRk/csFvreX58+f/za/vdjv+4T/8h/yTf/JP+At/4S8A8I/+0T/ij/2xP8Zv//Zv82f+zJ/5kb7OVV3oxdFpQ287RmX4E88f883ba8ISMBW2uqE4i9E8GnuqVG7CzEenA487T2c6dg84OgVUKawGw8bq1sGsDWt3oT0a6DcD11PgLmZezAu/s7ujN56LbqS3FUnNjOayX/HLj9ouqfEaow2KjoImj5a1FAZXmcPCR7sdRje33MO04L1m7RxaOe5TYcmAAYkTWlWMwKbCNAXqA/1Hu0Zr+Wx/4uP7meernl5ZdK2Ez2m48LMSX1T+AbzWAa00K224NJ5OGf74N36O//idF+xPESo88h1YTed7no9ragp8ur/n9+52vDf2mM6zLAslF1StkICN48lqRNfI4jMjhnMuGdFs+45PlxMvjxMfT3v+w+GaXjRPt2s23jfihFZc9B3/r6/9AsVYnPcorah1TQqR9y7h4kxYO8t0mvj01Q3g6IjcTwtWKZ7rFdpXQk1MObCOmulUwTRH69Eorvb3GIFYaB0Ra3mxn/jd6z1fv1yz3SiMVpTTl6vg/6Jy8PcOt/RDx8Z2nOmGv/z5r77Htz654T4GUJoz7ZCp8ni75t3NiBbhNgQ+miZGEUbvWJJq4yaEmGbM1rDtO0ytHOVEVAvvjANmET589JiTrdzMgU9OM//fq1d4bzkfv8bKO6Y0Ecl8+GTDn//KV+lonS2lFMJAKLDRUDph5WB3uOXj16375LVmKoKpio3yjN5yK4FDiJwbw1IDVStEhFM68dnpgLaVJYMNoBFelAP/+eqaP/XkMc+NwVTN9CUjlX1R+fefDnu63nHWd6yd45FVfPjOz/GtT19yN010Gp54R2cc7wwDTzcdGjjGhe+92DOayug9x6VCLRiEQxTGrWVrHa5W7suC1MjX1muWkPjw8oxTMexy4XoK/N7NPYbK+bhmazLH6cSSI1/Zrvl/PnuPCDj/MP1/KGe2HkKGEc3d/YnvzDfN28Zo5nmiGBg7xwrH9bSwWxa2FOIiKBSmVGqc+eg+oUVxf0pkWxkGw/dPB767O/E/X1zQ6Yb2DPHtGQxv5gz+g+MO01k21jNaz0YpPnj3fX73kxfslgVXDE/RdMrzZDvyeDvgqmJaAt/fHVgZg+80y5JBKlYrJBQ2G022Bq8Sny4H9mHhqe8Z0Xz4+DF7Mvch8Cpk/vfdNSUWHvlv0HtHmBckVd5bX/Dnn79LsabloLLUqokxMvqFkg2dUuyPOz69eUlKGaM1RQQpbSd/pTpCPhBCW4utUlFaU6qwCwt30xFL5W4JpAzD2PPZfuJ7046vr8+bDuDh8vC5nt2P/AD+4A9499136fueX/mVX+E3f/M3ef/99/l3/+7fkVLiL/7Fv/jDP/uNb3yD999/n3/zb/7NH/qwQwiE/wNSaL/fA+CUI0tzrH3aeRSW3sLzYcVJO0opQMEUQ+gMt6mxz4sI3limUjAmEHkYI0tlicKmK5QsRGnkAGUVe0mUuWBTpleOTacoTlDVoYDvHHaM1nC9LOxT5GLomGPj9CKaKbauGVpIWfPJfGTUilOOHFLk0o981Q2MJjFHYdGCMjAYzYv7e1DQdwZrDSgDnYUsSGouu4E21j7EineW708T551lUJrlS7Y/+Eedf/CH52DRlSyFM+V5PK4xRWPwPN2e0ZuZ9OBsGpXCYrg9zUwlkSkMzjJR8GHhEEIbcdPwsqMIJc/EUumU5bFXXMWFeVbsU6TTmgtjKc6hpOJ7w+/eXjMax8f7PZ+dTjxfrdlPC7rzRCksMXEKsRkU5cz/fn/DY+s5pMBVWDhzI//XiwvGEDimzFIrVhv6vuNbr65QStF5h3dtLNp5wxSEuSROWrBKc4iR0zIzrC2/s7vnIjSMo8pfLtHuF/UOpMIxRbxWjKOn857OGt67HBlOlilkaq3MI3QKbuZAKgWpzeF70hpbEtdzJEoFEYy09ZkSE6UUOmt55lbcTQvXsWDFcKEdF65HDYbRJooqfPPlNZfjwCenIzdzYNMNLHNDE04lkXJlSYWlZlJO/PvXr+ht07LkKhgM/7fzc1ZGcZciWtoE672h5+P7ez7Z7R7WetqW6abruIozp7lSaqZ0ELRhHxIX657f31+zMY618Uj6cnVYv6j800qxpMLWwMW6p+ssFnj3fEtvLFOIVApRDNZqPj2ciLVQ0Vht2RPxkjmURpTLuZITeO+Y5wnQjN7xvDd8clgIMeOM5mIwOOsYjGZdNYnId293bLzj5WlmDrmRUOaF3jmWEImpkFDoTnNaFv7TqytWrQpjEUFh+dOXG86c41Vu7+Mz7fhwdc6r4z1XJ9WwylpRK2z6jlCEQ2lGdittkWqYYuKi7/i93Q3nzrIyjvwlkzB9kWdwqsISAr4qumFs3gjG8tWzM1bGcgqxOTKr5qy8P85MIZEqWO/YE3lcDPscSSKoqvAh4zvPMWbQho0fGKznNgQOJVOSsO4cF8bgnWWWjmAWvru/Zu0GrqcjS154qnt24YTHcZwiIZdmZWgc+8PMf7z9jDPX0XlH1pBi5n++uKQUz8vlSAY22vNBf87379oZbK3H2qbre7zxhINwnQpLzvTaUmrlJDPnvuPbh9eMutHRJH++7fwfqeD/5V/+Zf7xP/7H/OIv/iKfffYZv/Ebv8Gf+3N/jv/8n/8zL1++xHvP+fn5f/XvPHv2jJcvX/6hn/M3f/M3+Y3f+I3/5te91iQlGANDZxmGARHhrHN0TnFKicMiDNqiRTjkCA+i3a428xmTQVKBWrFKMRhNjO2Wp2pD92SpTBkuvWNWgqqCqRWPYXQWLYpjyhxz5BAjWSqg+c60Y5UHMIZSCjk3y+VaFUsuaKsxWrPyFqUFY4Sx85QUCVWwRvPuds23r3dQ4T4kamhF2ON+ZKeEx7ajaCFRuV8CSine6VfoJXNuXVt7+hKt9LyJ/IM/PAcHY4i1PnCZLZfDCiOKp+sNG++5n2dup4mNc6Qi3OYAtpkQDcowL81yOaZEfriIDs41FKLvULWQS2RKmf1ceOZ7jlVwUtECDs3oGhbvlDKHmLnPiaJBW/jfrj5jM3QY41hS5RgyuWaqVHYpopXgtOay62lAO9iMDhMVMVecMTw/3/LNz66gwk2JLHNBacXPrbZYBU9cx3mp5Fx5vZ+oCt7ZbpFaeNI1ytB9/PJ0+L/Id2DbVFFobRg6z/lqSxVh7DtQGqcjuzmytRpEcxcW0OCNpgPuQjNNmksilMKgNeeDR4pmPXQc57b6s0jiJiUejQO3ObZOWIVBa3AWaw33MXA8Coec8BpKzfzu3Q1b66jmASEcM1maQ3mUSomZc+e4cB33KTYjt87j9A841oZ3Nxs+u7mGWvlkWjhIwWnFL2y2aK056y1Dbfvh+5BAK97tBj6VzNmDCeHd8uVpenyR+ScVMkLRFdcZLjZrRITBe85XTV+0nxfWnUcozFlAa7w22AqnRZBBmHITufba8M6qp2LYrkZirBSEQ0nscuK9ceA2RUS1iYBSQtcrHJ5dCNzHwD4GpAqhRL67v2fddYhq1LSQMkPf0MWhAKqw9Y4L77hPGZHK+dChiyYXodeWp2dnfHJ7hVB5OR2ZSqE3lq9tz8hT4NI7TG1+A9fhhFaad8c1n6TAWlm6qrlNn08w+bMQX/QZLLW2VXyj6TrPxWYNImzGvvkw6YnbeeZ8GKAItymTEJxSzcspZZLS7MLMUjIb43g6OmqtnK02TKl5Pc1S2GXhHe+5iYH0gFFxSqNNZaBjCQ1Vu4uRUgsxBb55f8fG9cxTYJZMMYp11zejzlI4qUzvOrbGcV0zVYSzvpnRxVLorePZ2YZPX18D8CocmBEGY/i5zQYxM2eq58I1Ifnr44nOaZ6v1hxibXAbUezCG3Da/ct/+S//8J//xJ/4E/zyL/8yH3zwAf/sn/0zhmH4UT7VD+Pv/J2/w6//+q//8P/v93u++tWvEqRgjcZpgzaazlpqEbzVHIIwpdzQghSEJmzVD/+rtSJFsXug4GSpDdvlDSEkqtXUqkhSmUshlULXWW5TxjyosFcYkmhEKiFnqmpFjdcGEbgqC0kbVNGkkikiON06nY62x20AjybWwlQLnTcY17eDXCmWIg8rOZooQq3CiKI3jued5+bBXvxQ2t7haC2XvUfVDMqwVFi+PLXWG8k/+MNzMGbBGUtvmqCwG9ouX+89u2XmEBamlDC14QUxqqn4UVAVOQt3MTUBuKqIgtG1zpgzQ8utUjlmad1+Z7maThht6bzlkVHUAErBKUaU0nTa4HyHqfDpPPFEVxSBKQpLEkbXcnDUllIb4cJpzZwzU84Mfc9m0EhV5Fo5ptgQsw/Ep0ihw2KV58OLc17e7fBUjjlzyIl1Z3lntaLUjKqVU5YHYsuXI77Id2CSgk0G17W1QW8cSjLeWE6SCA8W8nFJKOVQuq1jGVFUpR4aITBYTy0JB5x1HUvOiOtQGpYc2KXEJIUPvONVnDlJZm0dW+OIS3MKv0uRrlSshsE6dBZu88KyJJTVTPnBgv5hn/fMeYqU1lwBCpVQhHXXcT6MVAWJyi4tzLVSVbtMzKU0kor2vH+uuZ4O+AJTKhxCYjCaJ+crppzRVEKuLF+ipscXmX9LLjjROAFjwGgDpaC1ppTCEjMxF7IKFASlLQbQ0khfSjS7XFgZT80JK5qLrucYI673KF04pcJdTCxVOO89r1LgVDIraxm1ZpJGX7mNM502Lf+0IeVCLJmYhWwUxxgpWbAP779t11OrNG5KLcSaWXJhO3asVNfMk6riKkzsS8EAcylkqVhrGPqe95zl9S5jChxyZp8iT2zPWdeziw1JHKUR+r4s8UWfwUvMDN7SK40xulGaVME7TZmEpUjTzOXG0tdK0RmDqYpaBKGyS4m1dShp2Pa1NxyWiYt+gzHCKQv3OXEqmU235lVaWEQYtcU6uIuJWtu7ypgGjVlbSy6FKRVCLKSYOZaMGIU3DpRia3u0VogUUoSUM3PMnK0H+m5LqZBR3KaZUy3UArM0K9WqW83x7mbF7X7GKM1UC6cSWNue867nLnbooigPdernif8hgOz5+Tlf//rX+da3vsXz58+JMXJ/f/9f/ZlXr179n+57/SC6rmO73f5XHwDHnFCisGLIAjW1v23VsF8id9NCSoX9EplTQSlAWicyimrc8JjbjjEQqWitmFPguBRyabSdqQhVCgpYQmGpFW8NZ97htCFQSJIotRX0g7GICHOpTKWQUyKVTKwFrSpeK1a6cflzqaTU6D93qaCN5dE48Gy1ZuM6PtmfCLUQakWqwmpDZy1aWz7YjK07jGqEHxr9ZbSW0XUsFe5TYf7y1Fr/TfxR5B/84Tl4iAmNpjcOpRqBJNNWfa5ORz7bH5hi5PY0s5sCthq0QM7ycBkV7sKCcxZlDUU36sQUAqclklJmLsJcm7uj1ooQMknBdu1552xkYy1BMsclkEtm6yxPuw5TYKowiWJKqXkzSKZ3hvO+47Eb6LDkUts0LEVuw4JxHY+3Zzy/OGcYOr5zd8OxJqaayVQGbTl3HbUaPry8INfa3Hp167SsesNF33HuOk6pchMbEu3LGm/yHTjHgo6CS43WVaWgaTi3/RS5PTVH3JvjzD4saKvRosixdTi9VhyycOYHVtpjqsVrxxQX9qFQq2IW4ZQSqoJRzf12loL3jsuhx6rmG3EfE7lmRqPbdLFoisAuJJYYKTmBFAZnuBg6nnY9jzqPUXDIkaUKh5TonePJZsM723PWvuNbd/fcxMJVFkqprGl6GYXmg80KhyJVmKVySpmaMys3sLGeJSv2GfL/2DH2Ux1vMv9OOUOquAy1VEpp+WeA/bxwezwRUuJmPnEModHsUORSCCI4q9lL4cIPrJRHi0Fry346sguF+JB7p1hQSuNMAxvGInTWcd73zck3Z25yoEhh7TRnnYOiCaWwnxPHZSHGhEgr8EereTqOXFiHEmGfAqecOKWGFT4fRh6vNnTe883bG25S4jYltNJcuJ7HfkRZz1e2A/qBb56lkqQ5pXprWBnHIopTVW3c+iWNN30Gn0LC5OYtUopQUqbByyv388LdtCBSuZ2OHHNi1G3NyqBID42ofYk87kcu3UCnPcoabo47DjFTJbOUyDElKuAf8NRSG4Zz01lizRzywmfLkTlHBqM5dx4qlFQ5xJmsMiihioAIXmme+jVn1iElcT8fmVNiN0e0VVyerXl6ec4w9Hzr7pb7WrgvBYvi3HrOXUcqlefrFUghV0EQtG7EqsE5NqYjiSFWi7Pd53pe/0NvyuPxyLe//W3eeecd/vSf/tM45/hX/+pf/fD3v/nNb/Lxxx/zK7/yKz/y565Ucq2ELCxzoeRCzq1731XdDDt+GAot+gHbloGMNkJvW+c810buWUrlWGG3RGoVagEpujmY0kTAZ8YwGENvLJe0LqxIZclCkoKqBZOFJHA9TRxSbheTAq/niZwLxihG1W529w8rG3Mu1Gajxf008dHdPZ52uE6SaLY4EGrlPkRe3Ow4hNQuFQVMbSip41yQmOmL4sJ0POr6/5FH+FMdbzL/AGpNLCwsNMpSLZnT3G70HYa19rjafB+s8aQ5sITIUjK5CDnD1nRkaeO7mAuHEBvhZikogUYEdljtMRSeuqE577kVY7ficrVGlCYAuxyYUutk1QRLjnzv/o79EvDV0OP45NAcAr2zXFiPFbgPgVOJ3OcTKWdyzrza3fOtV6/wvv1c7EIgS5tCLBK5mfZ89/UL9ktkHxLHmBqiDrg9nAghMYjjud3w3mr7R/NAfwrjTeZgRjEbYdKFWAq1wilHTg8OzUsupFQYrMFjiUuj1+xDYl4COQtboziGIwcJnCgN55syuRTqgzeEN56V9oRS+Eo/8G4/cuZHxm7k8bCi2sYiD1KYpbTmg3bMsfI6JmKtOKWhKr53OGC0xgMXtmOlHSKVVIRDCOSiyVl4tbvn2y9fYancpIl9Su1dL5mdBD4JO37ns1fslshRErPKKAMrZ7k9nlhCYFDwzjjy1bOzP7oH+lMWbzL/JskcVWYnmfuldTnjw0eolSCVlIXB9KxURyyJicKkhKUUXIVz5zjFmbkEMokpzuxDbv45GUwxdNVx7jruY+K9ruf9ft0uCa7jq/2IUopBNKkIcxZiriituEmJF2kChLWxODF8dHvCY1lpeDp4znyHwmBQzLEZeEqFq/2e7756xXlvqVSOtGZOroVjDnz/uOe3v/t9rk8z1ylwIFKNMHSa++PCXAquKi7dwLP12/ffmzqDp5I41cwxB07zRMmZOcIcKwmhqEyRTIdhNJ4gleND3s66YIxmjed+mThKIFE5hMoxJW7nI3EJMAt9clzaDbdz4qkZeGdccT6uWHcrnncrlFX0gAhEaV4RNSoOJbV3oAgr7Rir4aP7m6b7MJZHrm/TBQ14uFlmplyIGa7uDnzvxUvOvG3vSNMa2ighl8iL+4n/9bMX3BRhJwuHuhBVxhjF7XQi5UKnLWf9yOX4+XLwR7qa/u2//bf5K3/lr/DBBx/w4sUL/u7f/bsYY/i1X/s1zs7O+Gt/7a/x67/+61xeXrLdbvmbf/Nv8iu/8iv/XepsZwxFV6aa2IXaxDlToZTAMbSdQIV6wDZpbmWiVMEUTVcd3aCxJLqqSVoRqmK/FDoFZ0OHtzDrSmcUz7Thdcytg+4HzAOH/ysXI4HIq5hxNbeuvShEZwyaQiSEyEwboW+co0QwCEWEUWt603OiEFXmFCbuD60T4RWIEr4xrLiTxmVVtK7wMS98Ns14LIsqFFWwNOb2UTdOcagVXSuD//J0F77I/AOwpiMVuD1O+KLRWXN7eg3AzWniFCJaKc6HgVLgNYlFCiToc4IO/AhbHIPWxCzsjoneeEbfMdrCEoVOVZ72ls/2Ct9Ztv0KR+Ov//yTS6YSsWZGHtyZ51pRXlHm+jD9aS+eUhMXfc8kwgbIFEZveN8P7HMmKsUUF373eIBSGashRcufuvBcxwDFAU1kuYuJ7x2OnKmOPQmp0GEIBXYlYrwhVsA0iseXJb7IHOyNwllNpHIVAk7vIMChzNyHSDYZYyudeIIIt/HEQkaqwmXLeefQOTEK9DRTwZtZGHWHyoU2jir0VXPZe753d2TrLR+OW7xqBnMfPrkkXhVe0pNzodTCTYp4V/gsntDALJqlNE+T7TAyTYFNZ6kiDEbzTt/TnRYmySzhyH88XBNTQUsThv7JiwvuSsYXRxE41sT37w58lhe+Ppw3MzAR1s4xjj23YQJlSFWjxTJ+zu7Wz0J8kfl3rhxGa4IUbqeFy2EPWXMfZ+6XE0EFlIFL01GAl9PCUiKlSGOgd5axKLyxdNqRUNyJ4qJf0xtBI0gtOODcWj7bRbba8OS5Z+g0Cs1wccmEsDG2NVJqbTonkzlEoQNSKiSVKaqy9Z7Pppln40CQRGcN7+uRs1NgksouTHzvbkfOGWeEwSr+788e8en9hHvAek+lcHWa+M584mv9mmNqwtCN9ujSqFCd8gQpqJjYuLf596bO4K3vMFZzksTV/sRKW7rOs4uJ/XRikUBF8dSOWODTuBBLJqVMDImn3QDesrGKogy5Kk5LZeu3rAH3sHKjRHjkPbdTZustT39gJgh88PgR8SrSZUd1lYJin0AQXrPgIxxrJeqCUZrLvudumnlvvaLmytZ3nA09d3NozZpp5uVxR8kVqzTOGn7pYsOL+cSgHBrDMWc+KTOfTUd+Yb1hTk0X1RsLJPYRlPYglVIyzr4B0e4nn3zCr/3ar3Fzc8OTJ0/4s3/2z/Lbv/3bPHnyBIC///f/PlprfvVXf5UQAn/pL/0l/sE/+Ac/ypf4YVy4Dm00vVKsvcVRuZ0Dd3FGaIxpamWwzZdx4zwpNeMqtFBmcM5ilWNE6FShQzDWshkcpgpzEGKFOQsmKzBwthoYvafWSinCxdiTbcJWz1QycymtGxsXDKbZcFdBP7isHWimIU7DXJoT5Q8WHiZTqAoUCg+82w8olTgeMyULxmisddRqycyUBwMkrRTdwwONHYBCrKJTmrF+eQgpX2T+ATxzPZg22ts6gyExTYUbFpYpkFNGm1bwGyM8Nj1RwRITU5iwwfO4G+iNwStDNoJWCqcNj1cORLHLkVISs6i2LoZmte5Zdx5oaxzPtj11D7113C4Ld6FZy3sMjsKyZIoUjFIY57mbjswOzq0nZuEuZXJti6YHP1OrepguwLvnA70It6eEUHEPzHfxcMq2dR3E4EVhpFIyiAFQKAfWVZz/8qz0fJE5+LzrsZ2jN45VNuiiOZbI1RxJWVCiEIR7YrtEGo/XBlUrJisC8I71OBzDg4OyUoXOerbeoySRTCFVmKTy1Pc4Yzjb9owPvhO1FJ6MF+hyjx/XXKWZ+zgxFs3WWLbeEmMTqBmj6XXhVQhMpmOVIVZhRnBes0hkFxdKKk2foDVfW23RKnM8ZGJJGGM4sw5bBqQWolRUVayUpccyzYVxsDQrRnC2MugvzxL1F5l/z4YeZy2jMZwh1Fq5jzMv94GYBVM1VSqHJTH0ngvnSdogplCkEJ36Yf71RkiqYoxl7S2d1VRJrKUiqk2OvroaWYqwGtes+q4ZAMbEe+MWI4IzG65iYJ8CT23HjV/YOgMVQm5ak5VTfHrcYUymK4oqrXOvvIUSKEVQSjUzT4H3hy2xCINRTEkw2jQwSIXSB3Q1OOWxpjXpbuPMyg2NauZMM1P8nMXWz0J80Wfwe+MK1xtMBSeVECLHkrgvmZQrvrQSdqbgjebCd4gamt+DmcAozruOjXeMtRXNWoTBeM46UBjWFSRmkio8HpoIvB96+s41X4kYeTyeM5iFoV9zvUzchROPfc/+GDlbaaQUUm1Th4HK9TRjB80GS01tzddaQzGFKECGJIVq4J1xC6XgUcTU6sDRe76KwteIVYreOny1WAWnDKNpjrzGNl1g9yYK/n/6T//p/9/f7/ue3/qt3+K3fuu3fpRP+38aG2NQ1jZ+vtZEwDtLJ+aHBbaphozCY0ArqpW2Ey+ZrXJYMXS9ZsCAcs1YqBqu52axvE/ClDO2M5wNDqUqShJVNEUUh3mBh7UiazSjaesb9ynRl8bofAABAABJREFUGcf54Lk7LUw5AYKIZuUNNVf2kjjmRC7wdPQ8X23QSvPqdKKUwtoa5qIARdGVUNrh6lQjEcnycK152Ptee8eHqzViFC/nwGU/cOE61JeIEPBF5h/ApnsQQmqFoDimJi60UVjbDmU70M3Vdjs45iJUgUUpErC1FiOV1dDMs0qt5NrEOx/tj5x1HXexcB8Tbux5tOqJuaAfxGYilcNxombFUtuBs+07UIq7ZaGzlvNh1Yw4cjP2ikVYjR0OxS4WDrERgj7Yrnh6cQGl8L3bO3LKnDlPnyrHWsmqCYYoha4aNt6RayEUIZRKbwzPtiNfe/wYR+V7ux1PVmuertZY9eUp+L/IHDwfOqy3VKWphlakaI1HYxRoo1DKcMiRs8FySpVQFVkBDrZGY1BsBwcCoWTmDDEF7mgHxakqjlVYOcvWG2JMlJyhWkTg7v7EtARCKnRWOLMGKY7bkFg5y3nvmbQmh8gszTVy1Tk0mp0kpofd2PdXK752/gxb4Zu3100A7jqmCFA5Ssu1kiJGqebwaiw5xTa5dZb1yvO1iwuqGD6Z7ll7z5NhRfcl2uH/IvPvyXp8ECkqTN+TsW1PmUBnLd44tIZjSHROE6RStG7LqRU2ypExnI+OsSqyQFGwSws2WXrnOEriKJmVdWxXPSpmcsoUbagCu9PMfgkEHgo1pQgoPj4eWTvHk7FnF0ITjRfhvmQGZ5Gk2EsmJAE0765H3j8/Q6P59HTPqSS2xnKKmalkrmNiyZVawSfF5TjggZwSVVWs0Ww7z4fbcwyaF4cTm6Hj0ThgvkTGb1/0GXwx9CjbCDWDsVTbIyXja0Ybi9IWazRShfXYc5oCWVeyrYgSnHJIrTin8MqQpLnq7paFkAUtsCuZBWGjHGvniDlTU0I5Q5HK/XHiGCNRVWyO9MCoDK+mIyvtuFw7Dg+mblkqx1rYbhxGVY4lkQWU0jw1jj/2zlcxAt+8nZhyYus189zWM++XgpCxkuikgWrGZKkZtIJOGy66gV+4uCBVeL07sOk6LlcD6nO+A39i90FWzjfcWynsU24HGRmlK7ZhbpBmII/ShiSV8lAgq1rRthXtpQrOGEQpDlIIuVJzE14WqWiaAdeqa7t9S27q4FIV+7A0ekSMZKvptKICiopGsXKeex2aVTKaLJUlF0Q0Cw8HWFHELDwdepZcuTXthViNxrmGs6tKUQ0PrGLBuEitGlGCUeBMU54/7kcSsI+FDkWnQfSX52XzRYfXFkwlSWGXI1EpdiU0UY62oDVJZeKDmCakTKz88IBwvomuUxUG28TeuyUwx4TQDExEQFeNSJskKKnEEOiUQirspplcK1dzYMmFzhikCiIVqzXbrmM/J4zWWK1YaqWGyKgdkxSmnJEizCnxlbMz9qeZ3u05SaFqzeA6jnFG2o8USYSQhWIEVBO8a9VQj5u+473tOTlnrqaJTim80XyJGlxfaKxdh3KKqRQOJaGMYUqJ8uCiW2hYQ6M1Tjdhf2lbXw+6Ev2w8tVgAhTYpbae9cj1xAqi2lpNrRXfGXJOHOel2dRXOEwzoSRehpmJ5vqr0RijWl5YxyE/TC6lCd0TlfPc9FNLEaiVOWXeW2+ZQmDVd8RQG3nIOaI8rKZpmkvrQ5dL1WYqY9B0xjJ4y9PNmhphn48YrbBG4dRP7DH2Ux1r56haWKSR4iQk9iE0QpfSLd+oGA1GQZBMeBAXVkVDc2ZhW+WBbifsQuQmLjz2KxIKlMIAIg3BrTXspgkpBac1uWQE4VUIDDRRo34AHAxG0RvDlVRSqYg0515nFGvdtHuzFHIp7FPkj6+eMufIuneUWNHW4q1jFmERQVRrysQsmNR4/EZBZxTeGFbW83gcG7ElJLQCpSrevM2/NxWDt6BgkUx8eOsdY8Tr2rYwoK2FmZZHc0oUaThZUWBMZZZKEKHTTQN6iJHbZeGy68nSpoPm4dl7a1q+LEv797UilYRSipdhZqiJXhu0bth1rxWddtywUGpF0TY7ilJ0uZCKEAVUNRxQfGN7zjzNrLqOohRGN5DCLJlUK9q0i8pSClEJFYWq4BX0xrL2HY9WKxYRTnOgAQEV3efMwZ/YTFUP39SSE/choHMik1kphVOmGQypQl8NYk0b1WlFpwydqhhniKEypQSqkoBXc0SK8Gy1phTBq8ZZraW2b5wI96GwKq2A3+eI1opDiixF4YzCGc1gNfHB7CVQSFQ8ut0c55kL59EPnfkkwuuwoKn0VnPRO/a53fg2vSFjsaUgFCqKJcNVnGk3F8EqhVcaawxKO3qtuegCMUZOCO5L1N36oiOndiFcpDCnxEoyV3FmUy1Gt27/jNBViDkTRMAaBmVwncM4xVIVNzFwqRq16ZPDgVwKH5xtyJIYtMJqB7EiUhBVuT2ekNwKubsQ0FpzPS+cYsN+ajS9NVQNDohSqIDThrkIr/Ynng0rzEMlPufMt/Y7/lyFwRqebUZuraZWzWbVk2rEBYPV7YK9i5EpBLy1eBS6KkbXMGFKWZyzXI4j+2nmdlKsu/9+HNvb+MNDt3ZEo5GE1j3ah4gDTFWUWgk6s3IdMWeKVihtsLVipLVDGgQgsNKeOcHVnDDW8BVviCnjFaAVMSZy70Er7pYZUZXOGIK0C8any8xeMr11DMZw1luWJKiq2cdMyAVbIaTMVQwYq+iswarmA/DpdMIoobPw3nZFNxlyqmxHx1I0/cOqpkZzyInrtOArbPzQ8MbG0D9AD6ypnHcdV6eJ66q48Osf63P6WQ2LIdQ2BS8hkZJwtZzoUUjVzAWKLlxq2/b2bcU+8MtracX7KWTuZxitYcqZj/cnqla8uzJUJQxagdFMKTKlhVSE+yWy5MC276i6XShezQu9MvSm+eM8W62IsoBUjrEhui1tdeI6Zdba0CuDRhFq5tPpiFWw6iwfnK24miwhw3m/Aio3LmI05CIcYubVMjOiWVuLNhpvDIOyKKVRqrIdPK+OB3ItPBpWP+5H9TMb+qGwT5IJOeFqZpciZ85RRIiSESVc6K4BMxB01Ril8c5hvSJG2IfMyrQJ+OvjkSkX3j87I+WCFU2UzFwSSVWSUtzOE3PJbLwDXemN5tPTgVE5Nr5j7T1PxxXHsqAyTLGQpTBoQxR4fVzww4CmNZYXKaScMLT36le3W27mmZgLm74nl8CqM1jT1tDmlHkdFgYMg4beGHrbzFmz0mijWI0dr/cHkqo86j/fO/AntuB/ddixfhBNdFpDpVFusqCtYrAGpxX3RTCD5xc6S+9tY5/fnQDYm4YbLLEdTB7AaIyWpvDObddQVOUqNfv3uzly7hIr5znWSogLVsO58xxL5i5GHncdl4NBqebgG0uhqGaWsJSMNh1O2jSg6NpemnFhO64ZneNYcnNAPUJnOi5cYS6KU60U22gu6OYE7HUr7gZnEFehNA7xPmdCFkbztsP/puJqd2AcDVXr/x97/xarW3bedYO/cZyH97QO+1y7qhyX7cSxQyAxpvN1f5Fa3a30TaNuUH+RuABxkUYiucEXAW4w9E3uEDdIcJPmCoHSEq0PIaFPHdGk6Q6QDoEQE9txuU679t5rr9N7modx7ou5XGCcfJTt2t5V5fcnLVWt457vHP93zGeM8Tz/B501zoNCUjIII5nXliMqng2OXsEnbh2zsC1pTFxcrpFMHr5DDKxzgSKp0TenQ5rdGCFlFGVqJLOfdlYvusC9oWFVVTyLjjEGaqN4MGu4cI7zYeS+tNybzRFAILCOjl1SHKuKXkVaZSiiEKVA6qmocr/bc7yYs0pz9h7W/cjbux0rXXO7nh52WzEtXDahMFCYK0WjLbPKYitNEhEFzFvD29sNV95zK/7wND76QXLV9RAUY0poVxhGx7yCIARaTTuw2jZshqmo8EfvH1Mbi3OBq80WVaaA63Lw7EWEBCbAXGv2sSekyXkslEwohTf2W451xTo4BhIrbRgVXI8DrRScNBX7HHkWR4RqOGkqTJo6+PpSyEqwMBXJBZaNRcWMRpCNYoyRbd9xspgzy46eye7z6WbLatbyymxBFwL7EpAZzkJASIUnYnLBKG5azmuSdMxMxTf9duouXB309zzovWcQkVLgxFggc0cbAiDKdOrcVJrNvscl+MInX6auLH3vuLxY0yjJo+stg/eEIPAJZNQc1YbBe7SUdN7TR0+Umf+0veJWNWOTI8lP/XN2KdL3nqYU7s4qtjnyLA5oVTi2U4M5IyW9EiAlt2uD7B1NlhilQUmSKIw5s/eBo7ahxtMiyDlzOTgaCj8ynzHGSB8yIhvWLpBkJsnJMVAg0FohpCYmj5CJbZyagf0wNb/8QdMNI1FONtczDLjEibEkDSpKVrKisZq9jzgFf/zV+9iqYhgD11cbFJKroWcfPeHm1LAShuWsYZ8CQkwe/qOfgv1vDNcsqFiHgZBGBqfZu8LoepoI9xYNriSufYfSNXMEOhVqKdgXCBIWpqFQmDOlUpLCtC1sFUO/ZTlb0meHLYk4Os7zjqqSvDI7xkVP7xOhBHwa0BSWqgU5pXBaKclZAw6tC11xrHuHi++vjulDG/BbpbhKgTFnjDQALGDKpbeaLARnIaJyobve87/4kz/Gcr7g/HLLs4st65SxwDZMrhUUCHly4vnqeqCSgplQVEKhhOYTtqFPhbZR00JDCN4dHOvBo6QAA59aLrAIvr7e4NAolfnMYoUEKqW5Xbd8o9vyzasrZlZTYoFYaJXiP/V72l1PQNATGYn0KXFcgYyJSESqqRDORE+fJcpmTqoZQ0h85dklX3l2Pd0bo6jU5Cjg/eFh97xYnbRcpp4+OWZ2sj9deA0S5pVFaMmTfo8i47bw6c+9wmo55+zsijceneEraBGcjZ5Lpp36TIGS+c13nyKU5kRbFlIjkXxueco2DdzShUXVEIF+u+Ht/Za5NJSm5gu376CV4l8/ecyT6z0vLRb8d6cvYZSkNob7Rwv+/aN3eXO9m4rd5WSpODea372+oD2/oidyHUa23tGOlvvVjEZpfE6QYYVBEnGAUZnTWrP3nt/8xjN+I78FwKyx1EojpOTdbffiBuljTFVJnsbp+FnnyVP6IXMMmhZJ5wLv7rfcb+Y44NWXH7CcL3l2teHZbkv0marSDK5nHT1KauRccx0DF5cOKQXHlWGuNK2Gzx0f0ZMZKDR6qpW63Fzz1DuO2iUn1vL5WUuW8G/Oz8AFPrto+RPVbWIpNMbycLHi9568y1nfoYxEFUEVBcZa3rzasNn3vDl0POl7ujFQK8Wn0sn0eqWkEYqoKo6SB2BpDXNbcz4O/D+fvMWvP3kLvOZOo1maCikkr3fbFzVEH2uyyFx4z6Xz02YZcNdaWlVjpWLnPX+w3XKsayyBlx4+YLWY8fTskkdPz1n3sGgb/tPlGp/jdELYGh6PHSpJEHC7brjVLCgp8/mjI7Z6St1ob06dnp1f8+bQcTxvWKmK12bHBAq/ffmMmCyLRvL501sUOW2OHRvDf3p6gSdAzuibTYtaa97Z7tmPPa9vtjzuB7oUqa3kU4sVMUpaKZBSYrVgFSQ5T6mM86blbBz4/zz6JuLRm1RKc88aaq1BSN7cHvT3vBj6zJVI7EuiklOsc58GkRQLq+iz5z+u15zqhjYl7t27z7xdcHZ5yTtnT0nDFAhfZ0fKUz2KlJmrHpRTpJy4VVWcNjUUeKld0Ds/dfg2gpwyV/2et/3IyXzObdtwMqtxKvMfLy9IyvDJmeFz1enkZGcMdxYLfu/JGdf9djJwEYKZtEgpeLQdOHKOP9iseTIMjClTxY5PpBWWiL05ta+BJZJWNRilmdU156Hj//vu1xHvvo6KkvtNzcJWGCQXu/X7up8f2oA/kPBkIhlJQBUYggYVyUIgiiC5iKwkVyHy9HJH13u2u558E+y3SnKiKlyJpAwl14gErZw6k1kjqI2iVoYhFZ7te65ToJISK9RUhHvTuU8K8GHKFRxTRqTI3CaK0QTAx8Du6pJ9iFRycmDRUtBWN7mL+4A3Gh+n/G0pNVFKii3knNmGQBISLaecwh6YJbhy/U1HzcJGeu7lij4nhJEICSH98DhU/KDpGAk5U1Ihy4iRGqwgeBhDgCTxHupYeJY7zi439J3j6npLTgmLpjKWeynRuUAIoLWCHDmarQhRUBlojaRVil0aedJ3XPYRqzqMlJAL9+cLJOVmRyyQs8eHiJSSuTEg5aSZfqAfR/beo42a8giVwVaGUBKP13sWlWUXPCHFmyY5magKnsxVdLhYyEWyTXHqTeE1j0NHHxNDnhxhXqJm30X0XGFkIcQf4u5vz5G1jwzRE1MCrVko8ECWGWsVDZa7EtokuGLk6fk1203PvutRWaBURYXglXY25eqjKFmwVx5KYcwFXCKXwqqpuBw6HifH9ZgxUlIrRRGKl+YrpJA01uJLoR+nXhAuBlKbGbuRUApOe7qh53K/pxE1jZLAZDubpOSxC3jgYvD0Pn7Law0ZJXsiWzwZgS+wvdnIUDpQmGqdcgApBSfGcDU6pNS0RlLUYQ58HpyFgS6mKXVCTYvDFCWDCWQFSilOZEUdBZdh5M23H9PWNdv9QE6ShZSIFHlt0RJLQRSJRHGWBY2S7HPCKs181rKaLXl8dcabY89FDFRKMtMKaRUP6xaDpdFmSm8LjkIipYhMmWEcSVrhtabf9WSVOFb15IKSoBSBJ3M27BhSw9PBsQvTRl4tDaZYXA6cJwdSQdHsQqaWmo4EccQlj0RSoTgqmovec9wIZlYgfniM8n7gXOMYmXL1HZIja9Fa4ck3duiKU9sgEazTyNPzZ1Rmy3bXY4qkaSQ5Z14Vc0YfKLlQ1ZbL5NBKsHGZLAvKChZVxdp3vDl0XI9Tuu1cKYwy3GvmzIShMQYfE5thxKXAzoOsJDEmxlzo4sguDCQdWOkWoTJRTs0DUw68sVtzy895vHes3WRQ0Eg1uZilyDWBwGShvPGgGlB4GAvOR1SUWATHtmHjHFZplJKE92mc8aEN+I2UmDwV/1RSklEoMRVAujylu7RG0kqLF4lHz64wUjL4wLULRClIRVFriQsSXzK1FshUKAqOK0NmckOxEtbOUxD0MTGSmOlCayxCabrgUWXyI44lTyswrVBSTi29mSytZQh0KaO1gHLTHbNMfq2uZCgCnxMKiRWFSKKSkqq2eCbBTPXIGlEiOSmygigKXma0AKs0OUXKt/7+Cx6njzM1Ci/KTW2IJJZMXVdk6RmiRxfFSirqRuPGxDtPzzFS0Y2OTYmIMeNEYWkMQy7EmNBScdOkj1tHLSFFyInWGLa9Q0bFzg9olZhrQ4PitrVscWSZ2IepoZIVU7CvrGITR3xM6DKVk/clURlNLpmUpgLfSKYPgSwlOx/RwFwrKIK5tNRGs0uOMaWpgFNrhjgd50upyCLRE4CCAnTJiFxIOZPzIeB6LuQ45R0bhbX65p5nosiMeTretVpQF01w8MbZM4oQ9D6yHxwzXdFIydzU7ILHx0ArNKJIjIajytJ1I8FNzbT2Nxrajm7q6N0ojFQspcWR0DnjfGIInloKGmPIWTCKQiqZKktESoxkmkqRBFMzrRjRWtGHiC+Rs+CAwrGZOkq2VYWRgvNxsvcExcrWU7BJJsSITwknMgLByhhyiUghSGIqPD7wwWNkobESqzX1TW5xo6bC8FgiILBCMKs0u+D5g8dnZASDj4yDZyUNUDhuLF2Y5syVqqnEVJ/3oGmIIrMPjsp5dsljhWA/BkRlODYGDVSmmnLnc2IUgbFEZlrSSEUCBgI5ZSoBlRakOLkExZKnRnG5oIWgSxlXHFfRk5l89ZfKUhuBNhVnY8SXjJaFY1VNgWYuU/NOADE9i+dGkoVBSTX1z8mHp/DzwmoJsmBzwUiBLpFK1aSYCSlSRMYqgU2agOfNswuSkHRuatS1UgpdFKeziqgyQ0lUSWNkxAIP5y2hREbvqW+enS2aJ2FEa402Biskshg0gpI8Y8yMwVOjMEpM+fmikCQgJKJMReC11EQKoWRSmVIf+wQXYmAdPaEUZsqwkhWVKhhr6capHkUgOBKWyXQ+o+Vkh53l5AC4qhRCVmg5OVSi3t+q80Mb8JcikGIqW5vaeQu8mAoZEYJy414jBFRKcb6fmsDkXCb3iakOl4S4qXS+ccIpiUIGoZBlqtoe4xSoIyeP9FQysUAFyCKgCELMRDENXi6gxeRBXNLUbMEIRVQSXSCJm9qA/K3ryAhRGHNEiqmgBDF19Wu1YlXXCKnZ+qmzrhfT3/mWa08SmUYrWqbrmKaXghSgxeFp97yQWaCERJIRZVrk7WNES0nKoEVhYQxFwqKuON9ukTd+5wkgZaSVpJvCSKmmXg+uTEFylhk1ZfgwpsgwRgRTNX6RhSIKSim0gJKm4CkU/54GKqGJpUDKWHGT5pUytTaEnMgFUsmElG4KImEbHAKBUQohJGNJHDcNi/mMKCVy39E7TxaSLKf88ZHpBGBuDALwYVqwxJwR6VtuWQc+aARQa41gatBSSUU3TiczPkZQk3MYBeZKc7HbTy5RRaCZXMc8GU/BpYSLEakhIZmeTQKtJSklOiLyZhgrIZAiE0tEZEMqmYHplDTfFHGWUmilJpSCMYaqCCrkZJnH1B8gRhhjZoiJSmRKyVy5AAJqo7FKvffeqdsZZWe47kd8SGQ9WS4P0bMvAyEXjrRFMDm0VFKjxNT7xB9yqJ8LOktaLUmyYES5cUGJmJvuyUoUWqUxWrEshovtHpcypUAtNYGCEAKXBP6mQ2lPQIgy7fhTECXjvecqbXEpo4RgLhQmQ4oZISAIOT1PQ8SLKYgXWdBYjVCSRmhKkRg5FTW2crIizgLizc9bIchCcuUcSgpaOaUk5jLZ09Z1S1KSbZgaY6qb90UfE12JpAK3bDM58omprs4oRWaqfTrwfDBCotVkXS6YNn+7GCALgkgIOdl1VtJQcs3VfsDdBNhKSpKY7Od8ypOjD4IxRqCQMig9xYfxJssiKoFWmrk2VEpSKISUEAL2ITIlXxe6lCi5MKsMWYIVGiMkQghkSTQlEUtiUoYAps1fhWAXAlpNp++N1FN8V1fMZjPCTrMZRmKM1BUEmGo+b0wYblUNgmnutlIjy2QzOpb3d8r+oQ34u5wRUqOkIJdMnTObErhVtcBkvSmEoC8JoxVrP2IkWKmwclrtzJTiOmUUMLtZGY0io3Jh6zQzbVBS0HmP0IqUM8uqYoyJmDI+TMfKKReSDKQsbtoqC2bWQknMpZ4ePkpxrQStCOxinFol50Iq08q0EpKrGDnS1WRRRqFQWFSWk9kcJVuQHWHYTrZjpTCWyBAylVIcmQqF5Enfo5TEIDA3FmUHng9DTCjFjQZhZQxv7nbcbRZTwyk57X7tXGBRV7y92aLF1EBrdmMVeNxWXI89shRmUhLFlBqTc+Gi7zgyFZVS7MK0Yxlj4lZb4UrC50QE9jkyhoKIkErCpUQgM6tbciqspKXVFqk0l35gWeBq2EP5lvd/IZVEJRXnfuBe0zLThlgyIWduL+esjo8RokamK878FWMONFpz6Qau/UBjFPeqFiUkb4UOLSRjjmghOCjw+RARNKZClul0qFGS8+I5xZJzJlKYCctQIiureDQ4UhEstOV23QKFQKRLHkrGyoKXAUVFKpNBQYWgrgxOJJSU+JQ4qS1DDuzCiAVyymxVpJWSlAt9jIwpcVK1FFE41g21nDrrPtt3NFkSbqxnpxMmwRgmS9k+eG7VNe2Nx/UmeZZtzcnxMUrW2LLhIu3YJk+lFddD4jqMzJTmoZ0jBXSlgJBMGW9xSq878IETg6A1dlo0psjSKi6Gnju2IYtp13FmDWOCRhkunLvpiGy5U988pxF0KaGUYiYgxHCT1li4HgdmWlMpSee6SX85cttW9CmwHkes1kQEYyzUaeoePuZEyYLTxZwqF1bCIookZEmHZKYsG9+DESgpETe/01jFxeg5tdXU5LBk9skxrxqOFwu0abgY9lz2WzoxpaJdxsjGeVba8ko9RwrBMzeipETJqXnS/lBH99xIEWZVRSzTpkVlLOf9yKkxFCZL61ZZMopZaVgPewqTocGqmjoghxDZhIDgxj42uilFO8G1c8wrQ2UnMxVrFC4lTuuKmCND8sQoqIzm3DvqMPVEcWQSmTvzFbWCVmqk0kRgdJ4jU/M0bRFqsssWSMYSqaVm5x2ntsYqSSqZXXKslituL5dIWWHKlnW/I9cJ4wVPfeI69BybitdmR0gEF25yqIpicnHbOfe+7ueHLuAvZdqt2fWe06pmpg1BZjofuGMrbJQ4phWXEYowerAQXaEogVJQ3XRevA6RGDONAqGmjrorafAhkkg4IWi1ZmVblJJc73s6EiEmfMo4QClBIkKQ04MuJ2qr+WOv3eLRkzVhDOSY6EKmk5lN32GVpPeRKdNBsCVwKmvGEOnStGMihWBW1TSyph8CzgdG5+iGQCiFvYtUUlAVgQ+JZ27glm4oJZKzmHZ7kyD69G337cD3z7fu5fngeOVozi1Vsw+Bdzcdn2oXpKiIJLKCQCEOhZgTbkxEIVG2UNVTGHzVDXiXqJUEUdiPgeOqou8jbgSvJLPGcto0tFLy+PIaXzI+ZFwASyHaKXUrusguTo1qGqv44uc/zTvvvAtjwIdAN4xsKaz7HXMkF34glEIpgoswclfVDCExyIwKU9ffe9UCUzUMg2MYHZ1zU9pQKngfmElNyYV+CLw7bLlTt8SQqO3kne0ylCi/7b4d+P741n28co5Xq4YTbRgYOdsP/OhyhhaW6zQSUsR5zyYnksxcuZFKKiop2ZcpR3532VMtLI2YdrI6H1lphVKSrYsIo5lbwx2rUSrx1bMrsp58q0dX6IYBBcilQBrNbvBcuhGpMz/12U/z+ptvQwiQPC4kuuR4Zxy4PWumhoRFIovgbHTctTNyKsQAvogpPUdUVFVDP7jJFSZ6xhhQo8TjaTNYLINPvOG3zI2hS5ETaxnilCq5j+Hb7tuB749v3ceNd5zMWm6Zmm0IvNNv+NGjI+a25jKMuBTpQ+Gt9ZoA7FKgEZIqZzZMp0D7bkQ3mrmRqJJJubAUCmUsQwhYDHNjOaqn0/avrS9xITCGTMqAjcywFCnQCHqf2KWMrTU/88d+nN/7T18jjAXi1AfgOgbeur5kWSvGcdoVLgmufOR+lsgscCFR8pT2YwpUpmYYR4IH5zx9P0CQpFA4NpqFVPQx8fp+x4kxrMeRU1OzT1OKyODyt923A98/37qX3Y2z0kIadsHx7qbjM0dLrBZc9BnnM/sceWt3TcgRT+SoqqhEZl0mS89h7UHDzGgqPVn7zowhKRgHh0QxtzW3lKKUwlf3V/TRwU2PHKmgeMFcaWQU9GSCLBit+PyPfZo3X/8DhhxQeerBdOUi62FHXzzeRYxQiKK48IGVSfjgiblGK4lgajLYaks/OEbvcNEzxICKkHJiiWIma4aY+P3NJStVEUJkaSz74NjnQBffXxwoyodMpY8ePeLll19+0ZfxkeOdd97h4cOHL/oyPhZ885vf5LXXXnvRl/GR46DBD4bDHPi9cdDfB8NBf98bB/19cByewd8b/y0NfugC/pwzX/va1/jxH/9x3nnnHZbL5Yu+pOfKdrvl5Zdf/p5faymF3W7HgwcPkPLQhOuDYL1ec3x8zNtvv81qtXrRl/PcOWjww8VhDvzuOOjvg+Wgv++Og/4+eA7P4O+O96vBD11Kj5SSl156CYDlcvmxn2y+xffzWn8Y3hA/SL71hlmtVj80+oODBj8sHObA756D/j44Dvr77jno74Pl8Az+7nk/GjwsRw8cOHDgwIEDBw4c+BhzCPgPHDhw4MCBAwcOHPgY86EM+Kuq4stf/jLVja3Sx5kfptf6UeGHbUx+2F7vR4EfpjH5YXqtHxV+mMbkh+m1flT4YRuTH9Tr/dAV7R44cODAgQMHDhw4cOCD40O5w3/gwIEDBw4cOHDgwIEPhkPAf+DAgQMHDhw4cODAx5hDwH/gwIEDBw4cOHDgwMeYQ8B/4MCBAwcOHDhw4MDHmA9dwP93/+7f5ROf+AR1XfOn/tSf4t/+23/7oi/pA+Fv/s2/iRDi2z5+7Md+7L3vj+PIL/7iL3J6esp8PufP/tk/y9nZ2Qu84h9ePo4aPOjvo8NBfwf9vUg+jvqDgwY/SnwcNfhh0N9zC/i/lwH7x//4H/OlL32JL3/5y/y7f/fv+Mmf/El+7ud+jmfPnj2vy/yB8rnPfY4nT5689/Gv/tW/eu97f+Wv/BX+6T/9p/zar/0a//Jf/kseP37Mn/kzf+YFXu1Hm+91wvg4a/Cgvx8cB/19Jwf9/WA5PIO/k4MGf3Ac5sDv5IXrrzwH/tE/+kfFWlt+9Vd/tXzlK18pv/ALv1COjo7K2dnZ/+zvffGLXyy/+Iu/+N7nKaXy4MGD8iu/8ivP4zJ/oHz5y18uP/mTP/mHfm+9XhdjTPm1X/u19772+7//+wUov/mbv/kDusKPD9+r/kr5+GrwoL8fHAf9fScH/f1gOTyDv5ODBn9wHObA7+TDoD/9wS4fJv723/7b/MIv/AJ/8S/+RQD+3t/7e/yzf/bP+NVf/VX+2l/7a3/o73jv+e3f/m3+6l/9qzx69IjFYoEQgp/92Z/lN37jN/jLf/kvP49L/YHhnOPrX/869+7do65rvvjFL/LlL3+Zl19+md/4jd8ghMAXv/hFttstAA8ePODhw4f8i3/xL/jxH//xP/LvllLY7XY8ePAAKT90GVovhO9Ff/Dx1uDz0h8cNPhfc9Dfd3LQ3w+WwzP4Ozk8g39wHObA7+RDMQd+YEuHG5xzRSlV/sk/+Sff9vU//+f/fPnTf/pPf8fPj+NYNptN+epXv1qA8g//4T8swOHju/x45513Puih/Ejy3eqvlIMGDxr84Djo76C/F83hGXzQ34vkMAd+eDX4ge/wX1xckFLi7t273/b1u3fv8tWvfvU7fv5XfuVX+Ft/62+99/mf+3N/DoD/w//ws9jGkinkkhBC8qmX79PYOTE4QhjJOYOS1KbmaneFG0dSypQiKBQeX21ZlsLCaowqxOA4tQajCk/HzFFTYZXk0X7k4VLjx0yMiZnWLNua2bKmNRXITI6ZEDMuFHws5BSwwH4YGEMiFTBaIKVAVQYpBI1WVEozhkyfHFW2rMeBsSRqq3llPuPZpsOVzKo1VFIQc6GPBanh3rzBGI1UEq00s6amXUhIhX7IhAjOR/7i//WfsFgsPuih/Ejy3eoP/mgNfu6//yTdPmExvHL3Pj/zp/5X/NzP/R9pasvF9QXr9Tne7Sij59+//h94dv4WlVbElDm/XnPUVKx7z5GGRa2oqunjuNIoAWf7kaO6RgvFGxcb7jc1RRViiMy0YdXWzOcNShs0ElEKPhRcTITiMZVBjpkYezoXGGMCCRqBbQ25gDWaSmu6biQrwVwYLvc9XXQYLXlldcT5bk8scGveYKRkdJH1GDFWcry8RRaGHEHpilc+9Vm0BSVhuz4jjVuid/yfv/R/O2iQg/4O+nvxfFDP4IP+Dvr7Xvgg58D/y5f+B+q2RUhNQRC9R5ZEjmBtjdSKnDLkTF1rxrFnHAdS8AhRKBRu33vA0ze/hikJRWLYbbFG02rF2TBwu22Z2Yqz3vGgbdjudxRZWFSGo7alndUYYzBISimMLtANgTGO1FWNjJEYA4MPDCEjpKRIQVMpSoFGG6wx7PyIFhJdBJs8MISIKYqH8znX3UgXAqezlnltQRT23pE13F8uoUgKBaUFbTNnfiwpsdD1nhQLzhX+/Jf/x/+mBp9LSs93w1//63+dL33pS3jvuXv3Ln//7/99fuEXfoFP3TmhmVliyYRSKEhqCpWUzNqWYRRcrNdEImoh2A89g3NIIal1hfcRnxPbUvC+UEuYSQEUPnlrido7ilQkqahR2EoxxoGIoGiDMYa2rqh0RVsrEIIUM95PH/t+R1VZXEogIkpJpBFsfYAIplYsZg1HTcXgEmPUxFExikTOAWs1R4sGFxI+JyoN5EwMid0QGGWizdA0hqqymEpRUmA+W6BToaQBWRJCJwCEEC90HD/K/FEa/MTpCTsbEFlw56jhE3dPeHDvHkortNUoBc/OHL1b8/jqGefraxolUULiYmQMiiu3Y4iSTVAcRcM9W1Oy4Mfu38aaPSFn9mNg7yNlFpC1JSJBK+raspg3xAwzbW/GWJIyuBTIJSFNoR8TKDBJUWRhM0aqktFKsZo3HLUte21JOhOHQlVpgkwYIzluK4KYFrptramkpFKSPkWuB8edWy2zpkIiQBgEgqN5TSkJkWqSzQy9Ag4a/F456O+gvxfJQX8H/b1o/igN6uixDpTWCGNwCkqIRAQQKSVTcqSkTAgRQUCLiNQCqTX7bo+0UKxBqApVEuw3SJn59O0Tmr3G1i2majluM62C3g84Espq6sZQNRUawaJpEEIQQ2bRBgZfQSnIYugGQRECbTJCKS6CZyEECFi0FUfzGXNvSSkSXGJMiiwKFsXxbNrYtlHSWIWWhZwz4xDY4DiSFlEE0gikMuTgWM6OKDlTksOXiDDTffxvafADD/hv3bqFUuo77ITOzs64d+/ed/x8VVVUVQXAF77wBX7rt34LgDh4ICEogKT3hdYE1nWmrmtGH1jvRhCBumkpyoCdfjqmjPeFo1XD0Dn6kKiE4qV6jlGJurL8iNW8sfM87gNeKu43K/qhpyuZUAAEmoJKCVkqlJAomREyIGTEtA1Yg7XDdIVKkEXhzHseWk0tNUZoYpZ00aOKZIwBJNRSMVcKJRLzxrL1I1oJBIKkBEe1YEtEioIsBe8C/RBZNIrTexUag5aCJAXhMMl8G9+t/uCP1uBt23C8qIhFcrJacfvWbZTRFArBDYR+R/J7NsMaN45cbwbWKVEpjdKKrvQ46fGhsO0lJi945e4CpQW1rfjMLcN/eHzO7z4555uXe75472UGI7nuM56EkJlKSbTIWANSTmOdC0ivIQloFH0YECphZCbmzFkYWBhDayxWGXKRJKHJ0dH7gVAiWktmxlAhaeqafhyQUiGlQqtIbRVVyqQ4kpwnpMwYBZ7CUfvS9HNSga7J5Oc4oh8tDvo76O9F80E9gw/6O+jve+GDnAOLi+SxJ5dEqQ3RtjCMJD0jFBACZC744GBMHK2WHC3uQSlc7a6JIXK5fkIWGWVnzCSs5jOMlBw1NYvG8jRrzoslzzQnunB1fUFKhZAzKWd0AZMLQkqUlEhAoZDCIlOmKMneBYRKWC3xwG6IPLA12kqM1SAFCkmOTCdRQtIay0xqrIKiBapIpJYIKaAIWmPoUyCGiFGSGAVulxlV4LZvMEqihaZIQZTxfY3NB15hYq3lp3/6p/n1X//1976Wc+bXf/3X+Zmf+Zn/2d/90pe+xD/4B/8AgD7BZp/wXaZKBe87dl3Hph+56vfs3I6cHZnMm0+fooEjo2mReF/ougEpE01dsZpXHC8qjlcz/thrL3PSrrizWiKsYZ/ztEgAVFbsg+M8dlxnh86Ks+stTy+vGbyj5HyzAAErJRZojKI2GikEe5cBw5gmAey8Zx0iZ8PI3FqELhxZy62qYaYMg/fsU0CS2Q6BqzEw5szSGl5tZlhdEYIgh4wVib5PvP7mNRebHSl4ZMmUcphs/ku+H/3Bt2tw4z1djozeMa7XDJs1OUSiC2wun7G7OqeExNfe+ArbzTUWmFUKqyH4SAgQxoiJmkYb2plhNp/xU5/5BKtqwclqThczj9cDShZiMRhqNjlwHhybmNFSsun3bPd7fIBcxLSrAEgVkUDOCW4WxoPLkAw+TeleYwjsoufRsGVpDVorVk3NrXbGomroSOADWsJV73i07TnrPa1WvLqaUZU9Y3dF8ltmusf3jzh/93W63TPi2OP6Hbvd1XMYyY8mB/0d9Pei+aCewQf9HfT3vfBBzoEJzTZA7xLGJebWktNIVc+wTYOuDEjY7K9o5nMGn1jvt+yG3c1fk6TBY5TCKkFtNMe3bvHHXnuZ1WzG7eUMW1ckrbDG4j1Yq1l7x7v7HRf7HlsE57stF+tr+mEgpUguiRQTtZI3EWHGKoFVks4HKgwByEUSM+x84N39nqap0UrRCEOrLFZrOg/eR4SQXO4G3rnac7brMVrwarNACYFPGXKhlpKdi/z+159wfbWDlDACZHp/ceBzSen50pe+xF/4C3+BL3zhC3zxi1/k7/ydv0PXde9VbP9R/PzP/zxvv/02v/zLv4w+qdFCM3ae62EAYHXvlEWXqOdL7Kwl3Am88fgd5HZP4xNSa6xUGFsIRrJwhjEX6rbldFFxb14xOE+qQCSDypoahUiFrdtTzRv+xGqGShkjBCklvA/UwKOh4zolXM4coelj5iolXq0tukhSEiyM4lY9Y5tGcoHBeeqQWUTFVZfJQbI6aVnODJTIu+dbJJKlbZEl42JBiEJSHhKsyRxXFVZCSh5HwF0HttuRtq05ahtqaZ/HEH6k+V71B9+uwTeGa/IIx1XFg+WSq6t3+O1//T+RU+Zff+W3+ca7b1JKJvQb7jYVq3unuJjY9QP7Xc/MaG5zn4v9Hj9GqgB3ZprLq2v2feT3Xr/m37z1hKfnHVpC/2pAofip1TEig46Szdbjt5lmmXhy9ZT1EIhRcNLO2PYD7/qe1+YtrVCEVGiN4E/ePuGZ39KXgBkci6g4lQ1Pt4HUJU7vL1ksW0SBZxcbrKo5qeBq7xlyQgCORJ0Taw/LpqLSkpwyKXoutxds+mtqbWgqQyXC8x/UjxAH/R3096L5IJ7BB/0d9Pe98kHNgcu7txEofL9juztj842v07QtuX8duTqFdo7Uhtc+8RnOH72FKh7Z1GRlCSFhycxiy+roFISiyj3HpWO93dO0DSIJYjJoYVBK4hixtuVPvnyKDCM6B3xM4AvgeWez4dIHxlS4rQwDcO49r1SWVihigZXRnFQSnyVjLNA7ailYJLjuB0RMHK3mzGYGLTPnVz3HbYvVinXqGJNHFEGMhUigh6ne1ChEgYpC33le/8YV1cywWrXU9v3Fgc8l4P/5n/95zs/P+Rt/42/w9OlT/vgf/+P883/+z7+jiOMP4y/9pb/EL//yL/PNx2eUIlhVNXcXLWOuGYaEtZDKFIiHGBiHHtNU7EdPzI5YCjllhDYorZgVKCGx2zneSNNarK0swToui6dogS7TQcdS1xhVSCWAmFaqJ/MWKQTrPlJioUKireLBakHjPNvRIUKkZNilxCfnmdtNC0DvPFdDT8qCSkSKD6yvR+resNCalOH2ckYKkYqEaSRCwH4XIGYM4KVHKIlE07uReaMZfOZi6Dnfe05q9TyG8CPN96M/+M8afPx0z7ypOJq1+CL56tkTlnc+gZCB7bDjYrNBCjiuNZvRo8UOhETGjEKwySNHsqHRhuwLj872/N9/YypaaqqGd656Hp3v2G8c81rTNIb5vGbsR0ouVJWkNobRGLRSOFfIQmCMxmjFK7eXqKFh7wc6H4ghcV0cn2tbbtk5AN0YeGu9pgBzaxiS5/z8itm+50RXkDPLkxZREnMhaEtBZFjv9zgPRQWCK5hiUVrihsiiMmz3jrfCDqsls3ywovsvOejvoL8XzQfxDD7o76C/75UPag7Ms4pKtYQcGTbgVcPDk1tUWXAVYb/rEBTG/SVJCvqdZ3QJrT1FSmRbY9ua9fqSIgRGCTo5xUzt0KMXltHO0LKFFFEp0rQ1tZ0xpojLgdPKslo1CAF+4zDFTIYsRnF33mJ7j+9HYklEkbn2nk+sViztVPPRO8+TwRFCYiUkpMS7l5fYTnJSG2QQnJysKCHTLBvqUiEzbDY9OWUMghwSQQikmlKGLIarYWTvHIvBc69u39d9fW5Fu7/0S7/EL/3SL33Pv19Xhk3n2I2OWWWIymCsBDJDGEnBk1PElEgsUwFEyImUCkIK2pnFCEEXIyFBKYKtNiilWXcD+24kCIk1FSJlUhZEAVndOO2I6b9tU6MNbGOgFBAItJQkn/GjZ+8CJRcaqbjT1sznlnRTA1BlRQianY888Y6aBEkivKDOIAv0LqApGKsxViNFYd9BkoJaCqyUgCAWsEKyGSOyCFqlsEXQDekDGrGPF9+v/gBCyPQictU7no2OTxxLuv6S7B0mO45bjZaCu0vLuxcbMoaSEiEmIgUlJFWleHS5Yb12pJB5eiVIIbJaNGxzYOsd+SY/UMiKrY/s9yNaSmxVYSvJreMZuhLUMQIRjUQLcCEgvKfzgZwylZQ8mC1YLVuGECgUYgYXMkMIXKRA00hCTjgfiEJTUXDjgFGSurFobSipsO5HiopUUlMJiSyFlDKV0uw6Tx8CNYIqQ4rvL3/wh4mD/g76e9F8vxo86O+gv++HD2QOJKBkxCvJqCqciMwXc7KPqMGhY4SccLsrRiqMkqRcKClhrGI1m6GlJM8bEBohBB6PlJbRD8QiSBkKERUCMWSCKHgVKVKgtELIQlVZtFbMfESJgMpM8aVzyBi4jg5KoTWKl+YLTuYtPk9pNrYY2gT75FnnQCOgUBC5IMIUhG/2I42U079jFMTEet9PpxLIKf8/TTUFlVZsO4cTiZk2zJD0g3tf9/OFu/T8UYwuMIbISER0EmMNXaVYtRXd6OlCoJCRVlGkoNIVNhZGF+mdp5Jycr0phYggSIWXCmMMfdqzdhEpFVZPu+pRWnwBLQW1MlNRjtYYO6UFVY3GpR390LEPiYUW5JyRYiomqozkyGqsloQCKRWMlLRa41JmWSt0KuxDIKWMlFMdQIjxverrIsCnCAiEligpyAVyKUQKAknOiUZLpIRYMp0/TDbPkxATu8FzsR9Z7Ha89eQtpAuMfYcWGSkEPif6HJhhMVoiMpSQud22aCG53o5crkdSyCAgx0jWhqAFQltWi4aX754S1DG70NFFS8kJaafF3Hxec7kfOF97EJnWSrZDYGEVImeMmByi5tZwq2mpzE0hT4zUppArQ6ZQzyxVTux2HTEn0BlrJNGHyUpWaTISH6cjamklCkMuGRcTaTIdIPlEowQ5QQ6Rzh00+Lw46O+gvxfJQX8H/b1IvAtolRDWYJdHIC12tiTIjtT3pOgwRtG0c5SsqMTkdJjSZPhSpczoA6JtUKZCCElGoW1FypnBeXJ0SBXIqTBIS0gZay2mMtQEtAK0YoiFrBqiyIxxYOMKtZYgJEJMG8EzYzi1FUYrSpKElLBSIq0mxoycG0woDGNEZtBIrJI4H6isQStJFgKXMgnQSiGEmJwqY0EoqJQi5cKiqZBFkFOh8+8vrexDG/C//uSCrCRSSfocaZVEuMxPfeohITm23QC60M5rFJplVVNLxWY7cPHoGadDps8DIDFKIwt4nzBmWvmpQTIMAS8Cs3lFqGr2zmERlMqyqCqqyiCV5HxdkO2csU883l+wT5kfXUjqmUUFQX0T2MeY8EPCzjQxZEQGKwUzo/nJe8fs9/C7zy5IOWEqSaMVuRSKhiygGz27rkengq0VLhdGH4CC1uJm4aBZWs2Z82y9x73PgT7wPSAERRRiTKzXI7+7e4Pry6csrWU7OPbBUyS82xX2fsAoxfG8RVUS4wqfOD7h9fMrhl3C95EYE5mMVoLFfEkWllxlThYLfupHf4y8OIV+jdNXbDZrUs6kCEVpHj3r+fevXzBfKE6PK55se75w6zZNXaNzZFZpZlbjXKEfPLNZSx8SphRaLQHLJ+/f4uq845HbM+RA1gnTaDKQkaQI3TiwXe+QIlBXFb4Idi5BThg13ZNawXHd8Pam46p3uHA4ZXouHPR30N+L5KC/g/5eMGPvaepC2zbUdQV3E7KeUyuJf3bBrhs4Pllx8tInsFYR3Y7RjYxdT9xtGdfXXIVIHZaYKqGNxVQarQohJULvEBKE0Xgl6WcnFOfwzRJdV2gSlb+iKHi07VmHli6M7IeeqyHw+cWKurWcWMXs5mNwgaAFq7rBe09JCS2gMvCZ26d0e8d51+NSRtYCKRWVSHDTh2k3Dqw3HSolGqMYBQzeI8S0GZ1CZGYMJ7OGx7uOy8Hh/fvT4Ic24O9dQGqJlNMqaasKOURceIhRinmlEbKQHCwqg5UWaQS2tZweLZAKLi8GtNQYO9k3jUNkrgFrQQX64PFhGpy7KdPoGe8+fZe6rTCnKz5ZFUqClxaWZ0NPLRO325rbwJA9umh8CLRVRaUVF91ALzK3qjlX/dRkYVFXLFIiRYmqYV5pFJq6siTn2bpAQ4WuMiEkfEikBCcqcbYfcKFglaRBMeRAEys6lZlrxVwrukMr7+dHmU5VXIhcba8RSlHCyKcf3sYaySwrXEoMoycleH2/Rp6vWTWGV09XpEry+PKK6AOSgtUSKTXGKD716isoVVHXhttHSz714CH3X/okO+f4f/xP/yP7YeDB8TGL01MAPv3pl7kaM2O3ow2FHz0+Zhgi1cxCASM0BstTvyElxX2tuej2KCFY1jXHKdNtB7QpLCpF8QWZM/t+oIuJtlXUMhFCwPnpePBIJZ4NA72PVBKWlQGl8SQ6H1g2lrax9KN/kaP08eWgv4P+XiQH/R3094KJcfKkVwrqugagrRqUUty+tUMoQcmCbrvFVRqtFUm1qJmiqgV0Dt+NxP2auF2jpeZ43lCnE0y9Ym4r2lmLkHB5ccFRu8Ipzxtf/zpJwIPjBXfuVJDgEyct8mzAVIrGnnBajyQvIUcUkVpOqWbPvGNmBE1VsXZh0mBVsbIa5xLaaBqjUTlPzVaj57qP2CZRC0X0mewDLkRWlWUYplpRrRXGKFIpkDLbDmZG01jN+D5PmT60AT9h6pKWVEKWgkiSjUw863seni6ZzyoenV2w33vUsaJWkpAlViteeek2qR9Yr7cMWZJKocSMLpm28uh2Tlg1DLGndJFKgGobKqBR0JJoyIBFAEYl5nnD47ThPDsk8EBWmBzQsTASSEIwasUnlyuOjhukkPSDJ5bEvNWklInOs5QgSoGbnfmYMme7PXNv0FIxMwZVSfoUuL2a4VzCiJvTgL0ApmrsdXT4nEn+YMv53JAFbvLtYs6oDNcy8XSzptWG4DP96GkXGpMU1rTIDDkmrjYD8b5Cp2nsU8pYLTmeVfzYa5/kpz7306zu3iWlgFaKW/de4uTolCMt+ZnLn2C4esxJW1OalwGoifz0Zy1ff/Imb1ycoXzkR6xBJA9FsA8jXXaMWvCJ26fcOVpOll99Ry6JVdsSvCeMntAnhiGCE9xaWLZ94Hq85p6KVEqyaC0hQQ/cPWrohogGZlqxHkcUlkDiPDoGnwjdYYfruXDQ30F/L5KD/g76e8HYUlCAQlKjUErhgHnTcu/BS2htePetJ+zCJZGEQiEkSC2xWtNQsR7eQQZLigJToB523Ao9s9d+nFl1j0Jit79i010TSkYBgoGZFrTSkqmAglSe03lgfdnz7maHS4mfahc3fRgKGxcoISFrzcOTFSfL+U0cOOX3L2oLZMbBcWItJRdSAo0CIrvdwKytmTcaUsXgp9d6tJghrKaWkpPKcr7vUEoCkstuZIyJHF6gLecHQUYgi4AEuWQksFxWjGFEyCMqW6Oz4ngG907uYGViGAeC80gp0SHTVBU5Q2UUCyWYlwT9yNXllnvHDQ8fPmCbJW89PcNWllVTsbmumYtCUzI7H1hYQ04JqxU+FZ7uR5xIHM8MbshURpEKROdZ1RXzyuJcoXOBkAJGwLbL3JoZUkrMjblpICLYO4dSghkaVQRWSKxRZKUIHkRiKibSksYIWq8pIvNsjMy0Zlkpeg4pPc+NfJO0+V5vs0zM0KfEqq5phSaHNHVHHgP/3Wd/hFvNAucDF/srFJnL7UhBYJScHB2aik+/8pCf/V//b2nnS3xIeD8icmK5nFFQvHL7IXuZsAqCXDJbrsjDmnbuCMrw2A2MJXJbLeh9YaZqXBLkDDNlWFrN4AL9GPAhIUg82+yQMfLu+Z5+lwlRsvGRFAsnpy1FCOZ62rGa1zXrbYfKmdhn9ruBEjO7LPnq4zU/8ZkTLtaeZaO5W1m6fMhhfS4c9HfQ34vkoL+D/l4wSjcYaZBCkhSgBQpIgJGW1jTMZy1HxyucluzPn1GGDhEcRUsCmfvtjPNhQBSYS8lCCELf8fXf/Tc8PL7F8t6DKS8+ZZqmxipFvFYsKCxlYUyJVklIUxH6WCLP9j2xZM5NRRwzy8ZSbgq751phUVxe79nuHTkntBRcbHruniyIKU+1LoVpsRo9xmi0UWilqI1Cz1pSGlAaQohUTAvOWimUMjRKcuEcjVacNpbho57SQwGyQIiCAIrI9HvH6+GM08WCu8slJ8cLILJsZ8R+R10kMcHlrkfFwInWMAyQPFJPN3JpFP/xYk+fHC8hOV3NObp/TFsSeb2h+Mi594SUmFWGZdtC9lNhiLUsrSWLxMn8xgYpp6kqHKAULrd7emA3DnTOUYAHizlNYzBavte4ofORb2y2PGxbEAKlFMYatNb4krG1vZlI41TAkRQ7l6k0mCwwYhJMjIfdhedGvBlXWaAUkhDooth2gdtNZtZYZhiu9z0hB5am5v7qiE3f881nTxjevuT+ak63GXGycLSa89kf+yQ/8fk/Tl1PnfKUFFhZkVNAaU1OhXaxROT7KJHR2pKGC3y3RuaBhRbcqSrGorl9fISUElImCUhMBXOX6y37nOl2PdtxwOXIia6ossbYitNlpCQIBTbB8fJsOjYXUiF0jVUVagzoktj3I28867najODh2jl+QlQcNYp5PWm68+MLHaaPLQf9HfT3Ijno76C/F0xjLAqJyAXyVERutcKXTGssy9UCnx0pSazR2ByprMbFwqPNhkpkToUiqsnJsZECIwqNMbz75Cn7fuSV6Ll1fMTnT1YIkXD9nk2IXI6ORGZWVcwWcwQZYyoWdc3ttgYBq2ULHpQsZCHJCETJXO/2rENg9IHBJwSCh0dLbGVZFIUe98Q4fe+t/Z571QwA7yJGSLTUSDWttisFm5zYx6nQd9d7oplqRlHyxonqIx7wi/JffDLNN3Sdo+sd1/uBe8fH3Do9JkRP2zT47FFSsA+R667nSBWOhKaKkZATZIlSFbEI1iGwCYG5VTxoFPfv3MJFwXoYKTFxPThcTnw6RoSAVAqpQGM0d2cNkul4ZowQgsMagZDTjn2/2zFkSDnSxUgREqnVtHrTilw8KQRCjowp4CjIPOViTdZPmhgCQkAtJDsfiTHicqaLGcF0BFRywZeMj4eUnudGvhFehiIKSAVFMAyR3ieO54LToxYQDLvAZj9wbrbsxoFdPxJ3gZWRNFYhMNw6OeZzn/0c9x9+gpwzbhwQZXqjaqkgF1IYMbYiz1aIFCENhP4xfbdB5EhD5uX5jEhh0dT0XSaWAWM0VmrWXU9/7RlLJLtE5zxjSiznFfOqom4MKjtKynQBdh3sk2U1q1CVQpkWIS25CFwqFARjgIttxA+Bem44vvMJKgIle1x0iENa2fPhoL+D/l4kB/0d9PeCMVpPG745Twu7WBBqyrqQ1tLMGpap5dn5lkJAqcnRcRwL267nXq2xWtECUYAVYASEUtj4QJcSC6u4X0ke3rtLHwub5HiSI1eDw5XMa6eRcuOQmLJgbiwPlnMkgnlliULj04DWEiUUu7Fn2O0ZcyJnbgJ+idYaJRW6UQgUOQaETIR1IpVEZQyTCfsUT6YyxcHz2jKIQg6B0TlciFPaEpAyjKUwfNRTeoqYCm3/83EiRKaAtw+elAWnR8eMoccYg2lPGPoO4XpIntuzltBFoCApiFJIJfLOzhFzoTYSBchcqIDKGuSsxqwFSoASgpIKbhgJObF3Di3g7rwhpWnnYzNKciksG4nSkvV+KvbRQUCBmdJU9qYTb5aAp6o0urI0NvPpYca2FFQSWFvR1hVKCJIUDP3IsqkBgR89yXukmVKdYi4QE0VOR1sHniNT84Xp3UWZJh4h6MaAj/DS0YxZvaCLnt9/+pg/OH+C1YpGKxDw1tNrYhZobVguTviRVz4LRiPEtFgsYURJiZytiOOIH7fIHFElE0NP352Bu2Z0OzbbkVwCt2ctSWbc6PjauztmbebuyZxaaS77HoCFkVghqIxFVIJZ0/Dw9gznPTorQsgwCo5EyzfPC5+bzTmdzWmsxI89znmG3tHIhgdHSwiF7Xbk5PaSH/n8FylDx257hthd0L7PyebA98BBfwf9vUgO+jvo7wUSEWS46YOQKCmhbDXFhgiE0NgiEWlyS1LLJU4UxuBoFDyczfBjmHpDlCmVRgvJk92WDCgtkAqESCgiK9ug5zU8KzfSVxQBMQScD4zOQyocNVOX3hQKm6IJpXAkQSu4cjdF30Ih0DR6ahRHiZSYyBKq2mBUoo2ZT/k5zkuWy4aZrTDaTD2lIkiRadqG25XFdx1ht6c2AmsEJSlSkRQkqPcXyn9oA37+q2D/PQpcXV/zdNYwqyVNu+Kyu0YpiN1Ai+Dzt+9Q2cJltyFoiL6gs6Cg6aPnVtMiZWamK6zQuNGBcFMluFDcqRtmjWIII3/wuKet5jzb7rFGUlWabXYsjm6jXlpw8eQdZHDoXEhqWp+9Wk0d/BQSqQzOATEREmhTs/WK/SC5e7pk4QNESYUh+/zeiDTWEAW0VYvOhn2A21qjtcTFjIfJVuqww/8ckTd5rDc7XSKTUFCmIrZt1/M1N/KNyx3zucKkxN35EZ84PeXuYsH2/Io3nl4xjhFjLVZrVpVhuTwh+JFx3CFywmiLCJ7YD2zWjwhDYL+7YHf9Lv36KaSRO8crLq/WSA3t3DLmjFHw5nrHy6LiVsgoW7CVAeCV5Rx1s0OXEfRZMbeWFBNyfh+jj6mcQj8+Q2/eIQ0eER5QhCGFgUoZqkXhd752ycm85nOvHiFLpD6+jbEniOYIMVtQL28h9eMXPE4fVw76O+jvRXLQ30F/L5op1SOlRE75JiasKAWkNNS2RkvN053j5eOWzXZD2G84kXDnwV1sKQxjwFNIIpGUIKrJ2fBW01BIVOqmGDh6SJPjUmss9+aSZVuRY+abZ2dUas71dodUGWUFYyx85uGrVNUx/ZN3qNOAzJmqVACcNmbq0wQUIej6iDyBwWe0btgOgt0Ap8en+NFjBaQgoOSp30SlWFYGXwpWWoQpBB04EhmsJuVCQuBiIZQ/5Nb9IXx4A/4/jDKtAN66uqRqKl57+RVOjufMWs3mas/Vdo0YHXePGxSKJ+KShRL4SiERRCDlwqdOZry8OmJRGYyS5KRAJySWHz1dkXMi5MLeZayKLJaWkCue7ve8vdtisuSoPJ6cebqBdc4MufCkH7jdNvy/Li95bVbzcDbnqK5YVhVaJ7SGbt8jSua4EpgxsVQRbxVn247NpSfcVHO/OwY+ebyglharNMfHR9Q54cY91kpchJA1RpkXOyYfY4QQCAQlF4qEUgrCRxCFi80OHxyn84bKKJQqGCewUbCyNa+9dB93esI3n62ZtUcsTu7RtDN+59//Bj8R13zqT/7vqJYr3PYZsdswXg8koFtf8fu//W/YbdbU82Puf/KnWR23VGrHg+YdLtfPuB4GKttgq8T//k+8yma947obeGO3452x49Ptkn/2xht8Zjbj1dWKo/kCmzX/4v/3Fts+kdIjYgGlNa8e1fyxO4Z79z/Dnc98AaTg7O2vcPn11/mPj65542mPKoJPPzjhT37uISd372LmpyAEMWZ86un8wRr2eXDQ30F/L5KD/g76e9HolEnBI4SkUhVKKbzfImVDFhW2bpg3LeXNr3J+3uH8QLha04TA7ZMGrRTnF+ecVoJQNEJKEhkvCj9x+5SXby9pzFQUnJ2arOBV5sfvHpNzJubM4AIKyWKpGIPg0Xbgeu2ZK8E9+4QuPaVPjj2FMWfe9jtu6YbffLbj5cby8rzldD7j2E51n5WGfbcDAbfahtol8ANdIzlb79j0gRAzWsLrw8D9kwVGamaV5eT2Md57YpwWJp1LSGEwonl/9/O5jdT3iSh5yiG8yWcSAAWkEJQi6X3gYrfjM7PPYsyOi7NrLrYd425H8gFTwJWAzQIlJFFAVyIvL5YcLyraymCUQSkB6luJMQGtBFkqRC5UCdZj5uzxOSIlOp/oYiZGz0M/JwKbkIklowQcVRX76JkbS60blJZIHTGmJiSFG0fOdx6fMpWSrJTCJBhFIqUyvc4i2LuAVYKcEn12BJUJGJ52W6qbLoCVbmmMgXzwAH5eiAxCQUHcaHEqHgfIEWKEmApCBGKA6ODN8w0gmTcVc624dVxzcjLn3v0HLI9fRjczjk5OkSmSSiF2l/jrxyAMftzyztf+gCFDaZdUq2PuP7xLdJfsd1u6fcemH9n5wFK3aD0j+8h1TjenQZaXDeyGwELVWNUipJnsbXPmqKlIaWSXIzFnhBI0tWalDDkOIBTSLkj6mK892vH2s2EqSBdg5gtO7r5KkoGnb38FgNSvGXcXuKt3X9QQfaw56O+gvxfJQX8H/b1oQimARt+kewgEMUqUSozjSKcKWQN60uf+esflszXCO9xYMTOaPgkWWmDI+JRY+8yPzGYcLeZUUqJkQSmQpCmBKE076kUItIjkNHDRBZ50F4To2LnAGDIpCYaY0ArWgyenQi0F92Y1Y0jMjEYJSZKCpMFaQciTPp9te1yKVFpzx1a0UeJHCElQhEJpQUoBWxnkdEZABvqcebTfcSQVAFLX1CiG9+kU9aEN+I2UJAqTC/DNYN8cWyghiCGw3q4pKaNVxfnFFZe7HWEcUHgWStPFiEBghSLnwpV33DZ62nGXEoRACIFUEiUNJQekmSrCS8oIkfApcu08McUplwxJKRBz4jw49jlQytQiWQogFhqpcDkxZE2DIAaPS/Km/qnQhcDVkNgYxak1wFSgobXGSjF59lMmK6pciCVBAuciIwVSYiUzVqT32oAfeA7cpJUJcfPQo0wnjKWQRSbnqaZkpgSpSEJOFDF1R77a7MizhmgUoXgUjmWrmd96wGw2o2Qo3lHGjjxuEEjSuCYPW45PboOpmM9XWGuJzuBQdCiCmHYoRtczVpJH3YZtDlAKdSrUUtPHkZk1+JIZc6YthSE4sijcWrXMUGyjJ2ZQtUZWDZHIMA6oLPHjiEvgk2BR11ASTdVQL04QZWB39Q2ic+QQCGPPvt+82HH6uHLQ30F/L5KD/g76e8EkwOabfhAig4KSpvSyGAL9mMkq00iDqODNzZ6+75EpcrlNpKZilyJSKxopIcPGRe5XMGsMSkhEkQgkSkmUVsQYUVpMmk8S4QUhZDZxxIVpoWqNRABdTqzHkT5MBbrxpmcSKVBpyVgSfUosUiG4kTIqtAKkwLnE4CJ4uN80+BgoZIwWKKnfqxW1RlKYYs44OrohEmRAIVjWBiUFY3Dv635+aAN+ayTDe5aThVLElEqoCkJAjIHNdovvN5i6nQaJQpaFIQRUznQxIcW0a16AkDO9D8giyDlRhKAUBUi0trgQubFGnSaV6HE50ceEC5HWKBZKYbOhy5GrcaQrmZxBF8lMK0yGxkyT35gSLkKKEVkSlbUoKRClMIZALBErFAYBSlJpSaUUow+MOU+9CJgWAF2M+JjxqqCyxMRITInRHSzBnhdFgBTfyiL8r75XCvlm1+vurGY9ZgYyi8oyqyw+JTo36UOOA7tuw61xh1EZrSQpBeI4kNxA9gNSZFQJzGpBMIKiBFpM/45uVpg4ovoNtd4jw0gJI9eD5N39FlemY3dbBCdVhRIws5qcEz5Op0c+RbIsHM0sc22Y5YJHUrVzRDtH2Jqh30C/IwyXtK2hrStWTUWtMkfzFlMvqM2SfvwDvN8xDCPjONAfNPhcOOjvoL8XyUF/B/29aEQpkKcmrFmIqSdTmbrrppQIsSBSps4FYQ3iJhiXSuFzoU+BfY6oPLn7SCRGSroYSSREnla0IkuKBm0NMSWyyJRSCDnR+YiPiZgTIRUqJWm0JOdMFwPP+oGEIOVp41dniSiZWW0IYbJtjzHjo8f7wtGiplJ6ivVCJJRMUBLnM0JCpSVGKboxUUlBEmCUIqbMrnOMPuNFxiiNiREtMs6/v0yPD23Av5w1KB/xKeFiQE2l2lNFssjElNh1I273BCHvcvfWCTp6+o3Ee49LDp8Lu1zwImCVYmkNF2Pm7n6krRVYg8CCNyQbGFIih0DJmc5Hno6OzkOXEpTJzedUSYQyvOMD3hf2JTOGhMlgm4q5mbrlhhBJITG6SBEGHx2zlBFZUQnD0hSUyvjsQVi0VFijMVIyOE8jJSFJFpVk60be7fcIBBKJFTV9DJP12KHpx3NFlJt0MvLNg2865wFIBXIRfPrWCd+82nLdF24tGu6sZtSVxfmOED1DKVxu1zQX76Jnc5y7RbNYEPc7XL8l+hGpEkopjk5q3nz8hH0fmR/d4t79V5id3CLnRL+9xCgLcirofjT0pCDYRkcfEjYLTBEsjGFZG3wfIBSCL+SikNaRSsToBaezI6p6jhCgrMBUC/rdGdF3xPGSB7drcjYoabh/bHnl3im2mlHPjrmdM2uesB/eYAgjMR+8op4XB/0d9PciOejvoL8Xibzp0lyERDMV7wqloUzBaymSUgTadXjZcHq8pKkE2TuK9/jsySXjoiDHSKs199qajZ/s3edWU5mKIiwlTplBIWWc8+Sc2bvAo+3A6CNRZDSCuVQcKQ2ycOU9ssB1iISUqYWkFQqrFcdVzYhHCYFPiQAM4wgSrJqaxNla0cwMRSRCyQg1NV+VUjL2maWxDDHT1g2ueJ6OHb5IjqRB2ZohB3T+VjHzf5sPbcD/f/rZ/55mMeP3Xn+DX/+t32Y6VJwmH2s0Tatp6ky83nK17Rkur+mGLVlGTpuabYJXigUC2+i4Co5uyCgtORoMLzcrVJEkn0m5p+88y7ah84Hd3nHZO97yI1vvMEjGlOhKIKjETyxn/M7jLQ9tQxcGgik3xzuZ27JlqSuuPexdweWANYarneO0gTPfU0RhYSVVAlspbi1rrl3get+jc+Gl0xVLO8fqzOgcwUlWwmKNofOFUTrmEk6rinYxe7ED9XFmsqAm3+wy3HwJxFRvkckIo/hffv5PsPzG13i8GKm14ahpOGprtkrxo8UAhav9ht/6g9/mX7/57xDa8CeWK+6vllTWUHJhdA4PHLWSO7csdhfJcsd2/Saqkryxfoffeef3Cd0VL1nFT5wc8buPnvKFe7f5fz86YzN6ihBc9Y7TpaFKhnXybH3H5RhpZMVVv+eN9R5xFDk6Spy2HVpJZFpzdzHHlcLgPTkmfvLVh3zhMxalWvT8Ac3xfdqjkylXF8t2HCgxcautaFYHDT4XDvo76O9FctDfQX8vGJ+hKQVBIsVCihEmExxiLEAi5MCiOMbdwPrqHOcDMy05rQyDUtzyFcEHrlPkqRt5a9iRgYVumN1eIGXGx5HrPuKv9tw6mbMLmX03cr7v+cZuxxASq7li6yLrpEG3fHq15JsX5/z08Qm/c73jqoTJrt1HXtINIjPVl/jMvEhmpmbrM0dt4o3tiIuFuVTYIeJazXI5x6dAjBGRC5+6dYqtDJVWDC4QfeC2bZjPZjzzPXEc0ZVgNauYrz7itpxt23Lr+JjToyuMmQoUjmY1LicqqTBFgzCcXa0pBPYbx0JXaNOQRgdJYW0kZ4mPMFJQGqSECxc47iO6Vswrw2pecaxbgvPsU4acsVJy1FTkOB3JiJw5UTX3bUtMNzscUXKsLQuRyQWGANfZod1UJKyVZt5U3F7UjE6zbBuOZnNu2giT8Ox84PJ6YFSBWktOq4bjVuLdwB5J7wt9KkSRkUkCI8F7xkrTpYx7n7lbB74fCv/1wbZQktoaFkbxzSfvYEvkR5YnzOdLrJY4twM8USdmUhJjYO1HRNA0NvE6mVZJlk1DXVfcPT4i60TwoHXH6WJORnJx/YSiJPdOXube0RlKKe5Kh4sJD/T9wImpMa0l5UznAuc3PsBJFGpbc1zPWR3V7B/tOLpTo5RkaTJLm+hSh0+Jb15eI2RhbiS3moqjVjFmyHlgHC6gapHtEW7ccnVxzlcefYWmFI6q6tBp8rlz0N9Bfy+Sg/4O+ntxTBn230nOhRynrIxt0sTuiiMt0FVDpSUiRHYpEmNmZiQlZ3ye6jqNFFz4jllvWQnBoql56fQY8IQ0paedNprGNGzxDD6hUKAVt9qK47amjxGF4KKPNFJxagWpFFxIbG9SbIqQzGzFUT3nZLZk6zZ4DJ9atRSRiTngfcBneHy2IcqpEdiyaWgqQ3Cwd44xe3Ip1NISU0LFwIaASJreScb+I160m7MnBwcpIcU03C5GxpgxRtFUirvzls4FVlaxqAqleGIW9Glk7UeWqpCkQOlCUwS2KB5UDbW1PNt0bLzn9qqhnRlIiZSmTmrGaI6UxETN6VxRG82lG5iZKe3mLEQ+Nat4px+ZSzkVgwjBSa1RAsbkUUqxnNfcW9Q0BoIVCBGov1V1nTPFVIgy0o+ejXNUWjKXmjAKfIAgPNedI0bB7XaJlIGrvcQYTYmwT5FpD+bA8+E/P+S+dZe/dbwtpWQ1q3nt7ulNkVBi1RYqORJzYR9HzsY9i6zoTCYrqLXEknnVtlhjeWOzph167q+WzNoWkiYnT0qT65MRYNIwtaB3V9xREWkNJiWedQOv1S2/v+5o0ZwqhdAKPa+QRhCGjDCC43nNw+MFyhRyY2iU5qRpaK1GacnMnjL0G55t97zT9bRGUWvDMiuiCyQC+71jvR0wzx6Tw453z59ADjifuRoiOb3P88QD3yUH/R309yI56O+gvxdPoZBKgZuYVutEUBnF5IJTaw1NTQ4VR7WaYrmc6Urmehy5jaEnERXYIjEFPlm1VI3lenAMOZJKZlFVSBTZZ1IRSCmpjOVOO0c3sDQV58NApRQaxbnruGtmPHF7JAorpqZe92YVCtilEVk0x4uKl48XaJ1R2pJyQEuDQpGAeVvTu8A2djwdR7ZBoYWhbaaU9pgi2zHgY8EqDUS0ErRSE1PmuneI+P40+KEN+J8+fUKlJfdOV/xvvvCTXF1d8nvvvEtMk3OOFLBqa1oMjRWMXU8IkS5EHvcd3RhYNi0LBZWxjChySiyQqAQxJvCCrve8XfYcGz0Vx46BLnj6FOlyoUFwfzZjXimEEJQimKFpjaZoz8waQs5sXGAXAieV4WTeEAFJoR8HnJtyC0GhpcQqORkeCEXRliADDRKRYe8j4XrLLoIvkRJhZmtm1iKEJDYZHQvOZ3zK+HjI4X9ulOkkBrhJJiuTZYUoGKuYNZq2UoSY0EJMrb/9yMY7vrHb0fvAqprTILhnLMcIcgwsikAXQUoQR88zdqQC9+cLUorshoGddwwx0uXMRYRPn664YzypkcRgmEvJKYC1LKzBh8jVOHCdPQ/sjOPFnJQjRgj2+44iCnNlaJuatq2otEYoi6xWCKVpnGfhRnIsXO1HQrhg7QMheyqhaauBWRgp2WOE40gbXAzTTtv77fpx4LvjoL+D/l4kB/0d9PeCkf/F6ZKUUxCuVCGXDFlQiKQ0oGUGMhZByIU+eJ44x2b03G4trZDU1uKlJoZAA5jJ8JA0RK7yQCqCe01DSonNOOnPpch6jNRC8NKsxeo5RUz5GciaOktkDVYqxpDYjp7r4LhTNdxbLAkRBIXdbksWoLKEIlBKTAvZLKBIagshWubeE3NmPTrUWrBLjj5EdFHUxlIZRQEWVNgc8SHjfcGl91dH8qEN+J88u2C+mHHv7m2++NnXePMtxVsXV/R+ixaCxmrmbc1CVMg8UhuLKoI+JnLJ1FLiE9zTEisMXmeG4DEIJJm5FFAExWcu44g0063YO8+VG9nGQEfhRBushFVdEctk1dUagciel6yhlMLl6BlSZjN6jq3mZNbQhcjoPFfDiAREUYwxM8sFFJPnfgajJVJKWqkJZPYhcB1GLkKGUlhpy9wWlBSApjHTAZcsgiIK4VAv9NwoFEqZJptpsXfz/1KwaCyL1iDFZE1nqgqrLEYWwOFCoBIKFxN3m5pGGrLSDF6gtUCKzLFU7FNi6EYeB8/y5uBy3XWc9XvWIeAy7MaBH9H3OWpqfK0ZtaSpFSkEPtlURJE523fs+8Rl8LwiFtw9XjCMjt2+59muR5SC0oZgCwkoUiLk1Bla6RqtJgeqwQe2/cBm3/GuCyhZuGstViioLQC1kcii0BZAkPLBGvZ5cNDfQX8vkoP+Dvp70SgKUoAQN7aZSiEUqJKROVNKIMUeVTKkSGMtVgocGYbMQmkcmVtGM9eKnDK7AlpLDIKFgD4VhiHgckdzU6uy7UeunKOLAZcKrRIglhw1DYlCLJKZtYRx5L5tCTnjUqJPka2P3Goa7sxn7HxiHB3nm4FSBLkUuiJY5ITSAhTkJBBao4RiIQwdni44QkpcRIePkdumpTF2+p2ip/sSBEYXVE7k8P4yPT60Af/OR55eX4OEu6sVsghevXuX677ntK24v1wwn7eYkNhudpwezVFFsOxHWqkopfD7V5dU9ZKV1qRY6LwAMTUx0FJMtpxSUBnN3k9v2t5PN1oWaKScVmEyIYWi1pLKSEpRXOw8ykqebfY87kauwrSboJSi5EJMid4H3OCplcSpxLMhUFkNskIChkQxmSwgFYnLmTElBIJ9CKxshZTixgJt2snPORMAbSVzbbDisLvw3BA3m1xMD79vfQ0huTVvuTtvUDJT65qjozmndkllFe3YUt0cfv+Hs2d89vaCI6PJKTBWkqQlOWUcgjYXNJlcFIOb8v42Xc8YPFoIlLAYpRA+I6ykNppKC3IuPB0G2lbxdL3n7as9551jZjVWKFT0k6VYjOzHAZMiQddcOUetFRqQIlClgI8S58NkO1YiPhcCma0bebhYUBmLVAKICAo5eFIuVMaijcGqw5H2c+Ggv4P+XiQH/R3094KZdvSn7Ap102wqMu2oy5KROSEAlRUyZU5PZlRKcqv3HKuGUgq/u7mgbWasrCSHiEwVup0qf0OI5DhZvucs2Q7TDqrvI6UktAStFK2AEhPCJKxWWCy5KHapo8Fwvut5dzuwcZGZ0WiVyT4gQiakxJgCOsEYp9OEygpysUghqaTEw7RJnBIuZ6JMuJRZh8yJtFO/AAqKyZEnMjlkSVmwRpDiR7xod1YZri6v6Hdbwt07HB2teBX45tljTto5K10h9gOqUVTU9CFRiQz859X2a/OGRT1DKYkrjs4HRGVpVUXQU7c9IySttWCn1buLmX1IJOC2NWituBpGyj6wnFUs2oqUMtVNpfhMV6xMIWUxWXwpweVmz/5m4LKSBGAmpkmhIdOW9F7Dr84VlJRcJM82eDSSpbQorWhRtLairi1K3ZStxApsZD2MhJBQ6RDwPy9u+s68l8laACEKQguOZjX3FwtuVZZbyzlWTbZZMil0EbS6hVL43OmC1dxglaLrM+vtiKoUVSVBgTYCrSR21mLV1B57qfasQySIzIOZpsuF892azTBydLRgMW/ICY5mLUombtmWsU0oUZBC0CrL2VXPzo/svWekEFGstGIEam1obvQOhb3fIyg8CY5NGKmLZIVlUbUIIdBaU2mNvXn6O9XgZeF6GAkhHjT4nDjo76C/F8lBfwf9vWi+ldAjytRwS2iwCCprKf0lQ3eJjD0ndx6wPUvs955S6fd6RAC8tmg5XtRUQtIlxzY5ah9Rcmp4qqSYNk9nc7SakohciowukYRgWSkuh8jZbsAOnuN5y6ptiDmzWMxQSXGnyuQZGO2ohGZhW673A1vvGcpUU0DIzKhACubWMrcWEJCgdwOFwrM8sg+eVmqOTUODx2KQKLRU/P/Z+5dY29P0rBP8vd/tf1lr7cu5xTmRGRmZNtjpMk1RotTGapC6KBBCLXqApZY8RjUCpMZCajECjzxkRo8QTJoBqIe01BIMaoCwqELq6jYXYzsvkRlxIs5t770u/8t3eb8efDvDlAvLkZiIE5m5Hmkr4ux9zlprr+9Z///7fe/7PM94XwfuMYDldppY14J8Rinnl7bgf/3mJbvdBsRyM93w+njgp37qff7Cn/pjjEkZCuSUePjognE9AJ4YlaVWsC0F7VE/8u2bPQsFg6EjMFTHq+NErXCTEyuFh2nm6e6S/XTAm8r7u56McJgLV87xeLdFq5KK8ObYbJMuhx7nCtsHAw+2uxa3HBfmEplK4bobyArHmBCBByGwlsK/eX1H1mbH9LAzfBwT1Tvyvc/xooVng+en8BS15GJ4fVh4U4+tpdUFqM05SM3v7nrP+Dxg+Y8dKsQYnr23pe8cu60lOOHB9pKn14G2ChtizJxK23RGgUebS3774z1TUaDSV+HSVj6ZFkxW3uTCIvAgrbx7Bbf7I8YpX9/2FK1MqfL1wfH08VOoLSL+1c2JKRWe7K4JDp493HB1ecl+mtmfJkpRppx5vN1yGRNvTjPaWx5dbJlj4n/56BOMCtfB473yvXVh6x0iGQMsVfjG9oqnnSfG1lb/6LBg6pEQPMecm7DOWbqxx+j5hvf54My/M//eJs78O/Pv7UIAxdynP2QKykU/UkpkXiZkWXkojuuuJzzYAZWUM6uCGTu0FK4Z+fbNgTUVahEsjo0RDjGTi3LUTGRllwrv7bbcTEdqLTz0jorBKDzZeZ5dX1HvXXg+ujsQU+XJOOC6wpPrLdvNyOMpcloW1piZMlwMO0JKHNbIsAtsnCGsmd94/oJamxB49JXvxpnBj02cXGEqhSe95ad3F8xFqRU+mVeeLzMdBjt6alSWnCi2Ng3NZ8CXtuB/8viSfggMoWM3blqMtwjPnryLPZ3QwwFZE1UtohYxQrCGi01H3wVKsXz85gVJK04MQQRrlaRKFcWI5cJbEm1EJ+eCc5ZDXhmdZes8VkBKYUqJeSmsCljDzrddWVHLJHBMkTUtDM5BET6OUEumE0NvLRmIRfk4rRxzav7GVVljS+dNLRkcWyGVypIKMy2SeQiBDsEWxdSKI9GHypJWltyCHs74fFCrgpH7tvZ9h6ZzFAprXFnWhZwWSgoYqzhv6YLBXlg2m5GshQ+ef0wBBt9Sk7XAVBU1IN6yNUIPuCrkUgje8SqtbLzlynqGlFAK87JyXCJJFWvb/KC1ihY4LIXDPBHjQu8cuRZOc8auC6623IokQk6Zj04H7tYVp4JmB73wQDy2CKl4yErSDJK4S5kXy0RXHQalSGJnOvLcEgBvphORijNf2svIjzTO/Dvz723izL8z/942VgXJitgKrhLw7Qea8QbEWUqFNUWqNg6KeKxxjMFQauK7H7/BFGEwFjFtLPqklYzBOmFbLfk+VnqpBeOk1VbOs/MBEZjXwrooU8xMpR3Pjs6AdZQC+yVyjIlUMruhGcDczpk9YGqlE0GSglRerCcOKd4nBsNUDI9dj8OwWo/VylLAi+VQIjdrYnABqZVcIsZ5JFp6sRxUmFNCftRFu4+urug6TwiBcdzgzb0dkWZCcGjfEVMhl4qIuRfBWqwIfahotigObzJWIBjBiXCMiSy1pbaJIdeKUShUjBHgPrkNw+MhcJhX3kyJaclgDJ23LFUIrp1iHPLKIUVKzYwbw4UdWFkpVZtQyBhSUUqt1FLRUslViaocFS78SOeEVC2mgldtfrG1UI2hIsQKaGVjYS6ZusCIY9dZnJxP+D831Nry5X8PLrsOWyvrujLFlWlNXG16jLHUWrDW4JzFFSHdfxC9NHcmtcLpXi+CNU1HQqXYJuixxhBotlydD1z2nrt55sXhyGHNOGsYvUNqZVxPALyZMqc1YqrSe89lP7BkpZRCrRVrm0NVzplalJJb1HwsGWM9j4fW7hQEtLLkzJITd9rU/xYDWkhSuBLDXZ5w0jFiGRxUzhz8XHDm35l/bxNn/p3595ahqhTaYWcrzyqqiimxGZ4Ej+Q2MiPWtK9aMALWC6VaUm7dJSNtfMdawxS16VKMpRZAwGFa5pKxOBxOLME5xmCpZeHVaWFaM1UqzgkTlU2+153MK0sqWAF6z7a3PMzCWkp7vUaoVdFi0VzRAqlWEpmA4cp5OiMEE3BiWXKh5MykiaLthL/c8/Gy61lTwlvYWU9vLMu97/8fhC9twf/g8pquC7jg6YYtg/cc4w1lXTHBYjpHXCwKiPWIqVRp7UehYqTirGvpvPdtkkpFUIw1SDUkVSKVQSpWBCOG0VhQQRU2wRKt4eWcWErBY5EsaKrsNu2tOy0Lh5jgXrgz+o4n3nBcIlmh6v3zS8UVQO9DC22F5rfD6A2xCFUFoy3Ey1Shtx4rllIKuSoXWJYKS1Ku+p6Lsadwbid+kYilcBE2OAoxJeaUiKoY2yFG7l3s7nkoghdh0kq5F4gjgtUKwWHEUqSQUDpnMCJ4Z7ksHe08zLINjnUtfLQcWIow4rAirClzPbbTjuMycYwZby0PRNh27eZ7nGbWlJsInfbSQjXtYqNtFtcYg3WWwdhme1YrE4YpFbRWgnHYKuT7zn5vPIUWP3459Ax9YC3nLIgvCmf+nfn3NnHm35l/XySUVpi3OX5BTSWrEmrFGINYh2jFGEd1vnmyiCLSLGUFcMYwpYQR8NVgbBtWa39XKLSaq7MGC3jjEFsxxjZRrTV0RvhkWohZGZ3FYFmSovfhAFOOLLnQWwdVGLzD7zoO69LMWxJoUVQFVy3U1iUQ2muwRghW0Gowrvn5rzFTa6W3FksL9dIK1hrmmFgLXIwDwXsO5rMFsH5pC/7Lq0cMQ8C5QNdtsLZAKsx3J3JRpBbw4L0nm4ASEaMYB5RKsYXOW17tQVCiqeRaue47bOeISYgxglbGYBitYdv3DCIco5Jy4ZTvtwg24aylZmWJEWcM49BEP+k0M2nGGYMTTwWGboOzHcclcloTwQS8K8i0ICr0zrEZHJ3vCBjAkGoh3y/ommEbepJpyvNaFEM7/RiLpUjE24CzgZzPKX+fF+p9IvKnwiGEuSSsGIxpl5NIxnUd4h2VhFDvLzYZYzoux4GXp5lcK7G2kbLHIWA2A6rKsi7UAhcmMFrDg2HgYC3T/Zzoaa3kYlBTmnd0UZY1Itay67cgIMeZWRNFFOcsAlxuN2y6jtvjidfHieo9AhSldYuC59FlT7cZ6LCYalBtIqVshKUULkJgtpYaFcTgxeOAS99RUqHrBzbDiM5nDn4eOPPvzL+3iTP/zvx725B7obSpYFSoNFuWzjg0VbQo1hicG4l1j9SMca2TVAuYUthuPW9eLkiFZAvHXHjsO2rwRIWsGVcrQycMUnnQB/ZRWFWpNTNFZS6KukIIQu8Mg1h8gd3Q3Ft0nluGUoWv2GbXHkLg2oOdhKSJFaVHUNsaZxtjueo6TDAMwdJZwykpa1EWVWZRRtdhrSVq28T0tnWTXG2vrwDOB/ry2Ua7v7QFv+mv6C967q1ywVjKmsll5s00U2MkVGE6nSinmUhEtOAEnHPkqDy57OkFYiyIKM41McRaFNM5fBXyrKwxUTbKw0cPcYcTu5RZUubjwwQ4xHYM3AdhGXg4eFbrwVm+9sTxR6TSOUjZcDvNbGmnCblqC+dIhUc4gvc87QK9t2y959J7Ji0seW5pcTiSVmZRVk102n73bAUt7SIU48rXtwOdyUynPd/bn97eIv0EoP7gtApBnPCzjx7z9UdXBGvpnGPTd8zTzOIcWgp6L05zxgALDx5e803nyP9RQFrRwlSVvHGY6tFT4dW8sN06xocP4PiGoRTmNfPRyztA6O1Abw1JKljLO+OOOwJU+CPvPOPnHDgHNRtu9we2QFZFq1DUMC1HNuNA1w18YxzYBMuuC1z0HYc1cppmYs4tbboUIplXEUJuF5hqFfGV/bIS18xPP7xk9IFpnXn++uVbWJmfDJz5d+bf28SZf2f+vU0EYwhARVnJOBvYEKl6IOYjJc1UrdxNN5j1yG3JVBSHZTQ9ReHJ5QUba9t4DWBKK6z2pWL6VgJPcyQeIz/99JLtoweU2z1DSixJ+fiw4JzlatgxWMu8Jo658GjTkc1AUeVnr58QHhqstDG2T/ZHtqHZZ665bZsjCWs7Rhvox0DvDBe949IbJjVNDF7B0n7nmVavWloOBhawlZwLpVTe224YvGNZZl7cHD7T+/mlLfiHDoyhhRVoE9ZOS8TvLqjek5cFcnszwsaS5uZLWrC47NCamQ4LN6cT+zUiCI/79kE/rCu/c3MkADtrkPs0wcNhJs4rWpWsBUdi13ke2R3WKi+PC3dzombDNM0c5oXri4G+6yjFcJpWPlpOyDTTO09nPVf9luIXLjcjF7XyyXTisEROSyQFz9XQEWzPi/lEysLWdZisOFfYF0WBXmATPM4YHu8C6iy3MXFaEzGfk7c+T/xgYEpsxXjhW/s33KaFjfNsveOd7cAf+blvMu46bg97Sm2OUIIhxshxjdzubzisCcHwuO95MPTcHGb+7cuXBGvYOYfDYLLhdDiyLiu1FrQUnMuMdsNXdxtEhDf7mcMpQq1MpztuD0fee/SA3o3UAqfTiQ/uDrA/0llLjoUYlevNyPXmgqsRPj7ecbfOHNJMShu23mHDyPN4R63CddjQkxjp+IATuVZ21vDQOEQCjx4PnJKwxoVpjUyfbXzwjP8MnPl35t/bxJl/Z/69bahpwVR9B6ET6EbKDCIDvsv0FAKVsOnJ00TR+6BSUWqB2ylzdzxxOydQw+O+43LrKOvCd/d7rDZBb6GyLJHD7UycI0i5n9cvXFjL7qJHRLhBOC6ZWh23t3fsp5lH1xu2fcAWmE6RN8vCy2nCO0fvHdsQ2Kij7wLj2PPJ/siUVuK6osmz60YyhmNKWBG2wWOjEKzljbY6cMQx4hARHuy2zKocjzPpfuT7s+BLW/CDb7saKiKKteBDE+tsjIGuowYIa0IlYrUgWlEqEwVLRe4Fs4eUUREGzTw/KLUa/shuh1NFSkGEe4FPS7dVrZgKl72n7w3rqlQ1BOMYA4TggMR1aGM+B40YhCLggSiKwTShkoNqe5alzVj5Url0hmQK/26/5+ftNcE6LI5gKrUqMS9cdD313o6qqjKnQjQtwlyzYLEYA2LOV5vPC4oimN81pAZKViKFb+wueegDYpTdJkBVTDFQIGthihNWFVcruQg3S0SBIQReHI7YXPhjl9eIKpobB5eyUusK1VC1tTEvQqALHdY0gZsPlqE6jBE0Rq46z5oXyjFja0vKCdZyWFbWnLi9WTkeI88ej1zYHgCjhp0ESs3827sjf+xyS2c6BuvIUkCUec1c9iOPbECplKK8mhLFFr7mO44RtsbinWPw/q2t0Y8zzvw78+9t4sy/M//eNqw12HtXw4TQieAJiK30HFsHYAj4dACtaG2ZSFqVQsQBnS0olWNOFBU2Enh5mOkRfnqzw2ihastGskUxUhADpbZArkvr6YeAkYCIEJzSh9xcH1PmYe+wOXM6tdrSG2UMlv1ccMbgBZwozlrm1Oq13hjGbkCl8sE083UpYGAbDEYa12/TyiPbM9I23gXhUFugVxDHSROj9/TOMqcfcZcerZVaLc5AcAbnHDpu+fZH38WmxNZYdtZhKaQYMZoRDLVWllzwang9TXTe89i0+abeBxYKUmF0DkoGEXrvQZp/a618murm3chcKlNROgzeOS6NYfACOLytrKY9p5bCEhWPYZ8TG2mer1UsYxeozrLmhKGJc6kGNcJvHQ4MzrNzASfCUjK3OdKXjlQVU4DanIg6U+m8Q8Syptzm135wJT7jc4MYwXjAVkouTXQtlaEXLvtAsMIyzRhtmQtalRwTFXhzXPA28GSzpQLBBaY1EXxgEwKaE0qi9w7EEGNr11UFEUs/bFiiMs0L3jm8cwTr6a2w5NwSo++TCEtRlnnBivDtF3t0rszHSIqFzgnvPSq4rsPmDFWpWhFN/Js3twzWs7MWKzBp5DZF+pAopeIt4AzWCJ1Yete1JMFciUXRfBatfZ44848z/94izvzjzL+3hFpB74OrRA2owziP04rzgVBXBin4mlmWBZMLQYSiMMdEB7w8Ljgcj/sBFcPgPWusWITROu7LMTrrMCLElJoZDKYV7EPHrMq0Znonn9rCegeLCkGa0LZUIRdtI+TVsJbCUJrsuFjo+o7BOMiFYhUt9b62E37nsCc4y9Y0we4C3JbEtgzNQfK+zDOmOUhu+oAvLSSs1Ir/jGnPX96C/96KyFrH2IUWr1w33J32TMeJx87zcNOD9+RYmgOPaZnDJWZULS+OJ752ccVVb0AqpRqMKxyWSCyKVLDGUq0DjcRUmjuAgFiDs575tHIsCWPbPJmRilTFWocRcEYoqpSsrDEixjTbJdMiuosWhs4xdD0YuFsW5tJ2obsu8OHxRFcyRhy9sUxFmaUylTa3NlSaX4E1bLxw1fVUgdclAZXhHLz1OeJ+ftUIJrRkyFyUlJWbdeHJ1vLu5YiokmNEpNy7QhXkXlDz8jDz7tUlV8OASKVZ8TpmVeZcMVWw1oG1oJUYK1KbQM5Yi+069vOe4zpzMQ4MoScYizPtRMIZC8ahGCKJaY0U53j+8kielbzmdurlLVkrm+0Wp4WUM7kKV97wb14fCdbw3rils5ZjKSxVOWXFaWXoHMEJAdiI53rYUIm8PKzEotRz0uTnhDP/zvx7mzjz78y/t4tSCyLNp0cqaKlUYzHBIdJjc6Eve0xZSTE3cxMMaKXETAQ+2c98dbPhydgjRqgiCMJ+icw5I6IYhIxBVFljRgwYcVjjsV3g7jizX1YeDoZgLN5arLRsKExzewIopbKk5t0jWtGcSSqUIrhQ2fQ9IpnbOTJr07VsrOVbpwmXDMV4nBhmKsUIUQVM61oZAWohuMDlZqDExJtlpmghuB9x0S60ol8QQugoJYMPbLdbXr7aE3Sh21RSgoKnOIEiaEmYrOQKpbZQhlKFipCB0Vi+Nc1sneUyNOX+q9OEkcwT0+O9AxGqGLLzeKOUstKJkHNiv6wgMPSZXbdlTStLUmIGsZZYCg+tx4thKZk1NoHSswtwtXIoiUNJeITBwbubgYqhFmUtFTBc+cCF82gpPBwdVYRDVgYrXHSBu3W9t2syXPThD3gXz/hDQUAc2NCUHkkqp7jwajG8X3qedD26LGAt1ntSTJSS2g2vQumEZCBhMbSN4K7v+J2XH3HpHA9ChxjDi+OEEeWZGfHeYWzFOIt1I9u+cDed7hX6hUOKUGHOmYdjR43l3jtakRBY0sqlCieBm1w4zgkxlmOsfOXyEXNcmNaJpAVr4I9uRnKboiWXilPLheu4piME5fF2Q5XC7XKid5Xrbc/dlCklY2qlN+eW9ueGM//O/HubOPPvzL+3CDWKWMGYijWZVBaKZmwwWNvRrTObfGJOMxhPdS3AraZID+TS7F7lB+PRtZ2qd9bwfDpy4TzXvccb4cVpxjvDu7bHOUGMoRpLMYbeD9wdTrjOU8mcSqFWOK3Kw8GxromlVNYKEgxxSTwNPUUKUQtLgjUfECBQuUkrc8n091agP32xY54zIs2JqAe2fUdnoVN4tB0A2E/LfT6V57hG5lyA0sJgPwO+tAW/apubi6WwlIzVwsbs+OY7P8M3w5Zhfc3GLJxWcM5wiislV0xVgjcss/LOdmDsPEvOxJTpgH2t/Ifjgd4avjaMPPCORRNfGXtu55l3+g1VLMeYmA5Hag3sp5XRGh5tLY+uerTCd19OQORmmUla6Wzg3XGgaMGawKqJKUZkrUzTwskaXs0rr2Ozh3LGsU5KsIZZlAPN2jM4Q5CR0RguguFi9KgIXWwBIlgYXNsFRpTzBP/nDAFxBukMJitilETl//j+V/jvv/EO14NhXS0W2MfCuipGDRvveT0rX9ldN3u3lJlTpgeKzfy7wy2dCD81XvG0H6mqPBpHlhQZLw0F4W6KHG5OBGt4GSf6o+HJ9YbLi4BW+M7HTRR3OM3kAn3oePbwkuX5HafJMOXCxXbL19/b8v67j/nKz/w32KuvsrEj0T1nff2C1/MLNk7IVTlK8y3uBMZiwa082g1cXQSKgPGGIIFiO7ouUe3EVBJTTm95kX6McebfmX9vE2f+nfn31mH4QbeJ4liXiKvCo3LkYXyD0wPRdvd14ELJFasVT+VYVt7ZbuiD4xgTpxixtEC2788Lxqy8Vwcehw4j8GgMJC1sup6MZT9lDjcznTV8tE4gnmdXG55ebNEK3/p4zzFmllRIuY2fP7vqubQeY0emNCMpUtbEfl0Ie0PUxCklMC1XYC2FgKFWmKW08SIMtnRYlKuxY9cFxDi87VHX0qa3Y083LUwxs+dHfIY/5ogrlrRk5nQk3L3m+aQcXn/MejpByQRnuN4aUmqFc0VJCqcIt2vk2e6iiXtK5HaeeJGUGDO/8PAhG7G4ezHSYDo+LJFPDkde58x117ENnisfuImR21JYbxem5Hj3uuPp1SUwseaFWCDVJi5+MWUOceJqsIgqU1ZOpVJr5d/f3nAohke+J1iIJbEviZdzxFtBcPTOMQZPApKd+Gp3gRbojWXrBdU2K7jd9jxAeXNaeHU3v8VV+vGGv7B0F4HH1xv+d195wv/pv/p5YoTp7gAl890PV547uN5acskt9bhCUuUQI4dl4dn1I4xkTvHE7TRzWwrHmPnvHr+Hd5VOXEuRNgMfTgc+PN7y4DjyqB+4DJ6HAeaoHLLlgzkyVXia4dnjCyxHYkysVUGg1MSLm4nTuvLR4cS0Rv7Ez3yD/8Of+HmuH1xjbUFLZtg9Y42V/e0NOgn/33hkNC1DoreWwTlWEoeysqkeOyfG4LkaB1IELYVxs+Gr1zC6iefms50unPHD4cy/M//eJs78O/PvbeMYT5iw48oHnnaWd2xiOb7k5oOXfDid+H5OeCM8vrSkVO7rwGaHOdXKYU08udriXWUpSiqJF7mgufALjx7jnKETwRpDMcLNmvko7hkPE9e+57LzPByUY2wjM68TsF+pFZ4+vMTaVvst94GpkuH5m5WbuPJoV9BUmFJmyZnOGP793S0LyrNxxBvDkjJrrfzmfs/WWbTSzGGcYbFTmwbJFpkSYyd0AWLMUJTNduSRKm/2R179qNtyUsGLYtaZ+bTnsN/z8d0BiSuneYVauBocKUVORchzum/dNKFHLgaxgreCcy3k6iGZ1Tp2/YCj2XFWUToR3hWPjZXjoiSpiINZE5oKpipFIzHBmgaqBDb9BhF46pqLTtFKzBlbLd5AkYpR8NZQjVCWxE6E685ijXC7KneTclMiF8ZxFTqsGNZc6IOjVMfGeQZroVaOKbNfE+95S7DQOUdwjrNc6PPD5nLg6aMtP/P4Af/N02cEdRyWWzoPh2VBc8ZuBlQrpxViXnG1uUvk2uLbxSne9vgu0xXlMlW2tnK122JEoGaqKhXDs4sNHY5PlpVVC2ICp5QoEbbGIzmTs5KrYKTjot8AmU1oQR8pFl7eHbnbn1gVEMf106/y9T/+37IdNlTajfHV93+L+Ob75DTzSVx5lSNXFp52HVYqU1oZfLOa3biB3htqVfbHxOvjxFcfPcSFQOg8XfRY89nmB8/44XDm35l/bxNn/p3597axC8JFiGyImGNhnxP7wwmNkbvjiVoKjzehcbAY4n0daAUyQi6t/vPOEIIy9oqkQg2Vq93YRmi0Cbi9FXqjiHa8ipniW9jVaS2kWtlaf1/rKakaqgQuQoeQCeKoWluYnGZshVoMpSrWCIOzoAYcPDQdj7tW771ZhU+mE3d1xRB4GoY2vVGVznQIjoe7DaPzlFJ4c1w5Tgu27/Bacc41Q5vPaN7ypS34zboQy5G4TDCdmA4zeT2SknJaI07ADJ4iFTHw+rRQVBm956oPhFCItdIZS7Cejat4Y0kKo/eIQFZYS7NWurSOh33HIc4sOTNFwylF5phxtAvYKWeOS+R4XOmsI2ZlcAahElNhSYrFtAQ0BTAMTYuEQxidhdqszjpncNZQMgRrGU2bIVyr4kQAS3C2RSynwnFJ3C6RJ5sBlohYITjXBE9nfC74mafXvPdgx9cur3gYRo7HmZoic4HjsmJq4cr0GFMJHj45TJSsDNaw8x7vO2IpOGcwLtD7gjcKWHrX/HRTqayqJM1cCjwaRl4uC6lkptTagHFVvAhzVk4xcTgtHA8zXixzLoyhwwDHHDlNB77zfM+amxuVGkd2PXO1PH3nK8T5QF5P5HWPNZngDTU1m7BN8EitaM30mLbp9hZrW8z3zXHh5XHiycUFp5MixmDt7wqWzvgvizP/zvx7mzjz78y/t42tRsIUMTQTl9vTSioTaVWWOTW7S9MBgrfw/DRTtLLpPA+Gji4IqSidd3jrGJzDigCGzjWbzZQzqWZyUXIpXHrP65RIWphz5pQTqyqIEPWeg9PKcT+1mjK1OrBWWHOm5IRVWFKiULACnbNtU5HaZ6MAIpXOWbwRLDBYx+BbDG9Rxd8bsvjQplGWVLhbVu7WxKO0cnfKiFi8s/edhj8YX9pqMd6+JqYJyZFODNNpxdrMIRZSLp8Ww5mKNZX9Gpli4nqoPBxHnIscYmLoPEaavRJG8Cr0FkRgrs114BAjnStshh5jJ9aSOS5w0sSScusaiJCqclpXbm+P9MGy1nqfQdh+rvejPXdrCwYZbLN9qlQCgjctTc2rxYph6zwht+ARf//vHYbufreWVUkCa0qc1sgSM0spTLlwOXT0zjKGs0vP54Wff/SQJ5sN192GThx380RnK4elEFOhcxVnKpVC72GKK3fzyi4ELsMVznr2y4p3PVSwRtoNQjz+fiYxa1P2ryWyquGyH+iMUHLhtEbmlDimgrWeLMJalNO0cPtmTxd6cgHFYkSoUkgKH97MpJzxzhDTwv7uFmstX/+pn6WqkI1tlq8iPOo7PlpOPPRNaK4CvTWMtgnR1qp0uTDHxN06c4qJNSWO68LFpsdb02xtz/gvjjP/zvx7mzjz78y/tw07nVDNzZmnD6xTRHxiXpt3vvMGY4SsBS9wXFcOa+KBDjzdbLGusl9Xhq5t5gzgncGIw2MAQUVYUeaUoBQuNj1hadlMUxSWqiw5kY0jUiErx2nhVu7o+h5VS5WWSq0ItQgicJcWjIGd93Teo7USZoMzwl2OLadJDJfeszOO6/sNSKZiReil1YFzSoBhjokpZ5Za22TLWrgatnTOMnSfjYNf2oL/+x98C18ND4aRB9c7TmamZKWUZkW5cYZaC6dTaVZLatqCCOQcmaaVpdYWzHEv1hBr8OKopUldJVdMyeQSOVnPlTWMYlhSbR/0zmHE8CImNs4wiiCpclNn3u0uGQaLxkLSQlTFGajO8MHpwMYIYeiwvu0+q22toFc5ItWwlY4RxzWWB85xyJmltNP+nWvL8uIwsbVCyoVDjlQMOSWOBcbOMgTL1fClXcIfeTxih4sO2zmGEDiZGUkFYmYXPKM3mGI4nXKLoG/XC1IplBKZ1hPLUtm5npQia1oQ6+g9CBGpYFSRnNGUWLtAcLDrA0sqFC1c9D2dVD5YJ658z9YJgcp+WnjSDVwMPUoi5kpRpffQ7wbMcWa382xcws1vcC5QsoJ15GHDyQysS+SBDTwbOh4GxyFlVlWCdVxsRgA+uZlYvaVoZi6RSrsAvYwTLjiu+4HroXu7C/VjijP/zvx7mzjz78y/t43pzR0WQ9j09NuBIELMhaKVPljGzlK08uY0tfEccRQprKWwrCuH05HshKsuMK9rM1Jxjk2nGBJSARJZE1NKPBo9oeu4DI2DWiujcXRO+P46M/iOjQhOlDfzzLvDwGbjmZeFmJWsSm8M2gc+OOwZg2ue+V0bO6u1UlMbTRIxXFjPJY7LrufCOg4pfcrBjW+HuR++PrJ1pvn5V0WMoGqZULYCW+d5uNl8pvfzS1stPtxtucmFj9eZ00d7nh8XdqZDgmchc3ta+dbtRFHDe3/0HfALF7lZX75YI1+9umKNMyVG7paZfYxYCXxt13EbI9Ya9mvidkmsCdZS+PjwmmDb7D9GCVhWVR4GT1FFRYhiiApm43nYdTx/vWdOhTUX9imysQZL5sN55TvTgcE53h07DlGZTCKpkCgc6hGAx/3A7QoXLrDrLfdhhUCiROXkIJdCzJkbrfypi8dcAoP35FIp+ewB/HnhwTsXfOf1DS9e3jJNb/je8cQFWzofWErh+X7i+P0bKpUDmUebnp0xjAh3CZ4+ekqZ7tCycLfM3K6R4DyXbsvrKdJbw+2y8Ho5sWpmYw0ff/iKjfeIKKkWfO5AMu90nhgLUxEWA9Zk3t8MbHc9H746cIqRac3cNDLz3/2xd3n8/ru8/7Wf4urhU548+6MAzPNKUc++KB+tb8hp5Svjlts1cxl6rqqQS2WN0AWAyAlYS+UUK0fJvPvginfKBc5Vcimksw/154Iz/+DMv7eHM//gzL+3i6cPtjyfVr5/2nM83vD8sDKannHomGvi4+OJw/IG6wLXT65xWrj2gjfwalp5cHGNKQtxnbiZVo6psA0whp7bmPDA3bpyuA9dfb5PPN+/ZrCGrBWRwlVwLLlwZT1VK1jLKhbNha4L7DYjx5SYVyWnJlofAzwJHR8tM8+PE06Ep2PPoWQCLRfqVBO3MeKc4b3dhhibYUylkoEVsCWTTWGWtvlYauF2XXi8ecpDBpyHnApx/Wzv55e24H95O3HMC5bSPojBIRiKwMOhI5iOKWbeLCufvN7jslJSpirs/MikLYpjKZ5gHA+DJSCUUtqbuWROSyKXwqbz7IJnvyY23oFRjBG2rqPkiZv71ECxHuc8zho+eXmDu74gpkStrU20UUNnDQ9kYHVwU1ZuU+S0Lzx0nqeh43WOrBisOKoq748jtUK1hqotIW4yiRgTPYY3sbZEXRHGYPn/fHTDNx7t6Ax4ES66L+0S/sjj1eEOZcYbxavlse1xwZJEebTb8MxsOU4LH98dmOYjHTAnJRdl7CvE1klaitI5xxPj8PK7uQn7ObOfM6UIl+PItRt5WfbImOmM0EngIgReH+A2rqipbFxg4zqsFb5385JnXBLjSr3PrOjFczFY3tk5rocrrnZfZfvop3AXj3hx94Lj8+c8/+jbLKcbrkLHqoavbi55p2uhOVUrqRROdeWmFAJwOyu1gHeWHuVffvwhf+RyyyPp8GLZnDn4ueDMvzP/3ibO/Dvz723jg5sjh7TgNWND4FFvEddTeuU67HjKJdMy8/Fh4vbuxCAF1ULvKrtgCKQ2GVKFIXQEV+iqQoSMYS3KkkCr0HnH5ehZ14QLhiwgxjD4wH6fiBQqtAwl8eAdH97c8k5ZWGOlYpp/Pw7nlI0zPAieSuUuJr6zP/F+N/CoH3hVWk5ALw5V5Vm/ga42t6msxKwsRbkpE312nDDkqhQtbK3jX334Ed+4vubptmN0hovtZ+Pgl5ap37vbM1h40DmMqeT7eaaUC6VarLNsRFipzLmwT010UUTZ6opdIiIBa1qQQfDwePCcsiMUwyKFXQ87AtZYNq6FWq1FybUFKy8Z3mjmmJtgZKAlsCWFQ1bmDMcSMVUYjGVwhqSWWBeCMVxIh1oYgYsufDrn77H0xnIi83gzogqlhcMRcyGnwvPlwDO/wVoolebeUy2VxOtppncDg/P3lqBnfB741qs3XHjHRRfAQ42ZtQ7EWOh9pfeO63HgOBceauGjm4klFi6Hngdjz6FWxJg2ckalC4bHm4FYLCl7SllbO1g6xArXvUXGkbtlwXYG0zmOufImzdxMC7VWdGgXIRK8OiWOS2FacwsUKS1Y5OHVFul2ZCPczQdevHmJCyMf/Yf/mbsXz7m9eY7GFiY3VeXRJlCKQYuitbCWRDyufPv2yHvbLTa3z10sipiCHFZeibC9cgzOkvJn8wA+44fDmX9n/r1NnPl35t/bxsenI4PAGCzOCzFVDIWyQDaFMQiXQ+CoihTl9rSQcmEXhJQyk2mBqw4otYlkn2wGTslSciaVwhAsG+OwRtg5y85ZTvcpuCKGVJTblFhXbXEALlMcFBFqTEynhUWEWgUvhk2wTKsypYwIjM5hrWWwhkfeU7RNhAiCWmUlctk/RLSAMZ86Pt6skbhAj1BqIWuhquIx2FQ4TCs731Kgp5Q/0/v5pS34N45PjYaCsWwd3EXIpTKvBQGMMUg12KrNcae24K1YChZDKm2G3xnb2o6rEjXhrSVb8LWlst3FxM4OLLXyellJpaAVFq2caiWIJdGS1bS0qPFS22sZvCflNjO28R6xBjEw0Jx3emO56hxzaicdIBhqE5AY6KylihBFOeXMqWSkGEbjsIZ7EYcQEeR+U3BaEmvf5tmo53bi54WNOLwaRAVvLGPouFsrWgtTjIASjMEZMGrIGKIUYm0faGvazWDXBaxxVIQp6r3lrJCMoRMl5cyL08qVA5XSbm5R8DESVYlFCcaxaCFrJRfFlEqpgirshsCSIktJ7DYdw8bhvcWZimgkT7fsP165e/7b3O0PxOVELU0IZY0QXEBEWYF9TNykSNZKVw1SBWeFpBCLgra51lfHlY3peLK1lHNL+3PBmX9n/r1NnPl35t/bxs62UDeLxYtjG4RDLqgKU1ypNdMZi0Bz35EmyF6KMqeMux/N2YhFKhSBKbXKsjNCsYKTStHC6zmx6TsWMbyYZ6IqtQqxKrMWnEKsiiuCilKljV9nK2w6z3p/WIt6TAUrll4M3lSMVC76AEk5pNo6UmLQ2oLsvG1ujwllKon9upKz4MVhERChIMQKQUAVDtPCcezZGtcKw8+AL23B/zh03GkiVzDVsnXCyzmC0iKFS7MjykVZSmoK6dpSy045Y0yg5Ej1FrGOtcDdnPAWHo4DFgUtxJR4OS+84zpepZWX08JaCrkWFlXGfuTSOVBts1UKFmHrAtsucDF6DsvC3bxipCnGrRGsGIIVdt7yaDPw3buFUgUvglAxNPuyORdMFdK9SnwfEwbPVQh4a6BWVAzRWtRX1ii4DDkb1FvOhmCfH56FnkkzpYLBsukG3pxmsM0m9bQKwTooibs1MQwdBDDWsNBstqZ1ZeMsxlrWDMu6MAbPEFzLgSiZZZ15fjjwzFlu08o+r8RYqQusVrkIGx50HXofKV9yARF2Q8eDYeBq13FzOvGmVi76Hmsr+3khiOJrpq533O2/w3R6jarBKGhpLfCt95zWQqiZtRTu4srLeUXU8sAHOmvBCMVU5looufLB7YStwjvjyGAcej7g+lxw5t+Zf28TZ/6d+fe28dh5Jq0t1EotO++5jTNQOcbEMQnBOLRWTqXgncOpkmplnxLet/VuxbkQC+SS2fWG3liiLdiizHHlk+PCY1P5JCsv50jKhaTKVAqPdiPemma7SfPuBxi7jt3geTAOHNaVG12wxuCrYTEZS0VQgoUr5/homUkYHHK/kQGH5ZQSRtuB9M2y8Gpe6KUnWEengDFgTJt0kUpcK5oySdsBdDCfza3xS1vw382Z4oXqhENMJAwHTYwG5qzkXAmunSp8dNjzdBwJArFkPpoiX6lbnoSONReWWFAjDKOlAtZAzplYCrEKo/HkUjhNC1vXdv1Laafv3laiLeRVUVVmEqjjm5trxmAJAqOz1M5jgkFK833FNHulRKGcDB/HEzs6RmMJVuitJRfDb9/cMQRPkLb4O2N4pQVQdnR4W3FioFpmXVEp9MYTXMXa5gV8xueDmznhegHbEvsqlWNZCBhul5mYC8N9QuN30573hgs6K2AtSwhE2zHYmWmNrFoRJ1yNgZXIUJQ1zeS1sGRh1w2UkjksC493A6UIqQqy8eRciIuiNRFrJWsmifAnHl5z0XW4ahlMz0Vf8UEQ6ZjSii6FcrxjLguhZO5s5coPXJwmqqkMncHQ8W8+/Jir0fKDwMgrZ/koQlDlWQh4q3S5HStMecU5YVst+/3Ma+fYDf1bXacfV5z5d+bf28SZf2f+vW0cpgWswTjDPiYyEAEPrElZa8GYjLXCB4cDXxsvGJ1lKonncUEcPOsGplw4pYr1jmcXhkymYFhTIubEUpTRt/nplFYeDR2qzXEqUZv1Z23W7nMtzPdTIP/15TVdEExt7jyXfWhj2EU5zRmtClRcMahkPkkz75gRsBiEQSwb6/n3r14xWEdvDFYMD8PATVIyygMfcAgBGJxn0hNRhQvj2TrL4Cz1M9qzf2kL/gYlauHVqrwpkUEFMf4+lbZ5n04msesGvO+pFUSbP+uEpVo4pYVcKpfdwM882gJwuDkSEI6lcir66YnELnjmWglYbGukcIwr0WS2wVJys4TyFCIJYx3z/cah1kopyhgGxm5DUcWh+KqUUtBSOdgFr8JaLIdPA6Dh5TwTTQtiE4TBdoDh+3HGoFx3Pe9dXTLPCxdjoAN6b8m1Mqfz8cLnBWfbXOAyK7OZeV0ine1QhId9h6fFeO9z4bL0bMVRjcf2HZtxZMoTF9ZxjCeSVK76LV978BiAw/41PZ6XpbBPhWA9SzEMNlAlUMWw6ze8++xd9sdX/LsPv8e195QKx6LkXFjXhBlH1jyz5oVUM3UNXFwEOoFyeEVaDkjoWGriZrrjxBvU3oe+Fch2Yo2Zb5dMtXw6R+esIVr4neOe3grXfcf7F9ec/IH/+sk7HA4Lpyys1TIf01tbox9nnPl35t/bxJl/Z/69bWRjsCKkWrnNiTvNjCaACI/7Dd60nKM9E9fjAN7hqrDzBmcyrhjAs09HsioPvOOdi0sApv2RAcOUhVNuAWr7IgQ89f4Evjcdfdfz4XzLoaw82FhEYYktLG4tK6MduVtj019q8+m/GDtGa1Ftj2uNIAUuGYiAupbhNFMpNP7MJXMTEwUFDM4OUITfmu4YneXRMPCwH9gWw7PHj3AoxgtZlWmNn+n9/NIW/JNkejyXxvNkcFxHz3fnhFIRbaEdIsJ1GBFfiBrBOB4NPT+1GSil8BsvWgy4EeE4JT54ufD0sueTKZGyMOWKEbjuO24XJeO4zRNaK14srlpqdcT78C1bBYOhVEONiReqvJpnkireGK584HBI/Nx7j3FGeHE48vz2gJTKu6HjNiYOZJCmtH5sOmzoqcCDbWAIljUrH9zOHCgc49yKepOY3MQmODpgv6ysFYoYbufl7S7UjzHepIVd6NgYx9bBY2v5zTczZfR0zhCMYER4ejGgthAVemd50vd8fewo2fI/ffIh3ikqcFsmvpNf8+7ja57fLswpc4orwRqebkeeHyeM3XG7HtvuX5XvffcDjuuBlDKRnmpaQl+4j5P/6PUNH00H1pzoxHDlBw7zws9+/SnOGj6+OfLx6z0ba/iK7XkdE3NeWExlYy1P7YB55wKL8PCiZ+g6lqT81ovnTCvclUgu4KthWx2PugHn4BgsuwdPkLBjWc6bzs8DZ/6d+fc2cebfmX9vG7MmBhsYjeEiGJ7WwL+/OZE7jxfFoCAw+p7LoGipGAsP+p6vbzZIUf6nV6/b6X2t3J0WfvvDG772eMt33kxY21yZtiJcDSPfOR0Joee4nrBF6MQzaTvQdUBdDXqvHQFLKYUXx4k3Swt7CxUufccn88pPf/0ZzlpujhOv745Y4OFguVlWogCi9FK5toFx3AKZy40nOMe0Fn775S3FGqIYShaWVVmNchFGSpl5dVwInUcEjp+xDvzSFvyxKNUoaCKnjAqkWki5MtdKbyzXwRFX4TYXrkOHVEOHoXeOqIoYizH1fva+sqbCIWbeLMo2BMZQMabSB4fEVtRnKrFWEGHrHZ0xjLGycx13OTKVjDeWVylyabsWh2wqnTWMnScuif/w/AW7TY8V4cHQoRUuO8/65u7+TKSJUJJYngyBuzXjxBDEIkZAMhscYjxJmkA550I/dFhAxVBq2/RYOY/0fF5IuTC5lYxwSu3wp1ha3HbMbK3h0dBRovB6iTzsBjyCoUVpx1LwwWGlAm38SsUxxcj3b45Ya+i9ZRcCwVm8MThr0dy4bikMpXBhDNb3bLqO27wyp0iwnjfTzNXQsxHhInSMvonPUlF+65OXXPcjFsOzix1WQNPMPiZ21iMWnBi0Gt7ZbTnOC954emMRU9EsBGu4ZEBrgVqZ8sKDcYsHnGt5E1VXSjnf8D4PnPl35t/bxJl/Z/69bRRabtFSFVQQMgRYqjKvM6OzPOgCeVWWWNnej1kPYhm9I9XEQMCLoUpGqqBFOcWWwHu97RiGgIN7Dlo6rdwpRJQ2Wu25sJ4eZQyBfUosKSEivEgL7/iREbDWMViHAqeq/M6Ll2y7jmAtD8Yep4qoNg6KwUo7jKYKm8EzzxkrlmA9xZv7LCjDtelJUqkCUTPBCrUA0sLmqjTv/8+CL23B3xtDlcpaCym2AhwqRgwJUKnU2mbxEfDG0BnD4Axyb+H5YOzINZO1YI3gzL34A8GIwVkHKLMqpbZZrVKFUiv5fm5LxDA6S2cswVpsFXItrBXmUgjW4QB7v7E41czxlDlq4dE48LDvqbUiBqw1bHEgQq5txt8bITiDEWmv20BRZQye1WaoYKgUrXhrmWOklMpEAaP3zj9nfB7YWINBSFqZcqHUQvABLZCqEmslaSVqBpoge7CO3tlPOfh4O3CMiVwywVqcN014RkVTZeMdzrpmq2WEpBmtlVTbfGLLhLBsRBmsZaoGYwy5Vk4lIdEwOE/3gza1KgfNTKfInJWn2y2PL0dqUW73EWMMvbNYA5X2O3TWkq3FikGkhYLkrOyGjqqFahShkGvFBst6TJSipOlEYWVezxz8PHDm35l/bxNn/p3597axcebeoaYyaSWr0gVHUUvSTKEQUYpWbBW8EbbGsbW+FdPAo81A1ETB4sXQBYMRmruUEbwzSK0cUjvJX0pu7jsVIhWRNm8fTMaLwRsBI6yaccWyX1cGa+mkjR9FVU4lw5RYU+HRZsPlMCKqxLTinG01owhaK7FULM2Rp22XBe4NGDfBMWlFaF+5KsZU5pgpRVlpIuLjZ6wDf6jj4b/zd/4Ocl+Y/uDrm9/85qc/X5aFv/pX/yoPHz5ku93yS7/0S3zyySc/zFN8imvv2FjT2ihFSLESjNA7x8Y7vDHE0qKGe2sQU+m9MPr7M3QRnmx7eu/w1uKdwTuwRtg487uWl7XyZlmJGjnkBRHBYbC02SsRyyYEgrcM3rPxHr1vIx1zwlqL9Q61llzhRKVaYVZFEQbvGbzjGDOIYMUhYqlGiDW3iGhncFaoUlEqKHjviKYtolS532tW9kvklCJ3MXIbI4f42Wa3fhzwRfIP4PHQcWEDrlhqFjRXeue4MI4L5+isYcmVVJTBe4wYRu/Yev/pYzwZewZv6aylMwZrFWcq2z5gqyA0Dr5eZhZVbuP0qeVsNSBBqMGx6ZuzxRgCvQ9kIBvlZplxIeC6QDaCGMshFrQKkxaKhXEIDL1nLo3TThwGg1aYa4J7S1nv7L2bQYUKnXVkIi2ipM0cGmM5rIU5Rl7v97y4ecPt3c1//qL+iOGL5OCZf2f+/V6c+Xfm39vEF30PfuQDG2sxGChCKpXeWbbBchkcwRqmohQjBNvK5dE6Ntbdz1IYHmw8fbB03tIHS98bgoNN17z3pULMystlYS6ZNyUBghVBBIwzYB0hNM531uGtI4pigDfzivceHzxqmo1rVMWKoVZBaju1dy6wAs45xJi2qQAmLZBg8E2bqgq1gBTovCWajBjFSNOJZlEO68qcM/u1OWSdPqOW84c+4f/5n/95/tk/+2e/+wDudx/ib/yNv8E//af/lH/yT/4Jl5eX/LW/9tf4y3/5L/Mv/sW/+GGfhgfBc6yKLRZrLdmmdgpuBNXKUgo3JXFpO1Taqb5UoWoLWKi20uO48IGTEVQqubYUM2sVawulKFOK3K4zYHmzJN4dOpy0JNzLrgPg3U1HRKnrwn7KuJIpWXHGcNk5gnfkWhmNoagjmoWxD1x4i9bm5TrPhawttCtKYSKRk0A2DB2INtX5lAuCZV0jU14ITqAaUjHcxYVTLLwuC+IMxhrKT5gn2BfFP4CroeeQlDU3/YazFvEWQyEonErmRV15Fi7IJYPt2/5cm6NT6/kktp3hZJrnbi4rS6701lB9hVo5psgLnaB47uLK+7sd3grOGR6PAwDPLi8oWkn7W16kBVGoCmM1PLkY6JwnJggiTHNmqvBk2PDAj2huc4c5F8QIU86stTDVTNZKyYVhM2BME8PFtdJb4ZATd3liYywBh6mGeS5MpXKzJF5OhTlXcvrJOuH6ojh45t+Zf/8pnPl35t/bxBd5D950PSUlcs44wOFw1mBKJQssqtytK4/9wF5Xdniktk5AqpBwmLywtY5Z2sl8NbDkjPftQLnkwpwihzKzpsbrr4xb/H3xft238NZ3xut2SHw6QF5w6umNYNXycBgI3pJKIYhhiS3X4UG/4SJ01FoxtTDHhBhYUmHRwiKFfD8S5nxtvv8R1qiIEQ5rZp8iozcELKiwjy0r6iAZTYCCyZ/TSI9zjqdPn/5vvn93d8ff//t/n3/0j/4Rf/bP/lkA/sE/+Af83M/9HL/+67/On/pTf+qHep7vnRboLb33XIhHJPD1x5d8682Bu2lFBAYPnRjGYHh/t8MYOOXCb98ecU65MIa7JFipBFPRonQYLNAV5eN14S5nHocRWwpfvzDs1bAvlaMufHBzADXs7CN6b0hrIsfCV/3Af/XwCgBrLUZau6VgeDIaDqXnwng0w0fTTEyJlcw0l5bUJ+Bq5aiRNU/gLJoEc9/HeZMndF3JJXGYCxvnGfqmBP+wrLx/rwuwIuA+mx3Tjwu+KP4BfPtwQqwwdJ6nYYOI8P67l/z291/zZlkwwLa2Fvb74zVf2W0IohzjzHc+fM3GWsYucDoWoOJMu/GMIXBplSfXjo9T5ITh69uvkvPMzxJJarhJiRfLxG/d3RAj/J//6Nfog0c14avwtbDlf//+Y6DDN9MCaoUU4aefPuE2nti4nnlZef7mlhQjFOWQFyiNa57KKspaMmaNlBwxxlJEeFET0027mpwULjrD0x08Xw48Lwtf3W540Jc2JlcK/88/1Kr+aOGL4uCZf2f+/adw5t+Zf28TX+Q9+HtLxFhhGAJX96Ni7z2+5rde3rA/LXQKj72jE+Fnhx1Pdhc4A8e08sEnR0ZreBA8d/eP03lLiSth8Oi6YLzjJq5Mqrw/XrC3E1sCM8JSlf2aeTEdmFPlz7xr6Jwjloiplff9hp975xoKWN/s3AdrKcDj6x1TXBlN4bjseX7I2Pua/CYvWNr4T6iVNa/crQcuSiDrCblPBz7lyKs1sw2V05KIpnIdLK9PCy9j5Kv9BhfAirLmzylp97d+67d499136fueX/zFX+TXfu3X+NrXvsa//tf/mpQSf+7P/blP/+43v/lNvva1r/Ev/+W//H0Xe11X1nX99M/7/R6AWaDEFkrlR9/m/4AHvaczwpIdS2mn5BbH89NEyZVSK+KgZMjuB/ZJzXu/d4Wui8SixKxcGMeuM+xL4oByt8DGCTsjBCxrqcxG+XCe2SbDzTpzypkr27PGQhcsx3VtvvsYnPdMq/Ct/QHv2mZEqjAD3xgCpQh3KSOqDMbyLPR8cDwiJ9iE9jsWKlfWcwtMSVlKwWGYYiRb2OL57jIzVMNoLfUn63Dhvzj/4Pfn4KmsaLVY4/DOEoBgRx5fK+M8M8fIkjJZhNFZXh+OpJqJqqzFECnY9cQnWYkKAcuV6em6yL4ogxGuveeBcSQiU4wsZWXbeUZbQR2bYomm8tGbE9uh58UcucmJy75nmRQfCqnkdjKVKtkY1jzzv7x+yUYcvTiqCscS+bntJXmGT/JErbC1ngf9wLdvXyM0Dnpn0QrvuI4Pw8o+QqISauWYM0tsgXHfPr2ht8JoXYsb/AnCF3UNPPPvzL//FM78O/PvbeKLvAdPZaFicDbQdy3vwGF5Z7dh9M1BMatyipniLK9OBwqVWCEZYSqK18RtWcmpYpOlzx3YhUUzmiwXbuRC4BQTEeUmCbtOcNXiiiAq9D18/3ii8543MRG1YrxwOy/svCetmTUXkla8tyw58ZtvbhicJbim21xy4Wf6DRnPG10wVdiK53K45PZ44o4TzlmsbWPpj7rAq1W5XSqxKr0rhJxZVNkFx/emG4IInbFolM+0dj9Uwf8Lv/AL/MN/+A/52Z/9WZ4/f86v/uqv8mf+zJ/hN37jN/j4448JIXB1dfW/+jfvvPMOH3/88e/7mL/2a7/Gr/7qr/5vvh9roRrAOrrguOwHVJWtdwQjHFfQUhg6hzHK3ZJbkq01DGLZx4zayiFH1qKMznDpOtYlMQRPzE20s2rlLsOlWG4k0RuB6tpG4160tKbEnA2nXJvan8z3Dke2Q2BaMnNR1AgbF8iqrLWy5oL3nq23HFPEELjsLBVHypVgHe9sez6+20OFl3ElSYscf+IHDkS2zrG7j4Q+pozDsHVwlyvhvkvwWWe3fhzwefAPfn8O5nunJzHQdYbrYUvVykXf0RnDwRhKmRi7pvJ/kSPQWnq9sW1X3htu5om5KJfO8c5gmBfH5cUlJWdqhaiVm7xw4Ry3caKopQnUBSfgPEypcGTilFe8AVzl39684aoLODHMpTCVjFWL1kLJhUOteN80L3d1RkTYjR6lJ5VM7y1Pry744OVrKvCqrsSoGAzvhh2yrlx4R49QBfZrIlTLxdhxWyeGCqEU9utPTrT8F3kNPPPvzL/fizP/zvx7m/ii78GlKBXQKlgT2A09STO9M9guMAH7JbLrAgD7WjCAwzAASyloEe5yZCmFi+p4x1ly9Dzc7IgZtCpzybxcI9chcJCVUi21CpWKM22ef42FtTRHHFcFpfL8dGJxASrMWlmrEkozflEDc1U6YDSOWQorMHYeU5RSKk4cj3YDL25vAbhNC2usOON4pxsQSXQi7IxHgUNMBHFcmMBtnfEItrZuxGfBD1Xw/8W/+Bc//f8//sf/OL/wC7/A+++/zz/+x/+YYRh+mIf6FH/rb/0tfuVXfuXTP+/3e9577z1iLQx4wv18vrdNZOOt4RgjU0rkQnPgkUKtgqV9aQXVwk2sdAaoQhDDYA1zymyDx1lhyoW7UphK4d1h4GXJzLUyCAQrrFnJCqfS1P1iYDQGqcoxKwlhzYWTNtvQH1hkjq7ZZkqtLZ65ZHJRem95ZHoUATEcNZPuN2axKAXwrolLnnSej1PG1kqqlVOtOITReUZNSBWSCj9JBgGfB//g9+dgUthhGKSJbHwwiBQ6LxznxBJb+uRUVlw2VBFcNTiak8RJhNtUuHQdnRRG5xg7x1Qi22GLrYZTTtyWyG2OPB53RGlJfoN1jBZuciKjHNN6nwNR2VkLVbmNkRwTzlombXOpF6bpTkbn0SqIVHJJFC3EmhkGzxA6am0i8EPJ6H3EZNJ7DhrD4BxfvdhwezjSGWGuyiEpW2vZWo9Ty2FN3KbEMf7k3PC+yGvgmX9n/v1enPl35t/bxBd/D24Jth3SHHWsNE98Y5hK6zBpreRaqBUQwdzXgm1CunKIiY1pDoudWEZjmNaM7zq8KezvOTjVzPt+ZJ9X1tLMYDoLcy5kNUyp0DuLM0JvDKKVU1UoK9yPAGXgyjbR+sZ6aMaLZM33uoLKpguMtFHsVIWblPjBAf1SlVKhQ+i85x0nvDhEegyrKidVdr4F1A0+4EvFVD51xfqD8Iey5by6uuJnfuZn+O3f/m3+/J//88QYub29/V/t8D755JP/5LzXD9B1Hd29OPY/Ri6KtYJTQyoFLQV7b9F0syy8Oi1Ycaw5E5whOI8TAGVOChTerJmnIdCLwRmLt5ZX60JnHEYqiyrHXNBaCc5hpPn377wQjHCTWxLvbYnsnOPSOrautfAKcIyKWqWIQq1UowQjXItH1RJz5javLLWw+kLfBR70Dmctx1L4/72+BSvUClaFXkxTl5s2uvTx3YxK86JVBGcM3ni2xpFSJVWhyk/WDP9/jP8S/IPfn4NrVh54Q4+hZCWXhLPtQnJ7PPHmMOGD4/U80xdP33dYFdBKdXLf8it8Y9gQ7y9GIfTcTHtCLvTSrL3u0koqGScFjGE1cOU9vTO8yYlTUV7HyLV6roNjayzkgqmVY0w4n4maKVWhd3TO4mgX35wyh3UhlsJSIhdh5KIbMWK5W1f+w8vn+PurgFHDBYad6xAq714M7I9HskC8t9LrHEhR8lT5+HblsKT7ILyfTHye18Az/878+4Nw5t+Zf28Tn/s9WJVthQBUCqrNGRHgdoncTiu9NxxiouIZg8XRLNvLfRF8SIl3uo7VNPcnYz2neSFXy87BWkqzeLUwesHOlgTsrMFbeL1Gptw2dw/FMprAYAKqFRXDoSSsaYm3AFY93lrEdhjbbGsPeSXmJmZ31rF1BmsN+5z5ty9uGE07LK4iDGK4cA618Cg4Xp6ErFBqy8LoncGIZes8VQtSIdjPZrj5h0ptOh6P/M7v/A7Pnj3jT/7JP4n3nn/+z//5pz//zd/8TT744AN+8Rd/8Yd+7ClVjjlxyCunmMmlfahqbf/Ve0/S5u0rIJVFM6fc5qusNWxts8PcLyvHGDmVyGmJHJfEGhOSodPAaDrmOXFtDA98YHSOYBxbGbC2JayhQimQSmVNcKyVN7qSUHqEoMJHpwULbG3g2gc6Z8hG0ft2i7EeoXKYJl7c7NmYZvaVCyQBFchaeTWt/MbLW44xc8qZuWSKKkPxHHMil0IArpznUej/MEv4I43Pk38A+5i5SSt3aWKOMzUbYoSYC7FWYi1oiezoEYRFV25z5NUauVkWJGa2WA7rzN00My2RZU28iZl5VoquSCl02XJFDxHesR3P/MBlN9IPI7vOE4LggVKVWAupFkw2HLLyigVQRgyuCN8/TFhruLY9T2zP1nqyEZb7i5GrHlsL++Md33/5CmeUtbQ8B60ZyCSNfO9w4n9+/hEfpZmXMbFfE2tK1Aq/8/Ed//77N3z3wwMvPl7Y3/3kjJX9XnyeHDzz78y/Pwhn/p359zbxed+DVy2cauagmX3M2NqK/VKay2LSwlIKnXhcaVMZh6Lc5cIpZayFDZZ9KhxLy11oDo+Rm+XEmjMmC0MJXJjAIWYe+Y5Hoad3HdZ1XIceZysba5BqmLR1hnIpxJrYp4zFsrOBzhiepxm84SI4Lr1lsBawCG0DUnFUhP208OJ2z8YqWTKz3rtSVstRle9MJ/7Vh5/well5kyP7ktH7zeUcEzUVnMAmBK795jO9nz/UCf/f/Jt/k7/0l/4S77//Ph999BF/+2//bay1/PIv/zKXl5f8lb/yV/iVX/kVHjx4wMXFBX/9r/91fvEXf/E/S509WtdErLVymBcm68jZc0yZQ8mUAILet0YcNyUStbV1DIUH1oFVLM3ffq6FN7NnDAPZVgKgqngqVxZeRiUYw9OxI7hm/7kdA+wjWgxiDHNtQlpvEq9SpjeGUgyxClWEC2/ZT5VujCStbKzw/qbnLhfexMSwzHy0tHaRsQbB8n7ouLErtnpqbTZTr9bI83TimRlJtaAIwVgyYIsSTCBpRRS6z7iz+3HAF8k/gF3wqG2tY70xbMyRroO5GA5l5WALx2J510Kxhu/rwqyKIGwxXFlpdnUEtBZOMfOyRi6sA1aWotQKO+/YesfzNTFaw+N+R+cdxgg/9+gp7s0L5DChrulI7lImGOVlXOmtkK0lamEplSvXsY+JIQRWrXgRvtJ1DFXa96eZ37mdmEsGKr3Ae2PPJzHRV4MCb1T5eJ35MO75RtgxlZVSKhs8Jhn+1bc+ogJrrqRc6d1PzgnXF8nBM//O/Pu9OPPvzL+3iS/6HvwgBKyzLcxqXtnbACQiMGsi0Qr/h8FRXOVlTUylIFXZYig4LEqPo9TCFDNvinLNQB9ATUGlMjpzX78Jna1cdxZvDRjD+PASf2N4xYwYw1qVuWa8tRyL4k0bHVuprAhb27OPK1emo6Rm3vKsC9yJYx9X/Hrg4ykRo4JWfLB8LQx8NK+tOyEw18K0Kh8uK0+7sYWLoXT3JfuprCCWkgtrVZz9bBz8oQr+73//+/zyL/8yr1+/5vHjx/zpP/2n+fVf/3UeP34MwN/9u38XYwy/9Eu/xLqu/IW/8Bf4e3/v7/1QC/wDPOk8zjp6Y7nwhqUWDnPmECsVGI3F1rbTG6zjwhqiE4o2s/sY4TI4Om/YVqHUZsXVWWEXPCIKohyLoqZyGQwCDENH5y1UqKlw7XaYYWJ0HXc5ccyJ69Axl5WLYMi5pQEjigcORGqGbfWULCwVbGg7u6OurTcVK5oLj8euCUzUEnMBI/TW8tRYKCMeC1KxgEeYKTgERHCu6Qwsn21268cBXyT/AJ6OA8YKO2t4EjxrXZknxxQLok3ojYVZEoPteWR6ZqeUolhVplK5DANbGxh9IZaCrS0xcjcOGM1YCrMWjKm8t9ugBXbbLV3nqarklHi0uaSusNuOfLyeeD2feNIFprLyOHSUHJm1UJxQjbJfFDUHrm1rOx5XpVjBhcpdPFFVqaoUEd4JGzpVxmJZSkGssPPSXDlOmTFbKJWMApWP7o7cHFJLy1TFCC1E4icEXyQHz/w78+/34sy/M//eJr7oe/CVD4gzBDGMAvt1BirHohgVLnyHSmXWjMewwzE4j9aK5MxK5lkIeGMIxZErBC9Ya9k4i6iCK6yqoMo724FZC912JHgHqmjKjF0gxMhV13NTErcpcmkda4lcBg+SiUVJKvRG2K8KATYiaIb1fh7HGENK6X6Cv1JQHpqeUhRfDQul1aHiGIOFTaQXS8YRc0Fz4bCubEPf5vadwTmh+4yT3VJ/MCPzJcF+v+fy8pL/4f/yC3TGYzF01hCCIxdliU38YAx4LyxZ2TnPPieKQK7KmjK98QwGHnQBU5uvaRHhEFdQA7UJIJLAxjiug0NVud729MFTamU/z9wuiawFbx3pPjL5mCPZGq6HQE6FY0wsOROMYfSBHoEKuTZ1/9VoubIdSOWD04k5ZUZxXIemvN6nTGqKE4IVNiFwc5wpAkkKRoTRBr46jBSBuyWz8ZaL4KkKf/vv/7+5u7vj4uLiLa/ejwd+wMG/9T/89zijWGD0AWs9UuC0tv22cQbnHDFnNsFwqkoyhlQqaU44EfpSebTbIgK5VqoRDsuEGkNfPaeSWSSzC46nYcOSlQdXW8a+R7Xy+u6OU5xZU2UIgUNeeb2eOORIqZZHm0DKmbslMaXCxjuuu57OOjpvWXJhjYUHoeOd6x5Nhv9wd8MhJgbreNJ7yJk3UTlpxomwdY7RBV4sJ7oiHHJmzgWr8LUw8q2XRz7ZR6Yl03vHu48e8P/4f/2PZw7+F8KZf2f+vU2c+Xfm39vGDzj4f/3l/7YZtigYLH1o+ssppSbeFSFYwzFnvBGyEYoRYlWWNeG1sqmGB2MPCKWCWrhbEzUrQSxrVZI0m9gnfd+EscNIHxyKcneaOcTIIUW2oSNVZSqJNReqMVwPA2tJHGNkzYXeGKxzbJ0lVEPSSq6VS+d4uBmopfCd6cQxtZrx2nmsFl6kRKytKzW4tnG5icfmFJkVatOXvLsbMSLcnBbG0LEbWrDX/+3//s//QA7+oUS7nycG7/BGSEWZaLP7MWeMtHS+pErRFu2sUlm1UJEWVywVEW1Cm9rU3VUrU8rcxsTW9eQCpY3+U1SxpqIKpzlBAWOFXAqWyssUsaUQrMFZsEUwrvmfRjIG8BiKwlwyplqqabHJtQqrCtfb7n4jYsjOYo0leMeSCmutiAhGIFNZNWMEalU6Eay0ObDLLpBqYU0Vc+9e5H5yJnq+cFx6h0hhzplDLvR4tESUhAKqTX3fzLuaAv/TfEnVtkmtSjHavHJVOJTMXUlsbE+qhioGwRCrIqIomcM0UWvFGkPOEQu8SpFeE9ZUOmuYSnMcCMZwpIK0dMhqKictmGoRo6yqLLUQNfNgGFlNYdcFCpWApbeeubTEPxVFEZJmoja3DS/KaA1xLRxOmduQ6azlyUXHPHRcXVzy0+9/Hfgf3+5i/RjizL8z/94mzvw78+9tY/QeKzBpZtaMqEHJjWW1UqikCqZK21RSGzdrJdO4spaWpdAZQWvllAvHlBmMJSGNg1JZgULrUO2nmazNzTGVhKNxN0WhMwYvTZ/pRPDGNtGvMXSOJuZVJRfbHrcWoip9NVx2PSlFRu/IteIwjM6zrpVES9c1IqhWZk1YzL3NqOCMZRs8132H1sq8JqRp6FsI62fAl7fgN5YshbkmVjWUqszLys5bYq3M99HdlzawFqVI5QcaZCvSCvlaOaZC5wwxF16eVqZaeLb1LEnwVSmqJE2kaojaOgCxFDahpboFIzxfFzrj2QTL1lse9j0HMk6FKRUolY1YFhFu0oq1hkAj16rK3ZzxF4KI4enYs89KRrjqOo6s3GZHkPbyoyh3KSICvlSctFjvXjzVGEKpbJ3lLrUm49b85Iz0fNHonSFpafOhVcEYTmVhlPahXrMSi7IzAZcs2VsQoaKoFMRashFOJUJ1rKny8eHEagpfvRzJSQhFmt1WjkRt3Nsf2knBLjisFMQ4vj2/4tIJG2/pjOVx6Imlef6e1oSgXARHxPAqRoytiA2UUlhT4kVNWARv4b3tyM65dpo2bDmI8kYTQw2Ye4uzN2XG3Q+MbcQyabvh/dvXB9DKN94Z2Ox6njx9xle/8TNve6l+LHHm35l/bxNn/p3597YRrLRDzppZVbFFmDQ2p0WtxPv16quBYsgeDKZZVWpFvFCkcooZtYaoystloWJ5ZzOQswBKonLSxEkja4JTWdhqaOPfVdlYx5tlZeMKg7N0znEZOkrK2FJYUiu+R+dJtbJfV4bqMK7lWSwpcwNIFby1PBtHNiYSk/Jg6HijTY/qbMuAKrlwSCsBR8BgpOKcxblWR1qpDMHzZl2Ic+Hi3gr0D8KXtuA/xcQihSUpoVpWCtYYplLRKgwSGI0l1kzA8dNPRgbnyWvlzd3UlPiamfNKVkG1eZVe2EAkgakUTSy04KyUhB2GN7oyZ88WTymF05oIRrjoLLlWbmNCusqAIEWpRZk0s9y3Avvi2RlDSY2kGWXFscbI2A1sgJozSyocdMFay1eGkaUk5ppZFKaUCXBvH9oEwWqaoEitxZrCVCJ7hcV8aZfwRx53p4U9kVgLD12AvOBKZbLCYA2X0jaFawSc5/3Hl2y8J82RV3KLqXATI/t1IbvWAUqpsA2OWtuJQFoXpmVinzPf1kjHyE1cmDSyJk8qhSkngslc9yNzqbyImYdd5RpIKSL3WRLJVK78yLUtXFlDLgW04oyllMo8FS42HUWVLIVa4M3xRN9ZvjpsSKkyR+VQEsc6s8ESvcVqZRgcz663zKfCm32zQvNXW7aPHjJsr9/2Uv1Y4sy/M//eJs78O/PvbeOwzhwpZK088M1qVe9rHucMwQhiDfslUoBvvvOIfug5TZEXL24wFaa4csyJVAyqgkbLbuOaBsNAjIklJxYK34kLQwkkCi4KUir7FLF2YuMsD8aeRZW9ZsBx4R2SlFoqkxZWo1z2PRvn6VBqFDwtiToVZYozF+OAJzNawSd4fZxxtvCVbsekLalapRJzBZvxxaFGsAbEWEp1QES8cJgzKa2c5LPVgV/aanHNmZuambQwmAzAIwJFLZe9I4vy/Xn+/7P3ZzG3b+tZJ/Yb7b+Zc37t6vbae5/WzeFYKbvAHDBKICVRjeqO4gJFUYFQQongcOMIIksRh4oUodyhklDukHKHwgVSLiKUyCI4EZbAqCKBMW5O492t/mtm829G8765+H9728ZYPsfe6+zmzGfp017769acczxzjHe8zfOwJlBs5o8//gJnm55X1ztu9ju2abHbvq2F+qGkp4UsUOaKVMfGei5MwDaVR53nOsFpG+g9CMK7c+WVKZyHhkvbctYExCvfHQ4U4FHXELwnq9BYy30f+db1DTdS6LyjE49WweJ5d5g5L5V3Dweuc6YCrYvcbyJQaHD0RKAyMBGtp+8DXiNX08y/v3rKL19ZHMJFaOmCI2C5mcontUSfexRTuZkXY45ds0iv3bdrmiSctA2jVr57uOGNbs12TvzJx29wuum5enXD7e2WMUHvHE+rcFsEqUqyyjaNHK4WTd7L2HDarFi7whf6jus0ct8Feu8RA9+dK+8PA6ex59REfuRkTTWOX3n1ghdO+NrFJZd5TRWh8Y57fcevP7llRyZai0GoFSaFJ8PIVEfe2e15OU/MUvDecb9ugEyLp7GGYi0+C9HCuXdgG57ZxCvZMvmM7QQerfljX/8Z3njwVYbbq092oT6nOPLvyL9PEkf+Hfn3SaMWYSiZbRW2cRmO3jiPr5amDQwqPNnuuR9aUhLeeHif03XHq6tbrl++ZExKYz2vzMRBFhlLv7K8SCPbNJKA+03LadPSp8KbZyuu0ojembZWq+zF8jQlNrZlJY7HXU91hm/tdswOfrTf8FWaxbTNGE6t5VtpB0AXlounEaWJjhfDTC4z7+5HXuTMjNCh3GtW1Dqz9m4xCXPAVBEC6xgwzvM8T/zb5x9Q03t4HA9XgXWMRBzj+L1Jw35qA/7bWpcefIGJxaUPAoIyiwEcvXpUKtcUnl/fsB9GboeJTOU0RmoQ2mwZ8zIQ2wXL1ZCxyTHd9Us1wRN95DZVno8z1yJ4q3TO4LA8tJHgHV0IqIEhZQ5zJhAoUbBFMWIYjfDOfMA0htVoaX0gqVBMpmrl+TiQUserWTjUuqgEAVobKoUshWosszEcasVhqRksQtVFy99XYeUiuynT4AneI+6HVwP4deN2HMgsCg27pJxGh/OLZvNeBYyyCR5QXtUDz15ecdgd2B8OqFE2XSCwZMGmJIsTZWN5/2q7yMICjkpjLX203KaJ93Yjz/KEMbAOgdOm5UHsaBpP51tyrWzzwFU6cOo8Eehc4FAr+7EwTrdUL6xqoLWeyVSKzESBl/MeqS1PhpkXaUZUuYyKuoxUyy0ZEUhF2CdoWtgDTSloKagKKx847VqeTSPvvXwH1WVA74iPH0f+Hfn3SeLIvyP/PmncTIVkDQUl5ZnTENgQGFzhUJYKzkYdoOwpvPfiiqvrwH7/4aC3wTvHG1PLlCqC4qyh1oqzDucEqxWHoQuO3Zh4Os9cjTMGpY+edei5HxtallnKRbylUkrG4umcozGGQ67sU2Jfl26U3jmcswwzSKk4Va6HkXE0fDAP7KQQrOUkNES1TCiHkjHOkQxMGO45x04KrSiuKC1+Uf8JgV0tBIHgDYTXIMv5g0SwkAE1lsVXS1m3lm0qZMkYwFvBGkWpfOfZNcZaDjmznUY2bhm2aX0gswxNOJaNBeNZe8WyTE83xrAXwTnLISUC0EZPEwMRRzWCNcJclbEsgxoOZUYoZhkSQUHNkkkwLAO/1YAxy1xBVuGmZLZaKCgr62mspTEW9YHblMgqWGM4NYsm/6FkWqPLEBFL+enSW5wukxoZBXfs4X9dUGdwQKcGbyxahdMmcD0mZi2gSmM8ViyK5bvvvwRn2eeJ7XjgvF2x9p7OR1LJpCK0WC5Wi+LFur+TfKuKBsPtnPHWspeF/6cGWmNYtQ3giFpJWTikmWjAmEDNUKlkqUhVrHNMtmBnRTHMCEkMHpimygdu5EkaqVI594HWeE7bnlkqV1MlqaDOcOYitiyO1xFL1sqejDOWL3VrdqUwXD3n2ZyQT5fQ1+cGR/4d+fdJ4si/I/8+aTinBGfpxWNQRAxd75jvKkZGIfpFk9KL5d0nr1BjGHJmmCY21RODZ6WLVGdSYW09m7gIpXStR7SSRGms5TZlvFqmumT4Wxyts1gbQAzBGLIIuVacNfTek+TOAleVwPK+GbWgakh1MYurRlFxTHVmj2FXFvnNtfNEHKs2YlTY5oSwzG4+9C1VDPiK4sgGJiMY4HEMxOTwOKoa5Hv00P3UBvxOP7QQVpxCYwyDLi9SliWrHZ0lGs9G4OowUu4CeBSSqQQWKSfBLG9+Eaxd/t+zKApMtZJnYSzL7+ycw7EsoKhSgUGFUipVYSiVKrAOFjXgnSVYAIPoMisw6kwVRS0YCxaDVMukBWcU7xZdWYDGe9qVozrHmAsqBfxyi9zXzE4zVeHUtxgWHddwp8WfEOpxs3ltsNaytoZgFASCUYYqeGOZdHnj9c7jjePMRK72e2aErItm83T3prb4pUqDUKXSxUAWxWGoKNPdUM+Ql/asTQg4B9Ytkl5qlaQFSYZZK/tSsBhWzpEFnFW8tXTBLUoBUhlkxspiBy93Zh6oMpQlmxGdo7XLXMoqBk6aFWoD23Ei5YwPbtGwzoUti0LChfMYYzAoXpR53HGVJ5L+8OhQ/yBx5N+Rf58kjvw78u+ThrcO6+wyy6gCLE63wVgyirHQOodicSrcDuNixsUys5kVnMAsi2qP3uVHo/MUrUtsppYklRsKkwiWRRYzmiV5m2XpuMhSMRZSFcZaUGUxX1XFG2iswXtHwTKVQq4VMYaqi8CMiCAoGSVaRzCLoWpWITjLRdOgU2AsBWqlM469CkMVDmSSCifOL+8pNbTGYTHkqkz5M97SIxW66PFWKUXoned5Kty3kaoVUKJzBDynFp6WkarQWsfGBVBFFbZpWVQHzFSCWW56e6kEu+hyXs+Z/k4a7KIJFLOo90ypMAE7Mha50xKGucLlSUdwnobl1qcGxgzRGAadgOUGaawBFYIxTFI5sRZnDAJkEdroOe9bQmi5GSa2w57kDSFZxircSmJjI2+GDc4YrktGRRG7TH+P+djD/7pgxXDatExO2ZfMxhieT4k3YsdcCxhhFTzFwLkGPpgPFFU67zm9GzCiCtdpxFrw1pAl0fiWoQy8GuqyWVnlKmdihbEUHnQN4iGpcluEmiqjyfREqhEGlirRozYiLE5+bePAeIYirMbAzIij4KzFmuWS3HmPrcqD2C4PTYWhJtrGc//kjMaueCo3vEzXiF8uqs/HzKs6s3GOL8cei+FqKtRSMWYmy8RuSJ/cIn2OceTfkX+fJI78O/Lvk4aqpbceawqjCL313KbKg+hRp4DQe0tSQ7SW27y04qytp/UNsGTpb0sCo0RrqAjWekou3AwzvVsuiq9KZmUdRSvnTUORyoiQSgICE5kJR9UlUawqnHYtjkWq01lDUWVfKx2OvWbuUv+gSqmZxlhmlPMYsCxtbYNUvLVc9j3RGl6OIzdlu/hNOWWbhUNNrJ3jcWyxGG4/jGstTFK5Td8bBz91Af+HPmDDlFhFT28921J5lkYer1dsnCHPMNXFYOvJbiDZwmgWaSLjDaOURbd/XKTEojc4DwoEA1aFqYCNjs55VhGCVb4z7ahzpYpg1NBisXYJ/j2LTuuIEB38T95+zLeeXJPzb5f09mq52e8WRQCtIFCBm7lyD89YK+oXfwELrAz0zpD2iSJQ5sw8J7QKI0orASOOUgsflFtO28jtvJSkJhUmVaZUftfrdsQfHR++ljdz5aT1XFiwmnh/nvixzT3WIZKkMleYsDwZdgwiHEicRY+znrEooLDLzEDjHGKVLJWVEVbVcUgW1wU2MXDqem5k5FeebHnr3LCKS5lySMrNdqYGwfVCCTBZJVjL2/cuee/lFSSDNw6xmdusPLvdsonCIEJlcYN+b3fgq+0JoyloXbIBDrjvI71fkcaBaZoZ08SYCo7CDPgKlzWQauVb9cCpbbmdEivrEAqTCtv5yMGPE0f+Hfn3SeLIvyP/Pml8+Fru50RvLRvjQJWXMvMj7QmbGMjTyFgq+wrPxwP7XMkWzkIgOjjcxUaJwpCWIW68I9vKxkFUmFLFtZ7ed7R0OGf5YLhmXzJeDQ0WquL80u2RR6HapXujC46f/Mpb/Np3nnHIBSMGEcPBKa/SjJNMRlCx1Gp4JZl7RCYKjkVE3mDoTKCzkd2+MFUhpZFpnnC6KPW0Bryx5Fp5tx7YuIbbvHBQRRlqYZ+/Nw5+6px233vvPd5+++1P+mF85vDuu+/y1ltvfdIP43OBb3/723z1q1/9pB/GZw5HDn48OO6Bfzgc+ffx4Mi/PxyO/Pv4cDyD/3D4gzj4qQv4RYRf+7Vf4+tf/zrvvvvu596qervd8vbbb/+hn6uqstvtePz4MdYebXc/Dtzc3HB+fs4777zD6enpJ/1wXjuOHPx04bgHfn848u/jxZF/3x+O/Pv4cTyDvz98rxz81LX0WGt58803ATg5OfncbzYf4o/yXH8Y3hA/SHz4hjk9Pf2h4R8cOfhpwXEP/P5x5N/HhyP/vn8c+ffx4ngGf//4Xjh4vI4eccQRRxxxxBFHHHHE5xjHgP+II4444ogjjjjiiCM+x/hUBvxN0/DNb36Tpmk+6Yfy2vHD9Fw/K/hhW5Mftuf7WcAP05r8MD3Xzwp+mNbkh+m5flbww7YmP6jn+6kb2j3iiCOOOOKII4444ogjPj58KjP8RxxxxBFHHHHEEUccccTHg2PAf8QRRxxxxBFHHHHEEZ9jHAP+I4444ogjjjjiiCOO+BzjGPAfccQRRxxxxBFHHHHE5xjHgP+II4444ogjjjjiiCM+x3htAf8/+Af/gC996Uu0bcuf+lN/in/5L//la/25Tzv+7t/9uxhjftfH1772tY++Pk0TP/uzP8vl5SXr9Zq/+Bf/Is+ePfsEH/FnG38UHn0eOXjk3w8WR/79bhz594PH8Qz+3Thy8AeL4x74u/Gp4J++Bvyjf/SPNMao//Af/kP9lV/5Ff1rf+2v6dnZmT579uy1/NxnAd/85jf1J37iJ/TJkycffbx48eKjr//1v/7X9e2339Zf+IVf0F/+5V/WP/2n/7T+mT/zZz7BR/zZxR+FR59XDh7594PDkX+/F0f+/WBxPIN/L44c/MHhuAf+Xnwa+PdaAv5vfOMb+rM/+7Mf/X+tVR8/fqx/7+/9vdfyc58FfPOb39Sf/Mmf/I9+7ebmRkMI+o//8T/+6HO/+qu/qoD+0i/90g/oEX5+8Efh0eeVg0f+/eBw5N/vxZF/P1gcz+DfiyMHf3A47oG/F58G/vmPt14AKSX+9b/+1/z8z//8R5+z1vLn//yf55d+6Zd+z/fP88w8z6SU+OVf/mX+5t/8m3z729/m8vISYwx/9s/+WX7xF3+Rv/E3/sbH/VB/oJjnmV//9V/n0aNHtG3LN77xDb75zW/y9ttv84u/+IvknPnGN77BdrsF4PHjx7z11lv8s3/2z/j617/++/5eVWW32/H48WOsPY5kfL/8gx8ODr4u/sGRg78TR/79x3Hk3w8OxzP4P47jGfyDwXEP/I/jU7EHfmxXhzu8//77Cui/+Bf/4nd9/m/9rb+l3/jGN37P93/zm99U4PjxR/x49913P+6l/Ezi++Wf6pGDRw5+fDjy78i/TxrHM/jIv08Sxz3w08vBjz3D//3i53/+5/m5n/s5njx5wte+9jX+yT/5J/yFv/AX+Iv/7f8UMGhVnDGIKKlkVC1SK6KCsQaDwQRwHuxHf8AYqKKceGiCwxiD1koTDFbhZipsnKdxhquSud94ShWMcTTO0wdPbAKN82DAiDBMhSFVQGmsolJIuTDngkhl3VnOHz2kOftPUVqkTuR8y83+ivzqGdYq6npcDIToceacw/VvIFTunV/Qtz1Yy4yn6U/Z9GswgvWR0K4w4nAuoRgOW2E+DEyHF/xv/vv/C5vN5hNeyc8ufj8O/sx/+TWqgVIqIhWpSq2KVUMqlYJgrcFZxQLOW4L3BOfwwdM4x34aeHy64rSNtNHjvGXtPF6VZ/PMvW5NYx3fvb7m8aolIzhj6Fxg1TZ0655gLY23IMI0FoY5o8A6tMx1YpomDtPMlCrBO8RbuhiwVmmiJ/jInCsIBAv7eWQoBWsMbzQN26mQpHK57uhCoKqyHROhs7xxumGWZTdpg2PVrehWHq3KmDO1CNOU+V/87/9vRw7+IfH78e8/+6+/hvGOQkVQnPFkKWiBIoLUilZBrGKMYozFOUu0jmgdwcLVOPHQB9ZtJAaL1Yp3jt5Zno8z97qWxjt+a3fgrbZhloJTS+c96z6yPukJDjrXoFXYT4X9nCiaWBtPyoWSM4c5M9RK8J6kcLmKeAvBe7wPpJI4jJWTNnA9DRxywRvHm33Pdkqkmrk4WdH6QCmF2zRhouULF+eIKkUEZy3nJz0n6waplcNYKEWYS+Gv/h//n0f+/SHx+/Hvf/nf/RfE4DGA8waplee3W/rQEoPDGkCVEBzOO7a3Ww6HkVwrWAtGud0N9FJZB0/0DqyyiR4vhudl5kG3orWO72xveatvOIyVGKBzkVXTcHrS0URHWA50DmNhOyeqZCKRVDMpJYZUmKuCczhnWDWWxhm6GAjes5+XvapzhtspMdSCMfAwNDzdjyjw+HzFqomUqmyL4KPw5skJWaCqEr3j4qRntTEYcQxjIVdlTpX/9f/p/3Hk3x8Bvx8Hf+rPfYVqDFkqipAnKFIw3lCqoqI4A2CWPRBLCI7oPcFaNm3g5jDzxqblfNXQeoc1hra1WLW8mCYerjpa6/j3L655axWZqtA4QzSOTdtw/6LHuYa1M6DC7ZC5GRJFKw+ajsO0Zz/O7JMw1iUmsNFw6pYzuG0ioWk4pISmSuMiz8Y9NymBWr7YBa5HwXvDw5OeNgSqGPYqYAtvbzbMogBsYuDkdMPqxGCkMAxCKTCmzH/7f/gnfyAHP/aA/969ezjnfs908bNnz3j06NHv+f6maWiahrZtcc4xDAMA501L8B4RRVRJUijZkeUuAFNd9hRjcEFRloDfYFEDhuXrWQpgCNZgDbjgeNT1eJdwgBpwWLwHnMUYTxc86xiIMQCGvokYoGsqfarkUnCmohpxc8K6TNVKiJYuWk5ONlTXIrOhHg64YtmfP8aopZCJUeiaiNoNdlpRqDQxEpylVqWWSlk5LAVVxRklOodxjhDA4pDeYc0K1Qwsr8MR3z//4Pfn4BcvL/AxkEslpcyQElqFYcgMOVMQgrM4A8YoYpXoA8E7sOCNpV0F9rkgwNooJ95THfzY+QVxN6MYxpSZa1342VicOhofWHUNXddQa+FsvcYYQ10Jc6rMORPxNBJwd++D6Ct4y04KMTja1rHuWlZNQ04w5gS1MkjCmkrrHZd9i2sK01zogsNbqLlymEZyUS5CJBXBeAu2gZLYrHtQwe0y2QhGl83oyMGPl39vnpzQNJ4klbEUSrGIZJKDooKoQlWcVypC0UqwjmAcisGq0PeOKQlopcfQG4N3ylfvn7LajwgwVQHnaKKjikKFEB19E1k3nlqEs02PMYZ1qkxTYcoJJ4VclMM4ItbgqmK94TAnQgx0wbBuIl1syNJwbSYaZ9gWR0DpnOe0a2hbz26eaLzFIeRaGIbEMCoXvkGqYJyhXTWkOXH6qEfFICUxa8UYAY78+xAf1xncVMHUgZwzCTiUShr2JDPhnMMaxWilbQLGWW73O+ZU8M5zslmDMaRaGG4PqFPWFhqjiBF+9P457ThgjacUg7OB1SpSbMGiNN6z6gJ9H6AqZ+sOYwz9qrKaMuM8IhmiOAYLWEsQoVrDQQTvDH0TOF91rNuWIRWmNKEZtrVgrKV1jtMmUiykWgjOgFRSErZTZj8mNnhyUXAW1g1zSryxOcFWg9aMTQX8kX+/Ex/nHvjVe/cJMZDrkly93iWMVHZkplJRVaIxWGdBhalUmuAIzmPU4qyhawO7VCjGsGkDZ40HrXz9wTnv7j1gGKbCXIQmGtQFECXawLqPnHYNQ1JOT9ZYa+j6wmbM7KfE2nlwQgXEFmwVMpWdEc6sZdVYLk56TtYrplQ5DCNzVmwxBGvpXOBy1dM0iqjgHeScGWfhqhZu88xpdUxFcMHRnBjqPHOyXmGrgTozm4JqBf5gDn7sDWcxRv7En/gT/MIv/MJHnxMRfuEXfoGf+Zmf+QN/7p//838OQKuOc9dwL3bciy3rNrLxS+BtrMFbS2TJaFk8JSvpLhgXVVCoXkjGMFZFiuGeb1i5hnXT8Ga/wrrAqyTsk9Kow1aDUV3+DWNAQavggWAtfXScdo6udXjnaNqG4B0heGIIWG9IScD1VN+SjSeJw9Kh/UOk+yr4Fd4aGgfWCL7ZoG5FFUsVUDyNb3Btg6YDzAOSRvI8MM8TteygFpwd8c2Mb8PHvYSfafxh+fc7f/ZDDp6Fni+fXvK1e4/48fsPeXx+ypsnZ3jrcM7RhkDvAo3xROeWwCwlpjlRiyCiYJW5KtdjYp4rb3YbLrqes/WKH713gajym6+uee9mx8ZZGmNRVQQwQIsSRQg20vqWvulYdw1NDNgITRsJPtI1Lau+Q73ltiQaC70LWIF5LktQrkoVQwactWxcWA7WdYuP8a5M5jDOEoMBs2w+TiqaMrf7kZdXW2pNYARnA94GvD0edB/i4+SfV8tZCLzR9bzVnXDWdFyaCAUshmAd0QfWoaP1DaqGUpZqY/ABZwNRoaAMVRA1PO5WPO57LjY9P37/AuMs7+z3XE8T6+jx6hBV6t0+2FtHFDBWcd4Qo6NrPX1saNpIv17jmoaua9msWjCGXS1YY4k4ShK2w8whLxfMXASqpTWBUx9pvKNpI84FRCGLIEAbIo0LlLngcsElIR0qz64GUpoQrUt1zTmsOe6BvxMf1xkcsnKijlO1NHPlsB1pirK93vLs5SuevLzi+csbXry85fmzG14eBiYpYEBEyalQSyaLMKnB2sjb7YaL2HOx7vja5TnWGN7ZH7hJwnloaYLBW3+3tkqwiskZ5x0hBvo2sO4CMQROe8/JOhKbQN9FNquGEJeKvREIapAijHPGiCVgqWXZ/4w1tM4TY+D8bEXbRtRYkoAgBKBWpaSCKRmZM9tt4tnVnlwV1YqzHmcbrPnEGyU+Vfg498DLbs2P3D/n648e8GP37vPwtOMr5yf0xhKdoXGO3npOYkNvI3Mu7MbEYVouBKkKopV9yrw4TEyp8uVVz8O25/5Jz089uMCI8Ksvrnjvds+lb+iDw5ilKyQaQ6MWN09Y5whhScSd9A1djITgOelXxKZls+q4OOkgwrO5kEVwatAipDkjYgh4ahVEhNYYzqOn845H9zes+wYxZtkDa8XL8n05Z7wImivX+5lnL7fkUlGWi3KwAfc9zo68Fqb+3M/9HH/lr/wVfvqnf5pvfOMb/P2///c5HA781b/6V//An/vLf/kvAzCWgpsnOh/ou5apQJURlSWbjwMxjq5rSCljbSJgMFhKVSoWKUJQjzNL2XHTn/DGeUsDSKxcXVfGAURhnwyg7ElMuSBOeRgjwzRyVSurdb+UFbm7bERLAqx1NGEpJ+U8UesO7RVqpmhmEsNgHnB5ecmNPcPt72HyM7K9hvaMetijdcehOCa1WGvZbM7obUcaX6Cm4q1CaChFMVMl9wlqIWjB+/F1LOFnGn9Y/n34sx9y8MVhh2jlYrXm9GTFThNlGhlSoholWAfGYDsHQDsp3lucMZAUYxw6Kx6wwdF3DffWJ3zh4X2cq5wCv/ryFdfTSA0wYCHDbZoYc8V7zyN7zmEeuD1csW5P8A6g4qwjMjPTYJ3SRYuqYz8ORB9J1WGTYMSQTWWWga/0Z1zVxEVosUaJ1rCvsvCYystDJoliUboYODeOlJe2EecszlpeTYnvvHPFg7MOZyNmKbO9rqX8TOLj4t9tKaQ9rKPnvG2JVK6HxDwVbGNxQakUrlJFxACCd5YQPSF66pyZRTBqcKJ0znJ5vuGL906WiiaOcrXj+lABw74qMXoOqbCTTF8Kxlmu5kS+3bFa9QQsWguqGQdMJIyVO/4pryblLPYUKeQaMA6mUtjtE1+9OGUoiT5YVA2CYV8LcwXrLK/SuLQUsVQGzp1FUmFXhRgtK6PMQ+LXv3XF/csznFO8VarIa1zNzyY+jjP4Nz94yrpbqt2nzdLSUCuUJOQgYFkqLZII1eHuEnFGLDlBTZWAw1lPsIYmWk4uNvz4wxMccAl8azdyKxkbYDdmApGtK2QKXiz31fB8P6LBcb5e4exSx+9ci2fG0uDtSNtYnLFstzNr55lwDKLUXJEKu+nAlzYthzxx6how4A3MKTN6QJWn08gsgsNwFj1fpGNKhRmhCZ6NE263E7/53WsenXVYHObucnPE78bHtQe+d3vNnCcu+o6TTUvXRQyV6aVSAGcgK4gsGe7WB4I1OGMoophsmKlgDK23bBrP+dmaH318TgSc90zPrng6TBhr2VfHygcGmTho5SBLC/fzfSI/v+bRxYbWRbwJrEPFAXOjxMmxJoKB59Oek9iQgQSMUhmniedT4qv9CVOqnJkGUJrqqFWoKWG08v5h4jYXojE8jpFN9BxKolRYxciawLPtnu/8uuHBg1OitUQL5Xs8gl9LwP+X/tJf4sWLF/ydv/N3ePr0KT/1Uz/FP/2n/5SHDx/+gT/3zjvv8Lf/9t9mZ4UZIZZENxSc99BHHvaRXRamKhiUOkxE4Hx9RrWQtCJFIFUaenItFBWaYLnoDGlOiLNgImotzgvWQmwC3lkunMOo4v+D4sfT6y0zS99fWy0zlaHCafBEc5cNwFNnyM+/g3Eef3hFO77gpG25vPdf8RYjwwbStCIfhNvDgIuOk3iJyIhIwVJg/wGpPOd6KPSxo/MRZkstE7t0wA0HjBwItmBLfR1L+JnGH5Z/H/7shxx8Pk+8LJnTNPGWJi5Cz/U5/InNl/j2iyte7A9U4AzY2IbzN+9RrDDmTJoToVgufccwTMy50Ijn3rpnHAZijIg3HPLSouPU4PpA2zSc5TVeoA8RACeWtM38xssP2JcJEE5jz1Aqz9LMl5qeznmSFGL1vB0tvgc1gmepXjWlZ6yW09DSXGzwTaDUzIuXr2iAs66js0ItiqqQ0oA0lrnCql04LrXiqDx5fsXVlWNzsub0dEVw7jWu5mcPHxf/BlvJqtRZCGJovOH87IR7vfB0nrgtGUygrZaK8tbFORkYUiYPM06Eh+GE2cyApfORvvO8HEbaGAlGKKUu8yew9D77lhMfsFVojSXNlShQtzO/fn3LthasWu7byJBmnpXEm6Gl854CrLCsHLQxInc93k6EHkutwmnX0W5WhDZQa+HmakuPBecJaqmlUkXYTjPFWyqZk74lWkdKGUV5crXn6mpPf9pzcbqid8cM/3+Ij+MMfjEe2FXHRdPSGMsXzk54Ngx87Usbvn2z4/lhxBnDA+vorOXBvTPGohzmTE4jrQAYzi8uOTk54dGm4e02Mw4j0XVkJ8yzUIblwjafwSY23HM9aCE4MBgaDYwvt7x7dcUexajjwkReppkn48SPdysuQmQWgUn4T047ko/LFKMKOs80pTDQ0/WOk5M1mz6CVH7rgysaF9j0gWbOpFKpohymJdAjek5bzzoYvIEYLe892XH7fMfZ6Yqzs46uOyrz/If4uPbAp9s9r8aJ+9PMj5pLfvz+Q97bvuBPfPUhv/L+Fe/dHPDW8Fbbs4mOH3twQVJhl5a22zNreehWXO8m5lJocDw6bdgPIzFGHFCy4qrFW4iNZ72KnLctviptdIQ2cr/vSbsd/2Z3zbYUjBjuhRVPhz0fDDNfX6+517bMItS98ifPNoyNoihDqpgq9CwXgHXfsF5vWK0bMIZ33nvJCdD7li+sLFkqpQrb7cDMonD0sI+ctA7jluTbr72348nVwNlpz8VZTxu+t1DeqOqn6nq63W45PT3lv/nv/nMaa2kVOusQEYJzdMZxPc/syzK4KFqQpJx1DQpUragKGVjHAAWqCtEZLuLyopxtesTBe8PA88NIKIYfP+3w3lJKQUVpvOXepl36C0V4Mc7MshyODYa+b9jdDYzZCoiyZeaNGLn39hex1rG93bHfHlhvNrzxY/9zfB3ZV2VKI/N0YJyEOD4D3DKApwJSMWW/tBSZSuzXNKsLQnvOpOBmwzwcGKZXWJvxxvC//e//r9ze3nJycvKJrdvnCR9y8Cf/66/Tu5aLvuONyzXOVKJtcGr57ssbXmwHjFW6pmKT4f7ZBlBSruRcKbZw3q0oRUiSicbwqGkBeOsLpwjKv37vA/7d05d0JvDf/Cd/jKaJlN2AUWG1anlw74J0mJA681u7Gw55KSVvYsdZ2/GijMyHEVfBqOFKEo/WkbN+gzGG3ThxfRgQWWYS1h7eG2eKVfpgqTO8cbrCpMxYllYipHBzvaWqW7K3zhCWQQHGmlnFhjEnrqTSNg33257/1d/9vx85+DHhQ/798T/3Fbqm4XzV8fCsJ5tCS8AHx6vDyG5KKEqqM2sifYhUFVIpS2ujtZy3kVQTIoZoHWd3e+CDszXJZX7z6pr3rvc0Yvkvf+SL2KajjntKSrTR8+b9C6ZpxtTKd253zFVprWcVHU0beDFm5nEkKFhjOFC517X0fbPwb5i43o8UrXz5/IJ1tHxnGKjAiQ+YXHjr4oSUClOpGAwIPLvZI7UASh88bfBYZxhronWR3ZTYSqFtAvfanp/7H/4/R/59TPiQf1/+T99i1UUenq358oNzelVuc8ZGy3evb3l+GLHAxns2oWPlA2OamUrGWkNUR1h5ojVYH4nWcVKXBNWb5x3JK7/y8opvv9rRqOW/+pG3iX2HyYmaZqKFR+cnHPaFQuLpMLJPFdSwCR4XlN8aRtwAK+fw3vCyTjzuezb9CoPhZhh5uT+QpPATD+/RquPb8wFjlVMfGafKVy7XlFQYpSIKpQjPrw7LPIk4+say6Rxd9NyOhVXwDHPiRqHrIg/ahv/d//D/PvLvY8SHHHz7z32FtQu8udnwtUeXtI1lmCYqll998or3b/Z4a3iw9rSu5Ty2jLUw5IzcJRtWqw5vDFMuRKM8Xi0Jgrfun5G88i/feca/e/8VvfP81T/5dULfEiWTp0ywlrcenrHbD8xz4v39jttUUDGcWE/bR35jtyUkYW0dxljemUe+umo561uMMbwcZ54eRlDlJx88olHl18c9xsFFCAyHzE+8fY/dOHM1zKDgjfLO8y0emCucNJaLVaRvI7djorWW7TBxYwzrVcub65af/T//v/5ADn5qm88at6hKSFkWDzW0ISCwbCYfthEYOFThblAbvetZVaN455moFDEIcKVKFSUfEpPN3OZMlSW7ZSxUYyhisQjGWowB7x2NCcQqmLwMwjkgp4IxgWIEzKJ+cmIjsWkoZcIYg2gFa6gykHVAcqbUEckjphZc7CnbgLV+GT42AjoyTgewsAoNXjJWRoy2BLNmbFfspxbY4upAqp+q+9rnCkWERGE3T9it4r3whU3AeMe6Cwgtxih9LFzdpqW8W6FWqGbhaRMcsxTmKkxVyXViyjPb9wsTiSe7PVUFtQoCcxFSqTTeYL3DWEPTLJmA9dzh7tp5GusYp3lRnZAKugxBXsaWs1WL8Uv7WQhLv/WhZoYiRO8Y0kQVIYZAtI5hGGkAH5defpXK7X6EqrTGE5zBOEMFrDqua2auBa2KmsJtmT7hlfp8IpWKNZmdM4TB4KKhbwMYQ/CerlnU2NpasdkCi2qFqqLO0AVP20TmMTOpMItFimHOE5PCSOJqmClF8RjmKlAFLYsijg8eY5YBStMENqnQTJlgDNEatvuRPrbcqpBFOPGB87bhcr2iuGVf6puAVGWYC5MuVYNSKlIFZNnHt8OMB2IMhOBBlHAYqMbjUYK1WGPAWByeqzwxacVWhalylYZPcpk+t8iqjFm4nSpPx4QvyuXaY61lHSOlCtbAyrIMSd79ccaAs4TY0LeBOSf280QV5aoqtcKomcFWbuZCdGGZE1FIuaCl4ozB+6Vlsuk8XQgcVDCaUFGit1zPI+eu5ZkZmWvixDke9h3np6tFVgylbyxn0nDInlIN4hWjghShSMaqcrufsAZ8u/BPi3K7T1SUkCseg1TDXARFuc2JfcmIGsqgvJryJ71Un1ukXNkLPBsO8AqcE760OcdaOGkjZdPjDFz0IASsM9i6DKdWq4gzrJqGfZ4YjbArldurTCmVqyRsSbx7u1v65o2hqlJyxRqD9RbvLVhD17e0TWBbK+hMLYsy36tp5kFs+GDcM5bMKnjeXHU8OluTEBRYied+bZjqMhvlg8cnqCJIKjipbPcjU86IVpoY6INn3UYQMKkSDRhRahWcNVzXxKuSMTjyIfF0/t7aGj+1AX80Fu88WYSE4oAkQgFKrUvfnFledLVKNYo1Bu8s3lrs3eFXVSmqZJRcIKvgFUYt5FqXF1Hhdi7gQPNSDegweOtQYzjMwn5WqlQ8ggh0TjG+IfgW4wxRlEjCO4fmhN5dSIwPSJmowxOYK9O8p5ZCsA2uv+DQ38das2T0pVJnz1QaHCNqC5pnNI8QGkJsyGYgRkcehZwycyqf5DJ9rlFrJZvCIQtlX/AOzn1HiBUxFe8VgxKcJZtCQpZh3s6xDpZoLY6KAKkKqVYGKiknws6xl5k5CVE9rhrev94i1pLzzHm7DEI6Y9DgebU78OzViCB0jWdHYoWh7RuCdRgHnff0ztP5luoXCdHgHH0IqFHapkGtMNeKFl0GK6Mh54wxltCY5cJcdbmsOIdXh1qhsigRGGOZayKGgNFCzpWxHgP+14FaKgnALAmMpvH0JtKEJbNhWKqXwVhGU/F+GTYLztEEOPGLbGEWYRZBKFQMSQo+O8acKUmXwTLgg90AQ8bmmT5aQhvw3oOFXc5kPDOZMc9IBlOE09gQjMU7QxcWSePgPdYppVSCc0ulVQxdu/StIopVCLBcNOaCWvDBQxVqWRSrQgiggqAkVUxVRAxTqUTvUBFqrRzmY8D1OqAGiii7OWF2h2UNm54ggjWGxntgCfpnyeAc1hvaEOn6SB9aaikMCkmWAcoJi/WO6ymz10xRaJ0nGLjOQi0JY4S1M6w+VKZzMOMw7YaatgyHA9tcUISLNrILGdVC6x2nIdLHgIpQpCLesg5L5rXvImhFFajgjCEYYZjTIt9pLWoMWSshWLxziMmAIauhlkULcMgzzhkoSiqF/THp9togRZirciXCWDNGhRPtaBuDynL2WrtIdY6SsEYRlLYJnPWBaANBDSnBLMJYKiktp1k3JK7zSE5Caz3BWH7z1S1qHCfBcd467p8sQgTOO55uB37r+YFcM94bkiwJtMvViuswIyKsgucsRk66lgOVVCptVUyA6GGzbvCyxHtGFyW/YC3bw4i3Bssy4DzVwqoJeGO5ZV6eoxqk6DL7NBe8s2hVhpTZjt/bHvipDfjRDNWx6Bs6tFZup5kIjLmQal0y+ii1UQ610Lo7Sc3WEyu8v93xoRBRUWGWjHhBAtgCvgC6DH+8d8hEKs4aVt4uOvwuUl3h6cuR969n1GZCKORi+Mq6o7Hg44pgPb4W5kmQCjbNVAxCg/qADDO8/PdoEQ67CUygObnP6rxF33iAo1KlMk8zw7ZhsoWY3mcsW/JcaK3FuoboHSdlz7rteP9mYDcL85Q+uTX6nKNKJQOCpaaKVuXdumWziaS6KEIZA7k4tnXGl4HTds153/Nws2Jle37tyXcwd4KxpVYmLUQM0Vva2aNAYzxahP/xt54CYKPh/qojeM+PvAnZWb717Jp/9etPaDq4uGwYq+Gnzy8By2nT0TpD6wxjTuRiWDWBOS/90NYoa+d5fHnK/nDLVARbDcF5IpZkKgXQnMjjxDiOIJVVHxmrZU5l6d+3hmBhrZ57qzXvlVtu55GUjnMkrwM5L6+rqJJFMKOB4nhw2pJqWWZFtBCNZ18z1kaiD3TOc9J4Vsbz799/l2QVEci1MqWJNjqct7hkaVjkFasqv/byGqohBFi3EY2Br7ctqvDyduJVUnZz5jDuOcyFP355iUM48w2tt/TBMqTMbpo5PenJ8908lVFigMenGw77A6kuUq7GWvROsr2KMA8Tc10SGQ7DpnXcZsuYZkDw1kKttHjuxxXPyp5dmUjHod3XBjHCXGZuthnjPR/cKJvWkVTIUqlSmNSxKwfOm5boPCddyxtna1r1fPvZC7IKRsFZh7Wes7MOezvg852krwEXHe/NSq2FEOE8ODoxhLsWtA92cPDnXEniye4Fw1z46QcXtN7ysGkIrqEJjlQr81y4WHXsphkpGalK9IbHFyuu9xO7LJiqXAZHawyjKtFZjFq2U+J2GGiBdeO4qTBIxajQiME7h63C/bbnA5m4TZlUjvx7XahSMWrQUilpWYdvlyvOTxvGUhlrRZ3wbDuRgMuupfMN9/o1P/LGPU5Mx7957z3AYMWAKNVUwsrS+UARxQVLsYJVw//3Ox/gsuOkc3zpcoN1l3zh3tL98W9+6zm/+G+eENeGy4cNhyL8Fw/eoPGBh31Pay29c+zSxKFULlYdt3UkS6YCMTjefLDh5tXMfhYQIfSO1jhu8sSqb0EN2ykx5JnL0HKxCtzmzKHCWM0i0Q6YpLy9anh3nLgq3zsHP7UBv4iSc0aqYKnUItz18yx65RZUF53fVAspw46ZtnHM2rN2kX0aaWzE4GgANQYhMGZZMv53ljaOQPxoSFfZayEoiOsxGL5wsaLkwpwrzgZMhGQMvk4YDXijWC/sXMWnivGROg8YRlbOUXVm3kZAycOAcS1lBRIKZwaqc1QxOBSRFelyQ3N1wTBtMWlCsbRtSx0sw3CLc3s6BRsj4/Gwe20QXTwRxFSKWcxWbseRVduwahtc14I49uMSdDx5ueUpO077hsO9cx5sLrjej6gVvIXTGDghUKVwM03UKky5UIp+NPiq1dD6yCEXngw7xIPTyk995RHzlDikmbbxBL9IeI3jxCSFpu+xIfKqjEzjgaZZM84jGGWziWgVbJ0JIRCtxaO0QbFUxlRxzhGKIrIIglYcEXg+DLxKAwHDWWg5AA1wvR/oraftV0z2GPC/DoTg6VbL4HbKhSyF23HgbOWxHnrnaSWyP4yA5TAWBsl4IwyNZx1bDocJbRxGHY1Z1MXW0TPUiYMtFBTUYZxBvWJqg5AYamafZ2BJrHz5jTPCy5mXovRVeaMXjAmQKjlNdL7FeM+TYeSies6LknIGA6tVS3eXuQ8hAhYVuaswwfNhyZi6OwUq64RSHdHCPA08HWe8NdxvI6UIVYQrO7KxntNuzXDk32uB1kWJp9al2mlMYSuW1rdEb4k+ItqyTSMiyov9AVMN2zBSysxpt2KbBgoGZxzrEGjbjrNuzfPtLWKVxTHHUBy46Kkj7PY7ch/p1g1f80ub7qMNvPdyR1crD1YbtMuYapjniX0qnMSI9ZZnaebUFJq2cjNPWGc4P11RqmGeLa1rccZhbCF4Ay4wbmeaztMbJYqhqZ6KEIFdTTybZpzC/RhZAynBrU1sjGPTOCZz5N9rQ10GXyvLWWyM4Xq/52QT2ETP2gSSVJ7PMyrK9W7iRhL7YaZq5o2zFS8Pt4gsHhBNY6kSGFzl2WFPcspQlxafJniMeiqWEizf2t4iQfnpH3uMVfgzP/E2aaxs80zTerx3pCrM6cB2N+K6DvrA0zkxjjtW3nF1GDAW7l90GLXUAquuwdq7ipGA2sqYhL4P2GBY20VCdq5LlfRWCu8dZoIxvNkFWuvZocQsnPrAWQhM32PS7VMb8FepOOOWXrwKVRZTFmDp02KRCHOArxYfAFlKHrvdgO0gElAxKIs04tpYNtZyBUtxWy22GiqJxIe6/kJwhpXx2LoEYU1TeXzW8GyAVymBqdx3vz2ZX2siScIYw3l/xsnKMRhlHGfSWImxY6gwz4mcHC4oJU+EVKGvUAteBhwzGiZ0NZFmWLcPqGnA2QA1Mow75rliXeJQMlks06dr5vpzB0GXErAqIOykcpMOfOnkHvdONgjK/+/bLzkh0PXxIw4+f36LFMfKefYpUWqlc443+jVnG89vbG+5TglEMQhiF3b3Dk4aoQuW+30k4MDAad/zp776iH///BXfudnhaubR5pyUMm1Yhs1vJ8UYw/2TNSen5xhgThNG4KTpFofqYeSNvqfWRY0i2AYYGWul6Voci0yY90tm6/G9Dd0hQKmsneFqLLg7xZXRCcUYZj3Kcr4O3Ds9xbWWokIowmF/YJyX/uFHmxM6H5jGxPYw4KyhV4UqZCnscqK0hTZ4JrO00DQYTo3j7b7j2yVRDGhJ5FKoAqehAVvZBMv5quGt0xWw+EFEKg/bxK2feFkGNAlv32sBS4yeSSpzmum6hrcvTjjt1xSEKc0YUTYxQhXSPPPWuqfUwl0GB+4EUdbrBmNgGmeKh50Ijx5c0O0HbBV653i+H2iiR9VwQ0aMYT5uga8NHx4vS8epsp8z/Wh4eL7mtO9BHNsnWzo8TVjav1C42WWmMrJygX1ValmcelvZcRKV5sF9ZmfZ7gb2+4FShX3a09qG3sG5M1y6pcJvDHROeNSN3O73XM8HrMKPX3bU6vBWGWplnoTgHW9cnCytGFjGecZa4V4bERnZTok3+paaC1Lu2ikx7PcjQ7FIVaQIbRvZzpkvX1ywnkZsrZzheTGNED0pQ/Kgbmn3OeL1QFUw2GWrUMAqt3Pm5nbg0fmak1WLMZZpP2PJnHQNzlgU5fn1ju00cq9d82LYUzK0zvGw63gjNvyPwy2pzgRlaWsUwRg42XjOO8tpt+LLlyd8yMHzTc9/9lNv8m+fXvGrV7eQJn7krCGI4ozlUAoljdgu8vbJPc7PL6nGMcwDFrjoWiQldoeJL3UNk1tc1H1dTL6uhhHjzR0HF9+SJ0l43LZYA62xvOkbntwl23IqbL3BBIf4T1CH/+PAOMyEuBgEBe8I6sg5kbkznVELUsh1uQSsm4DDLjbsRnGaWbWecV4CNmcgBAUKiPBW0zI55TplDnkxz3J1GbI8iY6TGBhqpY1Q6uJCqbNwKBmvlr0TnIMmj2RRslRiiPRNpGRhTn4xwdHClDLBtYwJlEBwEe8CQiXWstxpsmBKpslpkZ9zEcFCG7HBoqZlcC3KM+bDiPWWzltwx+zC64KoYFn0xfWukJKskEvhMI/orTCMlXlMjJr44sU5G9uSS2VXBlYBYrNiuq0EZzkJgU1rCc6xcg0/+uCc63Hg/e2Bm7nShMAqOE7WljdP1rxxesZ2zJx2AUyl6yMmOLalIKLs/UhSZeUjuWaqFvrYcBo75imzmys1L2/ylGYenDoSuvRU43HOLpvosHxP4yyN97TGMWslp0TJlcY6fLQEQJzQO7jKiZWPbLznEI891K8DvnUYb4gssxZd0zIOE6ih5Dszmdst1Sp9bFhbj3ohZ0uRSoOnOdmwHZce0N5aTrxlHDN5PvDVzQmjD7wYJm7GxGq9RlJmZSv3VyvurU6Y6mL+ZhBCcGSzDC0a4L1xhyPSeEsVpU6VPnoijtvDyG4/LXNP3jKOhYcXa2DpcyV4rDFIFWJXl0uFdURnCC0csqAI07To/XtnUKOku0DwxZw57xpWwXMrR/69DgTnlrkKllYbLBTJ5ByZ58KtDAxJSHUZTvzSG5f0NjLOmZfTlhjgXrNBDhNihM4YNtZBmnmx3/HmZsO67XnlIh9cXbPpWvoQmbcTp8GzsZZhLvTOLiaEMZKt4aokjLW8s50Ifpm1K6IUgbWPnLrAdKiMQyLVTLUwThMPT1pcFc68WUwGFQ77hLmrrnpZLjYaLE30pKSUMtOZSnBgVZZqQjC8IHMWIr0xDByr7K8NCmrunNwBFYuQmWol18w4wX4qbNPMqJmvvfGQEx/JIuwk01nhjc2aNCcKSzLjQbSIFzYn8BOrS14OM7+1HbjKCRcdnXOcrRq+cHbK22dnDCkvZ6ZxbPqOGi2vagIR3tvv6J0nWksGDkm5bBpOfeRmt2d3SFRRxCpPxoHH9zfUWthERxfcogo1ZLIkNENjLNYoGgyxjdQqaE6cqqG1BuuU6gxn1vAsC6dhkcTdy2c8wz/mTFWDN5bqwRiP9x41BmMqzhTqErtTMcRqic6RjZCkkLSydgEbCqguGroOuhCZd1teKayi5/G6xYeWrEqeF7OsMS/fv46B4DuszUtvLIGVJpyz9G1YkhmyKAR5YxGp3A47kippnplLQlQ4DT3eQwwRtTPBFZxMHHZX2DuX0pQztRREwLsG01pEDkhVrPUU01JEGMYJLZkGv1xu8vGwe10QqZiqoAbVZUhcquN6mNm0E0aWDKbkhQOxOjyL4UcVRWvlpOmwqx5UloA6WlahZchXvDdUTmLkj73xgBAbpqmS60Qtid1YCG7kZL2hdD0OJYSGk6blYdtSUU7PNuQiWFPBWQSLzInnV1fM3jKOM3POWGN5dLomNg1rE7C6R2qmqPBkHOntwuWSKt5YnDeQuRucdAw1k6si4iipsrVKyaDWoMai9Zjheh1YdS3W+6WNpWRcs7iEx2DvJIkF7y2pCFIFZ8GqLrMiJeMsnIdmudihBAveLIPlN2MC2XK57vmxexc0XYday2G7Z5wHrg8zxu3pmoa27TDMBO9Zh8hliHhnOT/ZUGfFGCXeXYxzyjx9dcMBYU6ZVCveOh6dnBJDXCRdxgGthSLKy5ww9a6QWyrGBZpmmZ0yxmAFrvaZXCoRw5SUK5PJuZCCxxlLOfZQvxY4Yzhdr2m7SK2V65stXWywPiACIgVMxTiHBy5WPb31XEul7pZ2oBCFjQNRQ2MgWKVxhhfDwCEXHp9U3lyveOsLj0CFkgqvqvJqPyKqeH9K7HpCgBg9Jz5wz0VsgItNh1UoUhdnXAxzTrz76orqLMM8MZQCxvB4vSE2EWsd7A+kkhml8n6eOQuLVDLqaKLFeYeqo20cQYVtScwiNLq0ed7muri4asFbx1SOJabXBdWlan0nu7SUnES5PUyc9h7noJAXpTujXHSRkxC5nWZeHQrOLdKcl41fpInvWgejNdzUTBn2XMSGn3rzHrFtmVIl1MJQZq4Oi/pXFz3NSaSJENrIeWx4MzRghDcuL/FFKaXgdRGAScPMu09fkhvHMI0MuWCt44unpzRNgzWW6+2WmhNzrXx3mLjwi1Ro4zxtdNjgqGqpVJoYmcxwJ75gqOK5yYl9rvRYWmeQ71G75VMb8BdVbK1ULaSqNE5p46LtbKzBGoi1EqugdckUFRZJTlHFWEMQ4EOJTrMoQojAkCpDmWh9x0UbuDjZcJgLBzPwYsyMpQCGe1VQXQ5Lo4bWek5DgwkLCeZZyLXgncE6y20qjGVY9PRrJdW6DGw6j7VK9A4cNL7iZGIeXjGS8CFQJSDqwHhc67FpsWXORVGEaivVZKacCCpL9aAaUjoO7b4uLK7O+pHEG3ZRfhpqZj/OdN7SRc9pt+J2HDmMieIqWQvVKtFYWmMw0aMqS5XJGrQq+zpzPUysmwveOj/l8cUF233h5nDDb714yc0wU43hi1VQhVoXJZV1bHhzvUZQ+r5ju50QKs2dQsuLw55DmlDvcXIn7egd3nmMXTYTTTPiKrNkpjzT4AnOLU/TGlzwOFG0GJqmXQbSSyLlArUy18WopFbDbGSRczziY0cbWlxsKK6QjcE5TwjL5apKxiqsuwY3CVXBGouaRdVGRGgtRFky5crS1mOw5FoXtYo6ct63vLHuefzgAYdp5kaVb00T14eRArx9foJ2PaUKIsrKex6vVlhrWMeW25SoVNrgcMDNYeCQbhG3lMFTFaxTXAhY64jRobK0meWqpLEsLZnWYo3FOY8LHg0eEaHBsk+ZuQiSK1ZhFMUbQ65Ld++cj/x7Lbi78Pdtiyhsd3u6toVFoIaAEqOhLREjSi6V0QhjydRaadVhRIhWluCdpQV3roZ9SmxT5jx6zk9XvHn/nO1hYFtGrqvyYh6ZtPD22QbplvNdUTYh8uaqB6/0bWCYhEol+IV/z8aZbZrxoQGtDKVirCOcOZzzeOcpZcRlRYtQbKXIsjc3vmHVRXxwTPMiCNIZ8Hk5d1NZ3nNDVUw1ZITBwnx02n19uOv6A5ZsP8uM2ZAyuzHTRkf0hs4HVIXdOFJzZp8yKSVO+oAplcZDVZY5SRVKXcy5bufERRv56sWGt+7f4zBWhmHg3z59wpP9gbEUvnK+eOaUWhEMJ7Hhi+s1apWzbsV2N1FYEi5GhOfjxNU4ETcNpSSGInjf4mPAWYtrO7o04lxGs5BtRU2DN7BqWtarBhscN/vFL+fsZM3ewnSYKGnZ68aqWDEUMczOUO33lnT71Ab8zljULQ62VMWZpaSzRF8G7zyxA9RixsqoBVk8OQjGcOocUKlpMdMw1mA8XA0jkwgti928UyFY5axviSi3h5GpGlQNxYBIohal1IJxhs26QXXREr4aC9YIa+dxzrC/MxVZy3Jh6PB44zF26V8ES+Mt0S3DkiZv2T69YbVeY/tzXFhjfEB9pZZE1ILxmaKJKjPqE84JpkCugqpS8nGzeW2o5iN5VdSAmI+aWoeUybXn/uaMPgrzk5c8G3Z4Z2kaz2nfcr/rgcxUCkWEzlo2xvJq2FIctGpprCU4Sx8i/nxF4y3vXF+R5yWIg4qVxDgWkiSsgYvNinInL/buyy19Z7nnPD4qVzIDcJYNwbhF8s7HuzYQgEJsPN4E2lq533h2UyUGT9cH2qbF2EBnHfsKsWk5wzKVHeO4xXuDx4E3ZIU5V6bvsZx4xPeLJUDxzhLCMjhZ7py1i1SiNaxDy2pt2c8F0ziyt2CUUwdv9T1pKkyy8K+1ltZZroeBYAzBL+6SVgtBhLOuwZcV3311jYremUpkSh7YzTN1XtprLjYdtQp5KrwYhRAEHwSD4bYsCYhLbfBuMfuyzlFKocgiidi1nsYtz+fBrFzlRAyetm1omohxFusi+90BFxzn6xWjwDTvOWktpQacFTCWKoYsxwrT64AamKZxKaMbR66FrBkUJlnabFfRs6mWlDPv39xizVKpaZ3jfttAXqRjiy7VQy+GJ4cZVOmtIxqLBVoDYdXTqOc3rq6ouvDJWlAy+yFTallMls7WzFLYj4V3p8rGwYkzYJRdWVKdm2LxztKpI1iH3FVcBVj1nkCkFMuQ4GqARg0nfWTTt4tslIVhGmi7yKXpGaowDXuiseADOEVZnFOrOZ7Brw3KR8n93/77cgMY5so4Ve6tG9aNQ6bCv3n/GY23rGLgfNXxxU2Hz8JYC0kLjTE04nhVZ2yF3ntWxtE5y6p1rNqOgw/o06cI4JylDQaMsD9M5GJw1nL/Yk0ult1+5FdebrmIltPWIygvP9wDJ0VFaIxj5RwikFLBEjnrGtxKmKuhiOPZldIaONn0nKx6iihXJlGs0q0ib7g12yzsd1u8W7pP1jGg3pG8uRuA/4PxqQ34g/lwnS3OWJxzOMrido3DijBOmWf7iRgXQ4beOU584CREOmA7/wfZb4VSLCssDovFo9VRx0yxE3dmoqyCZd06rDHshpFaHeM4E4IhesNuTqx8R44elyoiBl8VdxfwnzYNKoLKImu2nw/c9x2FBN4zKMyD0LhFvzynPaHZYCMYk4npBSjUtMdqwteKZKWvi9ZxAaa69E6O9RhsvS4YBXOXPPxoLuvuv1WFwzTy/ovMk5sdTWfoneWy73l0esbD0xOiE7bbRLWVrJXGBHrXMTnL49hT6tJ21hlHrRlTJzpXQQznTc/D9RoR5enLHalWtrc7YhOIbWCfKisvPB0H3ggNUhfH50aX0uBlt8LfCU6rE/bjyL3TBqkVaxu2szJMmcuzB/RDoZQZUxRMXZ44sO46RAqd89jQUXzixAuwppAZUuaQM2M5BlyvA9Yt7QXgFoliLVTuTKYs5Jq5mUeybwjRIB7WwXB/1bPyJ8RZGac9YkF12e8aAtEULru4VIy8p7WWVAaYBIclBniwaTjvO3Iu/NaLVzhjubne46IjtJ5DLnzh3iWPNw7ZH+ioiFSc8xjgNEYQZVHCs+x3I/ayv7vItrw4TOznymZzgXMjTAmtkJJgbKU6uzisVyEET20b5nGm946ChWKoCAOZ6XvMbh3xfUKgzJVDGphLZSoFH8al1YqGdRdZxZYkwrq3bNYdrihNWdp4Ip5tXhRSFMU6pfGBixkuuw7PEnB5a0hlWjwhXEJVOYsND/sGyYl3nw7UatiPM01nadpAyobVpuVy02MOO4ItOG0RLk8AAQAASURBVIS1RjBwHu0S5BuLVcvt7cjbZ/0iCRtW3Eye3TDz5vklXRyZ54SoJSUwbpkd7BqLyDK/V1phOmRWzrLyFoowAftamI9n8OuD8FGSTY357Wo7izHmlAvXA7xzM9CfWtpiuexavnh5xlvn50RNXE0Tthq8QucN97uOvlautGeqlXWIrHwDxVJrIrpK8JbHmxVvnm2INvLdD15gTeXmdiQ0jhg9wzBjDLw6DPSm597K0QSz7H0GTmqgSMU4Q1OF29sdb52dkqQivmGYlP0ADzf3OHEj0zSjIkx5Qq3SeMt5v6IWQ/Sepg3snePEOXzvwSzdKre5cDt9xmU5JxF6Z+magPeLekhKdTGSCbK48HoDFMBjCURxrE3L5WqDuMr10yc0waDWImK4nTPXMnOv63m07mjvBpKupwN9G3HW8tbZCaJL71geKnih6yJ7NdyOE2VYhtDOEc49DDmzL4ZcDbsq9MC/G3bcx3EZOtahuxuGFHrXMc8zyuKCKeMMtVLKiM7XjEASS1HPNiXOgsUaT+MjbQxUHM5ZrLPYUmispzHxE12nzz0+jPSN/namAdiNiVqEsz5i12YZGBeLycrKRN68eERi5uWLa3q7VHsshpc68EHa8+WzEx5fXLBpWhrnlkDcLdnQ/9lXv4JUJdXMzXaHd47T847dZHly2HPYFqwx/LGzS37my4+5GfbczImcE1dU/Cz80vAeb4cVb643XKzWNE3AOXDOMex3qMJq1eFSZoOQ+oYXh4GnVzdLK0XX8vRqzxuXZ0RraZvI+ZtvkHPisN8SAdQSTMvqGHC9HhiYxgMqQnCOcRqxtqHrHM5vkFpI4y1dXIKgvJ3Y5YprIm9dtuDhnefPOYserEFZVL1GW/nq5RlfujilDwFrLDUZnAu4KHz94SUiS9l7P8zLzNKm49V+5OVhYN4uTpSPYoNDmIaJ26oMGAYsPcK/ur3hTR94tOq5t+np+jUeMB5udwv/zpqGNu3pqYyrwMvbLdshUxVWrefFMPJgvSJ4S9e03H/0iFEm6n6CqNyOFeMd/ab5pFfqcwkbDGNNBOM4W3dchvWi/CVK0so2JU51xZe/cp9hGDhsD6Qh04SW++f3gMwHu2cEa0EMRWAk84EM/MjJCT9y/5I+BqxZjJEsBms7vvH2o6WCJJXdMNN4ePjwlO2zK76z3TO8TLTe8BP+kp7MPk28KMogwjNJvBEt/+ow88A43mxb7q1a1ps1zsPGWJ7fbCliWIcGN++5XytzZ3l+2PHOy0wWZdNGno4Db683GGPom8hbX3zEUCrDsAMUnSuuNlyE/hNeqc8xRJfKOrAoZyiYRWxiOyQkC7ppiD2AYkTQqRCK5eHJKakmvvXqJcECsiTqtmXi1/cHvnJ6wdceXbJZdfjgyHXCuZbgIn/2K19CaiWVwvOrW5z3nN875YNp5P2bK3ZTwhnDT1/c4xtfuM8wTrwYJ7ZD4d008IUY+aW04w0b+GK75uF6zenpmthWugrPr26pwEUfceMr+uKYO8cHhx2vXsyMpdK2kfff3fNjl2cE61l1ka/82GPG6njx4unS4uQV5zyb5nuLAz+1AX9jDDF86Nq4TNGXtJSBNYbF1Y/FZtg5Ry3CbSmUlCk1E3xgLoZN8KgqSQU1hsdtS9PZpcXHWpx1gFKLBS93w0hLr5hqYTdbtvNAkUSpwiiCScuLHGvhhWQEQ+sDZ20DtXIqho33BO9Qv2isJwTJhW0qZBWccYRqCVRKBpkXR2C5U8QoUlG/PE91kG3h5TjSZAcYnImLm2WdP9F1+lyj3vWRfdRO9ttQUaQKIga7CpQklKHwfDhg5CVN9KxDiwalM0sDYRElp8qXTk65v9mwiQ2Nd1i7lChNreAE73TpIAKsMdzuDlyNB6aUSKWQSlmkZpvFX2JbCrNWQvCsnEei8NhuuAyRvnV4LxCX+ZX9JFxtZ+ZaccGyMsqFscxZyFlIFbJCntPCXbt8n/FQNPHB/pZmmgHFEmhC4KhK95pwp3Cj1iyKUdbSdi0+OEpJ5DQiInijONdyc5gZdyMHa2GaaZsIxtM4CwbGWtnVzNsna+5tVgQbMWZJIjgWJRRqxbuIWoMxhSYVrsfMi/0LRilMIgx3bUUhelZVeL9k9rmAXVxRqfCVfsVFE1m3EecNJgg5RQ7jyIvDxJgFbxwXAU48d47AlYSSBXz5cBZrcX3GCIOM/NbVDas7nQLnI50PpOMMyWtBngvOWsQrY5lBLI3zNDEwFaHkSsmVe+f3uXavePlsy/Zqz04P1CnRegvF0lqLw1BQbkrly5s155sTGu8I1mIdGFsxYoHFQdTZRTK75MLVbuLZ+JzbNJGkUIHbJKQ5E13kkGZ2uSAYztuGUQtfaHrue8fpXUXUdZ5S4faQeXbIDFLxfmZdM/d8ZL5zdB1FmO7m47xfAiRBqVQOMvPt7Z7Nndmldw1NaD5SCjzi44f5HWfvh1o9xgiqS3ttVSGLYgNYUVJSns4jwiuksayNwxRD6x1WK1OtPEuZr51veHhvw6pdnOqXjg8LVXBAdBa5S2QFa3n/Zse3tjcMOUEBK3CTM03ToynzQZnZ5oyxjrdXa0opfKXdcD94zrsW3zlibCjJsRsnns2FMVfCfqYpI2/4jkOFOSljXeS/pWRiY7CLxz2lFm5n+I2bLe1+ifti6Oh9JJXPuEpPcA7vA9aGOzmmxW7dGYe9+8BZfDB4p+SpIqLMqlyPE5sozAiNVVpr8Bh2FFZ4Oh+wqkvLhlkiOmMtqvKR7rAqqBhyXdQmiq1klY+SvEMq3KSJcnfbzFVpjGUEwp1sbMXgMIhkskBwSww5F6FKJVTYeE+pmWzAGId37k73ehkyUlWKCLUY5qkw1+Xg72xY3FuPCgGvEXfRvsqSacCCubNm14UjBjhreuY6U+4Gy8Y883R7w6P1KYdacd7Q3c2UvJon1sGzahqCtcsQuln4Z4xFqWAFYxSryzB4Ysl0jXXhoNxxdzuOvHvYs60JawxOhc46bmqht55khBmlxVBTYiugxpON4TYn8li5aAKrriflxW3XR0djl3YPdRbnFzWoWguKYcyZmzQTMGxioLEfVtmO+LhhDXgXFsdnKUtlz1qMKioZ1YoxLL32UsnzMiw5S+X57sB9YNBKLMraOZwa9nPmIkTWocXjMGowGIxTnG+opeLV3nFcsAZKyezHzEAmqywXYANPx5GX48TNnCi6OECubMO2DJw0gVEzXixRA+OcGEWI1mJNINeJIU+4GokrTypKFsV5QxOXS8rGtIQQl2prqagsAeaLXHHAuQ94+Giu4YiPF/Vun6lVmNOiFnd20dDFQD4Uck7M80zrPE1ooSxmXWOpPLvdcr5ulgFrC723JBFezJkz7zm5q6irWQbJnQEXA7VmgjPLHofirZIQdlNmfzcLZVRxGLY18zJPZCofdhV2zvFiSpw4SxZIGKoxTHNdLjA4xFiGMjOlwojgCcAyBG6x9M7TOb/MDdqlNagWpaTKIU/sp8Vh/bJr6YBSj0p5rw3mbrPRD03afmdD/0efpvcOTUIuCsYw5cLTqx0P+padVoIuQX8VwwfzyL0mchqbJdl2909YC9Y6VPLi0aTg7OLwXbVyvR+YpNxZxRmi87wc97w7DmQKapd4cu09z9LMiQtUNYhxeOsY8kjeC94unLxNM9OY2KBsTnpyFRKCcZYOT7CWrgbAUqrg8hJ77MaZl3dn8EPf4zHk+r2dwZ/agN/5gHf+o/INqlhn8d7jrcUZA8bRxcWQSwxYuwRPc1U6KSSEUSvBLprP1kKWZcJeUMQtyhMsv55aZZFTlEV+KxUhayVXobJkmpq7Ic7bOXGdJ4z1iJpFGswaKkpjIKkSFLwYKoU5C7axBGspdpHwFARxliJLf5oPjiZEklgae9dNopVSFyLXqhQjOBZXXidQ6jHgf51Qfkd0z12Er7/9VQPcazquxsJkLK1zeGcZcmHI85L5VMH4iN79mUvBqty5VxqMsVhjMM6Rs1CX2yZFF6WnosohV5II3kFnHbUqLw8D7+xvccYSzaKy0zQW0UWmccrKFJS+gpbCYaqs+hXWL27VUguVSLKWcV5MjJrg6GJgTIK/OxyNLkPipRRqrexUabFEluFzPeqgvxYYY7B20WpW4U7CVxYBANVF1cYHvE5Qy2LOEpec5KLCk9nVitGKCwbLYjAzloIVg1IRswyTWQ82eHJZDGj0zmV6TJVSCqkKSe68R5xFgGfjwLu7A0YUawyqsHbL3omBQyl47+mrkktmyCOX/Yrg3PI7KlQLM5YpZwRLG5d2xyJKbyNYj9Wl4jnlxbNkMhAxzCoYKcxHaeLXgsVqcFEmk2JoguFss8YZuB0OzLUwpYTmGa+G6Cxt9CSUQyp04tmWJTgO1uGNIZhFYcUCUisVg2HpmffeU3JBZOF3lcJYClkWd+VSl/02WEMVy64W3p0PnJhmUcK/uySoKt4aDqXiq7AWKFNmnxL3+o5gLcEsTqbZGrZJsQhFlmxutMvMYFVDMQZ7dwHZTzOlFPZ1iSl6KlYzczny77VBl7NXP/w73B3Hyzov8b7hInr2pWCM0IelcjROmSl6brXgquJcg3eWaB2HVDG6qD9VY7DW4BCsc8x5RO5U8bJUxlqWKk8VUlkGx721NEZ5Me75zcOOy9gAZrGlvnusjbEMtbKqAgLTPPMyJ+5vOpy5SwZXoVrLQZVcKzOCc4bGeqoRIp4qBm8h18ohF0qubKXSa2BEsLqoSH0v+FQH/M4tjmlSLYalB9nj8B6MUQyOi65lmhMaDRZdLgLilk0DQ6rC4ITGWk6iZzdW2mEmRId1S1ZVdAnsSsmL3rpCEuE2ZYoTDA5nFw3XaBZN9ptcUFGSFlI1ODG0cTmIHJZqDEmExV7LcsgDzgS8s4vF+Id92x4qi1pB5z3eR4YS6RtDrYnGBOac2E0j6hzROpw6si6bsbHfm8PaEX9YfGjxd/f33zFEJHcX0Te6jrTbo8GzDoF10xJcwzQnchV2pSJB6L3nQWgYpbI7DPRNQ9M2cMcpNZYxZ3LJWMmMaebFfs+UEoekBOtYe0fvDTPCVZ5oFIZaONRCNJVgLE1w2HlRkspemP1ysd2VEYzFIJx6z0kHsWnIprDXZYYgBo93ULTSu0jF0AfPVDIvxwkVaEMkaiChWEmoHEvarwPyodubgtRFjg4yVRatuuAbold6KaQirPqIKYpWIZXKWAqlKqMqV5rpreOyiYwq7MaJNkAIDWoMWhxOhJyXdq5SM4eUeLqbKFVJuvg59NbSWUNW5VAKVmGuS7A0W6XxMyc+0BvLvlpShsFXRB2344hXxQW3qJXZxVMgKRyq4p2nCcv+PsyZaAJUoe0Ch6xcjROzEXrf0ODJFEpdJPGOeD1Qs1zgtCq+s6yahnGelvbEKkw5M26vsWpogqV2Dd5apjkz18pQ7xJb4jkLnjdWkVfTzH6ciM4RvEG8RU3FVWHMhXlOqBaGknl3NzGnTEWwCtFbol38GIZSMUWZtJBlaYNcZc+pt/Q+cqjjYtCUBHHw5LDH6zIMf+IifXSLRGPOTAawhujAWxZ3aizV/f/Z+9NnS68rvRP77bWHdzjDHfJmIgGCIFmsYlEqTXZ7+CLLER12dDj8XzvsCHd/sCVraJdUVVKRBJDI4Q5neIc9rO0P+wBkdbS6IZkpoqrvYiTJi0jc4Zz37mGt5/k9sO8cc1p5ezi3dF6xbNzAWhNa0m8Pos/1e69v+2xcLp7QlBffntMqDcH+k/2eL8uJU5cbiMA5qlhWmqn6QIUMe+f56TDylFaO08rYKbWGyx4sIIXznNCUUQrHGPnV04FzSSjgsQTTFCM1F04ZaoGnWIiloY/3zrOTjk3wPM3tojktCYzhr5+OGDJiLNcS2A0GkcKcV065ki7o7k5aoFsfOgyGTR845pWvno5oVUbxbOlZa0ZLaa/H96gf7IF/DO3w2/jSFVxFjOJCk0GoKgL87OYFD4cTv0kncsn0YrgZHKsaRlyL3a7K/ZpYUuYcM0WUnXQYya2TVSv3i/L6dmBdVpaUOeXM+5iYgF3wpJRxBfbW8dr3fIiFn4xbfnNeLptx5bQqd13PRpoG61wTa1V89WixUBxfrS2Zt8cSnLLJLbAkXyYH1lp+tLtBrMXZPet6ppwf8BF6WyjFUjsIVemwVP9s2v2Y1a6Rrdf13cJ+OXu1TpLjH/3sT+j7jl+HD+RcGIbAZ7sdx+OZvz++IJrM4zrzzbxwSJFoCn7j+enQY2gpuGtMHItytxn4cJ5Yp4XTsvDr+cxTjIQCSeCpCHe+4+fjhq/PK/+b28/45+/veciRQuX98cwfjVs2VninieM08z5V9tIR48wuw1/NE2st7JxjeFoZR8/N/gpMk04sqfLj/RUhBKxzxPVMWickwmh7ainYUuirYdcF/Gj/gO/Q392a54l1bgfupC2IyjtLcAFjAaN4W/mzqz/i6+ktp6cz65rZOMfn11sel8jddoNT5T4uvF1XzksBB9v5wM+Ha8QqMa88zAt6eOJmP/CYV6Zp4Wme+Q/ziVMqbH3HqitnhDsJ/Mj3vDke+EdX1/zVvDYkca2c58KrYUOKyjkljqtyjobN2DEvLRznV+cDUQsDlg7HfnTc7kfmWshZscnws5sbqJ6+h3WNpEXZqeVFt+N+WrE1Y6uy6Szd7nkN/NiltfJwPPJ/++f/mm9JxdYLw+C5KcLX5yfiMnGeIz2Gn19teJMW/uxqhy2Vh7jwm+ncPHDOEI4Hfnl7i4iSysLjKbHeP3F7u+WQE9O08mFe+IvpxKqJV37gSSNOhTvx/FQC/5955h+NN3ydVqbamhoPc+THPjDHyFKUU0w8ponrfmSeI9Um/n1ciFRGa3EKe4HX1xvOBeZUSBX+aLNjHAc6Z5nXRFwUmx0vwkC0QrUtbXpjHJvwvP59zGpeXfM7UtrSDv8GChVE+D/+6d/nX/z6V/ylPDGvha7r+Mn1jl8vT/yvNnvG4HkbZ34zTzykwmIK+8eeP3n5Ek9ljpFzTExvP3B3O3DKK6fzwpvjmX/x9MRE4dPQcSTjKtway4/7wL+eVv4Puzt+EyNnUVSVh9PCj8PA09PMsSSeUuEhKS/6HfenAy+18Nc5EStsjcVp5mboeHkz8rRkppgxYvnlq9fsNgOhg2XOmHu4Uc8+OO5txdWIzYa9C2yG7wcu+MEe+IF2dSqAti62CwJ4QLG2JUcezguZyAZLNYYgbRRTyNjLj5dVWbWwoPRi2v8WRZxhtw3swoCVhpV7sG0c5JzlIRVGoHOCFM8I7LGXz68c10RXBXexVawo05rouka+CGLpfMfOD3xTPoCzfOoa6UCpLERKhMdpoQKb0HBPIQQiDsbA6gwxRTifaS/GTIoJpWvR9Hn+L/2u/C+sfrfDf/nw8n+cc4RgeXP/Br+svAwDSQqDBDyebAsL0NECsA4ps5TKxlkep5VTv2JRhs7x8mrPJ86R1shkDH3weFN5kxZ2xREGz5wj1z7wsuuZaiHGzMPhRK+Ga3EUKnNJvI3texnFE7rAZjMyjgNv3kyUvuNPd1tETMOanSZiTHz9cCBbZRMsL4eRIQSU1u2d1sgc00UrLdhceConqhsQLPF/iL99rt9LlVTI0vw+epFNDf1LDIasmapK0cyXhzeYc+RGAnl0BGdxvskeizYT2qrKQpPkBOC4XoLf+sDY9Xy+2wEQy4LDsvcBh/I2R8YOnBXOq+HGOV44x5QTSuXhFPGiFykPZDV8Gc+8sj2d6xn6juvL83c6T9B5frq7wwLkNqKGzPvHI0Wg945u6AhWiFFZlsIpRuas1GrJuWBz4k2ZuHIttfKgyx/oHfpfZtV6ybsRg7fw5v6JZT0TVuXGWroLsGKHY42VrRRWrRxLJanS4TiuC4d1QmrPEDo+316DLcQUORWlQ9nZyohgpUl2LJYb77hxlsOyMs+FBxbEGgZjUAwLhbcpciOWQVq2w/V2w+1myyEfKZ3nF5stVhrWNabEuk68PUWSFEYn3HUj+3EgqrLmxJxXck0418zEuaw8xZl96CkVvlmfn7+PVVX1our+H+zBajBS8U7wwfDnv/k1Y4l80vWsrrDtPfux40YHIkpAOWnmQRMnKn0xTGVmjSvWVkJn+dHtBuo1UQtHXZGc6EtmxDCKbxANNdxaxytnOc8rD0vijZ7ABwZxl3Od4dfxzOu+5yYMDN3A7WbD7WbgkI/044b/Kgw4ceRSeDg/UcrKr+9PqBO2wfHJpuN6H1CFOSbOaeWsmYjFGth38GbOvPAdmcrXx+l7vZ4/2AN/wbbuqqktng8DuIvJtmkCN8EyTwfMCldeKI2tQy6FUypc9ZasStZm8tlax13vCDTKwKKFRTMb28y42ZgW+gL0xvAieIwV9p1nSi3oxhvDlDJXwIeY6Z3gnDSmMAGhkMiI8Yw+sO87rDXkYChW6a1HahtJBetY6kzNwqFGSi4MuWMwBrG0sK26Yl2mHyxafEtcLQsqwlohP/slP2r9RwdlImyHjs9f7FljIsXEq+0WLZlcG9XiaVlx24FjXJlrIQiMxvKTzY6N9bx7PHFYLbf7DV2/I5SCloI1BvEOEcsXg6B9ZTdYPqwTwQgdwof5zN3G8lfzmS2OK2eb8cgFnAG1lcE7brcjt/s94ixfDYpYGLsBZ1qS6fZq4LSeeD+d+TAvnIqjCx13RTlrQXLhsESSGq6GAYzhvka66qm5MtfIEp9Nkx+jVOtFT6+IvZCcxGCquaSLwk3oSacTzhbutr7pTIsy5cxhTdw6z1kTUBmkeTf+qBvYhJHHY2ReldutZdsrVpo/wBiDeMtoO76o7esOXniYI8FYxMB9OvKpD7xdZ0YXGEzbiLoO1qqsWhmd4XYMvLpu6axuMGAKve2QalALt11HjCsP5xMP64pLGTHCVQenvOBNy4soBQbvKZqIZHbeQ1VOKZLys6Tn49ZlwnkpvYw4R+/4bL+h+srG9fhL2m6uMJsmZdy7ygfNLKbirRCM4Y/Hnk3wvDvOPIbMi11l3AygihaLOKEzAeccf2Q8Fdr6d450YvEGvtYjd53jzbpy1XuCbc/lXjxnMpnK4Cx324HPbrYtx8dVxIAPFmsEl5VhEKZqOS9n7tfEyRu897xQ5bRGMJXHKbFE6KXHUGh8FEvOldk0n8FzfZyqtXLRXF8kPL9z+DeGbRf46c0VKWdcVn58PVKqUkxlMSuLVbwT3iwL51TosPQC//B6SwD+8vGRYe34ZL/lqt+CXNQj1dCFnhc7x5+5DutgM4y8myY6A1aVvz4vfNEFvoyROyt0YhEx3IyBU6rMubAfPZ9c9fzoaod1gnuyWGcZ+mbKLbnSuSvmdeZ8nLhfIyuVXT80eWVO5FL4sK6cSiYESzDKKRZcbdLbc60s/C2n9FAvjBsRDL+rmc7YS6qYptKmALZgK9gKi1ZOmllzwTcnD2JaiIupldE4vBGsM6CV0xIpGK58T60ttj3lTMyFpWasenoJDF0jYlQMVEunFecKQ3DtgJcKqyobbxldU/JbmlxDbKUXcKZhQK2Ri+GkEpyn1kpfMqKVOSXM8REVITqP5oLRRBd8Q0BKBQKaIpoSz5Cej1dV6yV46284dQEubHDLEAxLXjFeGToP2rpX98uRY1z5lIGqcIWwtQGLMlLpazOt5Vl5r2fWpHyxuaaUwjknznFlTplTLHixfOb29P4aqE2zJwADQ1fYOk8uheMaOafMXejZ779lQ1em6YxYobcOZy1iDU4MplrUOqqpTDExxkTNldO08FX+wKEqMSeqVgYXGLuRSmWTI75UqjGkC8buuX7/VU2bDOWcvjuoaNU2zq7ayCZSyWR8MGxroETlSVce48xhWXkxOjqtWIStuGYmqwZbFJeVrIkP9cyiyo+2QzNlzytTjqwlMaWKd/By2NJvh4YLqE1iabMShsJgGxrznGJrhoSO3XYErZRSeHg8ItIuqgaDsw0FWtQgVajOEYLDx0RZC6c681V64ECkVG3+KBsYuh5VYZMv0yYRUlXSs4fko1Q7XLUJZ7Mr1e+0wj4YxsGx2wQQQ99bfPbE1XBMiadl5XFduLUjaGFbhYF24Ogq+GzI2rJG3umJmJUvNiOlwDklTmtkSYW5FIKBH7k9wy5ghHYgu0gqn3Ji23myVo6xkXy2PnC7Gy9oY+XheMRay840sp13bfquVlAqvbcMOeLXlVIyRzPzdb7nfSksuWC1MDjPthuhCoVCXprpM2nzHTzXR6oLn/o70+63vGoDPgjbjWe/cWQKtS8MnQOtPKXIN8vEu2Xhpt82OXa1jBisgc0Fue0SzCXxZT6xrvCzmx2lFE4p8rgsnGLzovQYPveB/XWjRuaiYB02Ke9z4qp35KIcYuIpRfbdwN2uw4rFFOXh6YB1livxOGtx1uCswVrBqUMMjHPE5si6JO454wvMKA8xolUZrGPfdw1iUJRdMthCy8T4nnvwD/bAX2tpUMSWck2t7RcdClYMBiXGFVcrzkEn0jrnWRHNDM6gWtm4FrGNgl5MFWLBG0ME1lhYy0o/tJdiLoUpJdacSShOGwJudA4EcjU4Y1lyZLCWag2nlImqLKrspGfT9WRVUkycY8bZigVyrdSG0cdcjJrOemLJdKUZjeeYiOVAMZUUNnRKw4r69vWdVKqx5Au5QuQH+xb+7a9auZysf/vxpcbg2XS+MYHJ9KNlGDtEDdEoZjmy8RYtmZ0I1yFA1TaipCKqbMVwLsr5vHJeE9e16fCe4sKH5cxpTWRgtA6pIzf9HjVNzz12PXNcuR4hUnlYZpbUuvKfeseL7Y45R+Z5YZlmOm+xxbLmStKCE9PIQHIxf1rHaGw75M0zX88rH0qiADe+Y7Tdd5kVG+sxJlOsUOrzYetjlVihlra5VC0goFoouWBF8QaQjJELE196qm1oYrtMjLaxm2+s4ETQ2qaf1Eopib4alqKc58IpJa4u09PTPPNhWS5GNcMYDE437IYOjFCqYeg9x2lh5wyLKuu6sqaWU/KJD7y8GpjWzOk0czyu9MHjMKypTVzFGbACGYy1iFhcNZSknMvKMicepVCBWx/oB4+IQcSxDZ5jVqxt9Oz43OH/OPWdYRK+QyJeQGVj59mNgT44NGeMhbH3dGIpBuyyMFxITFtj2VrTsNPlknOTKj2t6XHKhWPM3F6OI4cl8m6eOacEBjoBoztuhr6FTquyDx1TjFybwILysCYWlLMp3PmR11cbzjlzPM0cD2c2wRFoUISrS8ihkRYGJl7oFkPQylIK57rwZs28rY3ScmMto7W0IZswess6m9YNpmX6PNdHqvqdZ7d9+C2Hk8pm8Oy3gS60fy6DoR86XBXWGco8E6iklNmLNGOu1pY4khvwZIPhGJVDWjivmReu7fcP68JX05ljjFgrdLkReF7sRoxYsla248j5cOJKlKVmPkwL56IccubVNvDFiyvmNfNwmHl4OrEJjl4sSyrkUvG27b9iDNZ5emfxFZaceSxn1rRyAo65cBM8m94RjAVj6SQStF0Y1OjfOKb8T9XfmtNiU6I2fJeXxhxPtWCtpcdyve1xImxipDu1p+NX54WbMLCzginKHHMzeohiVahVUFqnKV9uSLlkVJtDf8BgreJqQqRxg60RsO3AHazlfZp5WjJrrjgrSFFMhVwzS41kzQwIK3COC+6SsnthkTXOulZSudAQasZpZnKZ0VxhpGIMWG0/v9SELytGKja0YJ3n+i9Yl/Xmehy4HQaswuAc+13HfjvijODPBpcjbHf89w/3/Ol+ZGsttShpLsT2Kci14kzDbKoJPK0nAKZ5JsZMVRiCowfQFTEJ5zzB9Gi1THHFWsvbpyfenM9MKbNzro2vjcGaliMxx0TvYF2VczoTnENooV6dGGJ1ZC0NC1YSlYqzHR/WlZdhQy++yYT0EvJm24XVWktXhZ17PnB9jLLWMnQdWgrzkoi5ULKiOTN2rZkRBNQEevHsdj2iFhscpmbqtvKX9498vt0yOksqmWlpdDMApWAqBCNY4zjl9v6WFDEl42l4wwGLU0WoiDVNDlEDD7oQMLw5nXmYY0NpBkcIHpMVa5RqCkkLfbEoyoc5EYJnUzvE0A6IYliyMpfEnFMzJ9vKU1JehY7e9VhrUY3fvS7FtWCk3ljQ/g/2Hv2drgqXdhug3805K3A99LzajPTGUNeVtCgvNy8JG8t2XnAV2MK/ub/n1RgYrW+X11iJl89aVDFV8VYwNnC84FWXNZJTxtRKb4WiSokrMvRYCY3T7yoPcaWzwm+OJ96eZ3JSrvueEARj2kQ+FmWKkY1RJoR5yWy9x+plIa+O4i7o2ZpZNJOKUGy7nN72HXvn8WK/OyNYlFSht4aNFTDPSc8fqyq03JFvP/idutn13F2NONcCKHd9z+3+ht5ZxnPApgLbLf/y/Qc+HQcGMY04llp3X2n+TqvN2ylWeJiaJ/LhPDPFBBW2zrLGTFpWdOMJ3mJdwNfKgzkRvOff3j/y1WFiScrN2DPalt9Qa2XRxCGt9FbJseVEDK5D8BhjcK6SLgf2otqeQWkN6YcVXvcbXgRLb4S4NumOqbAa2HvL3nq+c9L/z9QP97QooXH1v7vi0TQ7FTRFfFX2BEYLtlhyNC1tTQzOtbHzZ13gqvN4qSypcF4UYy22CPmS3ts5g+0twTqgcrXYxvw1zcW/YpnLyjoXhjDSeYshsXHtpbvC4Zxhtt9+k4HTeWHRlfWidqzaUF7WNTPwt3pcKhQSvTXcG2XSQlcsN9bjLHR6xiI48VgXoFZinCkixFQxKt8Zk5/rI1X9G3YhzOWt2wbPi2HLXTdwMwaCG0hrBaeIMTjXQtP+aOy4HXdYazguC2+eFowYNgiRjLGBMXRsdh3fXtJLjpxyolblhXOotI3r3eHEbrNlO7bNc7exQOBH/RZfDY85sg3twH94PJA0MaeFo4nUGTbiOcZEh2ewA6CUvLDm1oGdTOEhJ7wKn1jHYD0Gg/eOIXjGb59bAmXreZxPrCleMJHP9fuuXArOWjrvyTESU4ZSKLXx6F11bHXADpYS4XzM9K62FirtUvnH25HbocdL5XEpfDNlnFFGuWx6xhF8x831BpG2mXRdj9QKmhmspVg4lsSHh8hu2LAbNijK3ThiTOJnux07N3OIiV0Y6azj3eOJWDKnnDjVwmOceR0GdlbZBdh0Le9knVYWIkEq51p4qonBel6NGw7TDBiC84zeE6T9XBPwYrPjaZ445Ugtz5SUj11/I+1U4GrjuRs6durpHNi1Z6lAUAyG7rIv/Xzbc9U7Omc5LoVfP52wzrAXKGqIpeKM5W7o6Lr272wnx4HUtPsmULqMGnh7PLAfRnbDiAKbC/v8c18InXCwTc44iufd2zOxZKa0MGnkm6jchoDF0ltPsIFalRhn1gK9Fc5VeZ8zY7W8CjsOdoVk8K4FcQ2X9S/ScXVleZxmliXzPeXTz/WfUQa+DSS6DNjrd8/i7Rh4vem5cj03FgJXpDljQwtnG52FWvmHu4G7jaMzloep8FePJ4q1vBRDApYCNgRebEfGrhG/rqaVJzKFzDVw7CylKF/fP3G9r9xsPLVYXo4jGPh5f01fLIcUed3v2NmeN18/fSfxWUrBVsfeKhQleMMw2paXc5qpNAz9sSrvijKK41UYOOQVVcXUnsFZxtBw81Pp+dRavllmTuuKfM8t+Ad9WtRvk04BtGJFWZaFapt+q+8tN8G3KGQgZsjJNwe+ZvZje4MzSqqVJQtdw0NgY2E2ULRypZYubHiIESPKxgmb2pIB98DG7am2JUHO5xk1iSEEMIFN3xGKMqTEUhaKzpzxjK7H1cxSEuBxLtAX5c18Qk2lMwZTCgdgFEup5XLgU5yd2ZSA4qjWMotjvuxp68EjTFTJLRxsfl5tPmpdZDztvw03m0D1St8L/Wi5frHns6tN66gX0JypCD5sOJaZ63HP1/Pc+Eop8SZHrlxgumxo5zyhaeUlWz4bB94sJ0Kp3HU91xU0F/YOvB3orSUvK+/OE6sqV9d7BmfZ3Fyx3295WhbuDyfKNDPZge04cC0Ws1hUDdZZdgb+zTe/oRjDYD1SMgcKWz+Q9bdJ1tvNyB9vBmy2xFz58rRiXGUbAjkXii2XLuuAs/U//vo91392ySVx2Xvh5uaGbgg4Z3k6T+xdT6eWwQovX95iY0SLtktBrnTdSKaAs7xZV3IxTGtlUmHvLRMQaehgE5X1AHej4+G4YkzhtnNU45lzkwRdjSNZLUULD6cDx6S8HEdCJ9xsd4Ruw25eSUvkME2AcNVtcTbDGhmta/AFo/y/37xDL1hEUTiQuZLx4kcSqgq9DfzJrpGillL5zdNM0cw4dIgzxDVyLJliKu75xPVRKjhH8K0BtpaMAXYvPGKFYQyE4NkPI59vRyBhjeccF6ZlYaJN08chcFJ4mJXHJfOWwpU4VoVVMqeqGK3keeVHwJvjiSDweujRCnPO7DHsxi2YwhoTX57umbXwarcliGd7fc31dsvTvDCdFw7HCS3Kfjuwtw4jCTc0ml6cI//tN1+39U8E0cSxwE3fkZWWMq2WvvP8HA84oma+PE9ELbgijGPXQpkA4xzP183/UtXE/DefjFSrhCEQXMfL3Zafv3qBJWIILMvKtFRWPIXIOG759RqJMXGYE29U2Xh4AyyqzFS8ZuyjYbze8avjhNTMF8PQkm3zwktnuLnpKdWhsfDV6S2P68qPb27pwsAXLzbcXd3yNM8czgfu1wlXCrfdwOA8hxzpvKcDSkz8P/76S1apBGtwRTnlwifDhlIqPYYe4db17MYNHjinwn9YI1Wa0dyHEbWWbJr51/3H8SJ/o37QB/42ctMWHQ8UzSzLjHhDEY8miwm0cbM0I24vQhc8UgLvjg9gKl4MUg3Ft8uDiAGBvgpgqNVSKjgHsTZzbWcMvgo5ZRKJnGvT0lbw4rHFAspkKnNaKTkSrCGKXMaC7cXtTaPpuKJ8KCurZkxp91TrYQSsFnytZK1kmnxnCUpipWOD1Hab9KXSAuwr03xgzZGYnje7j1Wm0LoLpoK0sXbnPbhG01nXSEoJzUpnFbFtTLcZha4L3OSOv/rqawRwpkmzbqxHMRhxBMAbB9Zga0vU3VrHSWc68ezFk51Q8gIGppiIpZnXg5f2JBTl/bJynFdSTGytpfjKkyZKVKQqvlrmAhRtHYGccEYwVVEqL31PoflglktStS2W2Spv1wmn0gxGGFbfaBu9WN6fHjnFRNAf+DLyt7kMeOew1iGiQCZcEr1XMokmRxBVjAjOOzYi9F0zcv/7r+8x0v7d3lWugmXBNGkkwo0YRARXK7Vaxs5yyi2ocHSW3hqWtTEgznEllpYELZc/JRrepZnjulJz4bYLSBUel4KsCWNgsJaUCtbAN8vMlDOCQdRgpfKJ7xEjqGupukql0DxRjynhradJcBsFxhTDYCoPMRNrwVr/h36X/k6WFcFYARTNBYphawOlb8CJVLT54LTisVjbzNV3G8tVv6Go8u++/Kbtt1XxtbChSRU20lCHG7k8i7WQS2GUylMubINj2zk665jXjMEwL8qc29cMzkCtZM3cn5vBck2tmeJEeHecMPOKd5bBWpalMFP5Jq2ccsFcJBwdwitrqaVJK7NTtCoxFRYxHPOpTecNTc4Wmhdm4x1v58whJbrvKad4rv/0MrQk+lr1u2v9zjuyVwyFnCKlFJacGUQJQemHwJ13XO23lFL413/x14g0ZHvvK2Om+Sil+TEGwJr2vs4xoTVxLpnbrmfvPEyZJbcgwA9zk+3Uaui8b/JCzbw9nXk/n1nSyrW0dfMYFTRhrbAJnjlmFuA3aeWYtdHQrCAOXrqASTBIINeW6psizJL5Kq/4LM3D5MBejveDCr9eV6aSuPHfbw38we7U5lsS2HdRay2+3XsLplCKUoqSS8GLoNKMuca0TcTSDvMtkbfijGHbWVJRqmm8aKiICEYstXlwkNLClqxx9HKh9mgzo5VSL0i8FtUMMF9YvaYq1nlGZ5HMRQrSnAeuXj7OBYpSKhQDUgx7MTjTEnwRQauQSiKtglrAFqrJZGMat1WUmh296QjOMNVnQsDHq3ZIr22uCLRnZNt3OGNIMZOXJrXYuHDByDasYfCCNRWMwWjTIXoM14PnnJTimkGxKUnbf4oqzhjMhWbirbARw1Q8a27GylwMBksxymlu/OfHeWVKLa5+43s2Q08tSiktuN47S1T9jq5XFRYKsSrWN9OQM4BYqvUkqeQcSRUWLXQozetZCV0gpgXrPHtxjL1Dy/OG93GqGR1VKzmuUA3BGYbO4bw0Y38tpFjpfMsHQUEwWOsRA/ZCKtGSkVq5HjyPuaAKFkEvCaPibPtn0pLCqU2rfxss97lwXAvHdSUp1NqgCePc9K7nVIilwQ1KhW3Xg8nfJWMaaRHy9QJVq6USa6UodJ3FVYHaxtjGGVJtfPSIIV9+hqLaghWtY8krnbVtM7Z9S1d/rt97VSqq9aJFpm3KtnLdeayBNWdiziwxEroOIxVRcCJ4a8mlXHp19bugzJvec6yVbJRefEMQG4NoJebCWto6ZRF6Y9k4CzlxWhOHJTYWumvepHeH5nk61UpUxRkIzjKEbyl4zadUDcTY9m9q+15SgVwqO+8ZKziUrWnJv7kqU8okb8nUZiavlWwK18GxxsTGwpVz9CLI84DzI9blYKbtT6VSC9zsAt5ASomYMsuyMmx6oOFZnW2y2pILqSiWljsDhuvgWS6y7cFZTBUshmCElAvkdta0xtCJ8LLrOEbD4xz5sERqBSeWrPCrD48AvF8TUTPBgvWefRdwOEwVjLQp5BwzpbZzaimVVBvAYOf8Rbqe2YqlMx3UQkmJ4iDXBqTJF2DDXjzzPBMq3FrhNgyM7m/5gf+33FXTyADGIE7o+0BNa4vEroWiluqEKpe/V2uzGZlGuVhVoVSstBGlpZJo5g01tPAG27wCwbTbpMViTbulZVoXaSkKVdqmpomL3JBYEkkVawzGGDbW462wloiWCgUspnl0FYy2hbTKRWorBgdUaYe8qlwwhxYXBKkr1IqphWp7EEh4tr6nMw5bn0M/PlZVqe25+p3wraiZMQyXAJZMTgmtBmO7Zi76nQuqMdA5yzJHkirGgOsaGiw6w5qVXCtWDMFaqO3A3xmPNe0gPjpLtsoxrUwpY7E40zwpq7Rh8nzpvHrnECtshh5XK/PaGOWpKM7ny6RB2jhaKwbDaC2VNgWoRhriU7WhRqvHI4hUSsmkVKgpMS8LzhWuQk8XOqb8PGX6GGWNR8SSNLKkFYtnTitXg8NbAQOpVioGYy2U37n8X2gqwQnHNZJSxnKh+VDJxTRJoIFqheActSpODJ0RTDVobXSyk3XcTwtzilgjWNPyTaI0k2/MhayAbTkpYxcYfGBODY+85tIwyKVtqmd+m5QuxlEUvFEEoZM27VpSRrxnsBZj2u9KzBl8ZU2RqTi23cDQD6zPbOKPUjmXSxJ9W7uMwKqFV7YHKmtOrClRgsdaB5KpprbsHC7YQ2tYNFNKE+j2nVAWJTmLN5ZC69zaKpRcoLasG9ug3IxWWKzl7TRxjpnRW3qxHGPBXQL/TgIqwsZ7gndse0sQx1q4XCIynWukK3fxIOdyabZ4S1oKAYOz0ppqVZlzxosQvMOokHJmrspVB0tOnFF2vuOlC8Tn9e/j1eUu/7vAqGnNfOaHNnEuhSUnirYJuzGgNVOrUml7nXPCUhIxK6rQW4utMDvT8Ky1KUA6K6CV3lxacNqojvsQqKXy6+OJY0kM1tFXw6kkzEVS/VC05Ue4QBcC+6Fj4x0JJZbMHFe8d0gCTyNIJlWMGIIPlHnBmUowjkFaB3/JETGBTjxiGqJ21kSxyrzOWIGbMLAfR8r3XAJ/sAf+dthqxq6qBhsU5z1OMrk2vFIWqN59Z4K1RvGmbYBRFGctS8wNf6lQSmFrLd5aqsmXjioMriKa2DvHgifXy2RAGpZxKqnxq43BCqwZ+hAwwEkbB1tp1BKPQwL42rEsiTkXiggdYIKhxNYB6UTQ1MzV9TsagkGrsubKphO8FGpecRoJxlCGnk4HJh9QVSoNLfVcH6f+x3wwpxSpWNRABqKCcwPVO2pMv+OWzy1/ofM8HM9krRhrqAWug2PrAodkWEzBecsuBKoqVz4gatomaAQVT5GFhzhhimProHOQirAbGp3kUBPTWi887A4RYQiBru85nlfW04JIm3lFeyalSieOq9ARuoEQI7UREslAwTDlwis7UKy0GJuq+KLYZUUyLKXQewsSfkvvea7fa3V9wHkLsbLkBW/gaZ648luMbWNuVcX1nopAzU0+YQxVFZvBe8d0XEgKYirzsnIVAsPoSLkgClYse2eZ88JV1+F0ZVVDqcKslbkUPswLRuG2C+y8MBVhs2kHv4fpzGnNBGPYDQERxfoe5z06L5xiJouwkUaqIrcQxGsXCGHA5RVbK7MWFlMpplCzcNtBZyxzKuSsdNVAKpAsZ5PofTNtan3u8H+MWlNEVC7NNoMITGshAaEqqSSWFHHhBmM7as1tz64tNA4p9IPn8RSbDMwAtbCxhq7boBVOJVIUnDgGKbwYB94vC6AkU0imUkrlN8sBbxydOLQWYlFeb9r7v6TMsTbcsbMCOMbR0RXhMEemNNFZS/FQSpugbkS46jyfbAeW+QRYUqUd0KqStDCkgO88uSrUii3tolpy4V1RXrsR7zvSJQX7uT5C1XppeP72yH9cI7kYim8M+qlmXNdhbIfWM2pSQ/U3kjG7XcfTY/wuryNT2Vu4GjdINZxiJNeCGI8Tw2fbwNfnFbKitvH2ZzJ/eTrjxWBCmzrmJfOT/QYqrPPKQTMzlX0Y8VLZbEeqyTxMC8eYCZ0HEmlVVGAQx13X8cV2w9Mx41ylaiWJsprWzH4tnqRKlta4JlVKUFIxvC+Zfgzgeub5+zV+f7AH/lIKtWRqbU7pzlmEiKMSQsCp0CPESzCCXg5aQhu3FBWud1uc6ShkxCiCIRdLtIVu7FnmzLJk4qK83ndc77c8nSdyVpJW3s+FctFmW/RCIxFejFuwLQHwbgi8QhFpusY1J4hNp12AJJlFI70MBDw3weNN63QZD2A4rCtGChVDMhCtwhopBPg2P9gUxnmB+I4fbz3VbpjUcyrPB/6PVVLbFPt3UNT8+PUVL24Htrah5py3zNMj1u3IcSaXgph203dFeX11Q6+GJbVP0JFYSiFay+Z2T57OnJaZJSX+6OUdL19e0z0+oaUQs/LueESwDHaHDSAK1QhXu55yIQr8qHvBj6XlTbhaOa0RiREIFCCaxHFd6cKWK7vlxWZLZyudNY3NHwIP83TBMxoWqUxx5e0KvesRY1vys4EFOBf4xfWGTSesaeHp6fyHeHv+zlc/7HDSZIRmFOxg2BZLJ9ImhaWSKUznmWJhTjM5FyyWjfRQDK+ub+lMYM2ZSsXWzDSvxAIyjqTzwsPxzNN55p98cceL2yse3j+StRBr4c3xjDWWz7ZXBGfIRckVPtl57NhCan4WRn5xwWTmbFnXFeqMWkvSdimZ15XNMHItI/sROmMYncF7OGB5OrasiMFYzgXOJZFXGIcO04G3Dp8uISbAF/st225gKZmHp+Mf9o36O1oX5Dff7qxVlU/3PbddTzCGDoPJhuPxhDMwp4UlF4yp7C65H599csVN3zHHQqXiTeH9aaY4CNsOPSpPp4lzzfyTT2744u6GzYdHcinEUvnmGMkIN37LxltiVo5J+fEwsru7Ajr+HglnKg6wtXKOqU0LCJSsLFk5aKYDbsOWz8eOQYTegEd5tx15czozWosX0xofVjgE2BeLwzJ66FzFZmHSyi/6gSsrLOvMN8fn9e9jldIw59U0VYQRwxcvd7zcjAzO0juLU8vxGOnckfN8Zo0ZZ4SrvkOs8NNPbrjpes6xNAxnzjzMZ6oTum3P41Ph/dPCQQv/ux/d8dndLfsPJ2pJxJz51WFFVfhkHNhJYC3KUuFHNzu2dzegln8iSmda957qOccTxJlkA6cIT2vkXDNuXnnhd/xsF+is4IE+FmTneXOc6W0FEarxFAvvSCACWDofGI3gSqOe/SL0vKCwnJ/41YfD93o9f7gH/nUl1UK1Bryl1sBxOlFKu217Y7jyjpf2mnHjmOYFrZWGgvBYScwR1rKw5EStMDjhygeOMXKYF0wVPLad6LJwWiI1GdyFOGzIjPQMncUYmObEurZR4LomjvHMVTeycR4H5KwcV2UqM843du/WDoxG6bpAAA7rypIyqWa2AYTA6CznqlQMvbWEbOhsx1wilRYS1tuAGss4DixiWwhSrYg+j7M/VinfyrCaybvaytt5Jr9Tttay8Y5Xux1/+vmnjF3HMa3tYinfmsED98cPPJ4nDrkZGF/awHbs+fBw4NfzRLWG4C1Ku+TOxxVtOotGpqLQdZZPxj3OGM7LypwLVoTDITLPB17d3bALHoshpsjTeWYuhcEPzZzuA6P0bLuO/Tjw/nzmKa2YUriyMLhGs5hjxopw6xy+dDgsJ5cbAs8Jr2xH1crL/RbfbVlLZE4LxTz7SD5WFVVSycxlZSiNR/Mhrnix9GKgy3TdC7YOqiaKabp/BGoUjsczH84HnpbGlL4LFmcrD3Pkw+kEpsl4sigP54Wu862xoe1yOQJdMOzGHcYYjsvMmjMiHe8eDkzzzKfXe7xrMIFaVx7OR44Kmy7gjbDtPPuhjdu73vPhNHO/Jh6isvUOb6EL7oJoFG5CoC8GUzxxaVrs3sGmN+Rk+MndNc5Z5pqZNJOeG/wfpQymJYUaWsIz8CEvpIPSYRmNcLfJ/PL1C643lnJojS+xgrMOm4X3D5F5mjjGRKmVUaDLhq/micfjiZawU6lVWZbIw/FEPie0ajvskemt8MluQ+8sT8vKKSaqd/zm8cjT9Iaf31xzPQyICOsSeT8tTEXZdh4xhk1nGPktK/+YM4+xQC5sULbWsRfLuRSCCbwII1tVegvvdKUAI8INHc5U/t6LWwbXU3MippVinrHEH63qJXT1O04efHOaKKr0wbLpLZ+VLf/4Jz/jauxJecVIk66KFSjKl+8i63rmsCRSUUZRumz486/f8422cD8HeBHunyI7N1POS7t0UvEkOoEX3TVDEO7XlWNMGDF8+f6Bx2nll69uGce+ySzjxPvzxAqMfqRq4bYX7kzPegn2epxXvsmFapQ7aX69XXBMKRPU8sp3FGDjAn81n0lVuXWeT4cNU1r4r370KbfdhmmZmdalZTJ9j/rBHvjXWLDe4q0j+B5roYhQS2G0QsCAKsPg2pj4UkohaUWaJY21KIfUOvNBHL85J8Q57oKjqkG16esziYqliqK1ohW8GLpg6I1v5jELzhVKrZSyMhhPzpFjKThp8fD5ki74rRnTGUO1luXCijZYBt90PG/jwgvbNGC9cUALA1uNEvxvdWu5Vh65TDzUY3LhahzaeMk86wc/VpkmLqWab99PpcRCdpnb3Y6rLmAFxmGAmkErRg1aC0spuGqx1TGXyodpQcSw3QXeHE5YZ/n51S1FI0kjgqGsmborIIZSmh+gt5bedXjX9NHGNUxPUSXnlSF44hp5yi09t794d3IuZFMIztGLw1hlSfPlJ8tsXEuI/GqZ+LELiHeXLVHaFiwRW+HukjBdMUwGVio+ZZ7KwjZ4Oj/QuecD/8coVUVsGzOZnFkWZdw5Ylq59S1jxAXDLlioiZxb5LoxrfPvFJwxrKo8phWDYddvOS2Jcej4ZdiyritLXJtxm9ZMMrQQQCoEe6GeOdfCjFxboxIZL4W7TSCXyOO54KzQe0O1Di1NStloKO1EHmNbq4KADxZV4ZsY+SR4xHs20gzvbSpV2Xno/KXFbAwrhkjBp6bH3XjL4Dy9e5ZUfIyqwMVC18IoxYA2w+3rYWBrHSKV7XakaiRFSBlEKpoblamTyDcx8fW8oBU+63o+lMS+7/h8O3A8n3k6TYiBGEG0UkW+s6P0YuhCCxIsl7AsK82gvp4WXFLWaeWxNHmro3kNcixo8VixzbckSkrtk2oqBC1gCt/kgrMObJPd+otSIJbEoD03YpqPUCBaWKuyy8qxRnbWELzDm2cw58eq+i1p4ts5u7a1KVH44nrHzRDwxrDbd1RV0tqM5NkY1CqdMXSm8OW88JvzDApfDANfl8SmG/hjqeSU22RU5OIrasm1RU3bg53gbcA5D0axCFaFeYk8zhGTMtPpDDmDGKwqKRdWFWxNeGmqE8GRTFurrBe2UkHh61r5nAZM6J3FWaFSmVNkcI6XruGJrTUcXGW1wpALj7ISgFCFkv6WYzmXkgjVEnCIgVIiqep3HW1vYeuETiCmCDXjEGqFNScscEgr1jp2XhAM3nqsGrwInWlGXzXNrCNUcq0YI22EKUIXHLkIx9q+nrVC1zUtohiD1cboLbVCVaQoRYWVgtc2OagihOCxMpBLpmijV1TTwsrfxwVjhME6hNq6ebXQKRTsBVdULw+iEJxFMGgulKrU+rzZfaxqnKWG5TTSiDtxzUQr5FIITrgeA0Eq6zxjyDgBLZVlTWQj3J8nOut52Y8YY+h8R9CKxTJaT6GSTcWJ4IwQ10xRoWIQcQz9wBQLmZnBdRjTnktv2uTLi71MFABV1qVQSuEQF6zxWFqnY+gDxUFKmSCFbxdRVyy/PjXaxY3rsGJZqjLbxumnXugIpknWxFmC6wBBSyZrQevzpfNjVNHW1xLr2OxGEo1UQ22Grq2HW983E/e6ILUQrFBKZV7bZvB+SnTW82roMcDgPKoNX9wb01Bv1mG/9XisiUq7DDbMYs8UK6suDEHw1iHicAK1ZLyYdkGsBgosKVEUzmskGEG8wYllDB7nPDln1FSqVVQrQ8l8NS8EJ9w6jzOGWZVF4MZfNGy0pkesirGGwblGVrugHO3/qNvmuf7/rUprLGBqOynYCy0pV0qFzgu3o2PwQjyvOFOwXigFpmklOMu7aUKqcGUcRmDrHYqhw9IrxCqM4vBSqakQ14LYtq45Kta3rmdKleAghI6uE6xRNDvo7SUMs61th3VlFeEpRrxYsA2KMIbA4AIxR1KBqhaDshD5Oq6kUnjhe5zzxFpZTOHKfJtIDrkWVi3t+7qgRFPOrDljvq9j8rn+k6tCa/Gbb0MvKylpU0mUTOc7Xm07ghjW6YinYC0kVU7niDrL19MJVy03Er57BouAV0swynp5DjsnmFxY1kQVwTrBGgj03M8LG1ubaqPvcCLEdWXjLaN3zSNSazsfLJlolA+xBSSOVvAiDMERhg05F/TiIUWVZU18ta7kWrkLHc62nIozlW1tUBkxQqrKlBLeC04M3lRSzqScCeZv+YG/XBbzrAVXI7ksaC1oUdYCW+O46Sy+KosW5KLhywo5FRThcV24DQPbYBCak39LI1sU1cvI0jT9vbaN0tNGmCIG44U4F84xcRUs1laMtIO6XCgqrf1ZL+zeduDPlxFlqQ0j5a1lCB0pCkucSKrU2jRf7zRjkJYjUCtryUQqazFU4/C2Yo3iasWLYxNCO9ilzFryd6maz/X7LzXN6GikYmzrNaSYmY3h4TRxNwZe7/aIRkpaEGmkkZoKaVoo1vLufOSz7Z69byZvEYsJleNcWDUhpiLm8muoyro0uYSIxVqhmsCynHg6nHkxgvO2LXy14m3DwmFtE6CVwnnO5KKsOZNdIZIoaui9pR9GRFcmk0nfUjOq5VfrhDHCKD3eVCZNZDFY79HaOnvWNFJUZy3bfoMphaflxJwj5vnA9VGq+dXa+9APjlQKx+MTFssxRjZOuXE9tRZSjDgRrEhbQ5aIYnh7nvhsu2HvXSOYGYsPhlPOnOuKUUWMUJBGNFkyVgJiAWmNjXVaiOuM1J6+898lmYtpBmEvjlohp8x5ziSplFzIqZCqQW2l945+8JRkWEomNUIeg7G8KQtdVbauQzGs2qZcYh21JpwIaCGVQtd5dl1HpXKYV2JK2Pp84PoYVWlSHiNgvMF4Q9KKjcphjbwaHT/ed1gyJWc63+Rk81JYpoXqhK/PC6/dhlddm7j3YrHWcs6F47S2Pdc6rFGWGJmnwDCG1sQwgjfCw3okpsKVNBll8IFaE9uhXRCNaetUyoWn8wp9YM6ZOUVqKTix9KFj3/dMprLkRqky1bK3yrt5pRh4eaENzakl+1rrKBS8NL+MxkTohDEEBMfTsrLEiH/eg/+LlIhQUVIqzAt8OM683nV8fnODlEJOS5swGkHnxHyeqc7y5fnMT7s926HhLkcLnREOa9vTLIZgBS+WeY2cp0DoPN4LVhzVdqznBZcT29AzeIcYg8nKVuDKO3znSRWyZh6XBIPlnBK9QM0WjyVI4WozkCWz1oV0abrta+ZdzhQjvLRtKjVrJhmhGNMkj2IhV+ZYGKxl2/WYqrxLiTVntt9zyPSDPfAH00Y3i2ZqqSRt+uL2sXITKle9UHSFyxQgaSWXAiqUWqgRsJUipnHvaX+eYmS0Qm8tWiqHFOlNwPsBdY1KUGnmyL6vHA5nKiMxQsxNC6tAJ4Wk5eIdaEY6RdnSqBmLgmYotmBC04rFXJhTwjTWCy/GnhKbQbSq4i5MdrGtA7fphEzhtKY2vnGWaWrGT6phI99Pu/Vc/7l1EVa1/BlqgeOcuA8TUUduRk9OkYRgXUeKhWldWeaFbC0JQ7GVbBqhR2K74H2Yz7hQuLIWh+F9SmyMcGctnRXEtq76qpau2/D+eGYXWndqKU36YES4GwcoQlJYSsPJrRVuug6HYU2RWCLntPApzdR7jDNzynhjWTXy+TC20DCtDX1IpQd6wAXHbtdRSuVwXAha2A4d59OZJbe0563/wS4jf6tLBLougM1gYjOuSiDaFX/p0t+MDk0Z6KmuhSHlmKjLQhTXaCkVili0VmzMVFv4Kq6MGPamJYU+5YU+GzbBN4SmXDpWpbLrRt4c71vYXIKcm1zntBR2o8PlTCqFNWcWVSZVXvYNXdtSWhOnkviEjq56HueZORc8hnmN/PFmA5dJVNKKxXCNw5IxItyMIzkX7s8ngrWELnA8npljAYTRPT9/H6OEhsM2FiQIWINSWUtp4Wmm8unoSWmlisc4oUQlxZW8TmgKZKC65qsrJbOsK9YK35TEUCojBqmVJ63MunC3BurYXZoYAsbT+56H5Ylr3w5LsbRp49M5cxM81rb9PRvwwZON4cYFVOGUCgXlaI780YXNf0wLsRQ8lrIkPneBbAODMUDBitKp0HsIatgPjiUa0lLofGU/bPlwPDNpw8Bs3bOk56OWMRhpk5ZSm79yjpmnJaEVXm8GcjojvlF21qWQloU4zWRpUHTTBRwGTZGUGur865IYKYwXgOdjLMyq7EKg7wPWO4w4qIZr6TnGM+otMRpOuVBFWJbC1nu0aCPcGdrh1Qp34qmxcsiRopWnlPkjZ/HA07qQixLU8LBO/KzrcLbDGUGLYkul13ZG7a1w3Xtisdha6IzhdnPFN0/3DYldKxv5fs/gD3alFBHEtm5mNUoQzxxXcs78g5fX/OJmZOvhmIFsOGkLtXK1MNjCMSs3vSc4S620g/llo/oyTgQRXljPRlyTzjgoQBDb9FMx8TjNbMQSaRvpGCzjEKjAm0PEEZkLpGKwBq43tOjtriepshQhVQfOkTMc18zZtMXMkjiUxD4CVlloDnRXLFz0/kFg4x3VWEw1ONPMul3wTDmTLyzr5/rY1TIWEP2OuvnP/uQn/LM//ZTdIKRscC5wmlIj9aSJWhMxKndh036JgahKjiu1Rv7l/J5+FT7vBm5toCjf/Tb6ALkans6Jd/fv6TrfeNilcH3V82IzUIHHQyIC5+XEqoq1lrubPWsEK46UEmvKTKvlOK2c3cRDPPNQ1hbHbeCRxE/thtkqTzW1cCcchcyZlbswsAserc3v4qxrhrzBYhahrvmirX2u33eJCH3focYS9W/6JP63P37Nn90ODCZxLkJxhdPU1ri8ZlJSjhq5HgJWWmc2pkKNmbVW/vJ0YMDyynVcOUdVpXOWWAqbriV+H0+Jd/dHOum41xkbK5/0G+42fevo5zYlOsREyg2J+PKu5yrCNgTOa2ROBZNLk1scErHMPKWIM4ITYbYZ6Ji1smrzEgRxrJfU8ZvOMXQW7S3V7elMIATPOO65j4U5zpgc/wDvzt/9alQUWtqu/NYZbUT5Zz99zT/9/I6brvKwCurgNEVSXInrgibDo0auQ4c1yrcJhpnKQuIvTgcq8NI6bi4Xto7AantuO6EYy+NcuH/6hk46HkvkKgqvesM4tsn5kj3FCodlvjx/lp/c7ZmKYq2wrMq8thTWZY28y088mMxxKQSxzZSbFj7zPYnMb+YF5yyjD9B5zmvipvP0weO8Q42j6zydhXG0PBbDPFfW+Cxp/GhlaJIyUxuJ0bRmqwH+L//gZ/w3/+AzrvvCcbIU4DTNxCmR1hVTE+/mlauwZdGVKgYjlYXWxvvv5yco8NoGbsWhqmysxSD0vSUby8M5cv/4DUE6/vx44FwKX7zY8MVdh1b41XvFycBxncm1EmzHL+6umMpMGAOndeW8JuacOZfKu/ePHIETicE0muPXJVJmi2FhleYpGV1r5OYsbIJh7B0b6ejD0MJlneNq3PF+iRzymSV+vzXwB3vgf3lzw7Dt6Jxl6z0vu8C6VOb5gOTEV28XvLOMg6VkobPfBYmyVlgj7MYOZ5V5zUxr5lyU6Aq/GLctjVLqJYnScSLx8HCg7zt68XQi3AwDpVimqVAy7KqyHy3XQ489FRoRKLXoZ4THKZOJpDK0qC2rWJuoGd4TyRLZ9hZSYYkZY4W/mk5srSPnlq/aucbzL0RGBk6xhUNsnWe5SCe2uy1qhPM08XR+3uw+Voko1hpu9yN//4vP+D/943/MPGXW0xnLwm++WvHWc7NdWWuTVGBBQ4cdLTIt3O23VKccjieO55lDVeay8l+/+oKqtQWymZYmeF8O/OrhAzfHhavQM3rLy5uBYgJfxZlvFmUxiTvjeP1iy5f376jAKSbQJoE4lMR9XNmFDkNi0cJkCsZm/tXjG8658KPNNQFhLpEuDPw/H998lwMQrGfwHaUI0a1cseMYK521XA0DKSaKFq63G0qB909n3j5jET9OeShE+pp4HQx/cvOKh/GK09M9+hD5148rQ2e42Vam1EyziEVcTxnBTmdejyPOWh6midMycUxKsZl/evdpyxWhJfMqlae48uePZ8anlb33jF64Gxpzv0yBxwpiI+IsL6535IcJYks9r7WiWVgP8G4+cQgeAZaSmS+ToHfzSinKJ/2IE8OxZoL1/Lf3H9j3bYoURJps0XrmeKDvbjA548XR20BKM6qW/ZXw2ow8HOD+8RmL+DHKBoPtDLebwC9fveC//sWfMU2F8+kdNRb+7X84E4LhZoClgrNNMmZcII1KHzMvdld4p9yfzrw9TzyUwpIi//TuBbXmS6Kzx4jjMc78q/M992Vg4xwOw+4yJSpU3q4JnSyfBM+n1xu+fLhnioljzCSthGL5MFm+OR65HjYYrcw5MpVENoa/Ph2oGD4LHdZUThqx3vL/Oh3ZBY8x0Ksna7sgL11iY29ZUiUI3PSO9TIxuLvaApX7OvMhPodffqwSB9Y7Ptlv+V9/8Rn/1//93+PxsaEoKZl/95dnvK/sr8BmafJCqUTnMLanC4Uf390gYvjm/oGvj0eeauWsif/zy0/IqVyoj4I38JvTzH93PPGTUtm6Nv0cce1gqcK7Y8LKgnWOz17sWZghnonlkhCuCzJV3k0nujAgJbHSPEmaK/8mnjBWuDWeYhKPUtn1I//f5cieDqOGXloS+ZwLUR/Y8AK7whAMQ/AsaSKViet9z491y1upvCnfbw38wR74Q+8Ye8dgYWsUWVfiHPFFWWIhURBRSrXEomi6dF9ri4iPKM4q1nlMUUwBj+AwbH1/ke208CrBsCkQfGatiQJg/EUeXxmtx9TSUGHaur1b66koOzGogtYmQTo1RURDxWlDNIqzVCk4enpdqZJJprCsmbkULMJOmpinmIq3rSPc9SNePFUr5xI556Xh+JwSnLB4h9pn0+7Hqt4JL28GfvbqJf/w00/pVDmnAz5U1vNCKoXtAFE9yyLMGptJtjjIpXk1nNK50LIjYsSniu1HduOIoaE4iyoK7OjwneUpZjbaeOpzzoh1bMW3Y1lVqgpVB3Z+i5C5qS3e3ZjKkiOuNg9KVRAqzhiy7Sgxcjd0fDIOiIEPa+H9dOYpJ6wTXoYBbwxJE852aLFsXGD0glblvBYOpxPGO3wIeGtxzvHc3/9IlWd8iuyccG06jocj8+EEtemdqYp3HSkJcyykvOKMRZoXDDWWGgzWeYJ2DKogiWoCu7FvifVF0XJZB4twVUMzPPqWhDqtGUS48pZcGwUoZsFoT+89BoMXhdK+ZtSlTcNMS/K1YumdYSlKrSvXvudmHLBisGvk6+nMqWb6Gri5mHYrlUEEqYFt19G5FhL2NM+c5pm+D3jbNYmT98/hgx+p+l642Q389PqaX764o8ZEmg7YqpzWlVqUvenRrrKkxBobLEOqwdqAmoJ3leB7+q6wyZkSM0OwjN2IoaK1NsM3sMVBVR5ipmLYe0ssDYTQqaeRqCu1CNSB3vdQE7NmOmPwAufzufmOaiPYBdt+D85AEbh1ln0foEJcK09r5EBEiuEudAQg5cQgHRKhC0LvBFXluC48nhZsf4XvPMF7fEioPK+AH6uGoeP19ciffnLHP/niE0xSbJ7oQ+XwtLLkzH4fMMlwWArLuuAMGLU432F0Bl8ZvGOzCexyoKbCIJ6bbgOh+VSKtuyl6w2IKh+Whew8O2dRzYxi8EVwXZMX1WqgDuz9gNTEspxxRvDG8XQ6saT2NUXAacGZSrGFAlx7w95YpAqHUni3LDylgpXMj7oOb2Gpmc5WcoRNJ4zBUapyP008HGZ+6nv6oITg6buAtdP3ej1/sAf+TiqdKr42HOJpyeQcocCaMsYom04uFAt4miJqWieyF0+wSikV6wQRixeHdaBq8K4FuJRq2iamSkyFzlnOJZJREkoiQQYnnlgb4nNeYXIJJ7BmQ3AOYyupFOaieL5NKxWsuWDCasUDNnTovEKpOASUJtWBFqZjDKuA2JagKuEakcAaF45L5pQN287gooIRnP0dQstz/d7r569u+PRux49ub3kxjsznhZpbaNF5WbFUdpseBcQK7w4z1HYZ3InF2UDKShCDMQ5rPUGbSbezFmMM0UDJlVgiU4zsfcf9uhC1EHPhtEayK3gLWZun5RxX5vNKL54lK4P3WAOpJEps31e56FWtsWycUATsAte+b+ZNETauIzBjKgRxbFzAVoPkjK0GisF6g4iwrIkP54mn08xut8VMBWhhS78z7X+u32ONaWVjPYMJuGI4nE/o5flbY8aaigVqVYLA18eJCmxdYO86grbwomC56GAF6xxSm0nNGEOslaKQsnJeV25Cz/0lbTRq5ZwVWHHWotq6Todl5eo8E8SSkjbjpOWyRpZGNQGolWAMg2/r8TeLYeMcRitWhNF5OuOwGDbWMtimt1VjcBe2uZELgSVnnuaZD8vCy5Qop4p1FueE+rwEfpT68dWWT3ZbPtts2dmOp6cjWhbWtXBaIpbKTW0w3yDCrw4TpSr7ELhxPc6mZrQOjXAXnGOo0FXDEEKjQpVCLI248nZZ2GGYU2PvD1Y450yR5m2r9bfP3/44EcSymsLmMk1SrZxSwqAkWqaDF4sz4Cq8qYaN8+jFJ7J1joM0xtPgLYM0P1WutP25QrAOa9r39OG08m5euE07Hs9zI6V4C/b5AfxY9ctPrvn8xY4vbq656noOhzOqE8taOEwTUpWbGjAXjPq/ezygtXIVAi/6nk4La0qMF9xl5x07BHGePrQmayqFOSfmknkbIxsjnFIiGGG0wlkL5zLTuyYpWoryNCf2x4VRhMU4htBhjUErrKlQU0WqgG1Tgl4b9tNg2JhGRHOmshVDX4WCYXCWvfOIsZTc1AXQEMbWtRyob44z704Ln+bMw6ki0kIJvwN//M/UD/bAHzRjVxAsxlmWmDAmsyRIpeCtoYUbKSJwTpFYlU3wDF24HMgV60vbYGg8aDW2saYNaGmLxFoaAWLX+e8MkEJhqYm6VqQ37QClsFTlRMRLQ4A2WVnraOXavk6kUo3FixCaGxctgjjDOWdMVqQKwVg6I+1hNN8iQh0hXAFQ/Z4igViEuU4stSPiybmycZe/+7zYfLT6009f8uJ6y/VmS+ccx+OCNQ19uUald1z40AWxcJxXFlVy33E1bLDimJdMMImStT0v1uAULJfkZwNqKjEn5pR4OYx4A7kok2kHtqnO9OJR0y6oU1w4HA50oUOrIBcsXdWK1mY8O6YVZyqjdYyuQ6vipTY6QVzx1tFZx7UPDGK5koCtgqkGbxzu0nVbamnpkmvkaZo4xEjKifmU2Y89nRcG9/wMfozaqtInxUvrmuY1Ym0hxZZeG5y5kMkSzsBhWVmLUgfDbb/BZMM8ZzrTONNJlWgUr4ZQm5ws10ouDXO35ky/cbhoGtM6K1qhaKaYduDKpXBeFx4PjwyhI+u32SUtgbdoEwidU8JX6Lxj4y29SotENIZzjAR1BOvYB88ojit3iTs0LTTn27nRlBJqDNOaOK+JUymsuR04b7Yj3lrss2n8o9QfXV3zou+58h2+GqZpIXhlWQoxFnpncKYR9bzAwxI550TWyov9gEGYc2EoiayFVCtqwGeht6ZdDFXJmlhy5mFd2Xc9aEMLp+LI1XCKGamtQVdLwS0zj9XgfEcUoe8Cepn8G9PIfaeSGKxlNIbBCH2tuAoOyyFmOhFGb7nqOro4c9sFghqqGhyCu5i1Uq4sJnNeIk9z5DFnYlKmNHE79q3B+Pz8fbT6s09f8HI/ctUPWGM4zAudj5yn5svoneCNac+gg/fTxDll0nbDJ5sRsY4lZpLLxNyeQWNh7xzOVoyBVQtLyZxT5MO6MoauNYJRioEkwmlZ8EaoWlli4em8sNVHxi6wWMdmGEGVOSXEOCyRSRPOGjyVwUAnBntB0i6aCUboxfIidPQ6c+t9O1dq+zv+4sNdKricOK2R+znykDNzjqwT3G47OuvoXfc//UJe6gf7pJo5k6SNLLZ9hzrX3P9JMMbirKGqZV6ahl1rJSvEUkk5cU4z1lpcLMSUWYqSvMPhqNXRKMO1oT7ryr4f2AbPWZWlFFItBBzZFY55ZaRrGy+VlBKhG+kHqEUp2njtIhaDYzJgnaN3FpGGXqp1pZSZYzmjaaXHsrOOGDwb71hzJavivGe7f9m6b50HI9TqMEPARosxHUcKgcTgHLtu/IO+T3+X6257RbiM3rxzWFdJMRNTJhjLIELNhcPp3NL61GDVUIqy1sSaZkieAMxxZkozUUCNQ2vk2wtr1YLJhhf9yLbvuF4iq0IC9v0GWyY+rMo+eAZjcEV5mA582r1iO/SkslBKe/6dDdQCb8+P7HwgdCMi2lCy1jLryv2aERGu+sDoHXdDz62znEtLLfVW2Nq2NLw7TcwGckyUGskeqsncTwtj8OxDT97t/4Dv0t/dClhKLqjL9LbSi2HJmVJoKZOh4TEfp4U2benQS2c8xjP384mxdgwGlpg4p5WzFEZ1SCmtI1VKC6rJyqurPePY8yK1RMpaK1vvqVgeNOPFMlhDXyuP05lNNxI2ljSvxFxJWum8o5TCh9ORjfUEK+RLnsCIQbXyIa+4WLj2MHrDXd/RG8s5Z7KBwRv2lynnm4cjgzTqWjHaQuSMIeZGRxu6wIvN5g/3Jv0drhu3waRKtZW+M2TfJuAxZzorjF4owNPc9MNGWnaIKsR15TRPGNuzLiuHZeb9vBC18sI4SlqoxhCXlWmJrKbyk92W6xCYqA1vrJZ96HDzwq/ixCY4ejXYpJxr8znth47DsjJrIYvSd4FSKn8Zj1yFHms9PQZTm18lpcJDXhERbkzHlbN8EjpurOOozdAexLG7nLZ+fTowmIacTRSMKEkTizYFwegcn3T+D/cm/R2v23F3CUiFwRnOhmbEXhIb8exCA1o8LWdqBWctvgoGIa4Lj8vMtWyIS+RxmngznalO2PaOnFunfV5WjtNKzIWfDD03Y8dJW95SNpWN6zHW8KunM1sXCF2FuvKUM5v+MzZbS55XoipVhP2mY/bKX6yP3BB4YYTxkhj87ZPykCNGhVvbc9t5PkueKwyHFElA7xwvfZP9vnk60ptGeFRRjBjWlDgl2FfPNgQ+2Q7f6/X8wR7492PP/bJwPB45n8681cieESeWlCNP68pfH48MWEoQBiMEZ6BmHmbYd1dYEympcl5h1oqpiY1zHOcZK5YpJhbNEKBo6xqZbwX5VDppo5Zr69GSAY9Wy6yRl2Og6+H+IZGLUqpStLAJAzf7O85u4InCsZzoywE9zEieMXkl1sqkTfhzaztmVTbO41CkRjbx37PfvyB2N5icUKv4bmDoT9xsOm5iwapcUHvP3dWPVbe3L/n1h3e8ffyG0/0jX88nPhv3iLGcTebN8cTTm4XeCTOZm35sZrMMx3PmZn+DLQtLXnnKC095pdqKCyNfPT4xeM9UYS6FmnMjTrx/INDSbRMJXypmNbzohERhxVBq0/5/vhF2m5H3bwtxjaw5cUhnNmK5cx1frwu/Xs54ET7tt6wRos0gmVNWHo4zzgo/G7fMRXnd9RiEc07EoljArZGzUVKq5GyIOrMbB266LV1n2wSiPGt6PkZtrja8ORx48+EDbx4euI8zP93dUqvytBS+PCyc09qCA4dASIaeFkP/1ll+fP0CWTNLTTzVlVkjNVcOTvnnh/e8dhuiwlSVKpWHeeXdcb189ZZSeeM9D1HZWcdSCms1FBGKgded5UUX+GpW1tJIZkta6azwaQi8i5E/P82Yc+XG90QqOReqFk4kTuuKWQtfhB2zVT4NI7VWzqVwAELMSGiBTRQotXIsKzfjwL4LeO9IRSnlmZLyMepuN/Jv7x/45v6IiTP/9vDET3cvCM7zUApfPk0cvn6gt0IUw4tNz7UYbIWvY+Hu6poynzjGzJRXUolMuZK98s2793zqOhAh0ghkh2o4z2eKCCqGc03solJ05e9djTyuzUNyqpVcM5+OwmYzML1LsFpqqcSyYIE9gcN55ut6Qg28du4ivSlIadKfx1gYgvC57ykJPg1bqmlqgUMu2JTpxGFcUxNobU2RV2NrcPgAa1KO6/Me/LHq9nrPv39/z8PxEbN84J/fn/jlbo93lodU+Kv3jzz+amIjnvtU+NHVhuveYmvm67XwenfN4fiWNzhOl+nTcYn8y3oglAOvxbOUyvlCuaNU1scJZxsD/xAz25hYlzN/cjVwLoJWOBUBcYQxsNt3fLm2XKQlKQ/LysbCLcK748S/LwmM8mnX45yQTAY1PObM23xkyJafho5ihS/6gBp4ioX388oIjLVjIrX8klI468LrzY/QjSX0lpiVKX2/NfAHe+B/mCeSNgesYNjhWuqig23fsdeetGbOMTM1xSg5KsZawuCxVpuzGsMYhJ4Wyw2wADZBuYQI2mzZBcukBZEOLxVBCRjOZSGW1jWzRptMR3sej2e22lG0YkzTUqEB6yw7V+i7wiFOPC2PHOYTL3JmFM9cDb2RiyTJsek6diXjxNKmDpaSV8r5CfKWXCuqLYnVLsqX/WtupbD1J4IoW/N82PpY9eb+HaUsWFeBzI3toNm6uBlGbruec7dwf1qYtXVZ51ygCruuEZxKbml7+xDYuIb8WjAUgTkHYkqgsAk9w+hIS0WsspaMVsPgA8uaiJhvH1+ssQyu45t399yskemCxhQMHZ7uMt5TJ7xZIm+XhXfn9/xkM3Jr99QacU5xYnHZcLvpqFkoJaE1s+0MswhEAGXCkKSiTvFZ+FdfvuFnN6+4NoqzcD08P4Mfo758/0QqM0YLVix3YWSKmeRht+14wcC8Jt6fF2KEtUTOFEYcn3lHLisUcOJ4YQJ7b8gCsXi8o02RUsEoeBd4MQSOZcUIlKKIGqx4SpmJF5FNZ5q2GgvffPOBeReYcksOd7Zii4Ha1qursSfHyIdp5jAd+PlmYDcKaw6MVRixTDlzuxvJRRvfH8OVtyxApLQ1uEKshWxa0M2/+NXXfHa357Ud2VlLee6wfpT61dMTKa+IJh5Xw7U4ptjMr1d9z03vmbeRt1Oj1KxLYTaVwRdeX6SLc0xU59gZS28DZ4FTUGwOLaMkl9b59AM3IRCZ8N6SL/knwcA5cTHyQu+FwVmCGH71/oG7qTAt9ZJMbqA4NqMln2Z8cNQEH9bMv5tmvtgHXoWRCEhVgnUMNfBq26S8hiYNGZwlYSm0NNR3a5O9qVF2YvnvvvkNv7h7wR0dG294tf3BHqP+1tdv3n3gnCdMSTye4Q7HGi1R4HocuOl75u3IN8eJmcpcC9Oc2GTHj61HdYYI3lmubaWnclwth0tY36OtUKDHcRMcQxiY4gReiFmpqbILjlgcR6DayiCGnTXsPPzVN1/zer7mNLcJgarineUm9EzTgSvfArnex5V/lSd+2fe8oudIYSOWT5yjN47Przuk2EvwYGZrtO3BqiTgWFp6sJAZBf7vb97yZy9f8aoYtmK423w/pccP9kl9vywEK2zEtARTNaBCSoXOODrnCL0hYdBqWEsk18JgKleqqGk3HjGCYvDO8aLvOSXBJSXXfMlTaqabzrZk06LaRjM06UUqhfmCwwyXTlgCHtbCKSpaauOiWkNvDYlMyBNFM35NDIviiyF4R1Qh13bLEAwrhX3wjTogcokyLxAjs57RkMF6igolVkwZ6UdhZsNYLIHpe7uzn+s/vb58OrLtDFeuXdBWA4uuRC14CfTe461lyUpOcFoipSopKNve45MDXDPrlMroHZ/sdzwuyiknlljp3G+zFa5CgCAc14VUbUtwBqbSNjVMIwepgwVlPmUOpVBKS4J0Vdh2AVXltCpqDaO13IWAdJZP+xExTW5UqxCMMGvipn+BlkiqviVVa6HkhXuNjNoM7lUrJStb0+QgH9YTfbdlrI6Snw/8H6PeHU+MFq69ZeuEQ6wUCmuu9Fj6zrEbOwowLcqbi9lbkNZtXwCEAUs1wtB57vYb7s9t7ZpqpvOO3lqwlt4Lgb75NKgUA9ZWDgL10kGqVIpYsiqalSXnlqZ7Mc3tXSBTWNaWljsgvAgB0wWu+461GpZcECpWDBOZbfBt3QvtUpG1Qso8kCAJKkLJFaKysR4lNcKZK2RLC595rt97fXk6sRHDLniGYFH1lJI4xczV0DGEjuA9swp2jRxr60IWhLOzuFqprsN5R0wtMf6zIBwQ5mBJMROsEJyl846rEDCdYS6FtVwO8cZwlJV5TdRa2RRLKgWkScWOywOxGqjgMYy+8dQXY0jFEES47TzaBV6HQDGVWBWDoUc4a2IfdphSQCyp2maQT4Wv8sKtGzC1UXpiLmxEMDHzcJrYiKU6z/IctPvR6i8eH9j1wrUXjBNEHbEUjmvmqu/Y9YGh31Fo4Ixv1oV4kVtNIeOlQBjoQiClBaOF16PQVzj6jClK7xyjeMau424/gPY8rQsTmXLpEz9F4em8UCtc957aBY5r4lRWHnIhr63BHES4Dp5qLdkYVJXBGl51HsTyuu84l8JaMtYIXuCxLPyDcN2ofVXo1GKdIU6FL9fp/8fen8XqtqV33djvGd2cb7O63Zy2TlW5AdxE+EtIMJYgihDI4gIpsqUovouCiBQZ9MkWFyFSVPaVL3KBcgHKRWhygwBLuSHcgSIiEA76IPmCjTGuxlV16nS7Wc3bzDlH8zy5GO85hs+fwyn77FOnzl5/aUt19q699lprPmuOMZ7x/H9/Xk9CFEdWx5SNc/FQF54cd2zdlo0P1Fr/C9/Jrs/shn9lDmedTe/EkcSYrW+wl9IDtJzr+EGhz3iVZjhRslVMu4lxCP2nUdWxlG68DUIPYaCn2+5r48x5qod9qSxNUYSDNKoTpPnOmvaG0WhmNAQVIwSHYjSMURwgaM40K7jaWFtHgwJkHP0M1w1z6rrp05ynfZhgWArelIiRLODcChkDKTqkJVbz20gcEO0vNs3T9+wZfd71IHVjz2nbzjrCTatUNY650FTxTogxsHHCYsq8LJ2fWxulBpamjF5RM5oKx6x4cWx8xHzBiaDWeDod2IiRnfB0mjjkSjsZKxXw5llqpZgSrSMP++RZR3YtudByw4sHUXBCcnCJ59w51oMnNI85T/IBzHCmKJUQPTiPNphaYbdkSu3eEzVADVOlqhHFI9GxXxaWsmKQeKrme33SugqdMBKlP7NNUK6XXheHXFA6lcwDLjiSTyy6kJuxNCV4TzNFqB/VypSN5COb2FCMhGJWeb5MjDYw47mel1Own50C53pHdWntdNvZ33fgMfOMsZvQip7IEs5D9UQxzsSxdSciRgMhMrqOATUxGkpwsc9XW/dPHWuhKngcURwVKGZUeviOeOFuWTgbVmxdD1a81yev10IgemHlHKN4JApPlj4WcVj6+09OhnJPx09rruSqLLX1pOcTHcNEwAcUx8pHBoG9V7z2cZ4n9cAZQhbl2ZKZaqdHNdcD2IJ4Mq1jOdWoZjQT1AnrwbPURqmN4AYiHi+N0UMyQQKsYsJXmFSJLuKc9EBEKwwhgvQLzaUqu9r6rbr39L6/UcxoogTXt0zPp5mrYUWQwH3u4IvTG0Mgec8oPVk8JMfNsVFr47AsVG048TjzxBBw2dNOhLvcCrUmMkI81aBzneh04R0r75laYxDDrPD2sXKehMU73j/OHJZKaUYWo+BYh5GlVRwOUShqmHnEHGerwFIrrRnRe+wEc1k5x0rABc9mHPEFJvGMyQhiBNfX8jFFhN68mJtyVxuqvWGN68MtAMV1upSq8d7+wMM0kMaAfcwl+DO74T/H99OVgZlnEOWgtS9atXTmufM4AovUExuwB2bsW2OlvSvpBUQ8ReFZKSRPdz9L55arNQ65kMWxx9iVSm59jF8QNutIbP1jAah0k+7KjaxSYBx9n92qnRDgcCwl9w6FNiLGGBL7ohiORAQaIn3hXYoi4qitss+Zu1JIONYeVvQwpTAkhuRo2WHf/m9ZrwwXHlJZ0+b70I8XpTfHFXvNtNYQ6TSaD5aKiLGbF3ZmJN8pOU36D+3cOg3lmJUxQi4VUT0RKYx5d2A9DpyHQBZDRDnUhQ/2ex7TeKrG0zkz13YiWBivjRsGiWQr1Gos2nnUl+s1l8Oa7ZjYuSN3OnX0ooOQBK+GEyF4x+Ww5ju7mSEEzsKAaqVpY5UCh7aQFJZa2C0z18cZh8fFvigaSjU5ddV6SJiURquGJbnncr4gvRIT2bSja0xYec/7mkHgmDNTzQzeE/HsUMaYWKwDB/atMBA6VcIyiCMXYWkLF+OaTegdUFpjXxbemyYeNuMDg9vcPRy5NeZqfOHygiEIRTvNrCkgwnlasx4GtuvAriydze6F4DwSG8EaokKghye+PS+cjZ7zOFCtUa2x9r6n8ZoyaeU2L+xzD9pKJMbQ+f/N99vcIoaXnk9RteNl70llL0Y/OA7MGEUVUUgokzWcOPbzwu2kSBCSBA6tEoIjuG40n2rjbHD9xskU5x3mAgd1jCFwDqhr1Fo45IW388JrKjwV5dnSWKpStTHReH1zxipG9rr0ZHmBZsrgR87GgYuN525ZuJtyB3X4TtpJHjAhIlwOkW/OM1Yd21XC+46zXTvHrI1gyqSNu1K5LZVknrM4MgjgjOZ7w858NyrnUlhaH0cK92O1L0z/g4sz9qUxlUbQvoF+r1W8wC4vPJuOoI7zuGJnhSFFiiqKMtXC+ZD6e0wqIh4kcWyNjXecO89zFmiF21L4xpx5HeOJN94/FObSyKpMKF8ct5yv1+zKRALQfqt+kUZeHUbOzyM3y8ztIeNS7GPeJgyODv0Qx6OU+J3jRIwjV6uAUKE1Ll1iMiXiOLbC9TLzfC6kFjmLqaNfqxDVEyTQgqe1xjQX5mqY84SPOdX4md3w75dCXHmc66EtrrnO1ffKokpthrM+W32dZ85jInpHM7iZFQv9qrjfDgvmhHEMZGD0jkOZ0WZo8x/N95dSOPMBFSgN1BypGpVG9ZXajGWB6oUHY+x8dcCJEJ3rNBRRdrlgzaFmIEp1jeeWOWMk+Ag4nBibuOLp8Y7oR2pZUK2MOIo6Yi5s3HMkFDyBMDeOu8y3riuvT431+UxIjs5yudeL0LP9gsnpmVJxDXIxklOOZaHURhIPo+ed3Y43VlvW3jOL8cFypI3C63GNh75BEWU1wrEtnAVjqRO1NrIa2zhSm7LkwlX01NhvB0z7oaJaAWkca+PODC/CF8crVimRpDE6R40jPjlay8zakKpYUzwOEeX9PPNFH1mJJ2N4Lzwat3z96TWXbmTRPhY3RM9dg5Ybj7YbgmuszJFq4DAtTFq4lBU+9o5Lap/Z18j3tZ5PGYmdmT/lyrH2kLYYHEtt1GqU0Lsi39rd8IWzC8bgOLbGe0vHyD1ar9DWOJSe7L1Zj8xkkgpLLuSWyaqchZHgE7osPEzdm7S0Rg1GwpicYdJHeKamWBC+dJ4YUiQJrEWQEEjJ05qnlCNqPY0rI+DhSVnYDInkpCdDi+fRsOJrz54QY8Bb91QN4pihByA6x2BCiMIQPNN0RJ1nK4GVd6TgKOq/tw/qc6q7JeOio5pxsyhzLkzABiPbqcnVhCUp3zzu+MLZGdE7ZlOetNZzJFwfp82AAZvRoZxGckzZl8pUO4FMvOOYM2dD4jx2g/dUGmMTCo2qlSLGrk938aPjhnUKvf5cQIMjRkeWylEaXg1rDTGQWXiqE1dhzXn0iCilGW/4gf94/ZwL7zEnmAib6Lk7+fYuXWf5j9EzlMA+TywinPvIKiaGYUDl/sD5otRcJQaYinEzGdIKU6mcR8++Kcda8d5xI5nfnm/5gfUlWxJzrbxXC5u2sGVgCI5JYdGK85WsMJCoZhyXxrEa5z4hCPtd5jx6zpzvUxRKx9KSyVqZzXiOkavyxzcXbJNnEGHrAiRhHCOtKdUclUIz6/bTWXmvzHwpeC5cpFpvFL7qR/7fT5/ziktkrTRrbJxwRwUPa+cIY2SMiVUJ3OYdiPB4HDgfEuMwoO77fKTHsD63DxyscnsKkBmaMRAYkb4i+Maddwwaaa53DUQa+dT12VMRGhuXeDB0dFFrEys8d9qYTRl8D5hf+771NzGSFwaXuF4OHGlsRo9VI5c+2nMksw4rzBRad/4riTQkvFfUdda+NxiBsSXUF4priAnJHLUuQKK0mYOVblQSCAkOzXF4+nXSLhHimupX7I+NR+dbojlac5Q5czzm78XjeSnUaoPQUGvMc+NGM2sCzQuXYcTTg9+W2hgHB4PHm2dQsFbhqLS08FxmGso2DTxabwHQXIji2NE4NmMgoj7yaJs4lIKoY0yx12C94yYXHgyBVfTsSqFp5S7vOVuv2M3KbsnMtSCLY73esl4yKooLPfQthMrFENmXAwUwEZIP5BPW9kZndrmSTzdZJyo6b093RBEu0sCjccPohLceXJAY8N7TChyW+xp8EaraGK3PLL9TMneaOWOgqXIWVgTpG92FwtV6TYwBNeXM93lmgONxZt8WELiIKx6kbuhuubCN8Kw5ZoUkHp/WXAXP7TQjAudxgOh4px2oKA9WAzF6pGRMG9d54s31yG2eWJZMq4bqwuXZmrV3PalcPN1FVXhzSNRSuW4FPYW94XInVxTlOYWC4kRYuYTD8d7+DuccZ8OKq+GcMxd5/eoR0A10x1I4Hu5vOV+EzEC1UtTYVeNpqawIlAiXcSBGwQSWBM+WzKAedYakD0drgdm4mQ+9ntYj5+sTQnWpnHvHFD044ZUYSGnNq0RyU6oVmgjRJ55rZnHKoxgprbGrnaZ3lyeuzta9mdIaQXrzZJ3WbMJCUwUcXjvv4IFPBKe8Px0RYCWBlpTmjXdzpdEhISLCGEe0Kd+YFsQpD1dr3tyec3YQXr96QPAB5wOtGcu8/L7fw3v94aRqNKssWthjPK9KwrGnsV2NXMoGEzj6xjaPjE1oziA6og99jNo33t4dmTEuxzV/9Ozh6YNPXKbWTdzVeF0CQxp4k8QxT+SiCJ5xGPhGPpAneDV6qgm72vDauOPIa8OWJTdqrqCZY66s05Z1gqYec4YzEAqPw8Bdy1wfZhBIzuNDYwTeyxOHplTAARvvaA1+89kdIXhe2Wx482zL1V758uuPCAy4FGlqHA8fb7T7M7vhb0BTISFsYuNBEj7YQ4nd/BOQbpZ1K17xPfAgqPAoRh5tzhDg64c9q9Nozk4V2x95vF2zO7YeKNMaAVinyNNpxiRRXO4bdXXsZKFGgaa0LDSgOk7XhZ4pz1y3hcU6N3hVK0k9r11d4pz0sY/jzIKwSjDnniqIGpgneeUq9Rfga8OG6BytKO8d9mQ8X73NJKmMfmIMhcF7gvM80cxYQ2fILveL3YvSvk6n1GbHeTBecwPfnpRWIIQeoiXAeky8ypqq/VrutfGcty62iFb+mw+e9O6neXKDa1l47fySb+8OqPb51OiF7eD45jTh50YOxhAiUYXbZUJ8747NpW/UY4gkiXjnePf2Gbd57gQLF4i2J+cDX37jLbx3XO8OXN/dEWlcecdNLszWPx5Nacl4dXXeUXaPE0OMzMX42gfPyLVxWya8BNQJJHi0XtGa8v5+x5AiiLI/3BvHX4Rm7WFBg+vx6q/ZirdP76GVh9Gd0pQZ2bYMrYdxna/WvLFaQVP+myfP2PrAgKAZnh9mHmwu+NbNDeI6qSc6xzZF/tvbp1y4yKSF6DztRIvaEshUtCioMEokRM+ZE273N7y/HPuYow9cVuPZszt+4Muv473n5m7P9c2ub/hWjv1UcU6pZhSDs+a42m6IRFarSPBCzo3v3Nyyc5ARDANrOC2s04ppuuP5lEnR40Q+ymK51yerbx0L56mHR56L8mBMvDv3mXsC+FOCpZB4LUVmLTjneXVc8cNnG7Qp/68nT9gmjzNBq1EOjYvzLV+7fQoCezVUlOgd/3664dXxgqd5jzYl4DCBFQHTSkEpBt5FUnCn+tvxJE+YwkocThvXcuBH/8hbBO/54PqO95/d0nCcp8g+d69Jw8AZ6wpvrS/xK7hcJVIITK3xrZtrpubIPhPM46qyLBPr1YbdMnG9ZEYfEYHD/Rr8wvTvn048GAeSRK5C5jXv+J09fQ0WGIP0DBwiX4yJWSvOO76w2fJjDy4QUf4f33yPhBJMcFkptXJxccbX3tmBCvuiZG2cJeE3pgNvbh9yXScKfYzomDPJBUwhl54iLgQ2Q+AM48mzG56WhXbyXvqlInLgf/gjP0gInvdv7nj3+Q1F4SwpNw0KjWZKbY0EvHX5gAScnQ/EGFkW5Xc+eMr7rZKl4mujTROTwNX6jP2u8J3DLaP3eDGm5eMdOj+zG/7FKWKVqjA3SNVRnJKbkRFGETbBUzRzVGEQwYsQvWMIHoqSjL5ZaqCtP+ilVG5zZUyBEDzuP5nBE+skgIpiTlgR2RDILpMIHLRyVMWLcVsXNiZ4E7bSZ7QcQlPlg9s7xhRxImxSwJp1U5p3jM13o5MIixnbBHnp4U5ePBa6sS06IbWAncxCiBIk9ZNibagXEIfa/XX2i9JyGmPIaizaO4/HZjQct62SvHCRIlIch9rYpECSTp1YpUTLjUEiWEEaYFCKMNXMbS6cpYGN8zgPQ4DhOFPpJp7Fum/gbFiRvBD1yOgid62wr4UknifTwuXp34zA2ncSy7RkfufJ+1yMa6LzPNxuwRqWj51ocnI5OnrK4OPVSF4yUQLRRdQ3PJWVJAg9l0K0gRZWYYsYmBVyqbjeurjXC9BywgNnNXxtJzhBYEGZlsLoHRc+0qyRrecmfJTgHQJZC6MEgtmJ+NQotVLqxE4Ll2nFRnodBOc4E8GbUa2PDhmwcQODU/ZqrFxgVyuTNqKH70wTr64Gti7gBEbnGYJwXCpfff89ztKKUSJX67MeLqcLd15ZWWJt0HtecJYSJRvR9Xe3M8GJMbpA8iNVK9aMZt2IDHqyjfQ6vvdMvhjN1qAZ0hRQRqccWk+SP5TW12BxOCfc1cJZXJGcY+0CqxhYtHAWVhiFUpSJyiEW0jRzWzNX64GLEDELrIJnyMApUK1If8ZnLuGcMFYhes+dFqa2EKXxpBrnAtJgwLGRQIiOoypfffcZZ+sBb8LD7RYvDV+MuSnneDDB4agI5+vAPFeCgxiEZv3uNrnAY3cGmnFAVuPSB1QrgVMX5oQNv9eL0a5UxEt/D7ZMcsJeHUU6YGVosHWCrwN3tXEeB4YQ2MbIZoyU0rhYj0zTgapKaYUlT9xN8H6eeW0zchUStTVG7xiXGacFcaChe6c2rocXTmTW3rPT7vcgND6ojnO30KoSDEbn8MHRtPEfvvM+D7Yrkne8eXHWEZvzkWNrRNcR3YIjSuDhNrFMlUEigw8QMx5lI47tMCLN8BitVlbJU0pFWqGq0pnwH2+s7DO74Y/icNLDVpbWCQ5OwJ02RD3GvS9iouC9MLgTXtOEckqJrHTH/Ydz9n1cX1ARIh7ByLWnTpoZhqOJISiOhLNuOgviSc5INBq98+XUMYREcH2Bwnr4zEFnZmucp8Q2BJozrHUij3e9K2DAUhpODHH9tgIBk54kvAqO2jxqfaMJQnCOXDLWIJtiAnO9Z4K9KCVxOPqFzKxQrNI4LRTWqAZVHTTrtCgThhAYQ+BDH9fVODLlTiWJ3pFiwKQ/yxD86bCpFK0kJ1jq+/Gs3TtwEQTnYCD0GHeUST3VGi7DLI1NTL/7g2ydRHE8Hsit8Xh7xsP1Gm2FgzZCKATrNxNqjVKV5Bx4jxMPIph0dOwYQqfznIJDminRBQ55omkh116z08cM/bjXd6dNDDgnqCm1Cg3FOSM6IZ+IObN1MpiXAJzegc6fDmXwaBgprYAp4YQfFjnlejhPkm5enGol0P8thU5gscY29Fsl7xzBdT9BwDFpQ7RxbJW1T8hp86NmzBh5mqjZeLjacrVad6xhaQQXEDMcfWxzUsULmJf+XhTBpAcerqNnaf321AsUFAnGNNXO7QeQU/bFvT5xDaf3X7Xe1SyqGIJHOqnMOrFpFfqN0OA9Gx9Yh9DfIzgerVbsczc+9vVNUau9nk6NsqqNWStrcaAVcWDaARkfbqWj64jNwQWi6/P8TYypNVYxEa2PVzYHk1amw5FjrTxerXi4GjAzZit4l4kExKAiVCedhOUcnCh74hQzGLw7NUc6ic8whgC3B+1rvZ5Srdv9kfNFaSWC005JmkyYav+5F5NOgsIwJ2xP76XkPGexm129dKP/6+sN7+XMZKX7M7UxtoY7NR2G0A94syqDOKz2FGj1jqadJib0xvAqBIopx6ZU6VMoe2uMPhDNdfKdFw5WmXc7Jqu8eX7Gq9sNrTWelszgAl4/pJ2B0Q+z6kGkb95F+j504wOlGeY63bEJhOi5OR47KlsUEEr7ePvA78pt8ku/9EuIyH/260d+5Ec++vN5nvn5n/95Hj58yHa75Wd/9md5//33v5t/4iNtxPcNl/RNesUYcIzeMZzMsktTmirpdMoevGdwDhSqKGcpkghE3zm/Ywx4J6Tg8KdNdFXY1YaInOK7OubTAf5EAwh4wukwsfIe8YD0g0Jwsc/ySe+4t6aoGFkbTQ3vPCF0vq9IJ1g451ABtT4uFEMn2SGCnfhKyTvwfaF1OFT7grjUjoqainIslelj8lc/D/o06w/gzHnWSL8KFEdTCF5Ye9gGiGIdxWVKjKFv+L1nFcKp+yNcjZFVCqTBk0bHetXzHrYpEFx/pkUb1/MCIlTfySOI9EXGGQVjFQdSiKzDwDokihnRhDlXxjiQ0kiTTrYqgIgwaaWiDMEzJk8Wh3OBKIEgvS9V6R28VYwE7+CESgTppnAHzv3u56Gi7OYDS8sca2afK7v5vgY/1CdZgw9jZOsDkUAg4MyTvLANnjPvicCxFDi9V7z0xWv8cKOicDUMrFIixkhKgXEIOO/YuIA7BQ+22riZZgrCUdtHnafuZ4KCMAZPCIFVSAw+MjVj5TzH0gg+EdJA8x3T2ZzgfccVGuC9IwTHAiTv8a77pOrpSrupkmJv8KhCVUHph4siFe87frmaoq6ynzNTKexz/3V8iZoen2b9XfnIxntG5xhdwImQfDdojwgoHLQX0SYGou+hWGvfu9+KcDFGtj6yCoGUHDF2atjGB/oiCKUpz+YZL8KipZPGfN/4qPRk8SF5hujZpMg6Jir9ADo1ZTOODKuR6j0LMJ8Ojkv78EASGMLABHjvScHjnWAouW8uWIXQkcYImH5E31kso2Kns4Ah3tjnzFwzx1I4lMax3Nffh/qk1+CrEFjjSXhGH0niCL4niicztHWsOvT3UXCOTQpsY+gkHeDKB87SwComgg+YEwbxnDuPVmgVlmY8WTIqjl2eT/hfhzloKA1lPUTWQ2KbAmPwFJNu5lVjOw5shwEXIhICO1MKxrE1qsCYIqthYG90ApkEHNIPD6q0Jgwx4k/7XVWhmjE4z9Qqi1aqdCyxOuNmXpiLnRDMjUN+QabdH//xH+ef/tN/+rsfIPzuh/iFX/gF/sk/+Sf86q/+KhcXF/yVv/JX+Jmf+Rn+5b/8l9/tP8PaObL07mqij61IcCR6t2FC2ZmyOiGKAgP9JA4LgHk8rdMfqHgRnPOnTX05mdqM2Sp3Wlnj2AGX3uGsb/bXsZ/cHwwrKnBbjEM2tBkuCE76LG2InoZjMCNiHGtj7SMjHm2GOZhqQ8Wj1shamWiYh1oHhuF0SNFG0YZhHClk1xhOBdBqI7dGbY1ZFXO9G9HPiC+PPq36AziLcKAnKY8GMQy0YCSzbtxplZtSeC1tWUplk1ZE5xAztELFkShsgmcxjwsOXDeGQUG1P/epFp4sE1sbedIm3hjPCK6HuZ2N3WT5hfMtRYR3pj3ldiZnI647uWq7GlkNgaYNZwFxN9zUxmYcWKdIVvBN2C8HxCW0VeZW2bXK0ozWKmlYI651ukCtmAWO1THVfEqeFkpr3OYjNRd2TXF4PMbLNlT2adXgKtDJZAKr4FH1iAlWDNQxtcpNywxuZF9mXh07EUrVUBPMQ1tyb3Co4LyQnaGt4w1VC/lUf8c6E+OGO21chUTwcuqW9fp75SzhJPJkWbg7NobmcOqhKRfjyDAGmjVCc/jlyB2ZB3FgGyNqillmPy047ym1Ny7m1tNzqSCuhxtZq7SiRDOmquzawiiBpJ5QlePUWezHUnA+4L073S68PPq06m+TYEYw8XTUgGenlVobg4fmlbvSaKyYdObcrRic4MwotSc11PnIKjrwCXN9DYeAtsxsfWRtrpnny4KNgefTkav1mrXzROe5jCMAb12NmHjemyb2h0w0OOSGd5FxSKx9oKaAEfBL4NiUB0PiPCaadWLeLk8MEhErLKYcWumf/+aKYegbxJwrS+ljRVNrXLfM1nkGHGLKbiksdeG6VLwEgvPYS3TghE93DV4H4WjgGzwQIYQN11JZlonoGlkb+yY08ez9xKNxw/qjjr0xF9gf7tgOHh9SD69cR1p3ZPab02rc1YUP2hGVLR9ME1/Ybj465D70vQZ/+PUL0MA39zue7hZ868GVwQcebtYMPpBLI8lp0iPDG6sNlyFRa6WpcVszq9Mt0myNXa3sSqUtjWGdEAelVqZl7tS+BjtbWIkjNI9m4+Y4k0vhdlFS7A3t+jHDIL7rDX8Igddee+33/P7t7S1/+2//bf7+3//7/Nk/+2cB+Lt/9+/yoz/6o/zar/0af+pP/anv6t+5bY0Ye+DMKB7vlfPzLc/3R46aCQ7Wrht1Qgo8XA2sxFiK8v5uYu09wwCWAfNUgZ1fOAseXz1qmTtVFhOuTmEam1NIV9Z+ZXPrKgEY6tBn7rVQUR6GkdfWK1h7vOej+f0MrPEEXwiuJ8Ld5N819OxoDA3cKRXwSKW1xrKASsFLD/O6tT3tGFnhODoliLARz+2y8BzllRQxwDnXbxZeIn1a9QfwFMPRO6mjEzarxNXjLe8+P3K7m0jqeBz7hveSwBvbxMYLh3zk69c3XA2Jc+c5zUhQs3I3zVyuR+pcMF953vri81YaucuVP5JWqFPuSmU/NZ7kA2PwXA0RgrHMM9KUH3pwxo9ePiYEj/fdByBOadUDKzQXzl0i72a+Pl+TqQzAdZ1JpzklKZVjXTjUhh2P2EfBSY3ndcdyPHKWhKn0+epzET643fHuceH1tOq+Errp6GXSp1WD35oWhjEyJCFVx3oYeOXRFW9fP6MeZ8YQeSUGghpvuMSb2xXJdz71v3t/x/kQWSeYi1Kq4sSwmrlMK5alECPscufZv75a8WzKfMEJIQgHVW5LYd8yXmFIl4yucDcdOObMG8OWHzo/o+FxXvGiiHcQYMPJl4RwcziwmxaaF0aMJ/s9K99vIzzK8zbzbJk5p8Hcb7cKxpM84VUZqqfQUNdHzN6923FslS+MI6B9tldenhsm+PTq7zu5MIyJ6IDaGPzAl998k+9cP+P6OFNL5TIZayAQeGsTGJzndqr81vM7LkdH75kHcgXVhk1HGAqlNXxrPKsLiylvxpGpZB54zwqjqHHQys5mBiKPZwfOs5sWDkvlMo78Vw8vgQS+p6y6FAFP8I7rvLCKiV0ufGe3p5SO8H6WJ9Lphmm2xr5V5qVDYPX0/is03s8TnsbKVQ61kiWylcg3dkemUnngHEIjSEXdy9V0+zTX4G+3hXEYGIJHqjAMkT/1+ht89ckHvH+YaEsh0hi88QZbvrQ9Yx2M23nh331ww7n3QIFamarQmlLuZs6HSKkNT+NZLSwoPziumKk8TI7Q+oTGBBzanuAdX5hXiCn7JTOXxkML/KkvvQJwWoMDIp7cKj/MI97LB86jY3c88PbNc9rsGIB328RIt74tCtdt5rAcMTJN5RTmqrx3nIHC6JXbkqk+MkbP167vOAIPElTrh9/0MZse3/WG/7d/+7d54403GMeRn/qpn+JXfuVX+OIXv8i/+Tf/hlIKf+7P/bmP/r8/8iM/whe/+EX+1b/6V7/vw16WheU/cRjf3d0BMNGYxbFxcB6EECIBz0UacQihllMSaf/93bxwPCWamnMsNELzHCxT6SEIqXmadxzbwsYNXLhIM2Nqne3fMnjXZw2jOGLHoPK8HfBuYG9KxfDBkZuSvFC0Gx8xEJ9orfB2PvQkP+uJbBnj9TTSSuspwCgDQrLIcel4JqLHu4gzxzmRGc+RTFNDxFMdtKascDxrGY/1Llt5udpbn3T9we9fgzdTQUJl4wLbOJJSIoU1j7dCMthPsFhFfJ+hf7o7sg8OQzDrqXkhFN6ejyytMUjggV8xVWXKhe16w2tDpFpl1xq5QwkZSf2GyHXEa6vK1589ZZMGbsrCoo2VO2OfM4mElkKrfcEKMbDUwn949oxVcIynm6B9gR9ebRk4MpeFIMJ5DAzBc7275hYhRI93/ZbsUVpxV5VdzixUVgKD+o4kdQPvlwNmykY8w8u13n1670BtHBflzAfOwsh65fCh8WizZXCeY8kUNVrrpu3r40TwrqfUOqHWRvPwbO7pu1GE1iI+LBxL5iyMPBgTao2b02jgEccGWItncH1EAqe8e7sneM++VbwJK594Ok1sYyCX7qnq2WzCkhvfuL0hes9aPNGEu9b48mrDZRzY6YyYsI6RH5SB3TRzmGaC7/WHg9dXG3ZNeaKFasoaR2xKa44tga8ddphTBudI9/X3QurvumS8Fc5c4HFYsV73DcvVsMY3x0H6u6jhuUgD13PBS2VRRQMcmzLQ2GmhWk8LHYowJON5XrgKkVfSiAjsa+vput5wtTK6xOB6kKHExtfudnjnuMkLVhsbP3CTF1ZeqEujqKHSyWlLXfiPd3eMfmZ03ac3aeFL6YzqlZ1mghqXEng4Drwz38Hc57Oj7/eVXxrXTBp4Z16YW2V0CtoL7cKNvFf3qFUGcYT2cnH4P801+HrKuKVyFiKvrAau1o7BB97YnDMQuHEzh1zxPvFoPXA77bnBmGqjUjk2gMaudS9KMOmp9RZ5Mh94ZTPyahw/yoS4rUp2ymj9FivgKAUQ5etPblHn+aDMtFq5GEeeTZmVC0z1QDMQCYgId8eZ3zreMfiF0QmextSML6WRCxxPy4LHOPeBq+Gcd272iHT6Xwh9lP2Htudc58o788yxNCbfKZENeDOd8XbbU6sSBEw/3kvwu9rw/+RP/iR/7+/9Pf7YH/tjvPvuu/zyL/8yf+bP/Bl+/dd/nffee4+UEpeXl//Z33n11Vd57733ft+P+Su/8iv88i//8u/5/YYRsNNcaiRGB/RZzy0dSXkoSgwRkZ7MFwW880TfU03NjH2tZGusxHMWPE2VbRj7zL51o8beGmvnsZMJx9FnqzvFl05NIVOskzKqKu/NE+ch4Jwjm1LUSFIwU4optD4DODjHrJVKJYbQU1etG0JjGNhNy2nAo18yeQJbP5BbI6qw8uDoV6ROhFWMLKXhFbBOHXhZ9CLqD37/GlSpBBeJwbMdBy43K4IamxhxqxGHcbtkVnGFUHm6lI/MXin2+hIR9iVzbJVzpyQXqa3x6PyCJp5SC8cKd6psXWQ62dS65Q1QT4oObcrzvLCokhBymfmdPHM5RjDP8VTnZ0MfoQDlUJUYAlsX+mFVC+swEF2nHqQQuEhrrvc3AMxLo9Ljvl8Zz7j2BxzChQSCQDEhtD5Hu1uOJDUEY36Jzpyf5jsQMSKB5BLjuGKzSag2hiiYhVPIX2WIHi2wz5lVkk6Jig6tfYh+aoW5NTbeM+CpTXj1/KLPpra+KO4VzoMnm6FqyKkOvRnqHAgcaqNZw4txLDPP6sSDtKGJkFGaGVF6WI0JVDvlirhuTN/XwioGLtsIoh2tOG54+/ktDbgrM1WMIXi+OJ7xrDaiCFsX8dIpKR4YQuefO7UeEPZxc+U/B/o0609F8RKIIXG2XnO5HjBVNikQZGTwjttlYUiJiHCdJ4LvtLyNE6o5gsBNPbKoshZh6xNNHW9cXKJVMVMWbdwqfS5aGskJznUgh2kjqKMoHHOlWA8MzDS+enfH66n2pp0Z2SD5bjzPzWhWCMHYOMcBo2rhLAVC7Y720QXONlu+c/MMs37A1lO9vrHecF06mf8Mj28wmXUvi1empSGte5qcvTwvwE99DTbDiWOMA4/OLjg/W+MrXMYVYQPJCdcus1mtSR7e3824055pxFioXATPt+YjU1O2znMRR/COH3jlMQ5DayHnzBHHmRcO0v0hQRym0tOinWOfK0uoFK1EMebW+PVnT3l9HMmmLNoJfilGqjXwcGgZ3xzRGTONo3rO0og5oDW2IfLo4pKvP3sCwDIbFSMFxw+uL3ivFEwCF8ERRGite2R6mKfSWsNbf09/HH1XG/6/8Bf+wkf/+4//8T/OT/7kT/KlL32Jf/SP/hGr1eq7+VAf6a//9b/OL/7iL37033d3d7z11lsAjOJYu27m6ji2bhJR6zQIEahaEekbcTH5aJ7TRJmVTqxoPWq7f8MUJ+GEPqwcrIdvXfnInTaCGYP0+fzJGpOBnZz6Ita5Pq3Hfh8NgncsGMX0IzLLcPISiHXKkNJNvEOIjG7AS18IJ+3GDqAbNE8btRQS596xOy4E4aPUyxBCpxScDJcKVF6eDf+LqD/4/WtQTi75szSQYmCI3fnhvecANAUnjkkrEcW7hHec8iGEppWdGtsQCeJZO0/ykLUQ40CprY+OtT7L93i1Yld60M0gAmIcWsEp3eBo4E8kFlplBq6XRpDA3PqGP4ZehGdhoPDh7H1Pi160cLY659wlfA875XZpzApOoGon8XjzePE8Wo88PxwZpVMqZlNG82yGxFADXvvPXXt59luf7jvQYBsCFzESo8f7CNrwrlN0auvkstn6zRAn3KCdkpgLylRh4wNe+m3PEIS5Kts4om3hqMbd6YbzbIg8rY1sxuD6+3WuFdFunLQGyfekcjttqvalguv/ltL9BgCXKfWOl0Gmp0fW2hi2iYER54QmxvOcya2BE5p1FoqjG4vPh4DVnmLZmzPGuXMMMRGbxxXB6Sng6yXRp1l/AbgKkavYmx7JB4xK9DDlE7VLPEur1JO5VprhxYjSAwlzFFbSmUxJHKvgmGrhYr2haGVfFm5KZa+NN1Nih1EF/Gk9nK1Qmye37g3wrtd21cakylMWghdm7WNA/rSluYgRzHCmpz9Tptq42gxsUuqUKIG7Vk7T3Kc9BeDME73nEs9+ETYnD8DRjKgwDpEYIkbtN/svEZbz016Dk3dcpcjDITKEQAoRtI8VtWIoypgcc1toCtUcvjUExSMUKk0C29CnLQZ6E3VqmYerC2qr3OrCc63sVHnLO4oI1UESEOl+ShCcBmggpkRgscZdWTrUI7i+4bfKpXeIwNbFTnJSY9GemTI342ozcLYaOlrYYF8zTSC3U7PYDLTvdR8MiV2eOXMeQZgMEsI6JpL3lB4nQXhRM/z/qS4vL/mjf/SP8tWvfpU//+f/PDlnbm5u/rMT3vvvv//fO+/1oYZhYBiG3/P7SmeaDu4UvAL02RdhbsrUKk6EOWec9yQfEdNuOpROFTmWxlkIlNPf+5CIIqeNUMXIpqfUR+kbJDMCvTt/MOVI5z+vmyd6wZ/mn0ccVbVj5OjYT3MdvbltnVBRT7zW5o1a4Cw6Vj4iTphoPD/ukNNi5c1IpkQUScbZEDgsrj9766NKnj4rmczTToE0Xl6i1e6/o0+i/uD3r0FTWPnA2vdrOujmQgPulsLdshC9cJ0PrAkMaUUwxVo7bV4aN9V4mEaaun4o9cbcFlQCVgqLViZTijVCcFiBZo4YPE6MZ6UbdDOwdsLoAqNAlP7zcWyNMTTEGdGgNsWLcBlXmDPmUvpYjjWWpjxKgYs04J3jNmfef/Yu0EkqHmVEiDiyKo+GkcPhiJj0w6UZ0UEKgZWPNJUTruyTeZ7fj3qR78CixsoLm9BvN01dBwQa7JbKfikM0bPPGQhsQgRTSumjh8WMXOFhGJnNTr4fYV4KWOnz73ZiSqsyesH3bC2Cdzixj4ICDwob3OnZexRPksTSlCjy0Y2UiBHE8WoaWNQ4lMy+lI75dBCjZxUSQXpi9Ddun7NSwHdEbRLPKIFZjLPBcTh2hnEP6rIePugDyQecKk4cH3Ot+1zqRdafU7jynsvgMeuJ4951gtfdMrObC6sQuJ6ODCH0zbY2Ktrxhy0jceRhHJmpnaTnAs9LZiiJwYzclH1TqiijCAeEIj1XJyAUUWZtHKpxGXwftT0BN9Y+clcbW+8xGqKKqGMQYT2OWG3c1cLzVshmzAoxBC6GkeCEXV54+/kzRgdLg9ELKxxriTTgKkaenZo3ZiDazeQpJjYxUV1HlIaXqePx39GLXoO9Ex5Ex2VwqDawSnMREeN6WbidZ9bR8eR4YC2JEDdI62OwzYQqyrHBq2ngYIZTWDnH8zyxmkZElH2t3NbGokbynugUdYJzHYmda28KqxpbHCtOBEdRVi6yr8oqOAxD1AimJCeMkqiusbPC7jRyU52QQuCV7ZrgPdfLxL9/720SgdyUcPKlblxgMuPhEHlnD96EDotXoLGKkU1MFOlI+fgxX4J/qOGz/X7P1772NV5//XX+xJ/4E8QY+Wf/7J999Oe/9Vu/xbe+9S1+6qd+6rv+2FPrxsVda0yAmaOP1xnNekdcgBQcQQKNxmSNvTb21milBxUca2UuhVIqpcHeKtkKwXez4ap5zlui1sYGx9Z1lqsTz0AgIHh6WJbSr5DpZ3uy7x2pYOCbctcWcD3AYeNd78TSSRsfphM1Zxxq4eY4kYASoPhTpoAazYybnPmd3Q3XquxbZbJGiYL3nnpiTo9OOAuJzYli8DLqRdYfwD5XrpeJuzKTm/YQtFqZT4SRbA31xllIpOCobeFYFnZz5jAt1DkzVscxN/Zz5rhUjk24bZlWHc55En1E7WpYU6vyyCUepZGztGYV11z4AU8kAQloBosKzjvqArX28YvkAw7P88MEGTYBLr2w9d2X8uG4mp1QibfHifdurlGvCD0AqXkozpi18v7uwK/fvM/zWnnWMrdtoVrBe8dumtBcGJ1wOYw8GDZ/6Gf5/aoXWYPHWnk6LzybF+ZScVbBGkU7PWWSDw8FQ0/DbYVdLdyUyu6EJNxGYW6Zw7Iw50ptjlKVpTY8HX98FQauwopdFi6953EcuEprHgxb3hpXiPSOu3plp4XnpZvcqiqZCg4iDmnKB+XAgrJ2kYfBceE9SU7IV6C1CCbs5okP7m5ZecOvej27U5d4VxvfPB74d+9fc2gLh1aYWkNPOQRTnggZts7zYBy4HO/r70XU3740ns0LN0smN8MMamvUJrTWG165ZRKRVIV6ejfetcZzNZozVq2jqnM1coGiHW98m2eqFVbecZVGrsY1AFfqeCUMXK02XGw2vDKuGKND6DfyizWqGDE43MlYacUIVdAG31wmAB6lwFUMrIMQRFFVoIB5MOP2OPGdmzv8aS13p9RcTk3Ad6aF/+/zD3haC7daOLQ+TtQ8TLliLJw54dW44tFq/Yd/kN+netFr8NNp4d3DxPU0005rcM4TpS60ZuRqHOYCFqFAk0x1ymTG9ZzxVYh0EEs1pSEs6igox9xYamY04bEbeRQH8J7z5ngjrXhjs+XVzZbXUw/PUm0ULUxUZmd4J0QzilakZQY1nArfOkx9bDcGLgKsvRK8UqngGskMaYVnt7d8/b2nNKBQiQnE94b10ZRv5SP/9vn73JaZZy1z3QpVu9fqZpmx1jjD8aobeBQ/Xg1+Vx3+v/bX/hp/8S/+Rb70pS/xzjvv8JWvfAXvPT/3cz/HxcUFf+kv/SV+8Rd/kQcPHnB+fs5f/at/lZ/6qZ/6A7mzt94xpt7FPh4razI5N5bqmbQym1KKMYTOCNlTqTRMDamnOU9neO2jERVjr+AZwCmtAQqjgxTgLoP3kFLo7HtxPBgiHI4sKM0b2fqGfEJpOHyDAaWI0JxwRqTlHpDT45fhInR29rI4lgw389znuzDEd9bxtHSqj2EcWuPWjJwXti6QpXfmPKeXrc+Il34L4ewE8H859GnWH8BFGhmJ1Gxc28SYIr419rW/KCrKflHWwQGR52VmtoKpktRxliKNIyvtOQqLCSbCuV8DB6AnLm+iZxVht/RN/Wb0xADiApv1K4Tnt1y3Bbxw1ModhanCtU6s3ECuFT0F0Z2l2PMpWmdRRxyPwsDYPIdmHJcD7+6umVufn/Wt8cowcN2UjUud8Vsa780HbncHfnh7QaFSrXdyjcKxFWL0jD4xhOGlSnv+NGvwlTQyuEBtjf1xYec6lPjYGst8ZCmFxQkP0wq8cVO6z8gZxALVO0IWpHXcasG4LZ51XAETgsPjOHOO7eC5nhRq4HI9kIKAEy7GCxp7vpMPiOtXyAXQVrilkhBCaTQaBWX0iaNW9q3120cnXKXEWfPc5cphOfLObumUFgQfHK+4xPu5sgoJDHatcb1UbqeFL50PzDSWargmp0OG9hEnekhhSC+PafLTrL/LVSB5R26N6TihtZIoFALHtpBdI6vjInayyPN5YtZKq2Dq2AbhwERTZbaO8d2rcR5X3JWJXVPMeVY+cOHgOAtDHBhTIPg+S391ec7Xr2EOc78ZN+PYlFkKT3NvfkXfA7qawOM4sqPymnNUURKex5JYRSVr427e8zt7PY3/KNEbb/rIdVYSkYpwbcoHy8z1dOStccVMzyCJCAOeY104k7HftDp5qcDEn/YafJYiIXoO2phv97RpIXkoDQ4sLKGyb8qFeFqCd447ijWs9RHECx94tuyIVcjm8F5YSFx54Y4ZnyvqejbEKyg5D7hVT6wXD0Ecf/ThK9Trp7zbMs6MxWBpDnXKE624pmxzxJyiIjyOHQsrg0MajOK59OClkak8mSZ+8/aWoo3gjAi8mQae5YVRExW4MePdw8zTcuSL44qpVcyEtU9471goPBoT5F594l5A0u7bb7/Nz/3cz/Hs2TMeP37Mn/7Tf5pf+7Vf4/HjxwD8jb/xN3DO8bM/+7Msy8JP//RP87f+1t/6Lh9x1yb6zo4G1hHmmoFuQHOtUxtcdKgVEpGVClk85rqZa3HGpfZAmkxPyRud4oNnRcShTOZZrF9dX648rUWGmAihs++twfmYuFsyAwN7GjONcy/cUFmd3PkN7XPMHo4NFg9rAqJ9hj80R1vBVGYaRqFhKBctIKcZ/KI9UXcInle9445AKD2B0hTIxuIbyTtEhNYE/4e7oPm+06dZf9APa156h+gsGLZkbnPmYIYprCUSRTgulW2CVfREHLVWSl44qucVtyJGT3BgJqQoDCGx9f2C7lBhVsNhvDKMzLWxGrekFPuNQlMenW+pN5ltWHGnC4e6cBE8Ux04Cw5To7RKQTESoFw32MiAKRQz0tDNwndtpkm/pULhLK1oJ+P3VBrihDEF3gqe8diN4oP3RHW4BrulkNL65J/p9e1fnvXuU63B8xARL3iBMSqzTUy5UbUvRNsQ+1hiLqzTirM49hxwrdRT+vEq9hGYIEoTY5Vg7cEzIjS8dz1xlMqjMZDVM6ZVT4Q2xenCetiymhfOw5q9FY5aWPvA5BpbOuygmJEFIr3rf4tj9WFWiBlDAl9dN5n5fqOkWrl0I4saGxy5KkgP+Xo9Bkar+Bp6wqoo1TWmqqx8AOlz106UKC/Pe/DTrL8zGXDSRxVGK8xLZaeNQ17AG971562nbURwkUEC6hqlFvbV8XAVSSJMrWEGZ95Bgq1PmCrLaTzVaeMyBtQ7LsY1KQYwo6lyNWzZlczWrzhoZW6Fh0Rycqxdp5Rks24Ub5lDg28fJtbO0YAmwspFnmvmtiqOPhqSm/GKH1hOgJO5Nsx3KMGXXWLImY1EcIaEPjKZrZFO3Pm5dl7/6F6embJPew1+JQyMIRARohXuamXew+3c/Woh9DFTPHj1nLWBRiNLZR8Ld1S+xJbojGqGD5GzlWdASdmDV6o6mjqcKg9HBSLn63PiEHsQVK68uT5jn695lEbuWmZfFl7BU1xgPYI3R2k9DfyojVId73LgLCR8cPiaWTnHROs3/KIsrZGL8eZ6Q84ZyzCZ4mLgYoxsDIZ9YZSIBNfJjNLHezfa33mHVrDgOPuYTQ8x+2xZzO/u7ri4uOC//l/9T4m+m3CjCwR8v85tjardojaE3nEaECbXr7pbM2iKeFjh2KSO3lTrcfKH1hAFj2Oyfs2z8o71yQCxSYnofe/k18xSe68++EA17Yln1qjOsTZHc8Zi/WoxicNb73Z43EeG3Y0PDCni1Hi6zCza8E7YOoECO+mGtz7D6ogycrQDUvoMIwYDnsuhj+8cqjL6wBgCtTb+D//n/zu3t7ecn59/T5/d50Uf1uD/7n/9P8OfbliGlFhJzz+YtZJL7SSAJExFWA/CHb0+S21YrQQCFy4wpviRscv5HpjkvDGS2NXCpJW191wFz1yM8/MN63FAgOvDxH45UktjFQcm6Zv2uVaEwCqBqDCVxlwrwQvnw4qo4FQoVVGUs03kwbil0Pj23TXHXEk+sU0ebbl326zP4yfnSC5wzAvOHMUZ4oRNGHhjfUalcTtXVj5wPiQcwv/2//h/u6/BT0gfvQP/F38Cob9bYkiE0Alic2noyasRvWOqjU1KTHZabLSh2jri1wkbnzBAnRGCI+dGcI4QAvvamFtlFRxbcSwKV+sNqxRRGtfTkbulsrTCJqzI1ti3mbn1jc8mRdpSObZ+65o8narW+ix10/7uPV9FNmlAMd4+HDi2yuAdVxKYW2Hf+qyZd6c06xDZ5QKnrxNxeBd4dbMhiLJbKj441iniTfjf/1/++X39fUL6sP7+N//zn0B6GDzeBZwp0TlyM3IreAebIdIMgoOdKs25ngR/XHACj4cVSQS17m9bp8BzCtaUlXimoqfZaWFlPfn21fMzNuNIM+XZ3Y7rlhE1Rj8wUdnVhakqwSfWA0hT5tKYWm9YnKdIJDCe0kqrKGcxkIZAaJ5vHPYca2UIgUvvaVY65af1rdDgPA9S4maZ8eYgKCLCQOSV1ZrmHPOc+zsxRQLCV/6v/8/7+vsE9dE78H/5PwHXazC63qhNPnJYGqUuRGdsx77Hg8heKyZC0Z6I7AK8IgOjdZhGCJ40RG504VCNMxdOWPbGGmHllMXgzQcP2KxX1NZ4cn3NdalMJXMVVxyt9tv8Vol+YLsKaK1MtTG3Pmb+YAzI0tHsnfQhDEl4sN5ANX7j7oZDqZx5z6PQoRu70qg0kF6DD1PiWZmhCNUrIXiu0oovbLcEg+dT969ux4Eojv/6//SP/4s1+Icy7b5IDeKJDkpV5toIp6AWo8+mKp1v70R6Gjb005gZzUEyoZy8NMEJTYW5waE11tLJDoph8mFWraPRZxA/dOuX2jfbBypRO6Gnxzj0+G0ffCenazfvmHZqjtNO9KknCk90xpUELBipevT0OQUnp9uB/nWI9ZTMTjb+kEjUzZ5DCKxC7/ouWjDp4SH+ZYuZ/BQ1eAc05qYcT1jUCnCapa6iHFUQ8d1R0rrRtx+hO56u0okqseN7mFoPe9n4QFaH0cfHmkGlklXZz1Nn8jpPyRnTyl0rFBEkCNF5spxIBC7STAlOWHnf69k6FF2sG96KGrEpV6s1cy1s4oCaI0pg9OF0iK1453uqc+u3UMn1A6yz/jWOMXC5WjPZzNy/Ed04/hKNlX2aCgJYp4/MtWd3qDaq9bRZRcDs9L8bTbXTe6yPa0UcswkjQvCACMcGczEu1o4qvpvADGozFq8cW4NpomjFeyit4FQ5aMNqxokRTIjS0a4uCEsBrz0cUE+IBbM+N7u0Tv2R4njjbGDRxiZGRIToHIP3VC0U9KM5f9NGPWULyMk8JwjxRMyCxmL9ZhXpHqt7ffJKIr25ZR03ONAJJs71dOSqHTXY/Yg9YdxJRzOZWSfYqeHDCXYBHLWP5JyFABIQV3E0zAlLa0xNuZlmVLoxMi8LzSqTGeXk4xu8Z2mGWSMQKfRD4Vo8VeyUNK00FRYzZulr8OvDmloa6xixU+0NXpiW/t41B5hRtdJaH2eKH77fpWMaz4eRbGC+UqTXZ3rJwi8/TUXvyFo7LhjHCqGIEUOnlBWMyfq4S/KdNqdeOnTfehN1EsM5iEC1xlLhplTWQwKJeBqDE7w4jm1m1yqreUKcIGYclpm5KXdakOIJXlgFz2INMyXgmaRDZNZeOhlPWzexW6MaNBzOPK+u10xT4SoNBOdZO8foOzmtUDoERntjucTQAwrFSCIEFxhC4sF6TauNY2s0BO8dST7eO/Azu+FP0sd5FoPSOunGKsQTJaAizFpZm6cED60/HOPDDXwnOyytO6ZrM26zUrzxKAZqAYejST8nNHO0Zty1zMo8gzikCUOAt3NmFN8PIeJYhcCuLjhvtGp4EwbpJqYd3RwwmEPVKNo4Si8CxTiPicF3r8HKeYrPBISE7xhPVTIZ6GaTYB7nHMH1UR4RIQZhahlrjmQvz3X2p60krSNXxXBWUefYLZnR9ZCXgpKbMqoSikfVdRzniRk+xl6/curGNxFulkzxxmO3pjZjFCGKY9G+2Tq2xnGqVJRNGMD6GNe7+cBWlY1FBi9chsiuZYI6jq3gDdbe00TY5crKO7xAEeWoissg0n+uXtluWS+FWjqXOPrKXasMPiAq5NY40hgcrAhEddBhiZjQEaPRuD4eUGucxT84ju1ev79ECxWjYYhUnIvczZkQwBDaaZ55VMgqqBe8F3wTclWChyKdWe5UKGbctN6gGGIk1+4ZcdLfsRN9TOFYGosmNsnjpPupfuu4UEJjEEdyjofDwPVyRGun/CTXDcBFu9kzIf1G1BpHVbT0r2nwjlc3K6alUKuxSgGnlZ1ZD94y0NZReAFh7SNI3/AnJydemyelwNPpyGLGpfu9dI97fQKqjSJKQRkcBEZutTBqo1tgjaVlKAJ+6OuT640GnIJ4ptYIXjtBTOGolWrG1RiZ1JFcT2nOvjdVjgp5OrLQ2AbfGx8N3s4T5944j4FVcDyMiQ/yhNTAon2+/sx7mhg3uTB6QcRRTNnVRjPjh83RfOPVzcixVpoq584jS+OAnurLqKYcMJz0enW+jx2JOHCO2GBIntu8UMt9w+NFqrTGbI1FG84ZznWv3KpVVGDB2JVMEM+lD0jwSAClb6CDeg6u0TCGExpzUk+blcdnI1NTAoKYJ4uxq8peK+9MB6opW/Gn/aTxnbJwxLhMgXXyvBZH3p0y1hrFIDrHBoeo8u4x8+rQ1+CpKXe1ME8eT8+5+eJmw10uLK1xNjjypOzFiC7Q8GRT9tJHJbdeGH3AS+hj3M6DF1Yp8P7hQNbG1fDx1uDP7Ib/mAs1KSbK1kfAONBd/lGE0TvEOXIuBDyPzza40LnR+91CNONOlWPtjGABgjeGE+/EuYadOmINuNUjgchEphRlENeZ17UzV9OHaDjfuPDGCtf/buuc3wVhI4F1c/hKB1BjOCfdbFsbw+ApFNyJqX5sldE7HrVIMcgns+/kO0EjNE8N/XRqRPQ0fTU6z13JzNoY9X7D/6K0WwpL7Jzxi7iGE7G54PDOsfaBcxFupwyMvPlwRYyBORee3e5YWeR5LswUpIFznuA9AxEA5xtT6UmOGeOmFdY6sCuFwkRNlYBxLIXRhOg/7IIZ68ERCeisfSE1ZXFwOSbWVTlrjuyU4iAFo1rheJw4W68YqRRZUF3YFWVMkTfSirn163XXpBOI6GNz6sG5wOgSi0GywBg7PepuLiz1JYs6/ZR0aJnqBBc9D8deM+er2NnfCs51H9PN3QzAD736mCEKx2nm6dM9yeAuV4pmnJwObWasYux4YlOWltnXQkYp2rj0I1oauWYETwFsmRhcn4NuGPtTYJfTgJ8UTNmZMovyMA6scg9Pqs6xcoFona6xq4XLIeGb4k1ppbEr/bbr9RjI1qhqZIRdXUg4BjUWFO88oxeqP93HVmMqmaJK8eV79IQ+33p6nMkRUuobbCjsp95wW0XhLDjw8F6eqE35gdcuGaLnMGWeVsETuGsLB1OiCaJC1X5TOFE6NS9nJs3kALU2Ip67WqmTMseeML9jIeBYB8+CcayFi9Bv6XctM5mxNzg441GKbPBcpcCh9LV2cEpRJefC2TqhOlNr47gs7F0gusgbXlhQikIx5a4snJ3MogZ4F1mHyIIxeHAW2ZUDWRcWH7/HT+rzqw8OByYPyXle8b7P9lB7YyP0UeyA4xuHmW1b+OIPvs4qefa7ie8sEJtwV5Sjm1nM4V0E30duoMNQdnlmVxbmCHdzZusTT6eFqTbOfKCq8qzOrNVztkoU4DorF6Ef9HZzpXghCxQxHnvPhoEL75lLw6EE10cnj8eJy82K43Gh1oXjvFBrYPSet/xIVmUWOCBMuTB4h2bIoSORQ+gZUuKEwSduyp55ObLUj/cO/Mxu+BddWIojA0ffUUTnnU3D6JUmlZtqrBAOdeGPPHrMekjs9jNvH5+xq43BOfYoczsl03rhwELNBSF8NK88iHDmI0eU85ZwrucA7IHnGFsCyXm2KSLe8e48ETycN88Y0qnr6Vi7yPVyZGmKc45BwNMoAneaWU+eZ60wWQE1fAFZjyzVMTjtYUunGW+80ICV9xxN+Ua+QWfFV8+FFyQ6RAJT/p49os+9DrVSxDOr8mS6BeCx793EAVhq4Tt1YetWPG8L/9UXfpjNZsXT61sO+wPHWiDBocCxZYbmSD5yZ0fmnUMjbE04k9iDXtKGrJBtRcBQazxtlffywpjWnDvH1XrE+cA3bnYED4+HxNavULrZ8dX1iu9c33DdZoLBBggIC4F3lz3zkvlO2XOoFbSPET32jmURLobAkOBWlFZm1k4QHOdhxW3J/H+efIfyPrSqvJo6EjZ6z36+33C9CC0zMHqOqjyZe/2dxcBaIxfJM1vm7buFCzcQcuWt1x+wWq948uyG6+d3HDM0GnsKuyYkImMY2DGxHAPajI0Ir7hIFeEqBSqVOfRMEzOlNuMDMR7FkbOUWMWBAnz7eMvgYDPA1m9PM/bCEAN3hyNHVYLz+NpoRSk4jnmBXHh3PnDXSo+6V8fjYaBWZT14YvBYddR5IjnPkCJbH7gpmV+/ec7ugwZNeXUcOB8TWxeoU/2ePqfPq2Y1vE8053g39+/xms7HH4BdLnyrLLweRybN/OAXX+F8veWDp7fc7Q5Ag0m7T42Kw3HhAntdeH7st5q+NtYG585zFSPeO/Br5lLYL4VDUyaEL602nCfHKiWKCN/e7xij54vDGiNgdD/L1ZD4gB1zrhR3wmarYb6z12/zxAelcjgZbqXNvBG7EfLcebwP3Jnx3ryAwhfcgMTI81b45v6O/7iHvHTf30WIbH1kfpmixj9lzfQwNTF40hYAzgiMsTeBn8+Zt8vM6+PAvjV+6M3HXGxWvPfBc54/vaHSaLlwFiOz9dvSTXO81xbqoXGjBXJjVOFVH/mBtGL0jkZkXwq380Q2h6jwg6uR8xTYDCNFhK/trkkJfmCIkAImwhgir67PePv5Lbt8JAtUwJoyAk/yzJPjkXeW7ptrpizHPW+lkfMhsCGwMcdQG79xOLDGsXGJMxe5yYX/cHPNv34f5qZcusCD9cDWR/a7j/cO/Mxu+MtpDhozauumm4DnQEFb73D1TTwcFW4PRw7L6cRE5fLkpJcmVOlmyegi6Ax0+skYHJvg+8urFXZUjkVxdvIQRMelBcR1XKe6HrPcTilu3jsGoJ6i5Z/rARVh6x3qexx4q52bcmwZ7z1TWThqRURIrjOKG46jWo8Tl/51p9ZPj1o6CcXUGF1CknCryqYao+gp7uZeL0KLVrpfpAcZnaVIOHU9dxXUHCOJROSmHXh2e81uf+Ruf8RUuRgi29YYCKBClEBKA74sPX20gHeOIThGbzzLCzen/ImAsvGOTVjx0DUSgYthjcexXwoTmS2elffgjWpQauVbd8/IrXLu+4zgUjNmCxE4HhdCcjybK3d1IWCsvTtRelxPz6TPXlOFEAZa88zOWEzxAhdjoDbHThsrJwTXDw33+uS1twKtU5bU4Cp4LkJf2J6WiqmxkUgaAvucefvpNUHuuLs7MBflLCWSeUb1tAbRedbJ00pAsjE7oTnrqbbiuckzzzRzXY2Ice4DZ2nF4zqwCoHzOJJRdmUmt0pyvf7M94U0N+NuOSClcb4aEenJkLkpprAshcbA+3NhpwuDczwIEe8CE5mp9rTy5QRY2BJP5nKjtu7jemUTSeY5tnqKU1Taff29EO3p44rSjNmMxz6QomevlV0WsvYxwpQ8t3PhyQd33IYj17sDtVTOo8e5kbsy47WbGS9jgAoHXcg4NsGxcsLoPM+Wwr52LGuxxiDC45hw6jj3jnVcYSYcl8xdLmy8JwFoYRHhUOFumfCqnMfAlY/cUnhaMwvG3VJYe8fNnNlpI3rhPCghBGYqN6ebymJCaLDBc8RYqSKqaNOOTfbCrihnQUCUyn3D40VplxurMfQ1txQuY2SInlsrtOpYmrBxnisf+eZ84NkHN9yFiSe3u54ejmIxQG6nRFzPeoA5K7eHSnbGOgS2g2Mjjqc5Mxe40UZujQHhlZBwUTlPjtEnVIVjaxxqB8ZAIC5QnXFohW/Mt1TNXHmHOsdQHdcmFBWujwsrn3iyZG5qJTk4c7AJAVPYa7/lnNUICA9cIqunFqVZpVglKly4xE4bZ4CKsdjH6/x+Zjf8PVW2I8GaM5oI6xgoTWlFEe1puEqPQH56e6QJfTyiVrYnynRyrtt8TYjeEzQAjXWUPrt6iqE/dIo/B1UGYOUg4vFeTgSeHgXfrBFcn6UXBEQ+MqmhgDOKdj+BnsK0vOuJuTetsmsVxVg7x0o8g0tYPM25CnhxrCxgVRDpqDEzaKfgkQcS6TnBAjjuewsvTnKaGe7faWjWuNwM3NbCsnQ0Z3RCpRFwvPPkmobjLmf288yDXPsIj0Tm1jnlm7GnSIJnHAK0/mLxXnoiqcEuZ7ZO8M5jamxTxDfPKI6lNZbSN/DdblRPjvWeCkhpLBRGPNa6d6mEPgY35cq8LFznBbXKJkY2LjK4yDgE7mruBCyhj16oR12lmVFa4aiNWpTXxzN0McRZd9Z9TMPQvb5LCTjpzQVFmE15Ywgsk5G1G3e9SA/jU3j7vWsU47D0oK3cDBcCG/FkrdTWGH3HHXvnWQ89rOvQKnjrxnQTcunIu+T6O3IVI1E8wRlLq6gWRgdRHFXoZnXp7+yEdgfSCT5QtM/POhF2S0WCYzox+M98YCUBD4xjYmm1f004HviBUo3WMmaxN1pUkSq8Mo5467ez3jnEvbxp4y9S4voto1bIpphXvpSGbuK1PrKanCMrtKZ84/1rKsbtsnBYMq9IJJrrpBsxVHq4momxJnEepKeSq4HAsfWGw74po4Ot67dG56HjEbVVssJSM9EpSQLmeiPFAFVFW2G2xkodlX54bM6RRMgnT9+NFZopawuM1rGvicCtqzRTkuvhc7XCnfWRxYNWcqsowmvjiEkHJQgO0fv334tUtdbpmM1olnnsAuU0/mfSD51HbSDCb7/znNmU62XmkBfejCMqRjJHPQEoovWw1jH6PhpGo2kji7Gv2tfg1hgE1s6B66nOrRkqjdJav71HcS4Cggv0xHGDqpkDhaTdZ7U0Ra3vFRZVjlq4aZlC41wiD91Ico7q+y1oFsN5z2thQJtj0krLxoFK1Z61+ygCxfUNvBrhYzZ+P7Mb/kDfUDf5cDERyslgYUgfozmlMyZn3M2FYh1v6REKnW2O9WReM6GqEXE0OnFFxZhNydYNSP3f7cYKA5opZj2Vjdqozsg0hA8d351GwCkG3BOp9HnY+KEbmP4iEumfk5zoLU76QQTv2DiPtt5ZFevb+EJnC4v1a8m1+H6WNIendRa/QNH7+ekXpeQ8iMdE8b6x9YFMNznK6RSQvMOHQGzG7WFiUiWbdkO4ntKRW89ZwHXqiWinQDnfXQGTNY6n9FPoHo3oHIqwWDe8ZQypmaKFpWUiMPrQGdacYsAxVCJeM9kKYvoRgQrpZKtmjSjgxJOkHxjTkNgMK+oSOC4ZKRUvAUU4tMrcKmrKZeg/lUE9qXVSVdaOZLzXJ6/kAkG6mUysY38XVYI4qusY1cE5EEeKsJsmsp6wxU4o1jdOpfbuu2Jk7QcIDPzp/TirUukGMYew8YHooNEN3DhPpkHJfcPfGl5gHQK90julzItgEph1YSmls9ROHxOgKNAqUbqZLeCoBikGNqued7KUPrITmmfhZNhrHal3EU+3ttYD5TBYVNm3+3fgi9D6FECZT7QTZx1CYNprCYERx+g9FzFwc5hOeNYGTjiasRVBnfsIjb20SvDQqsMjLDQWOknswzV45R2pc8/IKN4Fbksly0IxY9IKKKvQDZVRHEFgEEFCouQjh1oJ3qHW33Ve+qFFrddpcA4vQlbDB8+DuEJzYaqdSrXxntvWU3eX1jCMCxdP4IPAKH0fkNWY7s+bL0zb4MF5inWiolfITT7an3F67tELFylyczhyWzNHawQfmJ0jCbTWp0YM5VAqyXc6jg+Ofe1BgTP9eQNsYuiUMDOyKJHIrmoPoUQ5fNi4PRHHxLtOXjSoTbCSOeiHpDX6QUNgsR6K2Q+ZfcpjwRiHkbiKLEdPmytaGyvv2FehSGM+GeUvfEToGUDVaQccaCW3j1eEn9kNv0gPPfIGYAzWZ4VXp9Eak37tOziHSqfrVFOSCFuXPmq5T01pJogJc2uMp6irpQGeztGvjdF3qs65eNSMcloEUaM4iKX2BF3Xu1WXKVJO7OggEJzDXIRaWeiYKLHeh6/WndkRYeM/zAWAgzQunbFNa1xNzCWTSyFrxbve6VCUQeDK9TPc3AAU9VBNTy+/e70IJecJkvCu0ZzjQRx4thQuvCN6Q10fCxvCQHXG03mhWGN0ngepR11H73l+mKliBA/HuhDMg1UOajgPNcCuNDbiqE15OIyYwIJiVqFAlT7KY1Zp1sALV5sVlN6t9a533JoTUp04WiVIA+mmptYagjB64VEcMO1dur01VpuBB9szZD9ybQeObUdrfZN2KEamsvV9XlZEuDmCa2CtslflJt/X4IvQ2seP+OdJGmcussuV89BJDmbK1nuqBIJXpiWjKKMXtrF7TVbRc7vMPXTGO4p0zn1ujcPSUAFzjgONMTiqKZchsZixV2XVGhlDvTJXB2pkgxaER2drSlbiqSFjCJmBqhMtZ5yznoRrjukULIgZZ6GnihczZiv84Ji42qxJbuBWJo55ohQluJ7q21pj4z0PU8SJcH3slLO5dprUdV6+tw/qc6pNCDgXiRjmlTMc1XmSKtX15tSI5yw41i7xZOop4yvnWI/dXO6cY3KdgCdN2bFwNiauVclZqN6ovuM6Q+pNuQfOk5uebtt7+NaxVDYGuNOmyYSH2xWa+8irEwhBcLJiWmb2tbCViMcTgWKNRSsDgYeu++6aKXdWSSnxaHPGOCvPj3v28w6EnnbehBllLY6HPiHAoQhShSzGIpWd3o/0vChdhoCEyGRKczCqYC6SFKrUk0dDOIuewXmel35gOxPP+Ylck0RYtNdRMeNpXXiUIinAbJUFZXIdLJWip2jj1dXIXJQpZ9QUUWGHkVqfJ5+lvztfOVvhayc4Odfr3YdAnCf22kfLByc0+to+S2XQxCt+xFxv2L5TJ/5Hmy/w8GIEt0DZcTvfkkPfa3ovHKoyOMerMQHgasJJ6e9ArRw+5hr8mdvwf5gDtmuFM4FkxtIaz73xqh9Ye8+uVOZmYJ3Zm12/4vYiiPMcqX3Dr51602OwhNw669mfApKcF1IIrOjpbHfzDKfkW07jOC58mKYLc2vMKMMYeO3qkm8/3VNLO9Fz+ib8ZsngGwdVrHXc5xFYpz4r7YrDaT+waFLGAaY205qSW2YqC3a62jQaQbtx5cZ1PNOSraMfW5+hPJ66wp+x/LTva334vbxeCpfRM9I77N/MO37w7JJt8Dw7FpYKePid/TNacxxaYSUOHzw3PoPBKrue4Oj69aNrSvKBqJ5DbTB6hjjwVthiZnzn5o7aKt4EMyhWUVViCkgz9rlwMGW7dnz59Vf45tvvkYuCNdSUpTreO1RWqXFXGuIi4gO7ljtB6nSwpaP6kcFzLiPlmClzJZfcka+50rzgKGzw5Nz46rRjtYrk3E1rS1YOrbHP+p993+71h9OH38ebOnEhI0kdiynfZs9PXFywHiJtXzhWWBA+WPZMauAqK3E48Tw/jXqdTY09vZ5Cg6X0cZzkA8+XQoiBVRy48h5nxjvzgVoLHseggtZGoEF0+GDMrfXgOHH80Fuv8ptffZdDqaB9zLK6yPNjxjtlkn4bESWy157KK1Foqh+NIvYbWs9xyiwV5lw5TLnfDDQ74RU9S258Ix84i4F56RjGpsrRlHm5fwd+kvrw+3ibMxcREo65Kt9h4Y/FxDoNPF8KM4oJ/M7tHdBHViPC2gK5uO6/m+d+mylKE2VfDCeVkcBdbsTkOEuJTYiYb3xnPzPTcHgGAjU30MbKNYJ5Su1Gx+Q9f+zLr/C1r95Ql0K2ShNh8I7nCxCN0mYwT66Ou1yITnqOhOt+pAaoBNZ+YDoWltMt+2SVZkIuRmuNFbBQ+FpdGMxxKMba9fGQ2ZTDcv/++6T10TtwaWyteyWzCR9Q+R97xSHcWmIBvBi/fTehTTk0JYqyjvG0zhmH/QxxwJnrdDCMpTQuh0iejVUIXIyJK0aad3zr7oaSG9GEIImyKM03lEaiZy1hxugcP/bFx3zrW08pS+O4KGbCEI3DYhw4UlogEMgGT5eJsSRqaAQzfANnylb7rf5xX9E5g840y7B4snTC2YoedvfN1vcV6MKAUKVysMrhY74DP3NJu2+//TZvvfXW9/rT+L7Tt7/9bb7whS98rz+Nz4W+/vWv80M/9EPf60/j+073NfjJ6P4d+AfTff19Mrqvvz+Y7uvvk9P9GvwH03+pBj9zG35V5bd+67f4sR/7Mb797W9/7qOq7+7ueOutt/7AX6uZsdvteOONN3DuntjzSejm5oarqyu+9a1vcXFx8b3+dF647mvws6X7d+B3p/v6+2R1X3/fne7r75PX/Rr83enj1uBnbqTHOcebb74JwPn5+ef+ZfOh/jBf68vwA/Fp6sMfmIuLi5em/uC+Bj8run8Hfve6r79PTvf1993rvv4+Wd2vwd+9Pk4N3h9H73Wve93rXve6173uda/Pse43/Pe6173uda973ete97rX51ifyQ3/MAx85StfYRiG7/Wn8sL1Mn2t3y962Z7Jy/b1fj/oZXomL9PX+v2il+mZvExf6/eLXrZn8ml9vZ850+697nWve93rXve6173uda9PTp/JDv+97nWve93rXve6173uda9PRvcb/nvd6173ute97nWve93rc6z7Df+97nWve93rXve6173u9TnW/Yb/Xve6173uda973ete9/oc6zO34f+bf/Nv8uUvf5lxHPnJn/xJ/vW//tff60/pE9Ev/dIvISL/2a8f+ZEf+ejP53nm53/+53n48CHb7Zaf/dmf5f333/8efsYvrz6PNXhff98/uq+/+/r7XurzWH9wX4PfT/o81uBnof5e2Ib/D/LA/uE//If84i/+Il/5ylf4t//23/ITP/ET/PRP/zQffPDBi/o0P1X9+I//OO++++5Hv/7Fv/gXH/3ZL/zCL/CP//E/5ld/9Vf55//8n/POO+/wMz/zM9/Dz/b7W3/QF8bnuQbv6+/T0339/V7d19+nq/s1+PfqvgY/Pd2/A3+vvuf1Zy9A/+Af/ANLKdnf+Tt/x37jN37D/vJf/st2eXlp77///v/fv/cn/+SftJ//+Z//6L9ba/bGG2/Yr/zKr7yIT/NT1Ve+8hX7iZ/4if/eP7u5ubEYo/3qr/7qR7/3m7/5mwb/P/b+JNbWNb3rBH9v+33f6nZz2tvGdYR7Z2IjnFFQKsjMQaoGVaKUUkqWUAnEwFBCnpQHBiYgJkUNSoghTCikkpiikgqJktKFZBUJKRKR4ALbYYejue3pdrfW+pq3eZ4avOteN4Ezr+177Ajn/ktbN86Jtbf2Wd+z3uZ5/g36L/7Fv/gD+g3/6OD3Wn+qf3Rr8L7+/uBwX3/fifv6+4PF/R78nbivwT843K+B34nvhvrzX+z1oeHv/J2/w0//9E/zF//iXwTg7/29v8c/+Sf/hH/wD/4Bf+2v/bX/6PeklPjX//pf81f/6l/lgw8+YLvdYozhz/yZP8Mv/MIv8Ff+yl95Hb/qHxiWZeFrX/saT58+pe97vvrVr/I3/+bf5J133uEXfuEXyDnz1a9+lbu7OwDefPNN3n77bf7ZP/tn/OiP/ujv+HNVlf1+z5tvvom133UMrT8U/F7qD/5o1+Drqj+4r8Hfjvv6+07c198fLO734O/E/R78B4f7NfA78V2xBn5hV4cTlmVR55z+43/8j3/L3//5P//n9c/+2T/7Ha+f51lvb2/1l3/5lxXQf/SP/pEC91+/y6/333//i36U35P43daf6n0N3tfgF4f7+ruvvz9s3O/B9/X3h4n7NfC7twa/8A7/y5cvqbXy5MmT3/L3T5484Zd/+Ze/4/V/+2//bf7W3/pbn/35z/25PwfAf/1//M/x0WK9I4ZAKVDKTEUROb3YtP94gArWWpy1BAXnLUWFXQisncdbi3jBBcNSKgCbGHHGcjvOrIKnGMEoWIHeOc43PTEGwKCqLGlhyRmt4L2nlsJYMrMoVcEIeO/oULCW6BzOWVKpiFaC7UiSWaRSVemMoRpDbwx953DGImIpQO8hOoNx4KxnsJG+j8TOYoyQi0EV5nnhz/2f/+9st9sv9kF+j+J3W3/wO9fgn/yvfgDrLcYajLHs9zNVW/GVXFFVrLc422rPWkMMjmAdJhtchDElnsTIKnqMA4xgrKLGMknhQeyJWN6/3fP20HFTC7VWUGXbRb7y6AwXAxsXqUW4nmZux4SRwuA9KSnPxj3HUimt7HDO4a0hIuxiZB0jdymzr4mt9lylmducKbUyeEstcB4859sO5y25gEExg+G867HGsrKW8z5yvtuyPXeICIdRKFnJJfOX/i//7X0N8sXW33/+3/xJnDVUEeZSKQU2PrDPlSVXRARnDBrBWSGoEqzDe4+1DpGMZth6GILFouScwbZ1p0rlIgaCcXw8FS6jI0shlUzRyq6L/Oijczrv8BjmrNxNE/t5QY0BDEEc355HxpoxxqAGYvAcp0ywwuUQOe8jt0vho/2RpzHyYpo51opRgymGsy5wMQRCZzAYUBicgjO4GOldYOs8F33kcjtw/sBTMhyPlVqUXAt/6f/6/76vvxO+qD34f/df/wls8FSUokoqgjeGvGQA1EBbDRW1SsQTvMM6KCp4LGWpXAwBbwyoUKugRsnafuYuOIKxvEyFjbOoKmINCqyD40vnG2LniGoptbJfMoecKaJYUQZj+XBeWERwGArtMzCJYEz7+WchMKvwci48CIFjKSRRjCi5GDYRzrzDBoM1FovFWcUEQzSRzlsGb1hHy6Yf2G06MJXDXKkFair8pb/9/7qvvxO+yDXwJ/6LN7HWUQRSrUx5YcCynxLBWSyGVIRiKtYYnLOsgicEh1iD95a0JN7brFl5h0GpqixGkVMdPFz1OAPfvD3w2AUmqRyXzFSE3abnq19+wmAd29gz5cKL/cTL/cgolZCVyxj4N8+v2OeCs4bslHVnuZ0KKvDWpuet7YrrJfPtu4m3hxUv54mpVKQq01R40kfe3HYU71Dr8M6w7iw2ghfP4Nv692Td8eDyjAcPAzUXbvaFlA21KP+n/9s/+5+twddC6fnd4K//9b/Oz/7sz5JS4smTJ/z9v//3+emf/mnO1wN9H3He4pxnXCpGLLMIRRRVxRgwGLyBmhXrDN4anIBzFmsKFosYizqD69qF4I3NilIE5yxFFJ8DQ+9Q7yil4kQZnGfoI4phPfQYYyilI6VMzpWqFY0WTQZXlYqhIFhn8aJ4a1nHjj4Ecl7IVQFLKYIVcMDae4oagjc40xbDJJWsylJh5cBY6L3S9R6LsF1FMIZlFkQE1AFgjPlDfY7fy/idavDpbsO673DOUVE+tnsClrEWxjlRayU6i3UG5x2qwhADFsNcKwYlRMdcKlUMMVr6wYBRfvTxOTdzAjGMqSIWdkOg4jjOCSMwdIE+Bg5L4a3H51hrWS8D5+PMOE5tA/aWtSQolYyStCBYilSGYDjbdDxcrekPE704bHY8q5Bq27zP+4hR8MYiUjnOidtUqBWmvfAwjhgMF0OPO9vShZm339pSxVGXmVQz1rcL9H0N/t7wO9XfmevZ9h1YZdTCnOCiC7x/c0QkIwjBGegtzgt2FoKxOOvBtcaA9ZYlZ0oRglW8gWKVH7zcMqeKM5ZFISg82nRMUthPrX5WQyB0kdtl4cvnF1wYw9nSsR8Xjilzt1R67+kpWHFYA/uaWAB1Fh8sm1XkYj3gQuauFjwGHKgABrpoWEWPOuUmZeZcqUUYAoxFUHFEG3i86fny5YreO95ZD9RqqGkkScGa+/r7/eB3rL+ha3ugMSwiHFNhcJZrVVQNBqgqVBQcWLF4Y9ulzUBQj4kGtY6kirQ7HAnl3e3AUiveWYqCF+WiDySEqSqq0EdP33mOWnmwWmONYZ0zx9Ohf1wS0Tp6FC+CA0YRBIMTg7WwGiJnQ0cswmIXojpmwEhFhdYYCaDecqyFJAVV2z4ni0BNdNZwOQSebHtWLrNdrVFjqLWStZJ9u/bc19/vHb9TDb6z27JdrahY7nLmejzwwAee7Y9Y50FgHBdGTThvwUBvPdZaJlNxCi44FiOkUrGqrJzhoJX/1RsPuJsr3hmOpWCs5csPd1znmQ9uQFJl0wU2Q+T53cg7Dx/ywFou1gsP10c+PBx5dT3SdZFh6CBYnIMbyWRvqBjUCLFznG8iYgzbUnDGgDUU2y69Nli8N0xG+OQwsy+CNbCLnlkr5SAM3vOlyzW8dU7Xeb7y3iOkWJZ5gVqop5P8/1wNfuEH/ocPH+Kc+w47oWfPnvH06dPveH3XdXRdB8BP/uRP8q/+1b8CIFrHLnZ47xCgOiG6Dk0ZrYUqinOCMw4M5CpYBbzFON86D0YoUpCqqA887DqsNTzoe5w6Xk4jV+PEslTWq8BsLZUKBoxVQFhSYTf0OGPx3uOxzFIYy0QIgaDgDYjAQRJLqQSa/ZEVxYrBqaHgEM2onDrD1uCDpy+WagVTFcQAilVlAiJgM8wlo1UppXBx1mGM0nogBvSeM/ib8butP/ifqEFnedj3dM4zl8Ky6TmLPZ9ME8VBSZkoBrzBB8c0Z5YE3lkIoBUIwpyEJQkXpufdh1tMVL7vbEtdK//++TXfvLnjalk46y85lsyEQVAUg1blcDdS37C44FkZg1WhSqXMhb6LbGtlqIVC5aNJuEvCJRCsQ9QwZWEpQoclKRQUUcUp7Kxj20eul4zUtimrbRdpTZCzUIwgo2IEjinz3rs9xnmsMVgcRvV1PtLvKXyR9dcby2XsCN4yU9g7ZROVj61gRUHAejDWErxjrjPzUrCu0g8WpGJ6Sy0FoXIePO+t1hSvfPlsjQp8/Xbm4/3EUQpncUUphc47TFWMGlKqfHI48pXzC6KzmK5rnXyUVB2bteexac2HqkqZhIMUvDEEY8gCN0tlKpVHMUCuiLEUBK/gO2XXW+6MUqVt2DiDOMUVy1QqSTOiQpHKMgnvfd8G7y3eGcQ5pN6vgb8ZX9QeLFVYW0twlkkNQSEY5cacLmyn/acaaQesOTHlQvCO9TpgMGRTmYuhaKU38CR2HG3l6brHGeXjMfH8mEhJ2G49d5pItU3MpSpLrjw/Lry93uKdZUXAAEWE2kU65zhTg2hjNUjOHKvgDHhjEGDUSqrK1nrs0n5uVW2l5iCEQCJTFKoa1CjBWgKOQy3k0l6f1FCWyhtvrPHW0lpwSqa+zsf5PYcvcg0crOPNocdYx8scCCo86j3VwlwhJ8GHCpqxneVwm5jmVoPdzqFVsR3MUplL5cw7vn+749oLP/bGAyiWf/vsJb/44oqrlHlzu2U6JnrnqM7g1ZCPiV9/dsufePtdVj4QVwaPUorASjjfrXivZnItiArmODGZSo+jGsMsyvM5M06VN2JHTUqqwlKUExmErvfcVSGftlIxhmLBFcOhVuZckSulqDBOmR/+wQuCtXjn8FYQ+Xx78Be+UsYY+RN/4k/w8z//85/9nYjw8z//8/ypP/Wn/ie/92d/9mf5h//wHwKQc2ZOiVIq0VpW3tE5i6FtcM679hU8zni8dXjjcK3vABgQB3iMcUQX2IUV75yfc9Z1bNYdxsJSCoohVU/A0Ikj4LDWolgSievDgSUnRKQtEtajGrHW4ZwjOkdvLC6Ds44QAz74tuAV4ZBaB02qw2PbLUuhlkKtM64Uxlo5qJKAYi3BWnS25GrIqqRSebUkXtyM7JdEJWNNwUn5oh/h9zR+P/UHv7UGr8aFZ1d7bo9HfAebGOiiZ+07+hhwvceuPJvdwCZ2RNcoYq1IFOcNZNqHOsBq5Xiy2/GfvfcO5/2Ki7MtBcvdlHE4xmQYJLLqIps+sIoO6zw3kvjg4yuWw4QpFYfBWUMpC6rK4JWtUbqqjKUydIbNes1Zv6GzkblWXlBwLnLMBatCMO1+uVfl+XHBGMOLWnheKkkNITjOe08WGDNMRTjmmV+/uuHf/MoLnr/aU6W0zrK53/A+xRdZfwcRXi0zxyUz1EAEpmnGGIN3Futac2NwgVgjeE9cefo+0Ho5gSkJFCFUYXCOh+c7/rO3n/IwnvFoswHgblqoIiSA6ljFyPmw4qzrCcBdKvza81e8Gqc21TKGEAJLrYgGNtYxOIsaOOTWVXvrvOfRbqDzkVwNU61sQ2ARhxGDxVAMTKmSTQUUpf17Qog4G+idQcVQaN3+Z/uJ//HZS37x117x4tVILq3pIVW+8438XzC+qD14nCvXNwvjITPQpuM5F7LCnIUxVWZpFEIjpu2FgyX0hgSIVETaBDpgGZxnu/L8J48vWHeRi2GFwTMlRY2hOEMR16YHxmCtQVW4TZlv3VyxnyZKrVho9abaKBzG0YvFnOrMOXjQRy4GR+ctpRpSFVbeYkx7L6S2S6rQfn8AsQpOcFZwrk0ZnAgqypIy1/uRr90c+frH11zdzRSprfl2v/z9FnyRa+BH10e+/uErXr7aswXWLnI3Ze7mzCeHIx8e9tyWxHq1wroObx3D1jPsPNaaJmAVy5vbLV++POfdiwseP3jA//ZHfogHqy2PL7cka7hOhcEHRmCaG936PHjOYkCB21n4xY8/4OXdDTknvDWs+0ipwqqPPIyeM2MwRbhJGQ985WLHD1zueNANiFhmK+x8TwZqpdFhk6DANtjTZ8gQg6UPhhgNq+Bw1uK9ZcqVr39y4P/ztef897/4IR+/uENyJajBfM4l8LVQen72Z3+Wv/AX/gI/+ZM/yVe/+lX+7t/9uxyPx88U278Tfuqnfopvf/vb/NzP/RxHKaQ50RflTBpVYlwS6+ApZWLKiVoMm8HTWcvF+ZqssNRClkrnLGs/kGYQVaK1nIcICyTnqFQmVZJRcOX0ZkS2u0gpM0YzK++p9Zy07HleKsUYVA2xGF6kCRbYAZ31FGNZnLCTQE+7qS5VEWl8x0RTVTw829J1garKzXHE9RaWRFMKgCgcshALlA5WNP5sQVg08a2PX+FXPbt1z9nQY1x4HY/wexq/1/qD31qD47TwXC1LcDxNwqO44sU4MniPHgrHcWQ2hpW1bOKGN9/YMWnhbp6ZjhPr4Lnse8axUEqht47LwXC4OzC5Aeegimk3ddrz321XfGk443YcWVJm6CPftz3nejry/odXFNqofFs8X7u9orhr3vWR8y5SrUWq8DhYdrGNE6/nkSkVFhRW0AH/6y+9xW4bWFLm1z68YTV0TGmkL6BiqBWu5kSsQG95GiK9t2SnZAr//bdf8e8+vObLjy549+GOVYyv94F+j+GLqr/L8x6rkakotmYuXeTjJbELnqWvJ+6qEqrDVeFLqw3Jm0Z7nBNr54g+8CpNSHWsbM/j7ZokUC242hoigzVIKZjF8GS14+ysYz9NLNPCtu/40bjj2WHi2+MBdRCMpS+O96dEt0ycGVgZTxGlpMplb1jHNgG6mxZeHkaOUni6vaTWxJ9+5xGPzwaSKv/mw1ecbVeYw0SuC7UKpQrX+0wA6CIrpyedjKFU5Z/98gvMN17wn75xzg8+3rEe3Ot+pN9z+CL24AmhSGYqcJEcOwsvqmPjPTeSmYtgjbCzEQf05xuwhqUK05zprWHj2/9nreG89zzYtrWiAlO1VE4XV1HqqOyc5+0Ha5ZSqFXY+sgPRbi5KfyH4xXGG5yxuGJ4f1qI0RIKrK3DOEOuSgB8ZzFYUqocl4VZlcvzDXsWfvTxlst1TxL4pec3dJ0nT4FGqGwawVdLwQEYg/WKOigGCpX/769dEf0tP/DojHcuVnTdff39dnxRa+CrsTBOwrFU3onwpbjla/s9sWQkJeZc8NawsR1r8Wzffkw2lkPOHOaJJ9bSr3acB8c6Rh6uet44C6RxItGm5lTHmkZtTWPiSb/lzQewnxZctTxdb/nqZeH9D/f86vNbjFc8oKPwy8eJX7y9wc6FrXdYZxjngsfjz/WkEc0828/caeErb23Zp8z//sfe4StPzphz5f/5r3+d87MNd3IkVsWqIAI3t0J0ShgcIoozBu8NySr/j3/+Tawz/Jc/+pQ//t4DNtvPdw58LQf+n/qpn+LFixf8jb/xN/jkk0/4iZ/4Cf7pP/2n3yHi+I/hL//lv8zP/dzPUYPFekW8QLCnmzjMVRAstO2AKqVRIGo7LKsoDnviMjn6FagIRYUPr44AbLaR7Cr7uQkevHHEGHDeYSIY604CXM9GC4nIvgqIoCJkDJvQ9AQpgzhpReAsvvPY6DDGsEyJcUnkAA/oAbhdMlYz7jRbOXcrDoPDS0UrpAKjHKgWcm19rw4IFoZq8cEhqXBVR45LPv3Ue/xm/H7qD36jBu9EqCUzVIe4gemk0chO8c7R24AzBodwl2fkkEkipFoxGEZZWHcb+p2n1spRlX/5jZcAvHGxYfGVb4+33JXEmsBmPSDeUbUJMr01bKPHblf4xZMPlakUjCqLKG+cb7iSws2o1KnivWEdHKvNwKpv1Iu7feGDeaY6yxtACJ5fu70hjIbOOI4o752vuZqEi80GFdhPiV96fofRypKFW5rGYHCGjXOsY8dNXfiVF1c83x95Y3Nfhb8ZX1T9vX+z0FthFx3n6wgehhI5HBOmGExunVBxlbkKLjUtkwgYhRnB49mtV4goE5b/4eMrAN7dbkkkPpgPXEtmsJazoUdXrtHFtGICbGMkn/f4RfnGOJJFQJVRlTcveowJTMeZu7qgVIYAm9XAuQ9YY9izcKgFq4apKlWFr93d8nEe6Z3HOseXthsi8LQbsMYwSuEXP3iJipBypYjBOIMLhhAt2+DIRfiVF3e8OE68OXSv8Wl+b+KL2IPj+UCHpbOO0AdwSqxga8YBwXxKEShkcZg5oRhElKDKgiIIxoCt8HIUDimDgYd9JLHwyThxSJngLDF4jKEJyo3BGkPvPbpyaJx4kYRaQWmagofrHm8gaSWLoFUZIpxFx5mzWGN4VQqzVIyzTLXp5L59HLkuicE6gnO8sxq4so7ONLOCfUp886pQAIxBpGkPggfU40OhqPLtuz13aWHn/tClkN91+KLWwPmiYqyjDJGw7pHOs8sDd/uMWT59dWus7pfS/jfmZIoCoxGKjOSj5WqcebHf8+F1+66n6zMWX/j16xtezAur4Lnc9LxIhXbKo9HT+si7j3eEveNX9teUqqgY7pbCew+3rLzl+GpingtLUS7Wgbc3HY93Pc4a9vXA3SETg+cmJ25r4V+/eslH+cDaerabyI9/6RFDtARjCM5ySJV//q1njb5WBNU21fdq6bHEAZYq/OsPrnm2n/nKbv253tfXVqk/8zM/w8/8zM/8nr/feINxlqrKYZlZjGdwkGtp7HXbRGLR2CZUVMVqc3lQ2xwkxIFRQ8GQq7DUCRE4s4WZymFeEK1tlKzKLAmyw6LNVYDmumNNxzIv1FpRUaQWirV4MWQjZC04MXTO0fnuM/GIj44gFoMiTqG2aUOtUKW9+ZNmqELvHS5YlqrMKSKuMuWm4hYMYi1WlGqgilJqhaWJe+/xnfj91h9A1baZ7HPi2eGIt56d80zTAjQxjjdNdLifE+I6nELAUJxF8TjvOOalce+KcjsJosJoKkcKL44zVUBd28TmaWa0FafKJjYebN9FQvQcNCGHmbQUFoR9rmyj5yUzY8ms1HIWAo83azQAGM5qJNcVR6kYq7jOUcrMUoSMw1nD1d2INYazTU/0jnXvuDouVCPcTKk5wWgbcXtvGVVIKkypufSk+Z5W9tvxRdTfrBnUYis8XxJ9sUTXZrfWgHcGa6DzSq560lQYjFGqA2cNGlrnXapSRBmPGcFS64FjnXk5ztSkiG9iynlJzE09wsoHjFdWgyd2W26tcDMuzIswS0Jzx+CFo1SWkjAqBGt5tBroQ8AYeLTqQFbsUyXpQvBQq7AfM5MRjHV8vD+y1MyDGDnrO4rteXU3MkvlxZjaaBSDs82BQyzE6LgdMx/fVA7H/Pt/YH8E8futQbd2GBvIVbmriSjgrIJprmQec6pDWETBGMyJG2+MRRFKEYqtqBiooJMiDuZcmbVwuxSyKAFFaRfJsiS8oWlJjKGLcN53LEc4pMJcC0stDNbgxJKqMGtTPUVjuIgdMTZy79Z4qhHm0+TIOSVr5W5RppNe73acUWPY9IHeG/pguJ4Xslj2S0K1OeIZsQRvgaZnmFPhRRZuzb2G5D+GL2INlEHJRtmbzAfjgb4kds6iYuidh64dhFfBs8y1udQ12TjZO6qBKVdmL9Ra0KTYsSDAs7vEXhIfHyfmXOiwzKVyyAlTCtE6zrqIsYZN3/FOFzjYzMv9zN2cOZbKSpRBDc+McK2tljfieOtiw6aPGGN482xARZmyMGrFdYaxFD66nQjV4tXw9WfXTCXzeLfi0WbFpIZv3O3Rorx/M5Kr0sg/NGc9p6yr57hkvvmqsj98vjXwu/dq6iwEQ63KVAqTUSy23a5UsaaNCUWVehIsWGdPfCeHoS04VaFWJUs7aIHFp8xSK0WEkxEcd0siZ2FJhsE5fAyfTQmWWjnOmbm2i4UWAW8ZjEdsQWiXDW9NE6vZRv0RawnBEVD66MjSBD4qijEGI8K4LAQEXKT1LoTOOvCGUpq4V082eiBkbXZ2IsoilVTuT/yvC4pS0GYDdydY6/DrNTlljLRLoTHNLmzRwkAkOI8PAesNViGrUGslVaFUpZR6qrfMXc6UpMSTDdcHd0eWXHFOeNh3nMUeYxy+c9zuj1wdEndjohahoBjnOHORQ8gkmmtVNIaV8xANpQgr7zjvIlEK55uO41IwxWIFgnGgyvP9kcfD0HQlKlRpQkofOoqClIraJkeooowlY2kTtbFW5nRfg68DRQtJHZKFdCwEa7lwrWlgTVsirQFRoRohxKZVwoAYwVplzko1jS8vgEhz8bnLhcOSqEVZOc9Z3/HhcaIAaw/b6NmedFK9g5e3M/tj4jA3K7u5ZHoXm/OPNSRjEVUChpUPrDtPrkLvPLsYsbZy2QcOk+U2ZZBmoVdU+Hh/ZNc5TGifuapCjIaNa7SfnKWZHLjWuZtToXeOLMJShWNOf9iP6o8mIqg3pNRMMWZRNtqaaA6DmLbmVIWiysY7vG0uPQpQhXFJyMnWswpIEYw1HFNlrIUiSjDtInedE7PAzjg23uG8wdh2oDvmwpxbEyxJJdfKyrTDnT1ZxCpgpE0uO++bNahzDN7jXOU8dHgjHErBCI3Pj3A1LawHD+oQsVTAe8PKeoo0sXi7SFuKKqLNGbAIzFo53OvoXh8cVKccpfAsK64svKWRWluz17rmxlSNsqhw2UdWXY+xlmwFo5WXVwcW36biKRdKqVjXCvcuN6OVlfPs+p5fvdpzuyTO1p6LLuCMxRhLjJbr/YG7u8RhbN+TRYi5HcC74HGhUnLFKJx3zWFtKZmN9zwYOrIXHp1t8d5wKBkrELFUEb7x8o7zlcdZUKOkWnHOcNFH9nNhzIK1EJw5ufEJaxxFhSlXxvz59uDv2gN/DQbXKVoVybYJtJaEx2G0WR4aazme/qEiCsEQu8C26/E47vZ3TEqz8KzNRaKLJ59dBG8c1jqswEfjjK3Qucqu7wm2UYaM8dwc7nh2e6QYwXmPiuPhaQSJWFDFApWKaqbTjlKULOCsxTnH5bBiT2FeRiwQbVsxxkWwsYmHyZBzBSydtSTjEauIgXpyVVlqZiUdFSWrsOT7xeZ1odIuhLXAPCfA0CntICQGI4aiwifThETFl8xu6NmtenadpxPDr378jGDbh7rURodYdwFvA0GU4TOhmOP/9+wKmy3rzqA72PUDIXqqU77+jVt+8devESes1p6a4Ucu1+xMT+4q6pvd60ETUyo8Xm+5m2YkN7/sTfC8+eCMD66O6HFsLlih5zgu7MlcinCcFuZSuZtmMMJ5F7lJmSM04bgqZalIFc5DG5kv6Od2CLjH7w45ZwhQxLIsrYs4W1g5i1ODlyY0vFsKi4XYWXarNcE5TF0wGL798gZjG0eak8ByG3uCX+irwxqli4HHuxX//tkVg3oebiIihk2AzkW8K3x8+wm/8q1XqDesN5Elw3ZlWFuDdB0r65lLJtVEFdiEwHWeGXNlEljHyI88eciHVwf2Vzc4DBdd5NWyMJbCgz5SKrw8LFynmZs085VNz4Oh42Ay1TQe9dWcYM4sJ6u9bBXJ96Ld1wF1ijhBg0HwpCroVLA06+sqihrliJBr68jvhgHrHLVmYja8Py94NYieLqEeNr4ZZETxGCrROc5WA+9Pe2y2xDjgK3S1NfEE5fnNwvvXI4IST44DnbV0nWOjStDaJlkiFBEu1XGXlZyhqGUTLV8+3/LiYHn/7og1yjZarpMwqTBoZVwye4GblJmWzG4b2PWRVDKibdJ+mzJU6J2lGKUaJdf7hsdrg7Gob42zUQySBTkWOgUnrYuholzNiUNNvLt5wqPLB/QhUnMiSOLwck9KUEs7kIvCEBxDCIixBJPpg+Pxgy3/8qPn2En5gXfPETE4Eu8+aWvvr3z0nH/1H57hB8Plg0iwcFEdKxd5Z2VY4bgZF6pRTLZcnq34ZLxlmitJlSfrjj/93lv82idX/LsXr4gWHvWRX7vas8+Vp64jV8OH10e+fbfn47sjbz++5MlqYF8K1ShilU+OM640B6rstH19zhr87j3wW2nhLk5RW8E50ghOTyFHgMG2kCJgnnOjylSoIgw2spSMxbaxY/B0NEqCIGSULApU8ELUjgq46JiNsC+Ft5xHtfL0vGdZBiYpEC2ow+KowEzGYvA4MjAlg/eVpAJW6XEYIhBZx8pthmYuYSjO4br6aX5YC3jyzRq0Fki2spxcAqzQ/JuqozohYJqbkLvf7F4XmptD6zqComIZU2IbVvjgCBnMIiCWZS7czjOIRcksWQkxcjePGO/xzrDrHBoCmxi4YWGxhSQVoelOMB4RqN7wITPUPT/qHmKBH3/nITIXblPCRIgYbIEkmdtpQWoLnJmdsk+FR6lyNy8YY3lru8NQYSlc9oFvGDimRJA2Kdg6j1RLKW0c751nnpXkM9OcuZkKWQTnwAVwFY4Oond0oXEM7/HFQ6tSrTQ/ZwumVshCrx6vzdKtCkw4SM2/vtZKqcJxmhmi5ZhKczPB0jtHcBB9IdlMjVBmJc0zx5IRK+ynmXqcua6GFDb8sF9jFf74l59ScuHVcUGtwfWOssASM3NuoUwigo2WZAopKzfjTOcsX7k8x1eh1MJF37MyjjEl7lBqqURpFpCLEaC5pIQK43jkOlf2U5vGqgdRQ8SRq2K0ccWl3l84XxtOYYGYSl1gBtau6emMNHtOIwUpFqmt2z8vmev9Hf3QxJPQJqGdNXjn2LjAvo4UYJFKloqbDBFPovBynLiOltF3vG3XWAw/8OAMJsNdSWg4hWwtpk3fc6Joc2wqDvamsKuVqzlhPbyx7ugSlFo5i5Hn/siSKtMMJ2kuCZiknvxGK47AskBKmSm3jmq2lUxbezO0Rp9RHPf197qgCMY4qgjTXChV6EPPzlq23pCLcjcJNS1IaZlIpgr7Zc+3nj/j4XrNYZyQYunMaQ30jq3ruI4HZlXGUtinxHhXwMK+VH75xQ1mMHwlnPG/WbVj8n/xn7xLmpR9XhjWDtaGZYGbPHG3CEtWrHEYr+zNwj5NfPN6j4uOH3t6QZeVcUmc71aYl1dcjzM5F461kkulVmEcE1mUkg19tlzdjSwZ5lQ5aGE0lVINF9Y3yuZJdyKf0xr7u/bALyLk3+Qx72gd9Fr1NF5rx2TnLCCcDT2boafrAsZbDkvGeUctzaLTGkN0lhghiW0/TxURS7PuhK6zeAt9aDxmaEEGMXa8eXnO1TJxk5fGn5dTR/8k76gGOu/ZRcem33JcDiSpqHX0HjKJpRR678lSqaXia8UD1TnU2NadKBVXHYur9M4iCkaFXpWUANrCmm1zHU33Z63XCGn8YQFVAxQOs6V3S8t8oCU6U9pr3rjccblbs+k6bIUPlht2Q2TMBYolmiY4fBo93wReFiG0/YVaDSEa+qisguG873i7XyOni/tZ1/Hj71zya9d7fn1/5FWaeSyFdPRYbbxYCfB0veadx2fsVhvGCnNOOCPsYketwvXdnochkMQiSUGaP//RJaQGahamJdF3gata2FrHHCpeLGdYnqdKHBw5V45SW0bGvZDk9UBovClTwAgVywSMpWCrYLBE3/Fw19bC6JrbU+cdq03P1XRkwDGVjGhBq9Bbw2Mc+77nZaiMMjPvF8zY7PQCsAmWy03Hm5sBaNSHwTl+4q1L/v2LW37p5sCyFFye6MTiQyAYz9BFztee93YXPNhtyAjzvNAJ7LqBukw8uzuwtuC8I1Vp1soJbseE3SoV5W6pxOC4lnZ5qaZgrLTQOwNd9ByTICd/4/I5x9n3+F3CBozxYBQNFmcqqRM4tGmlURiMYb3etdeLkJdE8J6H6w1X88iAZUagNPpZZ+DCWJYYyKbgKmgRpjnhYmAInuAD22B5GCJIcy/bWMv3PR54/074eBzJWkkV3NJyeLxxrHzg6WB5vOo57waynKgR2bDqAlKFF+OEsQZ1luOpbCwwLRkfPaUox0WJMTCSWURIRqhUTK14mhV3ro1iYYyh6n3g1utD24BrqaQpg1MOzuEkYOeMrcqq63j7/DHe2ZZcezsxdB1feviEb189Z7CBG83UIvTV8dBHvm/T8YsiJJ0wM9RZWVIlhMijwbEaAuu1551+TT3lfAxrx5/5scf8h5e3/PL1nsNx4fmrRBxafa2c53wdePNy4I89esr5xQ6tnrs0Eqzh4bCmLoVv769YO2UGnh0Weu+Qqrw8zlhnSVW5mzMPt5Fb4FAyM8osLc+nWpBV5JAzLtqTe9nneze/aw/8vx0KSKgkLJ1ajILUQq0FEWXzYGDdt39OyUJATyJYAIO3Td1scmZSeOA9i7EcSiGrQvREp0TX/FVXsaNUi3fShEO9Q4vhOFfqp378FbycVADOEKsjEimpULNBMVhtXdwYO6o026/Gxjc4AtOnIrzTz8S3LlxK7cLRa3N88VaQUzfiSMFYTtzF++7C64JWg5wulq3H3+xRcxW2J43HVArTlEhkHu3e4Gzdk6twmxZ6Ubp1j94tBDGsnWdtYZKZw7jw3nrFGCqvpoXDUtj0a6IkhhB40A88jAO11N9IEOwjySov80wVoSZhTWVjXRPJqcGLIdbI1d2Rm3FGtB2MpinxcLMCYBUcQS1NvilMWfHZ0keL7SyDM8ToeXUsdF5ZCE1YbgxrY+is4YMlt5G6hfFes/Za8NkaroAKTbZlmGluTM4YxCoPVgNLcVzsOjoCS6m8WhaoyrY3lNNha+2VjQrTuPDJOPJ0FVnheWUKRwrbLiJ2Zh0dT1dr3lhtySheBamVvouoNxxrpooiRUlYNqbppixNQwJwfXfgcEyUUqimcDstPOktS1Kcc/TOYVWYRahBscaCOQlze8uqel6lxEZdo45opbfQ4xEnTE5xJw632vsCfB2wRnBOUGcwJz99YkGj0lWLmpYe/2jYkB0Y5/ACJWcOaQaF0HnylBt1zBlWBlJJzGXmyapjMYb9UsgFgvUEhJWHi5OGqQKOZgccgyJe2Z/0AFrbnN27tj4aBV+VFZ45l88m/osWrkQ46zsSivWO6Jpnes4Fd4rKLDS+eIhw3lvG2VNDImeDEY93TQ46IWQE/ym16X7C9NpgnUWKUFNFaoWsTP3Cyhu20WJTq4X3Lh8Th56r8QZblGUauUojvTrC2Zrp1R4MbINnFwzzkkjHkR9Zr7jtPR/Xmf1SiVbpOsduCLx1tuWd3Rnzkuk7MNWyXvVM3PL+cWLJlZlCqoZQHdUpYpttcQBur/ccjjOptobfR/XAo92Kw5Rx3jKsAyUYAgarETCf0eTi4HkYPYelIFXIpRIxxOA57yIvJZGo2NICEsvyPd7h/+1QJ1AdxUMQcAIofDrJiNESrSelwmGaMVbpLDQBvWKMIFaJGKayULWwip7HfY+zzVGCmklamFOj6XRYOheItqWnBmeJ1iJYtr6jqmBMbQJdMaQ5cVUF7zxLm0fgjGETO4KHtemZ0kKWimhtHYYWWYhzkeg81luyVpypxGqpchI7qQWUWSqZ1mmwxmDvm1uvDSq/nZ/eDvy3S2IInnVoITHJWSKOTezoTWBKIy/v9nTWsraG3ilYRUxmVsVlw6tlJqnwuO/5ocsz+j6i1ZKWietl5uVxap2t4FhtVgzO0fWRPnjW1uKd5+2zLTUXrK0UICu8Oo78kjzDBct+ThQRhuB5e7tlte546B1304FRF1ItPJvyZ8ExG/XNznOwHJZC6IWNXTNNLROgVENUy/U0syxKjOCMbXqUe7w2NIckxRiLMUpCWdmW+m0MBN8hwLYb8GJYlsz+2LI9NsZwcBXVSsEyovTO82J/ZEwjD7vA912s2fYD1jrGo+PZMvKNqxvmnPmRh+dcriLuZCRgbQsUDBa+/PiCOQvRKMYaCpVPbhPjXOmtYS4tEyVay1u7DZvtind94G4aOZTUDBnmEw8EsOo463rc4Lg57JEl88ZmwDvLlBMeZcDz8ZygQPCWYJtTzD1eA4zD2HZEsKZN1X0smE3EGkHHlmLf+YAYYe0jpgp3S2Y/LQTn6bHMrtlzFqMkBYrhmDIYZddF3tytWfmuJTCnhX2tvDwulKJ4E9l1AeOgVbxrWhTg6fmKKWe84WS9UblehHyzp+8CU24Wyc4aHg2evos8dpbbeeKYm5j4qII70YJj8OxCR4iGrIJYeNh1OFOZa3NOi8VyLAW0/Q7Nze/+wvm6UKfmVFiXSs2CUaWWwp2Z2fiBgCOXijeOYpQzH/AersvE9fWB81VkbRxdMBSRZmHsIFjDi3lmroWnqxU//sYDuqFnWVpa8wfTnm9e31KkchktfbfDOT25PzlKabbZf/rLT7k6LvShmbaIKN98dcdxKjzYrLg6TuxzwnvLD19ccna24Qe95fnNFdTMYiov5+a4CHAePQ+2PY+3nsM0kyx839mOD8eJ6znhrPLAep4tM1pO3jYY4ue8c34XH/j1N/5rtPXFjUU86OlW41zbhEQKS05QoaRKTpk+gNVGiWnM0GZq5Gg2nkkMK+M56wLbfkAE0mx5sVTmXECVHDwd/rThGqJ1bEJAC6ycZ0oVPdmUGYGpZqaaCT5QrbTAL+NZn3z5+xBRqTgq1giHUtuEwCjBevrQ4S3sK9ig9D6SKswlI1lRbZ0FqwZ7ckpw94vNa4Ty2ycoAoy1MNfKBs+mD4CjlMSUMrUKh2lmmWfW/QovStVKViGr0osB65ikME2FR33kre3AW4/OmSbh5ui4fj7zcpwoKnzpfM3qpDdRgXUIPF0NBGN5vBq42k9gm0+05MrH48KLcWE1RFKtVFG2sePd80AIgTMfwCz0odBF4eXSnKschj4ENkOPcY5DGvFe2K1WLFa5USWVjBHDXITBOjrn6Xzr1N7jNeHTElTlJFxqnUj4zKfc++5EqIYkibkulCWziQGvQqWw0FJRZzWsTeRYMrdL5ixuebrt+dKDS1IR7jx88PGeZ9NIrpn3NgPSBdQqpQqds1wOPd4oTzcDV8dCoFKNsM+Fj44THx0nNtaCbY5CGx947+KM2HU8joEhVLZFuauF6eReJaKsQ8flsCF4y2Ge8TbxxnaD847nRxiXBWtazsDOBnrb0liTve+wvhYY2w79KMYoahw+ODRYKBWTlEBFbLuIglC0OZZJFfqghGqoCEmk1W1tKd+pCmlObGLgwdDxZLMliXKc4PbuyO28ULTyeO2A0JpqagjOsY0OaxyXQ+C6QrBKRZhK5WrJXC2Z7aonq1K1XXAfrx3BBaL3OC0MVji6RvlptpvK2kUuuo7oLM+mCXVwGTtwhetlIeXc3PUw9LZ9BSzp/sb52lCWejJuaVpGaHqf0SQW27X1z7RGKFnoaFTrJImaMqtVJGpzRxylMgNzMoxGuCuZq7TwcDPwpcst7z5+yN1ROBz2fONbN7w4zoDw4492gEfJVDWsYuDNzYC3lu+/2PKt7OiiYIxwO2e+fnPgWzcH3jzbMZfCMWfWXeBHH1qGPvJOF+l0ZhMy20UZnwvZQpbKtut4c7sl9p5fXhLWWt67OMeHANxxO86A4tWwtp7eNHvc4r7HRbvAqX0vpygFj3WN9qJFQR2dDcSopKw8v963aG/rWFnH9pRsNUqlnMQ1Hcp4OsBZazE4HJZVNKhGIoaXaUJrsx4zGNyJB1irxRrHtusah6pUpqUSgiEEg4bKcop4z5qRKu0wb1uWQBWLd5UheFYBsrSAm1oM1gnrriMGj1JxxVIxhC6yFgOLMOYZFXDe0FWHMxZrLXIv2n2NkGZxA3wq3f30T3PKpBjZrVeEKBxHwzdfvcB5gwfOgueNLjClzCEVplroaFZiB5uJ1uBqs3C1jpbhsOnBZuSFoRhF3emQV4XbZaYuhWgMb1xs0AR308TH48xZaP7RSOVwEtBO40yqQjSOlVGmKVNyxVrL5aYnWEcuGarnOim9Wh5uVqxWfQuW6xK6wG41YL1Ba+XjccZYyy561qEnBI8xypHlO965e3xBUPNb7pyfypqSKmIN6y4ixuC84+V0YCoTc5pZO+Wi88xLYl8rY60YVaIo+5RpCQ8Ob1wLDLSWOASopVkbY4hYjBXmlFikUJfmff7e5QZXLeOycDtWtr0hulaqdyeLwjFBUSFi8J1lmjMlQ3DKo81ACJ4kmUEXro+WOWUebzacDT1FhU2M1JXwYLMmdJ6pFp4djvRB2faeR6HHuLZJ7u8pFa8F5rPb5kloRMDGVoDVCc4ZOhvYF8UF5SpNLCWRJLOJnovBMY2VuShTEQyKR6i2HZyRZqNpTUsb76PFm4AbwahiXXO5Kydb7VKUzsHTXY+i5KVQJ8UP7W6iCscTmTkfMgsVby02elKx1GrxvnAxRB6uDEt1BGM5Fk8uhYfDim0XqRSi9/SibFY9plYWhds5o07pCKydoXcWK4ZDvXfKe13QxhoDB1YM2JP9qrbGW+c8m77j5TKzrZ49M4d8ZFomzleBx0PPYUxcL4mbnEGb2N/5EetakJW1YL1h5QLD1tObdtC2plHBrTXkkinLzDgWLqLjj791iVXL3W3idr/weOvogsVhuTo5J16/uCWXSrCGp2vD7XGmpox1jrcuN7z3yHLMEytZ+ORYuV1m3n1wzhvnW2at9M7zZDA8vtgydJGxFN6/OxJiZdsF3ul6gliyCDfp81kTf1cf+I1oo1UYiz1RCFWVgrCoIEU4TJUYYSVNrLaJkfPY45w02oGdUSlYVYbqKa4SfftnB2sJzp1oQakl7RpDDI6+i4gGbsaRKo60ZPCgwbC4SudgGmtL9RWL/U0CY7QtOtUaFqOkJcE6UAWsBpZqWAqcDxumOmLrSZNQFKwjxoorA4WMt0rnHMk7nPFEmkOC0Dpu5d6H/7VBtW08nx64Wi+8DY9TFQ7LAteVD2+P+JXSiXI5rHmw2fLkvMdW5ZbMpkZ0UYJUNt6gCc5doJrmgT5YRy2FUhY6AFEe9ZF3NitqFr7+4opO4PpuQhzYaMkouzhQygLBsoqOoO1CCBCKNsGvUVKu3Ewzzm1JKaMaeTnBzVG4uHjAamlca1XLvFTwsB0C2yFgi2EbOuZhYIxLmzphGaxtGQW1UOp9tPxrwW8acn7KUTYn1yj1huzgKs187Vs3hACdL6xt5Nz3PNx2aBVqdWythVo/E/jXqmzxiFN21jGIRZdMNRnrCuqER+uOdzZrlgT/7vnHPFqtuNnPTNaQo0cl89R1fJj30HvWvhEu+tPEsVbFVIsaWJxwlWZ+2LU8CrWR57fK3Vh5ePGI6BLjOOELpLkgVti6wMVZT1ZYd4FH64Grw5qNi8ToWXmHinBYCvN39S72vQvvT519dYBrBXgKNXYDmATjsfDBsw/wAQIw2MAuBC42AwokX1l3BkFPYX+AKKtoMcYwGEtXaW57Jp+CLg27EHjYdYgqH99M7KLheswUCyY0amVXHbMTgho6OYl3nT25VwmWdlkupTBNE5w1/3a1gcMsHObKg9UZ8Vg5Mje6SK2IEXpgFwNg2PjGBLiKgQ7HhTd0tgV7FaPk+yH768On981iQCy/oaiDGoTiKuM889998iu4jWHl4NL2vNFveefxGarCeHPkvPPMWjik2pggwMWqQ7yydZFBPbUUljQ2ByoDT4ee91YrpjnztcNzdj7y8dUtIxXpLIbKxdCcoy4ZGGLk3LRGNCh5LFAbOyW5yot5IlCZs1D8wPWdcH2bePfxU7bXEy/2R6IaUm5uQRfdit2qAxHOho6nmy2P+iMXveMBK86jJYtyVwrpc4a/fVcvlSpCGStpFIjQdQCBmgEVnKk4WwBLwuOKYqJhtWoxwy+Wjym1WWgFC+rhLlXeWp1xOQz0weOcQ6rHunap+NLuHBGlijCmBe8rMa64zZnDNJEOGYPhwg08HCK1CtVDcQZbW3DHvs501rK1jnPf0iPbUR2O44Qa6ELE1JFzoEY4jAu3qbKgxJXlbl7YELHB0HnPk/UFGbhb9u0zsLQwmvXQ/yE8mf9lQAXqSQMCirWWvo94aUE0t0vCYIi79hqZhWlK5K6yXq9wxfE/PH9GPY24vbVkF3jlFn7swRlvXzxiEwPBWFJqQXLWDvyZN9+g1uYnfTtmnDesths+nCc+vN1zO7f02x/YrHnzQWBJmdtaKMZAcNgMr1xiaxxPY8872w1vX+xwQBcd335+hQAXqxVnxwyukDrPt+72vHo1k0RYh8CzceZy0xE0sO0iP/TuU6ZF+eDVcyaBY61YF3i6+Xyx3vf4XUJO3X01UBt9EauoCIsr2GAwRMKgWGcoIxxKYhg8q4cXQOXfXH3MVECMwwVD9HCsiR/a9Pzo2dts+ojzllod3ltW1vJfPf0+ahVyLdzuD+ziiu7iguvpOd+8veUmLayMoWwGnlys+Gg/cZMcMTpWfWCehUNc8Lkdmt7ZrvmB7SOcd3TG8PXnr7De8fR8w7pMrIDlPPD+q1tevFqYEPrO8OyQOIuRTbDs+p4/9e5bFJRffPacMcE4JyKWJ338Q35QfzRhvSPE36Cr1OIQHLY6lijUoeJyxSSBk7gypYS6yG51RgW+9uqOYymINs2Ft4alCE83a97dbNiGQPCGQsbR44A/dn6JiFJEOIwZ64TYD0wp89Fx4nhb6L3lcd/zaGt4Pi4oDmdtE3kmmE+Gm4PzXHaORyvH2gsJ+OgwgTYntL5W+i6x9Z5Xh5EXx0oxjSr2clx4sEp0MdBZz49fPERV+fX9DUkLS2m5Ft2u+0N6Qn/0UceKLoJkbQwzC8Y1PcloKo7M1gToBDCUCe7qzKVbcXGxo1TLf/v+N7kaF4oo0Xu6wXHIhf/08oKfePyIs6HDW884VpyPOFf4P7z3JWoupCpc30ysBkd8uOLZXeY/PL/h1biwC44/frHlh97d8vWXd3yQJ0L0dCtHGgtpUEyF8+D5vvM1P3J+Qdc7fBX+7UfPsNbx7oML1vPIwxV86cGGX31+5JsfXDMZQ+fhv/voE97ZbdgOnsu+57/5se9nrMK//Oa3uEqwXyq9jzzZbT7X+/lde+C3tdnQ1ZMy1yVFxSBBWkQ3BpzDmAK1UWAWU9jPM/FwR4dDS8tKdSioYRThzPWsY9e4fM63RQLFmBZN7FzF2hb4pQWmUrnJN4w5M0sLUFARdoNCFibJ5IWWGYAChbWzRLF0zuF7h7PNs7+kzHRyBfK1MtgW8Qy+JUqqkEuhHAzqAJOheESV4gvXdSEdW9S8NYHgHKL3sfKvDycHJWuJIeJ9RGpmlqbx8DhEK8PaU1KhjIYxVV7cHvHB0VelN8qkLWlyKsKdE97aDjzZrBlOyczeG6wVjFiwBR9PoSIFTK5c7Qu/frvneh65WxJTqWAdS7AMRXk1LcwiWNc67xPKQ+eJFtaDZbv2dNGQKxwpch3TAAEAAElEQVSPmbtJGGviNmceOs/OGGqw5AxLgWMtjKUgKpiqGCuoVPbTzK/cHRmPjRh33q85C8N37yLyRwK/gxNXPfn0u4K4SsiOnKBk5aYufOBe0WFZ+QFRYa7N5cJYwxthzZe2K7zz4CzOm1OqiCCidAHEW0w2mNlwfUx84/AhL5aRQ8osRckGFvWwFPZLRkxmJYHeRZJNnEtLzr1c9TzdrVmtHKUK18fEKEJOieWmcGE8O4HFWMZSOeTMoSauprZeb7zHiCNn4YUc+WA88vHNAVXlwjdBZ/yc3a17/G7hMabtwVUVS8bWVifNQqJ1/Zs1dkUyzAVumPn47oqOgPeKL5ZERVGC82xDzxubjiF6rHUY26gQtQjOtRmqNU2j4hXGpPxquuM2Z5bahOA1CSVW5uoYq1C1icMdIFboTr3gtfecx0iMgblaxllIs5K1UmplozAAWaBgWIApFZZSSaYwFt/u3F5ZrPByXng5L6DtMrEyDn9PKXttKHcZY+yJS3vq71daHpI5MR2MQGhNuToZplT4pOz5JfsRuxjpjcVimp06hsEFvjTs+MrFGavg8dbifRN9G4RQlbULVDzeZEYWru4Sv3j9Ps+WJsKda6HWypiV2WRe5YIKbIqyc46bWBnEYQw82fR85cGWy93AmGhpvUtlksRcCo+BnTXo4qgK+US7/Oa8sJwcekqxjLmw1IlvHW759ZsJBR51PRexp3efbxf+rt2rTdPCYq1Bg21pigUsglFzuuoZnLdYUcxJuS9SOSwz4BEMGIcziiIcc8EFS+ctzp68/E2L77amRWa3Ra65+lij5KSMNbcYcG08bkwL/Mi1WQWJatPUWcgonWkjzEYVsiQVakoYI1RDCwspiWzNaUNTCs1LnVOomBeD9Q60Kb/nWplKJp3oQivjAEO55w++dnjrGEKH876Fr6lBT89dDJzHnqlMjNLcnXKpvLrbc2Y9BYMFOmcQgZucCdmyCl3jBxqDweIMmGioteCdRy0olmgzcx25nRbuSiZJi6bHKPucuaqVWQtJmqf+2jsqlQ6YVajG4Fxz3dmnQsShDsZcuT0s5BgI3YBIZtZKtmDEsjaGOwfReAyWVIRUKlOaOYi0yHHbJONpub90vlYYPnvmpz/CScSNs3RqsKYlLWNAtHJ7nDgPEWstagRjm1PKURSfDGvf4068e6enQ793lFzamqpKVUvwjmWeebE/ciULScEai1XY18qrmkiurXVjqXTOIloJGBatWGvonGE/TYwFlDZNPUyFF/uZvXO82/XUbDjmxCiZjLKJnpxg4yPOWpIIYylcTwuzKXgswTf+7Zw/H3/1Hr9btIIyqhgRRMxnlApjG8feeNvyYkQo2uxfVZXDlDAWnDVtY249ElIVPLAOHcE2T3vrbNON+HaAs77VkxOIAvusXE+JQ20d1/YbKHMVDvKpHUfL1TFAVcEa0/bkk9XrvAiVBUcEYxhL5ToX1sCTGECaVqBq89z33iJq6E6/WzmZFhxSIqni1H5mv1ju0+5fG7SA9TSOzW9DO781XVPvLYh+ltNUauXl9QG/7Qmu8fANLR16ypWjKZzFiLeeVqCOEOwpuynhosNK09F12TEtE89ujlxpbjV8+nm3ubCvlZn2d8UIXg1FBaQ1+qKz7HzgOC3sSyVI+72v55n3b/ZcGscPnK1YVc+xCKMKi1Z6ZyhqGIzDV0OaK7NOvDjOLFaxCl1wBKcc8/S53s/v2gM/NL60cxaiINW0VL/66U2gPfBVjJSSMZnPLNpyKSRryCchTzQn7rW08AJz6lgYbZcHNRZjPFpBpB3q64kHmIqQRai1JYBYbFu4SuEglXh68KhitXGZrUDRFiKjCksRJGe62Ditoi0KOWmzGZXafh91bTN1crrwGN/sRBFybd9TrGIwVCOfBYvc43XCYK0lnOwIOVnAiXzKuDBsXcDYTDUFHyzOtbTJdWeYTh/MYEwTGVa4WzIUQ7VgpQnKsQ7nHUtOLd33dNOfa+VYFpbS0m7B4GmuEsdUeFkWBlo+k6phq5Zw2mOXKqTauPx3KXOzLLyxXn3m9pJqJYsn2RY8s2gF2xJ0V84yK03WbgxZhGNaqLVgjCWEjmpgLIkl3Yt2Xwc+DRdsG5t+5v5naIcZlba5bUwg2dzcmpzFm5Yqmr2QTCWbFhCIQq6Vfa3Nx1wrKg6VtqB670/2q/VUf8IklX1NHHNmkdbV8KZdCA45c6WFYBu3ttSKFYvRdvnIpQU01SK8WiZmCg/W2/Z7FOVuTARvuaNxUceSKQjGwqZzLEpzggqWY8lczxNLaZ+xwURwhlEy8+cUrN3jdwtB1TV3lCotpFJ/Y+JkncEHR/SOJQNW8Lbtw7UqWQvFtPQINSc+vSiTbbVoDGDaId0Yg/eOOS8UFGNAjDKrNPe78hsNtlMkJrMIR2oLQdS2BgZMuxebdgGoqpSq7MdMKcLFYJvjlArHVFHLyeDDkBHUtECt3ntMEYJx9NYxi3BImVwaNTOoxxlLVSHJ/R78umBOdrCG32iins75refrmxbk0gamVJltpbOW4AxLLW0iZE5nMdPWzDEVXqiiRahWMMhpT7OEGJjSTD5N8ZNWjrVwlRLHXFhETlKWthjf5MRzTai0PZ6qDKfPjEoTm4sqtQrP7kZua+Wd3RZVZUmFl4eJ7BxnnWNVC0cVFqNUq5z3gZIL3lh655lK5eU4cbdkQrCsbMB5w1QT8/L5Lp3f1Qd+cFir2KhodcgpUbFxuRRnLA+6jlvT+IPeGbxrB5/sIJHRKhi19MaztZ5DhanOVGva2O80jbM2UmtqamxthXI3t/GynG5vRjhxCw3qm8XYfLp/OG23/R7bON5Uimk2miZb5rIgEtHT5aMzlhiUbCulNMsx42wL1KoW1zV/au8NWQpLyqi00BqHZREhC8i9JeJrgzEG6xz2pBgXUaRKC70SwZ4Wnp0z2BApseCcxRpLyYo4ZaoFI82KrneOXee4yYm740gnHX0IaPAISl8DUy4sY6ZIZV8S3z7c8XJcGKWN0Z00Z4isQkow5Yy4Ngnyp7Hnufdt9K6QS2VMmSzwweGIRZuri1o2IXDeRxLKba0U04LnvDPgHWfisALr4LhNhRfTRFFlHSLrbmCpM2Nt+oR7fPGwtjlxferD/+lapfzGhmIRHnUDN7Ng+0YzC6Z1ZRPKQQvJnCyJhWZRJ8LddMDSgXFgPLaCq8JhSUxLoopyLJlv3d3xwXHiiGCrxVeHs4YCTLkylkrwrbPrMfRaW8ChCLZAWYTDnJmr8v7xlndzOzCRlcEaBuu4TYlDEYoVgjO0oETHqnMYb9itIuMh8fxwoBrLLnRswsAxjdyVjJX7+ntdEDFINa3hhVBLOxyrtu59DLCNPVeSsKFiafuyNZZkK1Mq5Erb305Nj2KVfVrwVjBEqhqKMXiNpFw4pLZnZ6l8PC1czS3d3tH2TjCIWFIVRipe2lTSaHP18e5TO24liXBIBRXLPs9t4mlN644aS+cMx9LWPg1gTjaHg2sNHquWlfNkSY26JsKGiPeOQmv6Ve4P/K8LzjmsPXnkKagKJjiM0TaJ9I5A4L3Y8Uk5sB8giqN3nugdo1TuSmWRStF2WK9V2bvKi7s9jzZKHwOiAVGwneVwmLg7Togqh1L42vUN374d2VdpTonaAteKKLcucysLUVqD7IjhzAaiccwqODEsqfJqmhnF8vXrm2amoGCKZeM8u5Xj5TJjisdGj3UGVy2bPlI6jzWOzbpnGic+GkfmKqyt53G/Zq4zUynYzzlk/6498Dt/Gq8A6iymV8KdQ0rjWVkDMQTeefiQzdXEKzlSVPBYdjGwZ2GLB6dMtXKtC1hLrcLLxfHY9XgLVQs1HanV0xFJpbKUxF2Zeb4sSK2snGM2pokeDURrGSehd+CIWOtQVVKprKpwcBaMZ8qWSmGIwrEk6lQo1qAn3/Q8Qo2Vcz+cHIkaXWO3akFLn47Y9+MIubC1kbExKoFmJeW5d0h5XehiBHe60XkPCtOyoCfOpm9msfzwgzf4+ovnjFGYUyF6x5Ozjpu68BSPutZNupkzk218+39/uOaPrR9ijWNcFu4OB9L1DW9drrguM9d3R54dJ742j4i0aPnFaAvzCo6VKi/nxBPbtAXtUqKICKhwJxb1nlsRfn1cOO9XzDnzjdtbNHi883TWcHdzIALvnl/gTWUqCSvKD+zOoNuw7WA8JJaryto63uh3XEthXo6IVtbOsQn3osnXBdVGxfkNvo5BKa35UMAUxw+9+4CvP/e8ygu1ZnpneTgM3FG53FeOVGZXmU2zbc2u8PXDHX9s/bhpPmrm2e0tciU8vTzj6jjz8X7PJ9ORj5fpU9Mxqs04U/HGIgIZy0YMD8OKznuKCNOSsNUwA7Hvmazlo6Vw0Q28uMu8unvB2bqjDw4R5cP9gcEpX758wI7WzcVafnD7ALrI2cpxmAtyNxFt5Ol6S9LClCaWVPEYtvF+DXwdkNKyFEoRSj55oC8ZVW00HBzBWr7//JL3r295URdKVXrrOOs69jqzrgMhtjUvA9krmMLHU2XXbzDGtS75UnixLDxcDYzmwPU0cztlrvP0GWWnuBY3YbVNDUIxeIEH3UAXPUUqhzxj8SAteLNiOIiydY7rUbidjmw7S/RtUv/RVIgEng4BkZZk3VnDo25D5yyrleM4V17NGSPKg9ihwJQqiYq3zVL5Hq8HNWdEGoX204knVqidQzuHRIeI40++98P82w9+nW/lA3USdj7w9GLg42lknQ3ZekYHs61MTqii/JvrW/7L8w1DsEwl82I8cn098YMXD/jWfOSbr+745DDzPGeyVYIY6smwiqKwwGqy2AW+dLFmGwOLVF5NC3aGXiKhE/aqfOuYebLe8uFx4fnNx1ye96x6j6rjVz6ZicHww2+sEKkgylmI/MjFI1arjt1qYD+OpzBOz4/sNmRVDvNE0kp0lqH/I+DSY638llipFCsWS6iWzniCtVwvE7Cwdo5FBOsqnLrgALVmhHajogrOwZgSi1twaogxsGs2K9RaSbUiWbDF0hOZXQIiltJ41sZQqpDasvJb4HCMDpx3WISVN2x8pPcr3FLp4kCIpt1YVclBmOvIVCcyFotjXR3DaQGRKiy1kH5TF78TGJt8garKmO+7C68LtQrBtU3N0sbJfYgstE6PO40OP7i7xpbMebAk28JdtjGQWiAoVzKzN8Jo21Smt5areeF2P+LWymYY+P7zBxQyObXnbkVZG8tDPyAUooscc2awjt5ZDnMbfc8YduIIuNOYU3g5LeyiZWUjZ/2Kx6szzlc9Y9nzRtyxjgF34t3up4UXyx3fOtyiwMpYHncdqy4wLok9lbtl4lAXqrM0XklmlILDcqjK7TL/YT6mP+KooPWzRHFzWnVMMQS1eIQXVzOhwlurAZEOI6f0UFcYnOU6FyaUQru7ds7zYi5cjTMe2HaRr1yek4CcMmhGteAxPIw9UqVFxWeDpWWAjCRSVQbaFMiKEoEQI8+nFqjkrXLZR95cb7ncrhnTHQ/jwCp4nLOkUvnk9sgnx1vev73Gu9bxf9APrNbNInYa4WqaOebc6ErWsp8mXkwznXEUNXw033OoXydU9bMp3qc20KqKw1DV8GKcwAoPY493TQOXSqP5bSI8H4VsW24EeEKFF2niUQlYN7AJgbPec0GjPEpteqGqwiY6ptrcQBdp3HzrWr6OiCN8ZpTcUr/XruNYhc6Cd5G1j5zFnu3KMxI4d4FNbIYdGdhPMx+lkZdJcLW5CMXoWXVKqpkxVfa1MCMYDU1TQGEiE63DAcd7DdNrw2+ebH4agiNJGqU7QNg4utnxa588Z1gK37/ZEh90YAzHaYIMF13g+bQwo811T6DD8Ku3d3z5+ox3d3Cx6nnr4pJFKyUJTmwTclt4tOkoWXDWcEi1VZyHvc8klIjDF4s10ON40g18uEyc9xYbPI/7De/tzrm8XPPVeeTJemDlItF5Fq382nDN118deP/VHdEbvLcMg+Ni1zGNcOMPPJ8P3JREcC1n6uPplpdlYeM8tRqeTZ+vBr9rD/zVCt4ov9l5NUijPog1uOBP/P1mv7XuLZ0ECkpykFL7vkyTHjWJK5z5juAsN3lhtsLWdYTQiqqejnXewcoYrI0Igd45DpIbSVCU21qwTpirZaBiRTDGoM6BFGo1WN+iujd9JCDcRIMzQu8CzjhEIPqMoWdOmawFbwHrkVrJNA3BoS4kVaztwBRqACvtMqOfiojv8VpgUZzzqDGMqR1qnXfYk3B33QXeuNgiqhDg8a6jlub4MEkLyzJkUlVMVbwCTnm3G/DO8mvHAw+08LY1bPs1iqPWTDSBdb+ijz27KtSqbAbHqyVTadz7m3Em2uYqkaWFKjWNiSK1sJ+F3arjcoh86XzAe8ew7+i9svIWVUMCHgw9zhieLxOv0kT2lp3pyAmmMiNFuBpnUoWt78nMzW/bB5xtWoKa75MmXw9+Ezn5lDKpriAiWG0844dDYNIZCcLaWWxRchaOpXA7Z465IE5xptEgilrWoVEg/v3+wKuaec+sWa+G9nOrJWrHZWj+1ErTk2yC4/kyn8SzlW8cUjNJCMos2qySaRPTmQVZPLvOcbbqeOtyjfeOPgZ671j5rmUJGOXNsw273vPhtOcqZbK3nFtHSnBMGZGRjw5Hlio8Xq3JeSbngtcTfVOUe0bZ64FCGyOdjCFUmwsdgJFAbzwXNlLKAecrgw14Y0hVmBTmLBxqQU1LhTdqqKbirccrvH87M67gza1hxfqUGyFEdVz4wNZ6mikGbJzlSnITz1ZhyhNQEWso5eTcp81OO9VCoTVWHkTP421sbkGjZeUsg/PNrEOV3dDjbPNSn0pFTj7+OUEqYIxwvSyUXLgMjmwqJTWWgcGiailyv/69Lhhpxi2Nx087p6m08NUFtkTe3WxZxgnXCY/W7SB9KIUXS+ZFWbguy0mz2ay2BaHzAanwzz98xvNp4seeXHK27alZSaly5iNf3m14az0wGEehsukHPjiOjSZWCr+UbpCkVGdOhhrtMlwU9imzaOGB67nYdLz3ZIMPlr437DrHOkTA4Krwg2c7HoSOD8cjL8pCp/DIWXJqE9OUKx/dTZQKb59tGHNb1yP2lAdhUPkeP/Bb/fTeTrOhLO4zR5pgHdE2OyVbMgTBE3BiUWmpkkphYwfmUnEnAVBL+jO4AiAsp0TcXDLbEFC1LHrie0lto3Qcnfc441ERpArOOpLNVDyDcagKS60UUVbW0Q2xiZIEpmWmeEtUgzEOS1OMYw1OmsI6W4FSSLVw0Bb2tBgoWila8RroQ4fiqXWCE2e1uQbdH/lfF2KIbWFAyaUQrMdaS7EG6z3bPrJdRyoZv7EMiyOrstTCTUqMJfFG11F0wRtHV9tm2BhZjV96owtaD0yL8NbQUUvlLs3cLOmz5GYVeOR3vB06KjDXQsQwpYwPnnVwLLVymzJjFd5YDZxv1xiaa9VHt9d0PuClcVuNc6fPTkstXHeRVVp4UZRDTXxiGt97RhhPn4/eBXZ9R1VHPU5EFSKQMBzuS/C1QGgdzROJtYUQ5gKieOfog2XoLLlmfARbm0vFsVRelcJdqez6SJFEPHVNbRKMGLJU5lSxRdAijKnyoOuhwCFnbnKr30+d0h71W95drSjaDvwr69mXymblWLmOlIX9kjgW5XEYeHO9wbh2Wfjg9o5VdKfQRMVaTg5VHhFD8JabtPCyFl7VQjYH5tKaPWNtzhYrF7noBrI1TD5RiuAMJAtq70/8rw0n5xujhiry6dZDUEMwEL2QrSDesMqWXNtl80YytzWBhaGPDMZQqjbKF4Bt9ok3pgmu51o4C4GqwlwLYy0sJ0MKaw2P3MCT4Mkoc2m8/UmE2Dk2xlErjLWSk2HtAhedxRgHWnk1jfTO4tWc7LPBW9NMQbRNpZZaOUphX5sLS8qNQldFOUqhs47LGMhY5pqoxaBVyNryAu7x+mBoB37b5BuUrGgWdCy4qdJthVkzNrbGyLwkXs4T3x4PPMszapXtqmNrWqL37d0EYhADN2PifXNEBa6nhbfDQK3CzZK4WjL7nJttp1Xe3uxYn52RRTjkzBrLi8PCxTbwIETmUrmaE9OSeXPX897DsyY2VuEbL284i75RMg24YJvmVDwhW4KN7HPm43nhLiWWvGfOjb42qXA3Z3Yh8s42sljDVfToUihCM3Axn28T/i4+8P/GqA7aZtc6DEq0lt43u00nCn2Lu0YNkgtuEZyFaAzOOLJprjbopx2z5thTpZJrbYe5ob1hY1XmWihSMRiKKmcaGYLD4BGFoVYmsahzGDVMuTTuFTDYyLbvKKlF0t/lRB8dViwJpdO2kKgBZwzWNhcUgZMQN1FLJdkWbW6xBKetm4XDn5I27clS1N5bUL82eB/wzjX/XlGCtYgKwTpWneds07MaPPM043vLYDoiyqICS2XtDNEFzk2lqiEb5VgKubR6NqfNa0kjd8tClwYAXswLL5eFqVa8dYgIb6aBx+v1SSwWOe8iV7cHhqFj0cKrufLpFfXxes07D87YT03o+Ozujm3swFpuVBl6ZeUMzjmSCN675vxThYNkFiksSwLryWoYnGFtTfM7N4G9zqBCMKFN3u6L8PXBNCE/gCLo0vzMuxhYd57oDbkq3kPEU5wFJ6SSGs86eDalUKWyqEJRcmmOJKAchZZYvizk9RaAq5R4lRcOOZ/WIMMjH3lj1RNdoITGm/5wmblYRxaU63GGUnEKb/Zrvv9yx6FWPt4f+fB2z65vadK1KoMPbEzAW9vEay7QuYCo4TYnbmri9riw9YFZWzR933lQPTV7LIFmt4iBIdxzqF8L9JR3Q9uLRATVxonwYuidIVhlQVFv8TgqglZYaFZz1ZhG4TKGpJUqDuXThJPmeS8qjCUxr5oW6JAKh1yYS3uVsYYHLnLed6ycYe0cO+d5VRaGzoEIx1zbpNVbzr3jyTqQC9ykhVfzxNZFjIE7Y4ne42n7L7T1L9CchQ6lcKuZu2UmeN/MsYzBx3ZZ8Lj2edSTUxaCNfcH/teGTy15PsWp8YEqsVp6MVgpraEbDVECSSuLCFdzItMCu9bBE51jEkOqS6N4ny4Qd8fMt/KeF4eRZd0CrD6qmWfLwm3O4AzRwLtx4e2LDdFZinQ86Xu+Fm5547ynqvBsnJHSXPneW635Y08fcDMvfOtqzzde7XnYR4ppLnhd17GJsQW/SjNx6byjVuF6SrwcF54fFra9a/ayYuhXFqtCb5vYfDRQVBAD3v8R4PADJ2W2Um1zHXEIXXR00eKN4JzDOMM2DljriSnhVIDATUmsg6WzhqKWnJVE60i4lnp8uvE31xuAZclkqagBb2GRxDhbvAt0sSeYiAYljYLHcZ1H9jmRRVnZ9gCtWFSbQ8+sBbOAobLUjHNr+tNtTKxDT5tWpnmvmpOLgAqsaBZ4XhWRE0/aSfN29c0HuK/hD+e5/C8AYptvr1RprhTOUJLSucCD3YpHFxvWw4DOR7wKF9sdYaOsjw5bCvQd31wWnv7/2fu3ZkmWLL8P+/ly94iMzNyXupxrn+65YzAgSNBIEJJMfNEDJT7KjK/6BvwS/Dx6lelJRpNMIkWJEkECEAbAXLqnu8+1Tl32JTMjwt3XWnrwODUjmknskXVxeoC92uqctqp99t61MzJi+Vr//++fEskjsytE58GdqnS2tTvRA2EMfHPur/HrpXJxhdgxsGVtvLp/ZD9EnqU9h5QZhsDDGglD4C/enPj+tKDqfLTbMQwJrZ30c1blbatYdFox1IT9OBB9S2gOgSBCC53bf9LOTs9ByNZ4mfccYmJwYV27LjegaHAs9EyLZ/K00v4QFVwQUm/0pfGDe9bdOewSN/vMLgdokTH25OTowm6ZWe8bz4FfFOUT7S3WORrrEKjFO2IRw5rhsWvzX2/X33dlZt5QiqLGWoyf+QO7KHy8nzgMmUHgJlTGkPjZ3R3fXi7UZrzIO26HxFr6huq+rny1Xni9Bqy1HgYWBth10kYOisWJKs4c+j1QFFqGxYyrmJgi5KA8WmdNt1YpBHZRmJKwl9/8x9jf1nLCdjT8K14xV6YkXOXEIUHzSIzOzT4RNZLOkZM2rmLi55eVGJToTlQnSaB2hA6GdLSxdZnq60uf9t+XLt2BzT9QnV/aTIrCTUwch4gNA7X0vJFf1srbuVAaHOLAVRRU+0bi0ow3a+UcQaITqzLFuBHNnBCUEMY+cFPtW9UQKOY0bTyLmRgCbsZ9LYDTKizeB4o5BgZ5OnB+qArhB5Jizx0xozduAh/tj3x2c8U+O1hinwc+u3lGcKivhT+5e+RqyHxZL4iuiAdSdfZD591TeY9J70j0wJ8+nAD4thTm0H8/NCjF+G/qG+IQ+fHNketpx/UeZl25Ggb+b2++52d3J5ZV+Xg/8cluz7xU1lZ5Vwt/djrz88tMTIFvzzO7YXwP2gjmNHEWbyyqlB96UTVCM17ISAxO1cZ387xJzowZ5yiBfRSO4Ve7Bn9j75RhG8YHC0iNaCxdChEz+5S4HXJHYCYQIooQ3ckh9OAid24T7KSzeZcG37cO0PqrpvoUhKs4Mno/IaXYqB7ZaPcc6Gbec4EkmV2mE31S/9FNJliIVFEmNeIonC4LC4XVFMW5iHHYHrBRAnGj+ixbA+WiRDPQTgnYp8xZDGwLxhGj31MCSQcmbGNWO08Y/g9XAxGtjbVWPDjESB4Spsbz45GPD1dMLXCY9pQZFN1SaY0UOwXit8eRl9nZBXi1Bv58WZjN2W/7SXNnHyO/fXPLfjOan3mHty5/wBtxhMUaX749I7eJT6779/DRfo+a8PmuU55OpXGQyF6EX7x+5F1ZeFd7sqlL5UinVO1i5DhkSlO+fndP3I8UqdTomAYmFz6dJu5KpVLJqeNDf5i0XLNnpPLdunCuTvKnB96HKt9C/fCeZgoZTDnmyLMcuDLj5RhBB0JzVAIuA7vxgLvzMlY+UWev8Abnq3PFgkOEqIAFdnHk917ccEVnrF/eGtJ6GMRJDYnG21r5k7sThIEfpwnTwifDAQM+2e3w5pysMuHsZeSPv/+e+83w2MywGMgWOKuxy4Fne+HSGn9y98D1VX/AXlAsBHYh8vmw64OXJuQYmVImDf2em9oAGG+XRqExPh04P0yFCvRnobnAZtgVFY6DcBUjgwVe7qeOptSOKlShdxYOuxFuvHviZuC8hfZBH975lrXz0e2Ofeu//+f6wGyKE1jVyEQeqvLL0xmXIx/FkaCdGhZNOIhSkrNsB+IowlenmYsqy/tgyo4X7TK5yCADxZRvTwuHAV41ZQngCUSca5VuIMY45MQUhRQ32cQ4wFpYzFi2wM+n+nDl/kO4qffN0HYY/Hi/4/evn3MlAuOJqAmqsXgfiu4GwXFu48ALgQOBh2q80u1FE8jWlSTHYeDf+9FLrkVw4P/8i+84UTGB7x8bkcDXy8I//e57Ugz84ctnNDWeH6+ICh/LxCk33lkhtsAwRP7rX37L/dJ4tA1d7AFpgXfas0tuh8SpVP7pt294drPnFw8bfjt2NMNLgUt/W3G9G7nZjUzb4fKj44TNK4+bBH3vf8sn/E7nlLo5VQrxIlzte2B2x44bOQ0cJ2EAIonadNMYZqAQZeJu6VOrRmBOwjCCamQeWkd7iTPQSJp4pyuGkdMPqWwgsa8qk0XmuTJfCubO7XTTjUrHZ9xYY2krS6mUUpAB9pYYibTgaIrEBoHCN6e7fvPcaCetRaZBqCZEMjlERjkQWTGUGeOkIK2nDi7xL39CAu8nIU/16y9rXT6RpJNJ1nlmP2VkEFJShMZORm6ePyc1JQRYlhVDiMOeCJRy4f91fwLpeneVxLOrEYCqlVaNOTiPZQEyf35/jwXlJvY06EtTYhaesWM/ZO7mmVfnM60Zv//ihmmI/MGzl3xybLxdV85l5avHE6Lw6W7geojcq3LII2FVXuuF/9M3v+xDEg2IGyeDzw970MAe4ZrMx/HI9VC5X7r5qZYVVe30n2mPWmZeV2atZH2iVHyIMjOC/2XDEghcT5FM4vk4ckgjOSeeTT/cFBJLcaLBszTgEtHLW/7ssW7yRZAQeX7MaOycf42GJngojRhH/vzxATPlahsw4J1m8knekxN8Mz/yzeVMDIF/6+ULJkn8vduP+fGx8WZZeJjP/OndO4oqxxjYxwgeuco7HuOJv5gX/ndf/6JvkFy4qMGrd3y+P5JDYp/gViKfx5E3XBgOEQ2ZN9VY1zPXGab9AUkL9dRJQaJPDf+HqGXp2Ta2+Y4Cges2kJqxbyMpRkI0rq6HDYoxcCqVJMYnw561KYXGt6t2025XoTJNvTkxEZp3Esq6VkYyX88LCkxRttAlWJrxcuySjFfnlW8fVyQGfv96IkniJ4drPt4pD7XyUFZel0YZEkON7ESIYuTdgKaR00X55+uKrDNSjcdlhdC42eUus9TAKPBsTOhG4yv0ME+vTo4bKhwo9B4hlCdJz4eq/75H0dX4/Ce3xCkxXQ3dU5kSnzx/sZGkhPV05koi//7z5yjwj795xZfnhjh4hHHKHMeMVEMjrDhLMh7Xlas48v949RpBeSYRJaAjnLXxW+OemyHzL797x3/35Wt2g/C/+O0fMcbIP/zsU/7g+Uu+frzw5eme/+7bN9xrI0S4zYlP846rceA0V35+mfnf/vnPyDEgwMNF2b0OfHp1RFLo8h0RfjTtuKgTiKSYuG/Kq3khZ3h23DOSuJsras6vmLv1m9vwSxHC0Nc50QKBRoq5p/N5d/NrMEwHQlRCFPKmiR+HAdXM9+d7Qna0dcSi4KgmoDF2xmZf17lSDFbtjOExRGIIaAiYgkRotG4cESFqb9ZNnUdan7bXvq4W6QFh7rZ9foHapwcn61N7rK8So0CKnSzgW1BI9YrawiKGYohG0G7sden7z9GEi3UZkNkTku5DVowRTClagcbzvGPI/TBwmReOe6HVgLiT48AuC3IcOUxOMOW/+eUdgUBVZVFF1eib60iMMA3CJNJDPmrhrixYCtzGxN4Dps5sxieDcdIFpEe9T93UQa2N75bKm3mhlsZHQ2aXhbfaeFz7IOM6RKpWHkLjXVWqe9c8Bti58CwEtHbaVaMb6JZ15t4LjxqIMsCWKC0CBWWvgaR9K8UTpeKDlLNFLv8QjRxgnxI5KyIOZl17bJEokRAiOTlXEjmECQe+Pd1DcObWmEuXK15qJ6bsdpGb/YHrcWBAuF8L358LLVb2sYMGWlU0OpKcx2rk2Ke7h5h7irgpX54X3swL53VlFGOXYa7OTE+93Ikwt8JjdVazniruhnmAIEwWuKwVoZM0ziiv2oVTKT00MfXwMTEnkbYQqEjdIuzlSVLxQcqbv093/qH2sSchBzqNThHMEkGMGBq7FIjTyNU4YE15NZ9wV2YDI2Bi/b5Bn8RPU2LKCQnCqTReLQUPMIr0+5F1P1+KkUUbEjpEYx8CNNCgPLTCfVUutZGDM+ZAc6WyPeM90Cp4KMQY3jfsVbpsc0+iVMW3DJPanHugOiDGXjKEnhzcgxj7tk2tJ0mnp6Hbh63A1h/18MtpSuymjLeVZTnjSSjbMzgBxzyQb6/56OqIqvFPvnmDSuVxbdTST5j7IJ2cFxPXu+6J0xT55rTws/sL5D6sSATWrT+LOfD9ujKkyM1h5EXKoJFq8PPLma9PZ+7OS6cxDsL93GWykwmizrw27pauzGhqNO1LcwvO0RLntXUglnc5z1enwirOPieeWUQNzqXwIg9IFMIcqcWpboy/oo/uN7bhx8OGGzJcu8ExeCDFCAbaFA3ag4Z+wGyFQIxOFEcl4xgaoAUHcXYCiyvVFAlC8oiH7tYuwbe4726oJfQfjipocDTYlibZL777+QLAOW4PHZwYezNmrevCOiRRMC/vtYpq3o0+HggWSPKXNI4cujmqaesx5HQagjtd3hG6SSiFQJZAJlGeDEMfrMwaUSLmSrFGCIaass8j1hrzZWGVyJqFMadu5rJuJpxiwDWwajfxrk0ppmTpTXpFSRa6CTFtNwATPAZSEKILMQTG2JOdTyhr9Z5uGSPFjT+/ewDgzhU1ZQqByMD1OKAh0aoSjO1hVTECTbxLwR089NTdMSaKGVnC5kFxHpaVNQWIgSjdHLRq46gDd5eZ1YR9iuzzhD8N+D9IuYFp6PrG0Jt/D4HDOBBwSmmUlJjGgSwZkdAHDTghytZQh06OakrdGq2z9gwFlkYKlcEjOfd7qmEdfmD9NW/ek8DvlpXqMLoQQ2/M//TtHQAPdJpY3iSVxywM08Rca5/QBXqWiPeDRgx/iWMYpSekrrUxJHk/gLmrlWG7rztQrdNb9i3xUGbUnV2M3OaBnT8dOD9EWTMsGl1I8QMZrmclNJTFHJFIUdhJAGIn4W0mQqNvkTw4zf29UXJpRsC7qkIExXvz3b2YBLp8Q70baU2cU21Ucwbpm+0aAl9e+vZ+FqVal0wMKZAHIbVASaGno6OdatscVyOGfk2q9EOHa6BtNL+wNZfnpoy5p5w60k3v6ozRWLRT+SId8Sn+NHT7kBVCD976Adri6twMA2urvLk8csyRfdwz5YxvsJMk3ZxdiyNB8AAVp7gRDM5LQUQYa0CkUUSYQwcLVIfkYArFnbV1bfXbtbC6MQUna3/G/7evXgPwzkpPvDXn+dCzlHYxc186VS2HQIVOvXInS+8zdfNjtuqUuXR6VEiYK4/N2O+ElLr+qLpyMeXYnG8fz5wuyhgiz8aB6VcUlv3mNvzWtdDmjpkjoTfLI5HghqmjqZ+8PKT+Rt3u+30SKQSkn/RD18APIkhTPHRdrHmPhDfpQ8okm6pwm2Zm65OA2ZQW+jTNAj1ptfY3+ZoixMAuRlKMjCliMfbvb4tfDp3Yi5hQqT1LgECiG27dt0AROv6sbBSEEIWNzYGaE91RcYoo+zgyhMSsT9OFD1WqfZplpqh30/ilFD4OE27KWiulVNSmPmWUzhb3sLEtghNFuJi+R2wOuVNVQujOe1OnmlFDN2xPY0IUkvfV3iiBxY232uk+gwQGtT59qt0DsuIMKbAfO/lkPybiIKxFKbVr/KQ52XxroPrhNnogxY6J1WLkIAwSMYzH1hjijl2ORIHSlKUprcGpFkqATw8Hno0Tl6fgow9Tm4/pr/L4qxlDHPENXziqck0kxkRM24erEULvrlKC1bsRzByCQPXO5acasxVMHd8NDK3fZ8V799W2+2815+3SCBKoGmlNmWOj9MuPNXrX5Y+JYxx5NgrPdgPz0rF2J6sMQRjooTVGb6wkBK7ywOytr+ZJfVhDb6quxgHb7sXVjHMzDuK82WSaP76+4uP9hJYnI9OHKN90075tZEBYGuxypNJYrJENqgs7EiAElPBXZBgpSp/sYxsaW1jNGQSCOsuieAuQnRiEFAIi/UDg2/egbjzUfhrQILgZKvJen2+hN3j7mBglckgJYqRJYDbl4o3alGZ04lpQgnQgwj5FSutZJ8Nm3GzBqQ5XMeEh4h6o2i0MTY2LKsWc58OO65RRyt/I6/NvRL33MPn7e+F5qWQipRXufObZOvJ8nJiGiMsPH/aD6RumIWHztoiWPuiaS+N4GLvsdq08NGMaNs9k7NAKHKr5NqSF75fS1R7WD45FGw+Xfg2W6OQYeJYz18PAszEz5h13S+FhrVxaI7iSQr+OowiG44Su5V8aRZXDMJKl9wgNYx8jg2TUA6s51Z3SnHfzTFHjd59d8/nxQPsVA1h/Yxt+NUNUO4JJgQRraBwtIaFrsVo0JAoWQ3/A9f4YUKRFRhm4t9pP9yHQNgnPIQ3EILRmuCl4IDVDdpFSlKiB5H1iUaNypoHBQCCFgJvzfDPtNvpDMRAZYtcMWk4Ei6yt0MqCuJC19YPIZoyTEEiyPf4UXDZyj4FG44pMEhDT96ERqRk+9rVWjIkhDZT2NF79UPVDwqRtcDoz43HpAS2H3LGsawyklHH6qRzxfiC1fli4mTLfnsC8p/KmGBioPM8TA8J5qbSi1KTsB+HlOHK6LNAMk4hKYDXl0RQxYURYPYAGfrLfg8PbsvYHmxnTMEAOPEs7bHQel8LbZSER2TUltYB5R9LtEW7SgJeVZAYmNPo2yYArERKJxbWvHzfpTiaCN3Yxcxj3NHtquD5M2V8+7OiTrrJWTHe0IVAEmvZQPokd35nyNlW10AMJx4RuG84Uu6xilMDHux2jRU5NWZZGdkh5ZJciWitofxhJ6LKJNSiugdKMFWEQ5/P9Dgfu6koxZ3XhZrdj2gX2aUfb7ZHLzHy5MIlzCQ0Jjm3N4xATH+32vCqPNLqcovVLm6xCkC6/MGtdxtMCNfX73SiB2zzyfNxz708N14cof990g2mXDCy10UJgiH1aZg0892ehbwfKEPpADoTDMBBkJkggvSf+BK7HnguyNGVZC2jiOg/kKB0B6v3jUoy9UTcIphTvEt0SA8/GjgWetSM5LRi7nDnKQEoRS8KD9aydnOC+dGmlOUh1Bpznu8j3S6GhmIc+XAtODhGINO80NdX+nC8FLCgDgesUud1lHv57OvOn+jWW/1VwQf/3w3lhvhSGbJgIqzqWIi6deS+pr2rMFInwydXATx94D0xp3SHKx9Oem5x4fV54nCtDC3y8GxiHTHLr26Hg5CwsZlQ3ZMtfVXGKOp/uJsB564USnBoDL6aJT673TGnPy73y9fnCV6dHRPtAlwDNDLfAiPDFsOdfyX1HxXchN03AUkBV0AZrqD1TSiNeDWl9k/rp/shnx2venn+1tPvf3IZfFanbcS0E4jhxFWEcAmPK5ChIDKwUYmssmt7r7Ic4QoDb2wl7p9QNcQiwOn2XtxsIsXUzTnCuDwdeXA/M50rx/t+cZ2WvXcc9BaG5YwGO48D+MIEmrrwSBHIUdhK7aZdGpVGt9YAbGlGNKwZEEiHY1vxDUXhwJWiXA0kUTI1z1M41TgHMic2ISVjVuELYJSVoTwB8qg9TGnvz695P7xojnzzbMcVA9tDxX7Xx+DiTrpX5cWEpXZh32GUG4A8+/whToTQjRCgUTmvCgZubI0OpXOYVovB3PrnhR8+f8dV3r3sWgxm/OJ/5TDKfBdjFboqr2vji6oqPXjxDzfgt7xP+MUFy5+6yolqBzGNR3l1mHky5Qvi96arrY0Of2q005lE4z13qtguJKQ681caKEYGdR4hGooLOQORWMrfBieuJ+Tz/jb5O//pWwj3g2nBvpCHz7JgQCYhkUsqEOPBYCilNzKtRakWAfc6A8Ps3zzk/XDjlpQfCrSs1BG6GzLQ7sNfKUntk+x/96CW/t9/xs29eU0plNeUX5xOrGidTblJirg0158fXB37vxQvO22DmsPlK3OH7x3vKAJC5tMKlnTETfu/mwG0R1tqRnc2EWheIsNCgwmh9S3rRxumyvKehSTBCajyWyiid6/71w1vePL6j1aeG60OUeZcc/FBJIzejcJgmkoNbY6Wxv8ysTKguzFvCw4EMGL99dUNZe4hWdeehVtR6WNvxmJhb5VIrSQJfPNvxP7l+ybevT5h2r8c3y0Lzkbe2spOEqyEGH6eBT1/coqaoKqN0bT/uPJTCXicsNi61cForEefFfmQc93jVLdcHZhSiYQgrkEJgDIHFnLXMjMOuH2wAq8pDnZmmkaDGq8uZN5cz5Vecrj7VX79+gM/8sGkKo/Dj/ZFDiGTP7IiYGnfvTuR95aSNuTZigJtxAIV/+Fufc3dR5lIpZnx1mqkJpiHy6ctr8s2AXC5EEX7/5gX/m9/7nH/5s69YSuGsxp/cXXCHr+uCSKBVYyLwh8+v+Xd/6yesxdCycBiFq12mrcZf3N3zbDAaiXfzzDcPDxjw926uONSZ89JoDhD45v6CZzALNLMtZyqx1Ma5FVISEoHgyqOuPK7w2XGgGPyzb77ln3/zHbX9avfA39iGv/Mzu0kwZ4hRuQBaC7vqjFHYDcLL8YpxTNRSwPuaDqD4yuPjyqJdd9XevyedS5spp5nO3+kBXi0qZYVLM5r2m0EEYhTGEXbaV3/rhnQqa6GUEzfjkV3qq+imjXNr6BoR6f6AQRJZB3ToUyizPqGv3nWLAzBpZBUjeGDUgTX2j9WNx5o2Jj8EXg4TIwOKsm7Iu6f6MBWUTabTN0opB6oJ352X/rpJQKeBP/j0Y24PA6oNkR72Nsaemvvt6zvu5tOGUe3n1xH45lT404dTjw53GCTyk2HiKp54uCwspT84dwiYMgzj+4ChxxapEvjy8Z67+cLvXN9yNewYgcul8ep8obBwjHvcjeM48pLwnqT9UFcetLF6P5AeNHCQyMWM4M4UEs9il9K93fIfhgBXEvHQ+Hs3z5EAS6vcr4Xz05Lpf5RqxXl7mmlqLOPAuhtgMn403LDfJ2RZ6MCervlszfj67o7vLmceL52y5PQwv1/Mj7R8wkVwDwxR+OL+kXee+WZdWOeF6DClSDHnOkeuiOQYKNExT3z5eOHV/T2/e3vN4TCyWOXt3cIv1hPxsXYSBoGX+chOBnZjYD+N/Nnbd1zqSjHlUnqQzKB98raPwsvdyEpiLY0H1fcr+mR9O/oPX7xAa+O7+cxZ6/v01Kf6NdcPpvy/UqcVtF0QGik41ykyTBP7ER6LkT0gCBGhNeXN45k3l8K6yQkVwb3y9Ulh3pZX1pNvP98X1svMu3Wh1r4FlyiUVtkB+ygQIm6BNgiXUnhXVj4ZR4YUcZx3l5m3VFIr7BlwoUsco3BUOACvZQuhcyjNEBKZggO7IBxS6rKypsy6PYu1AzdijPzOuKeqcdI+HBz+x35d/k2qHyajm78yReHr04llaEw5cowJbRN/8HsvuH1+g799YIzdRzfkRFuVP331hp/ePfBQavc/hq6Z/4vX9/zs/oGmoK17guLuhvVh5pd3Fx6WZfvayqtL99+l6FzlyJ4Bs8SXb97w6v7MH768ZkwHzlX5V69f8dPTzDMyz8eJGOAnz64ZEG5S4sYn/vHbt1zKSkC4L42RLhkLAlMQbuOIhsi5NM7eNQZNndT6D+XfevmC87nw3TJzscYgf9sbfrYXOAl5EEIM5O3eM+S+lo4EdrvEAF2jakYgYCiCkDbj67Jl1oyhO/OFyABIcKLoRtzvzZiIErbTf4r9CwojOQrqbSP9NGqtuBtzmHEfydJvZK1pj7rPGQmRFDKeIGwrhlqt034A1QYIKXYpRQwQg5Fq7Ox9+vXecM6baUqsMzoTTiLwFLX74apnIGQayqqKDIGUIrFVnk0T+yTEAMf9HrdCWSqlNWJM6CC4VkbrRsVL7Wzg6yGxInx6dcNZK2stWLONMNXpK0NKtNbpTRNAFqYxEyUwurMazEtDXRFtnM4zos4QhXVd8ALVGm1YGVMk5wgWWDaik6TIIQTGKvyyzlzvOvXCTRliIqWIWqN4T+QN9IC6NSSqC2/OF3bDyGhbfoQ/HTo/bPUTZ7SAe5+i77OwT2BeOe4jIVR6kFDXSzevuBVSUzCjWL9fHVJkBvZpTwnWV8vqm4QRQlSOKZJz7rKeptxI5JgzEgWpDS/GuVTOZWFZK9+dzjRVxii80wsRsFoJUdjlTE49HPG8bSMPux2HPNBU+Rf3j+yHxCCBtRlj6l6o01KJMXMlPxyTBfeEYXz5cM8kGW9Otu6xeqpffyldSy8eSNaZ5oXG6MYkHS5gJkxTJADJAmKxGySlEWg9WDCCeufq74i0mNmJ9KGXK4YTHWh9yx2ToN4HYAFnl4QUYsdcu1GCsyq8nlfWprwJK2UL4bzHcSKrOoMogweGfidn3p7nYwvs6FjQh5jIuRIkoWakjYJWG4wJan9bESUy5oEmzqu6crVlj4TQJZJP9aFqe/5sPqawNUXuzkd54ipFRJwXxyu8dv+IhL6RWcxwNQZz9iny2Hqezj5GajSeW2KtxkWNVb1TwqKRszPGyJT6/catsYtwu991n0BzaoG7pfC4XjjXiohyaisikZ8/Lh3MIYJn5TgO3KZMAEprEOBHxz2f2oip8o/vT3w8DFxWZWnOFCLHQXi3Oscxc78UcGeQwDSNVOBP3j1wlRO6+fH+6ibu/1f9xjb8MSaGMRJzQJIggb9EAwYYYk8M3SXBa90c//30X1tDgblUvAWi9htHjl0/laVLKvS9wdKprbG2RgwR6eho3AOXWhFLeAoMuWM5W62s1o22VWs/aISO6loDVJTRuuyjY8QEZEe1ijbHg5FwxiCcfd2IQIJYP3io9AhvC9oNdDguTkY6FgxBtfYX+0k/+MEqSCTEDkkRC0Q6+QY3qjVSHPj4MLJLUM4rWZyUEw04LxfEjHfr2jm6IRKDcQzCGedq85OcglCka+rvLyunpfSmZ4vUrsC708LogSyJ610iJ+N8Xqi1koF1KbytHQPbWkWlhxoNKROt42p3Y2aQCW0FnxfMjRgitzHxtjUygVFyn364QQwc8kj0/meNrq3epcxAYieBpRmldYnHU32YCgSCdDBA0EAfM2Us9EHBs11kEKXUSthe09qU8/kEqnx/OdOtJRspXYQKXCWhuHDxxhoUU+O7xwvPh4F9Shz3EczZbexnNlrY1TAwJef7y8pcVoI5l7V0qQWBBy2kFJlNmdwZrFPFDmMiDxFtfbravOFNGQM81MoYAtfTyC4nanCaCLdp7IOQDeVZPXAz7dmbsSOylMpqzq+4zX6qv2b16XvX0zd1gkItFR06KGMQ4XoUxuS06tv1B9WNealEdR5b98iJd2pPkLD518At4C40DA+Bt0vltmaOKW0JqJDceFi7nFW0pyqPAne1svTPyLLlpYQgzNVJKVKsUlMgSSJ6D9qKAmYV94Zax3pLM5bmRJwx9b+TAxaESRJxG9874BKYhsjOndEic10p2ilqT/Vhyt1w2/4tvdGvrevrG8puyHx6NTKNwvJ4IlhhEKEovDlfoDpvSyF613MoTo09LHKMAat9kNwtKoE/e3fms5sLz/cjz3cZdWccK189nDmETCZy3EU8w0/vz6xaaKa8PS1o68/gh0vhMGZm0+4vlS4VO44DLiO19vfFUjrBTwzOasQYuJHEGIVZOyr+xS5RzdCmeACJgeth4MU4cMiJqs6iRvjv83P/v9RvcMMfSIMQewZ2N+puODfzfoq7HgdSoOMOo2AWqW6sZaEinLQiLXRZRDRSCoh2Z5E5FIzq/exYtLKuif2QkbS96T1hxVBzzIUkkUSP4F6q9kmEGtUVDwEn4EOg4kRTIOASGHxgkIzRP87YEKKhc1qF0DcO3lF4OgjBEk1sW446McBEZJczoQXO5jRXnsYLH64ctglUp4sEFealksQ5pcrLQ+aL24lE5ayNaehUh/NaOJ3OpJB4vS5ESRyHEffGTgLmDddCcHt/kFWcN5eFm4eZF4c9+13Cg3BxaKeVS1NSir3hjuCl8rAqGaFUpValQfd7HDIlOMWUUKFqIA2Z63FHi87DeaY0JQRnFwKvauMqjVyFhNAnpjFGjilTra8YqxnNlGPKvNxNhKbcrcrZGsGetkwfqgJCECfkbpyUHDFJrC7EKHx6GIje0KadsINT15U3b98RA7yeZzDYSe7IzeAkjChK9j5IMe/bpK8fLlzFyI+vDhyHfuAUU75aSm/KNXI7JQ6jcFoK980YCP3aq4Y6LBiHmCnB+lCkNmozdsPIcTfQpPH9vPJYS0+wduOhGB/vBg5jQkLgog1SZC+J1TsKca6VS21Mh8QXh4laCt/NC7N3HONT/frLffuljjYjtN7wlyAUhJsh8nIS4vZas5GhalPuLzNZIyft2twU+j2uq7Icld7ke+jmcAVeLSuHc+STYWTMXeIlZtwvK6V1nOEuRcYgnLyxYN2EqR3P7RjNYEgRdaMFo7jhHskhMEnGHM62cNZuALbSWMy5yoEhZiTQsdgSyTGxiwGRwGqwqHPIiZeSKNXx1resT4/gD1eunWXjAiF2ql1RZSnKXV35NA/8zssjMTRcG2kjLT0shV98/46ByOu1EBBGSSxBmXGSgg7bZNy7WkQD/Mu3Z17u7viDF9cch4wapNJ4e1mppQMHng8j+yTswoV77ZjPy6LUsmwxS87ukFhrZzKeW2NtyjRmnu/3rKtS7x54sxQutdGa8dacT6aRvSTUnMfSOmAhRa6ngWjGpXZ4x+2Q+fsvn3OuldeXdRNp/m2f8MuGlvMA1ifuYL1Zx0kCxwimFWIkuPdU3lo4lwswoBmG7XDg9NhlQZi1swJMOofAzJlj5bgGPEUs9TS91owsQtWV7CMthv595EydV0RDv9GEHiAjZKI1iBGrxsyKW6WqcrVtFVYvlM20e9GVCWEiEkLn8ffqa8UUuoFNg3f9IJHrceCOgrc+cXlqtT5cFV1R66+KRKGtK7pRJK72iatD5qObkVoq5IwnYV0Lp7nw8DgzxAmAYYh9cq59KilkXmlBpCNXwSgoJ03cnWeeH46EmGhmFC3ss/BGL8jSUB2JObHbDZwfjJFEUcdTIA6xy8Oi8CwldGk8aqEFeN1WfqsZMcFbLSxWEDe+m1c+HhIv0kix/oDskrOOjD3GyO04MqsyzzN7j7w8THxz/8C6XbG7v7FX6N+Q2rTMRIiWaDXgA+yT8NF+RE0h7jCHZb3w+vzIV3cnpihICIxZiFkorpxL1yTf1YbFHvDSVFExWIWf3Z/40f6IpMzqykNbMeDdunAtiQRc7TIvdgN/8dDpZJiSopByYh+dXRw4hIzXxqM1NATuVPlxuyJF49X5zLt1oanxXa28kMzL3Yhp13qrByT25v9lihzHHW/mlbvlkVAqtx99zJdv37CJmDby2VP9uusHdHXwnvRepE9WHy/KeBRyHrjZZygBYkQkUavyWArfnleOIXXEYYqQhKZKadrJSxgFp22ZD+CcLfDtXeH5yx3DIJvXTXF37lflkCoBYxcGrmPicfOkuG84z0jPAAjGPg5YdWYqqzRUlSvdA3BvjcdaaQoXcwbgZtxRPLBq6yFvMZJz4BAiU048KizWEFNud0e+1zNBDBF/uvo+YLltrKgtZ8nNUZy39yvTLpJ3ic+eHbBlhTySZc+yrHzz+MA/+eYdn+1H8m4gD4nj0Df1p7lCM85joGzbKTPw6NzXyn/3/T1fPLvmGFO/Z1bjgvNmmbnSyAgwTPz4eOTr+UwOwkWdwQO7FHk+dTT2dRbKuvJQjUrgvlX+jkbwyneXhS/PC4s2zkXZJeHZMDI35dy6N3Ofd0SD5zvhs/HAq7nyx/eP7ET4+Pqaf/n999SguPSE6F+lfmMbfgfe97/0AKwYe7rsJ9e3/OR6z34I6BqBnmJaWmW1SjNBUdIghMGg9XANxWgDvG4AlcECeTsbraqsY+Q6GbhSmnEpF7zAO2CvF57JyDEOOPCQIjC877ijRA67EYCrZKxSqG1zXjfl4Vy4BKWpMiCkIKgKBwIhwoq9XytB5wXvB2FKO0KA0Qoxpa4ljJEaI0sw5ifT7gcrSQnH8C2pqmM6YRcT/+jHX/CPfuuWY1p4V7uz6DRXainMpXJW46xnpmFHWQvVO94zCohGvlLFi3GIkZ0ksIASibuBvBMsOO/mhV++eoNn5xenwn0e+P2PBj59NqLm3D4OHHxgYMMt5swnVxOqzjgmHi8r59K6+WwtfP32gUs2HkvlIJGdZJyV2GDNhZP19mkMiQIspXFz3HGYEhORYUiMKTOMA7dXR95pYdEzd7r+zb5Q/7qWQ0j9sPmDm+eH+vsfXfMPPtmzH+FhVdCVh1nRsjCvK491YQ2JYZggws6EpoEWjSjC13ah1cDoQhYhWN9QEiEPYFH5fj7zT159z+zGvFYu2TheTVxd7TF3PjvNDJ4AxQVyznx2tUctMErkslYurTBr4V4rf/z2LUrjnfZU3Rx6ZqLQg708CkPqtJWLARI4TiO3w8A+Z67Ggf0wMQ4DL2+OvGmFy6PyOD+5xj9IaSeRhQB9jKmYCk2M33125O9/dOCQ4E3rsqtLaSytsLRC1cAlGUPM3WtngobAO+nm19kMpaM6s/TnegiJmiCNgCh3ZeFP785oC9uWPbAfI4d9x3FeP6zsSdjQGf85JK63IcthVB7X7r1q1ljWlTM96fxBezBnDDBQiDpStWfsRAlE77I3yAxx5DAIowSGXWAfhBThatrxuja0GEWfPCQfqtwcjxty/QfGvnY63n/02z/hf/X3fsRhVO4b0ALvThfKUljmQm3GQ1U+u4qEoXIMiUkjsgRkB282imLOwpiE2pSAUPYw7hNk4avTmf/DL3/B3Dqxzqvz+c3Ay5dXmDu/u17Ig9Dmjoa92g/80ctbVuBqzLy+v3C/Fk7auFsK/+XlaxatvCs9j2kIkWFUpMGr04Jv3s2dCEj3r/7uYeLZYc/zA7ycrrmaOjr0t2+e8Xpt3JV7Htdf7Rn8G9vwR+tJF0MWXo4Hfvz8WU/XtYao8/au8pCEITdii1364v0UmMTBlJdpT02B+zBz9hVTWC/wozGj2vGX0LnVF5Q7NdZ3hRQKEnqDps1wlCUKJ4QUE7fDgXg+g5aeeB8CIRhrCZSmDGMPa6qbXqxhPGphACLCsjWPMUa+1ZmBxEBi+1sAcInKQMSBHBIxRsp2G7qebghE4ro86Qc/YGkrxJT59PqGf/vzj/n3fud3efP6kXl+JMyFP/6Tt+zGwPUusfjaQ2YCZIkc88ipNn7n9obVjF8+3PPt+cxanVmN/+D6FsW5eMXEOOQd8+J8dS48/vwNOXT7eXY4nSDFhDtclsJSlE+f33I1nChlZlFooaf65kd4XWY+mSaKWZ/Ma+PkjW/nlSE6hyg8WuM1kIeBf1lmbpa+dRpCZEp95f7WjBct03Tqq8WhTyNUlZfXR2pp5Br4rlz+pl+qfy0rWSCsxu0+8HdeXvHvfP45bx6WDVms/OnXC/soHPY9DGsQqCRS2nE8HKE2/uDqhmrGL09n3rZK88Rjbfyd61vcnEtpXFpDcQ4xEcj84+/eEZ3+OZtxKU6STIiR1RpG5ccvbvnm3Ym3ZenhSQQG6xurx+p8vOvpzbU5VQNNEt+1jlsUc1Y6QOE4DHxXC5WBaLDXgARDgbf1xIt2QPPILu94GQcurVOjPnne/16TJL6Wp+vvQ5Q0I5TIPkQ+3k380Re3PDwUVBXayk+/OTOlyLiLtCbEaCT6PWQ/dFPrb+33LGq8Wso2kYcZ55PdAXOjak8/lSgMLTEBf/79BadP99He7KsoKebe2Cfj5bTjfE6cdMUtE6RL0B7WmUuCcWvCNQTMhLYW7rVHZEU60acEY/DEKRoDgpsjBFwyMSaKVWCgbX+nj1LslL4Ez/YHinYPyuunR/CHqwSShc9ur/gPfucn/Ef/4N/mm6/uKOURLQv/+I9fcz0NXB8malX2MSFiTHngo6sDY4B/8OIFy7XyT79/x188nggZzsDv7Q40g7k2Fm+0nbC3zBUD//c/fYWZ8dAKujYWM4YUeYjKo1xI04Hff/kJ3z888PYycwlGSB2d+c++ecs7q3xyvcNW7/6j0KXjX5cLrTlV7X3y9JATZ1HuQ2XKmauYOEqkIH2oxoGqkX1K/Ogqs7YFBT55eeS31hlryqsg/Ktf7cf5m1lRIlMeuBknXu6nTgTwtgVmVdQNPCOSKNoJPeZd+pLJqPTJ0S4KNWZaNGYqyWGUHQhorF1PTWDSTFNjdiUTGEIAVwQ4SAK6aU5rwHNkGgZKKbTa6JbgQPE+wR9dEI+IKcEVc6WpsBOYYsQJLO4szWgqCMqQuymumnWTLzDmkY4W7oiwpS0MKbJPjZSFpBEJTwLCD1WHYeTl1YEvnl3zo9sr1vMFbyeyKJdlpbqS0shqhWXtybvmvcFJITLgkCJXkvmo7TE17mXh6MKL6z2EwLlWVu3c4LDF2L8thRQDuwgRQwRejj2ApqqzLGBt5GbYc3HnUs8khJ0LD3XBmhJG3cJKemCWAk2cZylyHTsy9tGcd8vKGSNX5/k+kQgspr35E+F4nBjzQG3K28vM63nmMA0Mw8BuNzCVkVh+tdCPp/rr1Zjg2THz2fWBL65vUDMijkiglK5tHUehVaWoMTd+SIVhHzJn6XrmPZllr6g4d6URVXgxTJ0akbRrQ914Fp25wmktBALR6Q2SgETHtDGXyFx7Tvjz3R5x5y8uJ4I7MQqnalQvIIlAD5oTCagoegrsJJJD1+SW4Ny1RlFjjR1NVx0uDiKZGbg9TOyHyFwary8zX58uTNOOj8cj025gvw4Ml6cN04eoGIXrJLzIA5+OI1YrmCLurLVPzqP3Lc3SzwDdz6OR7IkmioSBYzZm7wbFU3EmjJvUt+EqPdBoDsZRIjVU5vbDvcv7M1gcIYL1xO+5OoyRaciEAu9KZ+mHFJhjNwIH6WSeGAzo8ItWKlmEvjALqAcWVTT3DYN4wBGwwJiMAhxGYcoDFbhvC49LIYaR2yRMOTHlRHxq+D9Y7cbEJ88O/OGnH/H3P/uYNs8kLkhyHufGZW1knHFIlGKcSwPrw6v9kMCMmBLXQ+bzZc/cGm+WhcnhJ8cjP5i+T61yMuXTNHDWyt1aUHWaOcECWUPvGd2ZL8blpMhL4aPjRHTnu9M9Aoxj4J0Zj1p5UYYuByYwmqDRe8q0Qw5ClO7xfKsN7Zc3y9owMWqMHPNErcLt4cj1MDCXxtfnCz97uOcf7UbG4Zpn+4nHpXSE6K9Qv7EN//Vux+2w4yqP7OJA3fhY3rZQLnckOW6dvHOqBdNuRBtTopqwatf0hQBZ+kl/ECfFABv9QrcI+ZM2ghmFrmFOBDQYOIwh0YJ3g25prFJ73LFATuE9ltDcqTTMesy4BBi86/ujG1G6JUGA7N1cokB0YfBACN0t/sP9I6VICIGmyly7cfOgxlILwXtq3JOA8MPVF7dXfHTc83IaGdy5v38ECrU2Wm3vD1uCkCXx9emORZVdTFzv9kDhsTQOectkSIkrRsxgzGFDKG40HlW+vSw4cNLGMSSyCKt3EsXgjjrMTbmfV97en9jHjKWR60FBleDdsV/VOGv/+GB9PXhN5JtgnVAVus1nj/CwyTlyhJ0EcojU0HGjhMAwZEJwLm3lu/nC95eFn5SCntnoP5GUni7CD1GfXo+8OEy8nHZMMXFeCwTveHQXCI6FgG/m7/NcKKZEjI92E5TAuTSyRNQhiXDIkSaBIXXtu2z+o9CUt5dz3wq1fg0jwmIdJJC905sWNR4W5e3dzNUwoGo8HxtNGzEEWgCrHXIQttRpaR2NV4MzIVRxuiCygwskBILRsXMSGSRR6GnPaciIRC668s3lxHdz4fdK4e3p3FffuVPVnurXX88k8iwmboKQzThdZsygNqO1Pgxz7/rn4M5prjQ3BOc2Z07A2pwY+71ujAHN3c8UU3/eJYkkE6DxuPbX/IfntoTQr3WcFAJmPd10rsrDvDJJxASm0FBTpDlIwgKE0J+dZhBCPyS3LVtH6chP2RLse9K9bRhtIcWO9gaQJITQE3ofa+WhFl4MkVPpvz+myNPt78PVH33ynM9eXPHFs2smCbx+e0eylWXtvZi4EqAPgAXuzmfW1oDAF1d73i2Fx7UyxEQMwvWQsWDM1RlS9zhl6TkkqTZeXZYe+qeNQSIRaP6Dh6Bf70tT7i6F128euM6ZlideDCtFK3i/1qw50SJbVDDBO0ZdzXB6iGsIAdk8MjF0mo80J20Hgk6/C+Sxe2FO58IvHh758nLhj5bCm9NMEriaMjn9Laf0PBv3XA8Du5QQImtdetppM9ycEPpDwzf+6NwqrVSmmNjniDjMxck0VmuoG9GFiBOCEkJAt6aounHfVgY6Bs+jYJuhsjok+se5K0stnH1mN+RO/RFBt+h3CY5HZbG+lo70QJHokYgSAhSUaF0nOEngFI3M0L+3EJD0l4Ald1B11tZYtLB4QFW5mDHFkRQiIk93mw9VP74+ctxl9kkIqizLyrRzam240VFxBHAYkvCwFu7XwrPdxGe3Ry7auLss1Czcl5XzDzcRD8TtRuVuNFeWpny7XBhE+s1lk3itBqs51gzzwIzydr4g5nx8uGaXRsIIpa4stRCDdOJPbYwERnpoVpR+7RPgbMrgfU19nRMPtbLbePsxCEPKW7vVCVjBGo915l1dOauy1MqpVj467N9PuZ7q11+fXe25GgcOMSEeWGthjP1BEOQHI6+gdBzcUisPWtgn4fNx4KEV3l0KJs5jqxRr/SEXBQudGFbNUTr+8JvzgoiBC+NmmgVBvRJMUAJLdd6eC2N94MfPr5mGkU/2zqksrNonqCeFx6oMKeBmmPYwe5X+tWY3BuBAYBLhLNInxQ5jEPYpgXe/wlkVU7hfC6/XhVmVWhtvSuP5fmQXAlN66vg/RL2QzBWR0QOosay1B6/VilnXu0NAW0Bw5rVwscqUIx8PI6sal1JoMXKxnrQ7SG/2i2wNdRB8G5y8aeV9HkTcmjH3fn3HfpulKTyuSmozL4eRIWWuNLBqH5pEoEYoFohB8c0r8ANFTwk078z17E5iC1jEe9ZPDIwp9KAwurdO1FhqY64dKavqPK6VvfTDy/grNltP9devv//Jx9wcdxzHgWDK4+OJ57vAvFS0KUMSUow9GA24rCuv55VDzvz2zRXnpnz/sOAh8FAWCsZxlwl0uU4AogeCBYI7f3p6JHj3Mj3PwiC9xwo/oJgCXJry7enM0eDHL645DDt+fNzzbpk5W2MvgTvvqE3Z+kZ324hA3XS8eqfoDUFI9AYfOo1yJxshb/uSs1aSNd4uM99czsyqrLXxzbsTzw8jYwrsx1/tGfwb+6TeyxZpHSElKDWhrVC00p9zETNnXTt1IhTFoDOcW2MpFW+dQHHWwmxKEmEKHeMV6Lz+VRszRkr9v8+eIQkugVSgBmPBGKyfDC9eoRqH6ZohQSmJ1sC9kWJj0siDGjHC6DD0JQEaDVVhDX11uAP2W6rfQJ9iGP3im7aWf15WyiYVWjEQ2W5gQFJyCu+j55/q119TGKjNaalLI2JotLVjtHJOjDmCBh6Wc19BI8Q4gMMyn/h+fiDoQKHy7Trz6M7NbscNCW8VIXBZV96sjWZwvY80tmAY6cj1AyPqBTffSD/K3dxoq/LZzZHrNPLOnLk0zCOTOGVMfFtO3MQBQuwEApwppm0bpogbN9H4KGcuNREJnFSpHjgm4cb7dfXV3T07D1xaxT1wyD2LIADRnN2QeT4d/gZfpX996yjpvf5TYkRXwyR0/JwExhhJBE5bjHjNwmqCVeWuXrh7nAky8NZm7pYFw3i+H5jSwKUVQoDzxbkUowVl2m2Hh+bEYIwSeTHueGetpzmSmJfG18sjdVj58YtrjgdBLVNNUTfEBEmBvzg98mw3kgCtveGfPFFRqlnXrobIISbm2A+9p1b7NjYLH08D7s6Xd4+M5jysC8WUiUCr3XzZUmTMkRfDEyfqQ9TOck+izcZ1GjjPieaFDYxHSn1yv5YCBEyN5lDUWGrlsRWyGnf0A6fjXI2ZEedutvcgwbBtIvOgaOvOzCCBLMKkiaB98JVjZG1OqZ2x/3LcccggJqh1jKd7wxHeznW73/UmH2CMA4WOWg4bH22MQlbrdniH6M5oXV4E8G6ZWYJRrAdgRhHcEmqFGnuq+iE/XX8fqp6NB9qiaHCmq0xAWS7KMhcGiQxDRgROpy5paRo5F6haWabC47pyuqx8WRYerCA58NFxBBX+9OEBd2dEyL5N1CcQDaDOEAJXEiGOvKuFWZQUI++WwvlSWA+Fn7y84XgA1UzVyroYwSGHyD87v+NZyCQ1Wmt4gJwjpk6lX3Me+nbBMLz2YUhOxrXAi9jN6T9//Y4Dwut5YbFG1ECrhfu5X8eHIfPJbv8r/Tx/Y7vF3ThSTDmfV5rP3FnhmomaO39eL4rNXTeqagwDjKmvhu+tUyCKzv3kj9Ewzto4pcRDqUxNaDgtdAf4Pk6gFdWKB0Mt4Roh9ZNjlb8kZFwwYOBqGLmrFyQ6LcJJS0c2aWVVYdlS4oYISQXdTE3uHQf2mCrXseMPJ+v6sEWVc4SxqzRIqa82JwInrQzjNdDX88EDu/B0s/lQdXW15+vLA6/fPPD2lfF1PfOTfM15CPiy0tbGpazsYuZ+rnx8s+c69un997Nzy47v64lTCpQkqCrf14VHiXz5/cLzJDQLFHNydG7yiFXn3CoXUVQ6vi5aY4o9obcv+ZwlKgyZ/WHioVWGNqAOr5ZHJoOhCXet8T0rjrF3wQweWuu4u+B858arpvz2tO8sag9Udx6rImNArDIuI23IZElcifJVufDZ9ZEUIwyZqhA0/02/VP9a1s1+5Jtl4bu7d/z83VseC7zYJ2Kcuk/ocUW1cT1FhnHgxbhn1MDpcuH7ujKI8Gf395AiNURUIndVKMmZT5WgzlJap4xEuM4DxYRaG5izmPKwFNZFyRlCBEKgGnxdF5oo11dXnNeZSQMaAr+4PGIoUY3X85kavF/DDlbB1HAx5gBnlAz8KO+YqyLB0ep893ChNOWhLPzocCBEYYrOpznxZ+vCj549J8dEHnpzOZanLeeHqCln7mrh9enCz+2BczFeTEJMI3sitjqnuZCSEWXHcT9BW1i18a44gyd+WWacxGJKc6WZcRwzAliDZl0y4dE4DCOWjFKc4IIRqPRpfUcY902WBue1AnFgv4+cykro2XR8N8/YXCkCJdQu54mOiDBrfg++AGgYDeUYR6r2cKSmxp32AMVaZp6pYaHiNMQqpcL+5gUjO2J0mjX27en+96Fqup3481dv+PlPv+HxXyw8WuUP99dM044XUdCy8vrtiXFIME08u71mSfBwvvDLdz1X5L+6f0NLwkU7VemkxvU0kAAr8FZrN44H+K3jxLwab5eVkpQlRE7VeVcKI4IIxBix4PzZZSEOiZfXV5xL4koFi2f++M0db099m/BVLF2qE/qBWGvYAlMBgRaVWYUv8sDFjBY6LejbeaYOgTftzO/oHp0iSmOH811ofHH7gt0I+2mgVqOuf8s5/A/1ARfp2uS/EiqQFaa4gzFQQ6XogiosaGfVW2Ckr0kaXcqwy4IEIW7R7iugdC19cthpZBwj5wQ5ZSx0zKGYAPX9uiimyCDCzgKvL3fc6hGzrsXKJow6kCjE2MOyVusntrNWJiAy9OCwIEgM7Ag8j9281LyBNkYPRAagsMbCSpfpB3FQ+O584tm4Y5eFGCLpacL/weqX999zX2bqWvHQJTaaIvsg3F4PRODhvHC6LMw58lg6wzkJTLtINFCJ7IeBLMrYCo/LCtZRht81ZQyJY0pc5cSLYce7ufDJ1NFyasZqymtp7EiMGxEqBmEIzp9+/YpPbo/Uan0yGiNTjCSMIfZU3LMKd3Xl0SrPtE/ow9An/XggeOKL/QF3OC8rD60wSA+4qWWl0LiU/h50GgHhv/zmW/6tj1/weY4cUkT3T9fgh6gvz2fuase8jpJAYSiRsKvcDAPTmGmaONeFy+OZBWWuldoqrq0ngEdhGBIxGhXDFX4w/lwIIIldiIw58JPpwGWt6OQUb9TWuB0Gvi8NwboBLkZiFGjGP331it8rlXXphJOdRD4aJt4WgMokCUF51JVzU0ZVRIQhgW30lKMJf3h7Q2vKt5eZd1tOAICqoYvyNirFKkstmBv/ly9/wb/z2UteWmIIwvPxSdLzIerVJh+4VH3PyR5sJIgTQ2AIXcc+N7joQoxdglg8UDZJ4A4hZ2HQyNLANUBTbJOixRgYRRjDwPM0cmHFc6QFaObs0siqK4l+CA2hyx6iOz+9PPB52NGAIP3Zf0XksUdWEKSn+F6aYhgp2kbC+yGfXtiT+Hw8AIWzOmeDur0/tHWz+YMbzSpNFxqBrx5f8+nxiqsKA7B/kpR9sPrpN9/w3ePMeV1xNVJzbmIkxcBxyuxi5FKEthoPby+EHVzKylIaj9YHwmMUbvLAQODcGlKdNEJGOKXGIUaeMxBC4I+OtzyMK/PNxKUpa1Guxsx97SFsQSFkRzJocf6LL7/k3//4E0pVUghc5x2f7Y+sS2Fpyp5ExTl7owokcwSIefORWofC/DvPnoHCTx8vfF8Kqn2YcVmUU2hczFha47H1kd9//tWX/M++eImYkoJwe/hbLul5nFeGMZPpLOBsP0zqa7+JhEiITmQkZ+PUNs557KmUlY47Ch5Raxi9MXcg09/wIQRSEHIQpmFgwNHaUO0NP4Nxqn+pzwvWpwIXByuNsukKxYTkwkGEhhC2lN0kgck7aHM0EIV1SxcUAUf64QVoUokpUswpKGvbpvwxou649clE1UZVRZMTgtFC46k+TH1zfyJJX+2lBLlkdK1cQjesHlJiiAPTTjiGhXfz2lOfUwALRHWmPBKbM7uymOEaiNl72rI5mZ5kexMHboeBqyFzqbXTI1yYUua7Vnhc++ucIuQYmHFercqjNhKR6N0E+SIPzDSyNZo5mcBtygQS++pogMemxBAYo7BYZb8bieYc0sDBGg9WKRb4fjFus3USlhnnWpEIZ628u6zc5oFd4olD/YHq2/MCdCP1IAEVmL3SCgz0MK0QA16E2SuPy8rcKmqNEAwpxo0EaqDLGixspKduEAMjh8BeIrc5czVkrtLA/bogZgySYB95bJW5FNy61j9ujOif3Z2pNXBImcG6N+UQAtUiSzZWNYIbE9KTe9eGmjNveMZkXYJ5PY2IBg5p5MEqD15ZKhSZqW6kkFFX7oqxOHxzOvPZ48T+as8UE6U8kco+RL1ZLoQQiYEOELDM7A7FSdnJEggieOsUulkbqyvq3WMCsB+FgiMekCAs2jX1PzxVQ4BBhNuUOQyBHXsuWlh8I/PkyOwrl7V793ogZf/c355nXJUchahC1MCUE6uB5IC60MyJRHYYQoMApt2sHkRwEW6HAUhMDgc3ZjeKNpZNPibSc3HOtUsj79aVY9ozDpmhR1X/zbxA/wbUn72+p7W+CbwaMpcgvCoVa4UhZoZ9YhgypTaKVk53KyctLK5oCEgNfHyYOCsE6X3ZZVF2OyXswYsTVDjEyEeHiY+niY/2E9/MZ0RXxiikQ+JsjVPr2/KgoSPgJfDHr+9pxbkOmXG7qq+isE+ZFrvpvKEMIfA8Zx69oCo9ODX0ntQCfDIdiSFwGHa8rSt3VinNeNsC6kry0FOiW5fNffl44i/ejexvr7kaRlr7Wx68Jc0JuVuY+4MmUkOjuRGsUmm4G5FMjB2Dqaq4OsSud1eB0HoaaAjCSPoh1qpPBQKAc1FjqJUQMot65/56f6F8y3H07X+20VKixW7cjBG2cKaYBvDEiKFm3XQUAxMRLUYI0ilA3h92lgISA8EDav1iMTM0eqf5+Kb/x2n0lSMhMLfKFIfuNfir6WRP9est7RPtuFGd9gHOTVGEx6VSkoJ2rnNMkRgiuNK847xykG7Ubn37tPPEIWamHFnMKF6JOKs2vptnMpB2qWsEW6N6Nzl2yhOU0APAMNuwdRkQxtiv/WLGTZrIDgdLXKyjGwcRno2ZkzWmOLD6igRnDD1EZ4iZKMoFo5r3sBoPiESyRCQEFpwVZycdJ/ZuWXg2TtyMEXs6c36QuiyFFIUgUE0QD1y000rOoRA2ZKs7lNbBAa7WiRUo2ekGbOkkpWMQggtpF5hL7bhgU05ALV1Ss0+Jx/rD9adYaox54CoPPNaV2vT9vW3wTPTEGFNPTm3GVUrsgjNGNgJaJ7F8PA58W3tSc0Tx0Ke7EoVJIiF0khC1sVSj0c3jKff0aBA0C6M67saXD49cDwkZI609XYAfopaipBTIIWBb9tvihjRYgoIExDqdruBU7+FY5mBuJAQJCVTJEom7SNRGSl2Tj0NTZzZDMEycMQ3M2vNDqgXcO/3pKAOLN8yNZkYITgoJaxuBj/49TCmyU2fduOdJuiHyShKzGlmEQh/ohdCfqWMEvPvjFjeaKWbODxA8CfR+IvbtQDXlYV07YjtE2lP45Qerh8dCjLCLgm6LpsdaEen3sHXT8DecsytrM+IW6HaujezCzZCZrXEcEzEJ79alDyPWQGvGuRkajBYhufDR9Y65NE5r5aKKJGU/Jo5RuG+VWRvVjCRCaoJrx3Gq9sDWw7jjOmeqGmtwzIR9jPzksOfnFjjkgZM2VhouzjElDsOAhEDDubPCUhWzvpGPCDkJkZ4BkTzQXPnF44lP9hM5ZrT9LZf0jNAVy94P0JFIlUJwWL3h2x+MHjEMiR1xhHV0Z0w99ErM8Lhx0T3Rl2+BNTSMTg64aCDPK8TAxRoNQw2KGVMa6NCwfrMJOKaBKWSmMDDERPVCtYYFIXliDEoNXWtNgEkS9yiDJBKb7CP0jn6hki1STVmbUlo3HSXpMdBBQEM3dwQ6uWDRRlVn2A4LT/VhapJNSuUBb84U4I07Ozru8FwNN+U67bmgpCgkIopSVdnH2Ak8pgQPXIXMPiX2WTircm7K7MpJVx6LEdWgJe7OK4sqi3ffyUfTgV3M1ODoJl1zgxfDyPNxx/WYeFwXTmvDYiJjjCp9I2ZdYvQsj7yNzm3a0wCjMYRAzpFVO8rxrq68WRZOtTLmzGFIHf1JP7xkz2SMJIlTLZxqY0oj4Sn87YOUVgXvZi8Nwi4miiZCgEurNKvbBD1zrhWn61ClD2EJQIqRJJFdykw5M+aIZeVVMdQqZ20b+cZYSuE4JOam/Zcqqxhf7G75dNrRFqPMSitG9MDn0xUfjweOY+SxLpy8knJkl4RkgSiOGCSE5ynzSlauw8guKC0oLkbKkUttRIH7Vni9LLxZV6Y0sk+ps9alJ/ceybD0LJbX88xjueZ28KehxwcqUzqaWnqDHCXQrE/nl9afk9IEicaMIggxCC7GsqWTN41gRs5CzIFBnGpGq7Y1/F2Oe7KV2SMHnEttLM16cJsZz4fMzQYnuFRFWyNHuBpGDpI4SuLsjYWeH7Knm4uDd+9IDoGjRFbt99/V+udWnIizeCFaYNbGuVYuTRGJfZtKl1CqBEbpeEUQTnXlWnfkGP9Sk/1Uv/ZqxbCxB5s26+5uC07yyFILj3OnjpWmvNGFgcBVSkQLvGoFxLvx3I2rYWCahDb0e9h6UcyMtSpvvPBNXXiXVn5HjtxfCm/XlQdttOj8ZDrySdxTvcvc1Iwk8Omw59PpwPNd4m5ZmNXYDyMvp5HHuaEohnS5427ibjF+NEx8v66805UiyiFHHlpljMLbtvLdMvPdeeaYJybJ70lkGuFI7tCQAPe18lAbz0d/T6v8H6rf2Ia/n+Xe+/ghKqaR3ByVzs0FYwmNpVUiQgiGRedMYMTYN+lTI6DHGtTOvWegSd3IEoEYI9qMCwsSrKfthUBf9P0wZe9oT9GAWySOsXPwaX0KQNpoPIm2ztTt1CmbI3tJRgayBlQcT8bRhdfzmX2IrG60ACEJsQhtNFLu5qaIEEUo5th7HW0kSqJzXZ7qQ5Sqk+KW6m0Bl4SxoChu/dpqpiCFn11OvNwNhOC01hF1OhgvLHdWdejEKZJzUQV3Fvx9yMzz3YhF5ftTZYiBKUayQtBA1MAajWqNqn26LwR+PAaOaSALjCFiwcgZLCbu1z5BUDpm8b4a51hoUhgTLOY0Nz6NA//q/hUHBh5bo7gREJpJPxRIxIPzLEamtOPt+ZEcY9feDoGcAq3+D/0kn+r/n/KmtAAu9OwQ7/cY90CpjoZtom/Kd3phh7DrDjGqQUkQrZEE1ITVA1UUWkcNBxOsCWLGVcq4Ot/OZ8aYiLF/LjUotfEmVe60cKbhwRlMGEdhiJ1zHkNkiEYa4MgV6XKitUYxpVrjrnZhtcQeHla2UJtdgP/r2+/5OO+51IWiyj4EBgmczEG7N2BMIweEn18eyGPkmsR1jgxRKE9UxA9S5h1NrQ47C4xDorVOjAvqqHdSHgZ32rhKwjR0CWtpdB1/bYg4aoY1qJsENdIzZ8z6QC+LYQRer4VMf+blPl5D1Vli64moTcGcLJFdHoiBbgZ263hPMYY4ENeGWdue8XAiUNy7l857boC50kT5k1PpGMTWUDNy3+vSLJK8h9tlhNgC70pBUiZv2vBREo0nSeOHqpku5RroxJwXw8gDjXNrvJnXDhgI3Qz71fLIMxkZ47j1bPCII3MhZ0FaP+C9jBkmeGuF8kOQkQMSOFnjj9/eM1q/tpODqbPWxmsqb9vKihJjYBgi17uRIfbrOZN68vmQGG5ueI1xmReWVlit8tVlRmNjjpWy0cpWc+6k8X/8+ks+P068O69cqrIXYUjCqSpTTjyLmes4kEPi56cLz3Jm2uRo05CwX/Eh/Bvb8PeEMt/+f+C8/b6OfZoj7//Z17/SIEjXG8Zg3Vi29smDGewksR+6QbaUsiWnJSR1xGd02Kuhg+ChIzVziJxjp+XsY0bNKXQ2r6oSY5cVNevyCzdhPwysqa/ZAxsrWyNjVAoFDRUMRIWVLj/qUgrBvFN98mhYEB4NHGMMkeswUpm52l8xMnanOErxwlN9mIpuBBcKjdWN17V1o7eEfjCTwEhCVLgZB6IngjiHsWcqRAmMBr9cZkqAj/d7fnt/BODd3R0Hjww5IAEOIRMloVPrBjU3LERuLHFHZY6RF0NiUeWuVpZiXKwwDs792njbCisVmwOfXj0j6QlIEJwUjGzKR5JYrXBaVpopEgKvEMjOva2cXambiO2qW8X58+WEA7fDyCfTRJKBv3v1af/5bGvWS32asH6IWr1vMUP361N0RSQQg5NC3HI7IhqF/ZzZe6dIhNDN1EUSthReXWaQlY8OB/5wdwvAT/XUUa05cBThmIVBJo41cdZu8IXQyRMU7ouyM8EtcrHGBeMbm3k5HLl447XOXFrDCny6v4L5xM2wY5JILZV57sGDZ63cr41iRpRAyMKlKN+0EzF2T0L3WjUiwk8fz3g0Pt5NfLHbc9mP/Lsff8ZIZtr18DH9FadbT/XXq44N7/jKGuDU+rOrbRKDEEPfmLfAuAVGGk6SwIuYWel4xHMFb8btmPidQ8cH/mxdGXFS7AO8HDPD0H1PiyrdddKHZIZxVsODEiMowuJwV1Zu91esapyrc3ElZfhomFD6Vih5oJlyKeuWZKrMFrt0F2efe1BhUevhR/1vTncBCq/V4FI4psRNHmlJ+O39NfsUSWOX1Lo/3f8+VDVXmlrHRSTINOa1D7ZUnDlAQNhJ4HYYyBo63jwLnx4HaoV3l8rdvECCn9wc+A8//RiA//zxKxIJGaCKknMkpr7h7PurPjlPJXCmUseeD5Fal32flspfcM/nt5/wdil8c565r5WajN96/pLx4Y7PxoFnSTiXyt3jypwbqs7bpXJpDQkdb/tdbZzoEiSRsEnZG6PAt7XyZV34ZDfxxf7AeV34X37xKYlM3g2bnOlXG/z+xjb8NTqD93j3AFzhnGN/Y2Xrp3QPAc3CQUGGTirZxcTtuCNq5Ct9S/Cuuwve9fHH4UgphUhiaaWntQWYh8TEwGIzQegoMWDoIgqK0qcZ7kxRcAp3p8qKUb17BK658KgzXzy7JYiwLJV5rtiG2Zz7bBgP0uU5MXDFgSjGOA3EFDEzzvNKKTDTqQAxKJqUaRgwjZy0gBiOcVmfYuU/VDkDqatLsWTciLGUkYoy0lfFOBAFqjElIQThahj43asjaOW/fv2KaRzYY+xCT3W+Od7w9f0JRudSKmtVSmxUjCtGXlsn5YxRmFPgBSNvS+USA4uDeTcMqxb+xdvXnFplaX19PQ6Nr5bG//wPfkyKkVfvHvj27T0xCtcFvpkLc1Aseg9WisbfHV8i0TgcdowpUmvlLx4eWZfIRR+oqiwKK4FP9lfczSfuSyNI18nW+jTh+hB1k4Uxx47HbAoJruPw/s97imjYBhmFtVZSFF7sR377+kBT4/9Zv2eXE2ZQSuX1svCjmxuGmLgCTsUp1ZibwNR4lnc8tPN7RjkBRjLnpUuLTPu2ax8Duhb+xevXXKz2CHqHx8cT348P/Id/+LvkGPnu3QPfvr4nE3m3XLjTiiZQ6wORas7/9OULUsg8O+zZJeFSV/753VtYIkVWHlR5N6/cWOIPrp8zz8a39R5/6FuqUp+GHh+i9lkYc2Jx49EUqZVPpv2W5q3U5kgQbncH5tIn8MWd22HkJ/sD7o1/Xu7Zp0ShP0PfrYHPDhPHofuLzlumQg+mzDyfMt+eZiz0gULAEHfMnJEMYgSURGBV4y8uJ1ar73NQHlvlFCt/9KOPiSK8Oy+8fZwZCTzQuBRjZaUGx4m0mvn96xEscjMlBgmUVvn5+dKTW2ks1jCFIQ18Po2ozrytkbA6DeW8Pq04P1R9fBgYYx9CvK0rl3Xmj66uuddKbYa1ioTAYRiw1amqPLTKZ9Oef/jpS7zA//7rrynVKNW4zMo3Dyt/77c+5dm3b0jE954lqYExJxgD81J6Cm+KDENkCI435Ur6Jn2hsfPIu9PKf/GL7zh5ey/t+tnpzC/uHvhf//v/gDEl/uLVa376zSumlHm1nHizKk0KumGOgwf+4x/9mCuE29uJnBKPl8p/+/Ur8jDy1XzHQy2YGbsg/KNnH/NuXnm3zAQxiitz+dve8BsUl23KbwQzggxU66Y0wXs0tm3bgJAQ6eEcuzBgGFNMLN7ey3ocZ7aVokJMiVE7LYcUu94vDkQTzAwP3eCTLRHUaAIlGBq0B3CR2Pu2bqdTetwdVeX15cQ+DaQgTLuEaqCFyurOUH/AbHZ39jENuBtD5xF1WQ+BKMLEDrW22YYTKfYQJfWGt81G/DRc+GA1tx74od4nnpYjKTpz60FXCWcQCGKYGiHBECP7IbLLgWqBq92ec5vR5v1198ZpPnF25UUaiSLMtZEJpGgMBEIRFlUsBHYxMZHYBSMG2QxyXbLxrhrXSYkIU+yT32KN1ZR/9u03vNwdSARuj3vchKvo3FslWdxMvwG1wO1uRymFCWEMiSDdLDdI4NO05zEuJOkpvFc5cy6NGqDVRvwhnv6pfu1VN9d+I4IEGn3SH0Jgwbpu0xxZhYZyGPMWEx/JIqSmHGSg2ExtRnDnsly4j4HF4MU4kSVyqkKSHgkvGxWtjxOEfUwMAnMzkkRqNJp3qVjxhLWuvx9iBHdOpRLWyj/55Te83B8ZQ+Tjqyu0GUmM+QKTKil0f8F1yny8P3JZlRykN3kWqE1JKfJxm3Dr8IYWjWMamRVagLkq5k8K6g9Vixtm3YgbLfSm3ayDJbbBA2ac2spsjWdxQKQbLIcYqDVwPe65rxVTpdK3BN+vsLpxE3d4aoRQSYE+aY8djNFf89Cf5wiXjZ8v3p/NlUBUuncqCEkCvuWILGZ8fX/iJg9EC9zkHUJPd36ljdoC2Y0oxiFmno0D6+IMwBACGhJqARHhmnHbefak3hwjYsbqzqodpqFPProPVidVykayiRJYNygG9NT5ZoZoH75dUL7Y7dnFyDEN7PKItcon48RjqyyuXGrl6/OZ3eu3rG58fjyyq5G49OCue+2Ne6AP84TAMWaOqcu5CNKzINxZXIkxcd8qw3bfVeC+FN6Uhf/qpz/nJ9dHssNv396CO8fkXMoj40ZMiwJ7Al8cj6yXwkhkkMQSlcdWuc0DH+dpC3ftAJerYeDSKvO6ctbapbzhV9M1/sY2/BJCnyhtCnl33Uy83TjUZ/CQNxxRwMlEBjKyTWXHlCnaNWABgSA4fSoh0mO9g0eaBMScFrrC343+5g6CeyB6wEO/YUSESv/BV5xMQkI30lUqSmBdV8zgMAxMKZODcNJAsv4w/WFxWOms4I4s6xeXEcFD//7o6+1+RIikkLhYo9A2xFDowWFP9UEqyA/4OEERqnfMoFlfAePOKHAQYeicVXYCewmbRhSejyPVVlYRRCIhCNGNFDqmLgvUaCzar/SzdzGFElDvyDqAGAPZAiF1V8lpbbgHluocY0aCUFEurdBwyumCVni5n7jdjajBw4nOzqY3Zwas3vGxJOEHmrSFvsrP0ilSI6E3g9vE79V5YdaemuP06dtT/fpLNpJIDoFJEoWwccPoBCc3kkML2hv8GNlJZBf7K2nuPSFVCiqhHwYC4D17NKfA4JFk3WhezHCvSOxUKCF0Pb84Y+r3qV0UmiRWa51z7s5Hw0COkaUZj7VSzXn1eKI1+PRw5OVupCXFbCUnIdfw3gSakhCJDNE7DWUDHTRVph2sNRBa6LSVQRjGzKv7M49rgRBIEmn6dP19qOrPy8AgQrUur3DvMip1EA+Y9qFUisIogV0QgoO7d5SitU79AlLwPrWnX9eDBKr3r7SqY7W9HyAIsIuRTGAM8X3argV6WjMBM2OfE0k6pMCaoUTu1oK1LsUdJRG8AZEYdDvU9u8nxkAKYJFtsNb9e6sZU4q4BMS7RDMJpBSZS+vvRQmEEOHp+vtwpWDiJBGOKVHdmM0whNUqRRvZAktTIjDmyE3OneDlgdWdl7uR79aMa3/+ZRG0KWNM7HNG3bmkHr61qGKtD3FjgF2IXEliFwKX1Cjq5G0Qt6oypMhqyu0wsNu2YefaMAl8eXePa+WL4xUv9/uNWlbZFDsE74CFXRCG0ClQ+KYaCHCxxq1YP3CG3hPmJOzGzKvLhVOptO1n4/xqh86/lt3pP/vP/jNCCP8fv/7u3/277/98WRb+0//0P+XFixccj0f+k//kP+G7777763yJ95Wlk2qiBIKk7RtthE1XpUYnBrSNiepGRsjbGcYBkR5O1Rv8zo5O0h80oJgYLQRK659z8bU3OxLpN4cE0tc6Y4rsY2IKCaEHaxVgkIFdzEiMmARa6t9pUVALJOkXWFVD7C8f4kZvCBs9BVC2NLbosZOJ8P83e38as9ma3vViv3taaz3DO9a4a4/d2+1ud3NsY5semE6wjAjoEAZHIv4QCEJECNtKaAGSv9BYCvI5URL4wpGiiCEKQgRH4sMJElFoAWZoY+xgY7ftnnZ376nGd3qmtdY9XFc+3KvK9mn7eHe7qnr3rvcvVat31Ts+63ru4br+A4WM2GrRaai+xKNERs0kIxSrvEP71fcEnmb9AcyDY+4d8+CZBV83BlGYhJKjFHZZ8aVuiJb65u2wqNTueUe1vwzWYZ0HF+hcDfFIIiQp9FI4LYmdKCcpkrVeUJ2pGyhWWfjAIngOmoaDtsHbyUc/Kfuu5aiZMfcdeI84jzOeh9T6zjtmwXIyZFQMRswjUZOoQUqhaeqhXhCk9pGx1jCYBEYrzc0B1nA6jGzjSNJKZ9uVZ2fM9DRrsDWWmYW5U2bW0Pqa8ChaQ4mKarVGdIbWBTCWxv3agT+ZehHtmoZ5G1i0Dcu2bkyNUYpmolRHlE0StrnwII41HMs6WmNZeE9nA1e7ln3vOGwaDruOrq3CRWcMV7uOq7MZy7ZlEVqC9Xhjq6AdofOOeRNImGp1aGszJwNZqzVe51098E/vLxGldYZzE4mm1LAlayAY7uw2nPZ9tUO05pk6bz3N+muoh2FvKy/fU8MARZUkhSSFSoypuThiq3NJY8yjqYw39Tl2vq6ly1DtDZ0xdX+TgpTalU8i7MaE1Wqr6I1hbj3BOg6ahj3fsAwts1DXP2OrmHbfBfZCYOY9M+dwLqDGVj/9hyNwgVF+zQZEqetzMUrOgnd1ciZUDnjWOvHaWaFYqnbGGZx3rFTpqbXnvK9t2mcET3sPnuEICq2BhfG0xtGLkNWQshJzQajd71YtaqFrXA2YFGWUqhM5aBuOZy3X5jNuLObsNYG584gquVSjja0IqEGyErB01rNwjgNfv++NecdxEzgKDQehwTtDg6W1lhvzGc8t5lydzTiedey1Ld5bdlJICG3wdE3DVioVHSZbGqNgoeRM23isrRGXhUr/NVY5yZGRgnWmWtA7w+3djlVJ9T3g/XRp/u3xdXf4P/KRj/Av/+W//LUv8OuSXv/KX/kr/PN//s/5yZ/8SQ4ODviRH/kR/vSf/tP8+3//77/eb4O1lqD1gWAzLY7R1PAtRR550y9wFISZNJNrjk60B4gp0Sh4MWBArZJzoZDQSbSTRNimgm1hVwqdqwctbywLqhHv0f4MKcpKBs7ySE5SvddxtG1LYx2NFFoMOzKoozOBbhJ0iioxKrmtXY2iyoggxQER5+bTARGKZAqJ0UKRgs8QUMRHdjgGzWQRWqn+rC49O4sNPL36A1hYhw3KKAJRWZjA4KkHXVNIRqvnvjNsUuZ4viTYBsURtR6q764vWPiWeodUkqkuPWIrB3adC2c5cS6FPeNYpYJ3jtYa5t6x11bO9q29A4wxnKQdb27XaLHgDYeu5fpyr3K9S+KmNJzmBCMczFoWIdT6y4Y740hnDQ5DVNiSSRG0ZGwbELVIFEpOld9aCluJWFMX1F2OnO9GztMIVlELyRjEPkMnLp5eDVYhpJCKksSwDAExhkGn9c8q4gvX6NhKYRHClOlRz81qPfeGM7x3YD3BWpx3lX8tmXVSTvvMyZAoTrnSONa54K2hwTG3gaMpCfzG3h4WuJsG3o47QlRyNhw1DVfmSxrvmfvEkfWsxh4Frs9bDkKDqKVo5jQlqku2rWYHWdhqRg8KxgZElDEXNmOCUpNOL8qAsfVycDFkVpsdd9a7GhyWRnpJSH52Lpzw9OrPUAfJIkopQudcPYyUQpI66RZTOKAjlYQ6pulk5barKnd3O0JwzF3tmnbWkwuMUq21+1j334SyCJDFQpg+dqKUAdxoHdI5HqTI3WFHwtNg6UJgr20xXgliODQNQw2lpgueFodM1JttSSjlkRlIQiuNKNaAMEGQaiyEnS7NfYmIgWADRQ25FOJ0wxwnt593eth6r+Bp7sHGGoyrWp2UMofekYpSJBJzIU5uS1cbGBLItFbkKTxVnOULZytmXcNe19bm19yxjpldidzp4XQ7cr/v6Z1wddax0UgwhmCh84ajeZ2qf9vhVcQYPn9xwWfPTulTDV17oe14/+EePgQuUuGo6dAg5CJcaRuudG1dr1S4P2wx1uB9ZXuMKOeasUVwTaj7bEyshgE/eTTezVscNcS1HxMX/ZY3thHnFFsSWQvyDptuX/eB33vPzZs3v+bvLy4u+Ht/7+/xj//xP+b7v//7AfgH/+Af8B3f8R389E//NB//+Me/ru+TxRJ9wajiYz1Y788dm02i14FIHXVQ6uIwDw3OFIY0cNErzhdWOWKdrXp/EfyYmJeGTCE62OTaYZ054WFYqJv0Ahk4dfWd3OTafR+lWigeeMPzzQHiXbUQsxYTPCOGLlt2EUKAoezYjIVSHM4JsRQGqutARkkUcm4YSySTMc4g1rJSINbCHam327kqp8OWMoV89FTOWXrGLMGeVv0BXGjBa4MrylwKx8uOW9cOeO30jIuxRmeL1C1u6Vr2WmjswOlQuH0u7DvL20U40FK7CCWyPn/AFd9UWljOnOSRlWYWwXM3DiTgqrV4o/QS+epuJAkcNTPECvf6Hasx8b5uxnccH1OotWWdZdEssLbgVlvO/YgxcL/v+eLZgIzCYRc4HUYilQdZxJBJnI4DLQWTDcFWitt5H2mD4yJlRJU962i94VfiWX1xpLBJiWfRgv9p1eAWaJ3HGmVPCktJvPL8De71ifM41nAsgb4UGgt7DkyJPBgybw7V+WRVhKWp/ofrPHC2XnHNt6iF0zhyFhNjEXw23O0jGWitxTo4KZk76y2lKH+weY7gLRclsU6RhTV813P1NWgAZwxHsxadtdzfwjpm9n3Lehj40sU5ihLJnMWB3cS7txjOysi99Y79xlByfW2tt4wOToaRMRpMEbqg5Kbwn89PaWeO3ZB4u9+RUHx5tpoeT20NDBbrPUHrlGneBq41HfeHnlWc0sARNqkHYGkbPIaLMfJW3+OdpS8FM01hViVxf7vjsAlYCpuS2IowAh7PJgEIjfc4W200v7xbE4E9d4A3Qsw1NHPZBn7X3pxSHNY6nKtJquMMxqHuinsOdmXkNCdcMmAzfS4kqfQxa2Addwyth9iQyHjnwYRqgx11ciqqtMUMvJkL5zETx55iBWOqluBZwtPcg2kdobF4YC/Dtbblwy9e4/P3TnlrvWWVIsUqO9FqX2la4iB8bnfOL5yf461hFaFtKyXs7q7ntZMLrnUNBbi923KeElvJWDGcMJKScrCnzLynR/nX5/cZc+HKoqNxjr4kisL1ds6fevFFgMkq3XKzNYwHhdurNdE5jtqWs77nl++dYkdFnLIriaQQrCMYOBsj93YDXR4RFToX2DeWeWu52AzYPBWrGiLKfzo5I5XMxS6zI5OkXnbf0bP7el//L3zhC9y6dYuu6/jEJz7BT/zET/DSSy/xcz/3c6SU+IEf+IFHH/uhD32Il156ic985jO/5cMex5Hx1znNrFYrAHJOWBdwBkwjOFuYM0NCZcD7nKtPqnO0vrDRbX3jqZJcPYRnCiUqOnHkvQV1hXWJeDytrS+AADlXR/uo+RG/2lGj3Tb9AHjWpdozXnENvS+4YhhkrOIO4zC2sCGzzYLLMsmNwZGYmQ7rIjtJqBo8jrkK676woa+pbc5irD5yJCqx1AQ4a4i5Pqo9Gk6JlMr2pzxjNvyPu/7gt67B9RhpRFhYx7L11V+Xhlthj053bG2iiGBwOGu5N2wJWjUn4qC3EHPiwZSM663BB4dbNLz94Jx545kHh5fKyRZRLJakCRd89XoGGguvbc9IwGkeySqE0HIyDITg2W5HnLE0oYqGTvLIl7cruq1HJ9qQs57roWEvBO7kSgmbecuB9XxlWGGGmggdjMNbywuhowfezmCNspHMJhWM8+xZx72UalqmtTxrQZNPaw2MOSMInTV0jWHe1Hq4Aljr6ILDWEMqggcejP0jOsyA4MjVBSrHqnGylv22Y9m1vH62YdZ4GiMkCqlKg2mt4SJFOnHMrMPVngpf3lxgneUkRwYpHM9a1v1I4yz3xwFUCM6SreHBuOONTc+cFVmEHmUeGq4Fw55z7EohquDVcmQ9X9ycT6mn1e6x9Z73uQX3yYTgUTLrnDhfJZoQWKjjTFKd/gJDebZcep5W/Y0iaKmUxMZXQfXce46bFoshllJtNJ1gneMkjpWiMNGQY4E+Sg3BMmCxzFxL01jubkdmLhAwSJEaT+Qq9XYTC72tSbeqYMXyVhzxDs5KZifCtRBqci6OPmdyyqip2pRzTZz1wnz0pCLscqYJ1ZWqc5ZBqpuQVUtnLfdixlAms4yMNwNXCKxtoV5FlJSUB3lH24GlYURQAatKjs/Wif9p7sFJE3E0LJxnv23Ya1qO2iWv7tfQ1VUawCn9oIRg+fzFBajSeIcPddSzlsi4qgelYC3HbcfV/Yafv3fKsW8J2aBTXhI1xoQ7m5ELnwneMhqlJPjVswuMt9zue1Ylci20rCXS2oaT9YoktYbxhjf6Ha9vdxz7hiFnzlJiL3huNS37TcNZSmRVnFba2i+cn2BMnag11jFznpvNkntDxAWLoJUJcJFovSMIbH39nbwYyjs0ivq6Dvwf+9jH+If/8B/ywQ9+kNu3b/PjP/7j/IE/8Af4pV/6Je7cuUPTNBweHv6Gz7lx4wZ37tz5Lb/mT/zET/DjP/7jX/P3ESUYpbGeuWsITYPBMA8BB4wGRkk4V+k/g1SuXWW716APi2XUXA/davBiEQIHYUk0BZEMCtFUL/4wfc5D7ZgUqTd9o2Sph/1C3UzH2NM1rrKtpIqKjanurYKp/CsmfpY1eDItFrW+PmhjmJuWzbRYeACpAqEZrhKWFMzkzW+tYKxFrCBT+IhO/OtnBU+i/uC3rsFqHQgzHzieLdjbazGSWbYOXIePjm2MLLwnq9CPDpypIrcijFFYestZrh2BgKHJykXJvO9wf7K7TJANUYSGanOpdoqpL4IxQmsDmoVdKYylOqScELk/jux3LZrLo2TmvlTKkQX6nJGHMfTe0ItwaANXg7CVjMfy8vyQL6wfgMKOjDGGxjpe6ZY8SLFmSUh9j6mvC9HcTfHPWbC5bpzPCp7mGjjkwr537LmGa23D/mKOEZh5D8bQSGGjGeMUpBClVMsCa9BSY+aNqc9aVAnFogla53jf/j7JZM5NqY4kUgXkeaIcGqHqBUQJ1rBLiZxhmyNRhVPjOB/PWLiGMY4YqT7mahxRCiOFmHLVGhhD44VdgkUXOEBZxYxTy6t7B3z2/H7NLbGgGWbi+c7umFgiXh0jBTWWxjhaDcy9wWWDKYpXM9k3PBt4mvVXpHLp586x33gWXYsBFiHgMAypGkg4LNkZdlKdvBwwSiHnTLFCmkT9DqWowcfAC+2CYpVVSiRVrBqC9xRTyHma/2h1pAsWNiljc034LSL0ON4k0lghpoyo8JChnxB6yZRUA95Gkdr9lzr16pxHSsYZuNUtuR/rQbNQ+duNMTzfObIojbOMue7FLY4Shfr2s0iRZ84h6mnvwUMSliFwtW15/9E+NxZ7oMLBrMWwx3oIrNNIG5TkC2KUzloaW4W8JVcN5JZKIQtiMSPsp4bvuXKdqAnZ7BgQMAb3iG5dTS3k4TnQwN1tj3GGsxTZpcLaZX7mwQlzHzjfDWRVvKuc+l4Kq5iIuTDmwpCFxjnOY+LQtxyFBkrEGcN/deWQXzypk3Mxdd2dOc937l8l20SbLbtcjRn22gYvhtDBKidSKjWPxT2BDv8f/aN/9NH//87v/E4+9rGP8fLLL/NP/+k/ZTabfT1f6hF+7Md+jE9+8pOP/nu1WvHiwzEJVNGQsXhTOXXeWcZUHSqKEwTFqAHjqLmA1aqyqIJYLA6D4o2ZHC2EuQlkIxRjKr8Uqs+qMZODTn3YqQhGC2Zy7qkSJVPdAEQpueAmRxMRcLa2Ot0kyigqFFEUT2OV2aT4VqMUBMlKVRQY7MRu9WqZmYbONIyMNcDJGIw1ODuNgewU0qWg79CO6b2AJ1F/8FvXoDfKzCozC623NNaD1JFmSZEhJwbJaKmR694F1MhUJYY+Jxpnaa1DMTQYgkCfRq60SzZSEAzJGLKFhRoK9WKnFqIKfRYal2moqbyp1ETJrS+MOZNiTSFEBLI+coBaGkdvCv1DjmkRWgyzroqVEkrSuijGSc9iDZVhrXUcduA8J0P975o+bQlU55eZ84y22vX5d+gQ8F7A01wDjZnMMa1W0ZcPWK10Gy01YXybI0UFo5lgXbUPVMWpJVJonEOkGgU4UWJKrKLlffszLlKu7iPOVmvjoo86TNYastYur/eGkmMNLsoFUWVLZiTRm4JqQaTU98a0HjWNZaTUiyvKKIVoHNdCrb/YVuvlTU7EqbtW3Z6qELksDddCy/3tUBOvraN1Hq9wtek4K5FIwYtBnyENydPegwt1vam6okrS9xaUTNRSRYkqFKpBRbWvrJ3KQg1bQ+u/WapAuy/CYdPSS8FZiw+KFsvkQlvF4FhUlCxgnSKlduBT7XURpdAnaI2iKlVMzK+5kATjKu9bhaJKKhZxjpmv++eeNIipa2OeRPBp0v+JtRRbk12r65TgTQ1aVDEsrKd3mTI147LjmcHT3oOLVv4+BhbBsWgcqpngIYtwMSZOh8guF0ouzIzHTWdASzWU6JwnSyHYOnpap8j9fuD6/iFjzDhr6Zrq/kT/aym6DlvrogjOGR7Emsu7zYUskDx8tWy5Ehq2uTCIoEkJph6rvbH0uTr61YmXkI3jYNkwD4FhWafvu5IZRIlSG8qCUrzBeMPLex1n93bkJLSNZ2br1P7mYs5uSIymYLVOKN4JfketkcPDQ77927+dL37xi/zhP/yHiTFyfn7+G254d+/e/U35Xg/Rti1t237N3xsVnNQOlbiMkYC46pc/5Mw2J0qQqQvvsK6t/r1aQOvCgBgC1Vc8YGg1s7O5hmi52s3K1tbOutWazmtMDRRSZShKznmKTa7KfiaHHYAxK62tPL9qGzzRjaohUE3mnbLDxdVUzKWrAo6dRh4MW5BCxoJVGpRgQFyhMx3nJuKM1I7ddKFpaWhNJtlS+YPPznn/a/A46g/+J2pweiZO6xtTM4gzGGNZDYmTvifaQo6wtJ6m7VCZbCrVMpaMNY7O1Aj2FrAmscqJjUZ2FMaJG4ozeC14oHEBb+umdhILKiMO98h/ymt1OVGn7HJBnaWUeuja91VwHggYUxiBsVQB+4FxtI3nqAlYW/n5P39xpwrGJ/dXT72wRgeH3uOZxupTkSvCbHJueeh61T475/2vwZNcA62DTGZQR5667c5NG5kkzuLAaowUKTTOsuxmpFIoogRf3Sw6AkGUzta181y27HIklUwfq+N04z1FCyUm1BgWjcdNU9MxJ7ZFMdP0k6J4gWLqLHPUjA2TeL0IjS14Y2hpSFqFm8VUweSe87TOcaNtcdZxPyb+9e030AwRoRitaSQO1qZwo21JWju6wVisMYhkDnzL0gaGyapO/bNz4P8f44nuwUYZVei1PhuVms1gga0UTnM9aGUVrBj22pYyuUd55zAZAhavMHMeaywbyYwoA4UhV4e6mTcMxlZqjLXMGodRiLnaL/YqWCNYmSyrqRSHLOC0YK2hmOp6Fqjvj5kLbEqstC+tzRM1gc4ZutCixrIrha9sLlDqVLQSJKpLT6+G42D4chGKQHCTj6IoC+tYW4u6ShWOz7A19pPegzGwKYl1mgIqc8TZ6vJ0stvx5YsVD8ZIMnXduRkWdbqDsAiBcxJL16JqOPANBeG1FLk/7DgLHQ/6oSYue8+owiAF4wyHbYNRwzbWxN0kQjQ1AERLdfFx2bBzVZyLm7z5U8FQsMBR6BhS1X16ZxhLQV1gr2241s1x1nCn3/I/vPZVFEOcLqcPm269Ed63aPnpO/VSXZ0dhSiFK+2Me3nLTD3O2Mmm9rfH7+i4uNls+NKXvsRzzz3H937v9xJC4NOf/vSjf//c5z7H66+/zic+8Ymv+2uPeaTXzKhKKZaoSp9rV6kaMU1QcKMlx1R5fEmx0VJy9eBSzVSGoAKBUoQey1hAxdAYx8L9Wo+yDZY9H9jzgbYxeBoKiTS57wdTrZHqIqGTL3E183qo3ndRMFKYjJcoxOpaQEAx7HLidOwppooIAlTRhUBG2GnhNK4YVcgIWYRSBMERJZNL9YNvUBqeofbC/whPsv4Azotyv2ROSmEbIefCeuxJU6Jkvag5vHXYYojjwBgjKU+ixKKQ6zMcRYgCimNXLGfAmdRwoavtjGPbYTAEHIe+5cVuj1fm+1XhbyBK3SQx0FhPwJK0TqFEK6nBCVwMihU/uT1ptdKcrvVlmoCBctpv+dLZg7pQemUeAt7UcKeNFu7Fnv/fgxNOcuSUzAXCgJAEzkskloSVwsxaFk33O3uQ38J4omtgUfoCsRiY3L7WOVH0oVVqnfzt+cDcN4y50ics0KnFi9aUcDKppMnHvEW9JxdHn5TGea50Mw5cg3PVn/rQeF6ZLXh1b4/DEFCpFoV1CqQES11bqRePbUmVwqFKL1X0O+yqi0ZSrV3WIpzGnpTrdPat1QW/cPs2rihonWC13uAbS/Hwdt/zn04e0JPJXolO6DWxS8KDNLBKI31MiBja0PxPv5DvYTzJ+kvFksXVxlmp4tVeC6LgiyOUUJPF/ZzGBgatxhRWldmUH6JS3VKKVI/x4B66qFiiKB7D0npmzuNcdeJrreFq0/BcN2c/hEe7fQHUThbb1H0zSWFISkxKnmwYLdCXTCo1FKtQ1751iuRSM1D6Urgz7urvSca6as3pJ+vhi5z48qYnS6XlyuToU0S5yCPrlOlLQQRac7kHP6k9uIiSpGY+KA5R5WxMZLE0JjAznsZaXmzmHLiWnRf6ycRizzcUq5RS63akYI3h0LcYDMUV+pSYGcN133JQYy/JRbkZGr5z/4DvPjri2HeUXMP+slGMAx9AtOCN40FOnKfEkIRSlEitsdUuMo6FmJVxmnTeiQOxAEX46sk5P/3Gbby1FITgDM7XbBIcfGW75t/du8toMzQGccqo1Q78zWHN3WFgnXK1/7a/yWXpN8HX1eH/q3/1r/LH//gf5+WXX+btt9/mU5/6FM45fuiHfoiDgwP+wl/4C3zyk5/k+PiY/f19fvRHf5RPfOIT35A62xZHzoZBBJdGNGeguu6sc2EnghlgVuqLlV31zlVVquGWMpaEI2PUoc6As8xLvdn3jDTW4I0nyxQjXxxtaTDGEIzynLfcy5FdaasYg7pYpVKdyilCnhxVLIqfhoreVatQp44GT5quEz071mMVG9ergaVxAXLCWotgiNmwU9iNQuts5R+auhB5lC093oGKQ4xB22dHMfk06w/AFkGyJ1llKyNfPB/wJTELDff6HQ9ixAL7TWBXCoM1JAqaBdOPiCgbql1r1sSojtY1POcsF5LYxBHxwswXRhGuuhm9UxbeAEJjLd9zeMwXzi1nMRFCvWiWolzEVOvKKSYnglb6W9NCbwszV32zW6n2hr5YelHujwOvbzakkgFhr/FctYE7Q61BVUhiONlF3upHDqxHqIsYCM4Fdjly3AaiVZx6POGxPeN3O57uGlg3l4hwIpH1WZ0KNQHuD5GLWPVJuEDjKkVmSwYtHOSqeFzHhC8QnTJvHNebGZB4ICNnJdGOSmOE3ZDwwXEYWlofqhBYDN+zPOSXNytGtHKwRYlF2OWEtVS+61gNBFrjWHpHwhCDJbuaPdJlW62RLZz3O95eXbCNmSjK3Aeuzefc2Q601mOtJaFsx8ydtGVuGwqZJEIjFueEdYlc62asykjAcqX5xqkE32p4qvVXZ9pklJUW+vXImpEmeE5zZqsFQ3WAshakWOI0DbUKjsKGKnw1ogTnuTrrGMvAQGaQQkrgSiGJw1nDHo7GBAoG5+CV0OHGQgQCdS3KWogCzlliEYpEdDLamNlJ+UhAbK7ZNiKTINewKXCx3TFSGzGtV65az1nMqK3cfDCUUjiLGQ8kU0My/aRF2JXCMjhKLlijzOyzoyF56nuwKDjoS+Kt7Zq7K7i93XG0bHhz2/NgGHEGZBSWbWBtClvJ9JLwRuiK4STXix1quNp0fHC+z/3Scz4kVlIYBmE9Jtap0M4882zwBPpSQ61+/83r/Kd79xmCELSG0SVV+iQY74ijEGNt8jlrmBtLMJazpk5QPeCpF8/GG+4Na75wccp6iCRRDr3n1mLGl/qBlPRRDsUO5c56x8L66nI20X+sM1zExLUwZxwzXuBa8wQO/G+++SY/9EM/xMnJCdeuXeP3//7fz0//9E9z7do1AP723/7bWGv5wR/8QcZx5I/8kT/Cf//f//dfz7d4BOdrulimsCOj2eGdYSiZcXrjKRAdQMSZ9lHYS0qZ4gp7BRwBLTXlxbk6enFOCMXjqBJfr4IbA7RC11Vrwhrz23CtgwdDrJzULAy50DohEmicxZBRDGXqtOcCxtXNMqii1PEmJGJxFK3jl6LKXgN+lOpnLNXiq3W2ioNcz8x3GFpqjyRBtjTMMECylX9r5dlZbJ5m/QEsmkBrLTlnznYrQnDMrOFkLPSlUr0m1jFDEZq2IeAYTWYjCW8NxziWzqPFUoxSW2UQrKHF0amlKzWtMnoBAlf3FixDA1T/61eWe+xW59xo55znyP3U0wEz1+EY6yWAehl1qmxjws4aQgkspeApiDMkzQyl0IuwyRlEef9iyYWMKIU8dXwXIWCsYddbDpsGa2QK2VIg1xo0IK46eCyfIUrP06zB4ALBBMYIr8cLZh6Ca8lJ2KWMlLrJRAJQuahtMUQxnBMJGGYYuuAJrnKXM4VdqjqRRXB4LWipHXhEaILl1v685j9oNT94P/Cl7QVXuxknceAk9SjCFTpyiUQUMYbRKpmEw7JoGva1OqhscsbaenAcpOYKVEtH5dVuSZ8yWCVpYd+66n5hlZNkudJ4JFPXfa1fO7hqrNAET2sd3bOzBD7d+qPmxqQCb21GZtZiXGE7wDj5ftcVoabQz6bAtVgKWxGyM7TS4KzSWMGZzFhqqrjH4yZ9nqE2SpCaZH/cemb+4dRduW6V+0PPnq/NujGW6mg2NeHU2kcT+pUotsBeJ+wZQyyGqAaPJ06H/IQSS0FFOGg9RYQsFqOW1lta7yjWQszMgyNr7e6PFFocbvLoN8bQYpnJs8Orfdp7MFJDLbd94Rd3Zyy9p6CcrFKlywgkU9cVm5RrPtACF5q5kyO+ccyirWuhGLQI902kjzLZfVZaqqL0ZMoIcyzvv3bItcUM0UKKke8qx/zy6pTrbceDOPJm31OKctAEtrm68FHZ4WxVGSkczhoaMezGwjYlWnX0pbCN5dE0ShT+q709ztJILvW/585yGALOBu4k4Wjh2VEYirBNiUUItK7Sx0Pn2XOe5TscchpVfVcR0FarFQcHB/zvfvSP4b2tdnLO4TA0Cj1SaQxU601nLSIF5zwYW1XVUkfezSg46zHT0d4ZQayjd0KjVdSTqVx4r3V0tx/mdL526NcxMuZ6weiaKuAYs9TuqPXMpgN/UShaOdYheKzmmtimVF60syxtizHCaUxEEZytwQ6SqlCjpp5WAfISz8ZEGlvzda01tN6y7+eYYhhzxjlDCJ4Shb/+3/4jLi4u2N/f/6Y+u/cKHtbgn/xvPkgUxSjstw1WqhPE+XSpVFGsMxy2nm1UmlnAUOlkOUXUKrPo2A8eNTXV0RglO0+vmRk1FKugWKtEyYDh2w4POew6xiJ85eKcXcmsSua5ZsZOCvdTT18iSzvnoHPsYiSWMtWPZRY8rbOYSU+g1Lq8OZuhRXlt2NJnYYZj3zs2aaziYwGj1R52v3Wc9hFrLdkowRkOmsDN2ZKA52IY8N6y39RF7f/wjz5zWYOPCQ/r74/9id9dpzhqWAaPsxlRxzoKYxzJJSPWsT+b4QHjarNCVNmmiFNlbv0jy0FRyKXggwUsh75hlMw2RXLJjLHQeccHjg7Y71rGXPjq+TlbFc5z4vl5x64k7ow7Vilx3c1Zdob7w8hQBDAEY5iHhrmtgU0qtfPaNIbnugU5J97cbRlKprOOhXWcxVQnSFodrryzND5wr9/R+HqAbIzhStPyymwPZy13x56ZqXqUmTX8H/+f/+my/h4THtbfn/jBT4DzgKG1FmcqbbUvtWH1kLS68A/pOgZvTRVp50JRYW49peh0IK/8+CYAAp1zRK06NzVVONvgeXHWsgiOiHJnHNhophQ4aBxJhFVKbHNh3ze0TlnlOi2atnBa09A6wAhGwRqLsYYDF7AiPMiRpNWNpzOGVcnT2ls/1hmHDY51HwnT1DYYw4ENHDcd1inrLLQWls7js+H/8v/49GX9PUY8rMHf9/tv0pfaKT9s2uoOFRNnKTHmGkKqDo5nM7wxzPxDwwFlWyqb4hotfU6P7GITwtV5Ry/CEk8yymgEMcrFLrLnHB+/dZOriznrFPnFe/c4y4lVH3nf3pKdZt7qe07HxIuLJV0w3N72DKW63HnrmPvA0viqCTCGzlo6b3h5tkcqhS/tVvSlsDSew+C5M+zYorXRrPX9Mmsb3trsOGgaBi201vJcO+MDewcEDG/0Ww6ajmuzjs5Y/rt/+nO/bQ2+a3sjDzcoVcVZwVjHMHHcRQuqhkQV2BpTKRDVS6TGPVtq0qTWs/5ktWnIBgIO5zxFUrW+NLX7pEUZbaojIpRdTjXlUgs214RIZwx54pJZYxBjquh38kcxhmqXqdWrRRVQZWEbxEQaV0eOboqlTqYuVDCJf0UoRh5+NQz1+wTn6Fx1FigPR5RqeYZMep46XL3OAWaiVVlWKRMnLr1ayLaKx2aNf8Q1tZMANliLOEu2VfAlUAXlCnPrWLr6Rh614IxlUzJJCmf9UNNwRbi360m2WsGex1gdM6Z6GEriim2w1uDVTIuFwTuDPkwBnlJXxSo32gXbOHLgGzxVCGmsImPdvK21lTOZM2HywMZU957GWfZCy3Ezry4ZKSPTv/lnWTn+BBGMJUoVa2ErZ3+MNXxItLqnCJUTP7O2Tnjc5LKUAGPw3iG5VB1Q9Zij5GqtuAwesjKIwyJEIwylcDYOGANjFt7a7eq0B+F8jAiCp4rQe8lcazp8tjW9VOo4WqhR9UkLzrgpE0W5NZ9z3u84aBva4vCT9WKWiLE11XxUYZMye2pwYslFKmfcOfZDw41uzqjKRYkEA523tM+QS9TThJt0G6pUBzsDoqbuh9NuW8uspncLinF1j5QiWLU4X53wmPZB1brhelfzFlRqeJc3lmFyatqVjLMQVTkbI9k81IsYVOvF0htHksJ+CDhXNXQPF2C1SqyJWTTW4pwhGdh3gURmYeshz1mL1breTeZQFBFGVYKp1sYqv/bzzr3nsGmAQtKEx1T3nsvye2LobO2KFxRx4LRSrGKpnomTjwDOWBbB1uasNXhjkFQbqG3n6DU/WiuTFIpROl8vcb0KFsE4GF0mq3LS9wRrWKXEa+drsq1r04M8oqYGsXbGMebCjeWckxQZx3rBrNruOsUctDALniY4BOH9e0vu7nYcpUBnLa3xFDXskkBTpw1jVnalkFLCTXuASrVTPmpbXpgtKFI4S5HWG7rgqlPfO8C79sCfSl1kULApYxpDjVcpj/43iWJKjT92tlKAEMhiMKIU66Y0vIJVi+JITtknEI1irOKkLkKpVG60mnEKy6oRzoIySIJYreGqT7lhV+oYp1AP+eHhgih1QUJrxzWrYSgWF0CxzL3DaRWjWGsopYpE/MSRzQZGW31gCQ5nJpsyU7+3c3XxGXOGolPX+RJPAptU6ClYhD4rrmlZ1VlM3dRM5TCvk3B9ERBbnURGalBLi0e8ZWOql1y9jHpEhOtNS8ZUVZsWxiL0Usd9t9mRtXYGdlK7sxdSkzXC5AC1bxvezjtibilFMFr90u3UkWoVwJBE2WVFc8aqpQ2em8w4HRPbkmmDo3GQqQL2orU7NyYhamHPehpvmflAYz3GOJzJLILjbtzVuHP77Ip2nyS2qdBPnOVCYuY9m6TEnLCm0miyEVIpOFuTHr2zZKmGBX46sA1ZiLk6Ryy8YZOFa50nSRWAxZxJOTFKZpcEN1neqcJGhFYtO1s4jQlDvYDMTOA89YyxinoNdXqFwC4nYn6YHSJspNLFDIVl8Dxva/2tYmEWHB0DiWp7iFYhZtJCUWjU0jnDwnucq24s3hj2Ws/JsMPEwhX3zvirl/j6MBZFjJAVelXmrt4jI0Jj/NSUU3JRWq/gPN7byanHEEzVpVWffWqjwlat3dwGEoaiBaQ278QoQy6c2Eq7QQ0pK8ZaehKapF4aBFr1rMrIvveI1IujpTpCDZNhxsPDTTIwTOLb4BzH1jJooVfBOEMzQlI72QtLtYgtglLtQb2xtNPFFaDB0fnMNgnkQvvsROE8dVz0ka0pDAibXWbfBXYqbE2mmcxTsigxFWatx3uDD4ahFKIIM+MpVuindG9n6hTxPCZeWszJpa6fsRTSZO+y7jNfWa9JVOrNJha8sax95u2xx2JRgZk6ToaR67mbmtOgpQp7RxkrRc3U5ltSoZ9SUvdaz8u64HQYWadC4zytWgapVF/BYqgNGqOK02qEMHcebz1iHd4oh23LRR45iz0H73APftce+FdpJOBobLXDHMcEfurUW3AquKKUUg8rx3sLQjBEKawHxY2BnIVNqYas3gm4Sg+yZJpSqUFDmQ7pE7NpGyFqIphMKoWeiKOpnXlVioC1k89+qSNAADUyORBYHFLV4TrRj4pnVzJt2xBSLa6x1A1wPrkGKRasYClkfdgQyeAaLIEg/lGypLWWwdRDgOVdxch6T+FBP0KohyQnQj/0WGPpsOAMIkpTYGeU1ZD42Le9QOscq83AndMNvgirFHl9rGnMCxvYC7DvPcVZtCTO48BpHCv1wQoBw+0c2fSF1hi2WhiT0lrLQeNJIjWuXoVZdoxjtWEUVdRVis0uVUG6MWY6dGWKsazjjoN5y5r6uzzYDVxEzxVrCFK7cAWHc4ZVrtfrPtVQOovD4+rCNon5NilREqi/bHE9CdzfDWhXO4g2KjEWcDUJGSrn3ovFe8+2ZL7v+Zt4a1gPkaX1uFEoUrg7RmJSDnxgb9ZgbNUz7cbIya7nNNXOvbWCo9JlLnLC40hW2aTEvDNcaQIjhYsS0ZgIGTZDmXz/wVvHogus+0TNYnOMUhiIOGsYY+KwadlRuMgjb262dKZh4UztnFjFG8fMWtQKo0u01jNvAvuNZ+kcbloD5+p4fVQ2RORZ9oV9grgYCqbxtV5EWMlEo8UjU0fRUQO6hlL44PGM1ho2MWFz1SN54EIGAGbOsvCGUhwdlm0Z66U2K2bSoCjC2ajsJjcdxbKVgrXQ2dosiVPTLxDYxQLGYvH1YzyMEZRIQzXYGEuZsnEKe75hkzNDzJymCHga93CSJChmMh6VKUegpQuWzlczDlHIvtAUy33J7BT25bL+nhTe2vVoW5upNsF9k5n5BuccVkyl1WpmzJk7m8J/812v0jrH/YstX00XSBGWWL6Sqz3mXvAsG4dRw0FouSc9b8eeszFV+nhbAze/st1wniOtcaiBtVbzgysaSJNtcETwI6y2NeCrhsdZ9hvPxZAYkUcBdRcx4p1lF3uuzBZscuYkZr682hIay573uDGDrw2NmXHUAFlog+eoaTlqG5bOU7xiSm2CfHmz4TRGbs7yO3o937UHfskFsYYshjjNzJoMM+NICFst9FI4cA2FhivHS5ah5WLXcz48oLhCdhYbq22RGIdtHLEou7ypHXxq+JZ3HnKkE4DAOGZ6hDxRFVrAOs/CNTgsZ3GHc5bWCzNaHFVL0IbAaVmzLgUjllxMTSv0mRU9ZbepGQAKgpBIZBpalwhSPRFGY9lFwTtLEZhnR7aZN/IW6R2ZEUdDZ+uimfvL9sKTggKNGnKBt02dpFxtYCGWETgV4SxnXuhaYlFevHGFvUXHa3dP+C937zJDGW11V0qAGmUeDCcps9us6IJh1BpO07SB0g+0Fq7g2Q7CqhRsgBmwwNF5wwvtAqOWz23OIFTJ5ovLAzoX8NawDI6vrlacyogptbObcmEWKufv85szNkkm316twU14rjaVGmGsY0tglRNLDAHLQTsjI/zSxX3G03usyMxLHXEvXOB0N3zTntF7GVIKNhvUQT/9nUWYo9XRy0C0mX1biTbve/EqR7OGL98753O/+jq9RFyxJGOxTXXquZMyLfClTY+1hrVNZFvoimO7q05MMwmMpbDSSNM45h3MCYiFW+2MF5nzKxcX0BouJPLBw2P2mwaPZamOz3LG62VHlwy21DBDFyy/dHHBuh/Zlap7EuDU9WTbsmiERhzeeIq1fGW3wdhKTTqYNSQp/MzqAX26Ry7KbIqf33OBu9vxm/eQ3sMotjp/VWHuBKnp84Up3BKYOUN0npdvHnLQet682PHV7WnV0mGnwEroRclRccCm7LDOVNvtyZFsk+oU02Ppo1b6YrB4Z9ijxRs4bDuCtbwReygQgVuLjplzeAwzHF/1O+7HghYLUmAKz/xqGUnnI5FUPc2BTKIp0NjJGQ2DV89ZilNHPzELcxLKl8cNoyo2ltr5p3Kzn7283aeHYsA+dMZQQA19ziCFcbJMKVYxFgZVPvwd38ZzBwt+4bW3+Hdv3KvmGWPVAWEta8kMIxyGwH+89wBtmDrvypLA2/d3OGPoRsu9zUCx0LaWLliOXMcsWN6/nOG94+fOzsgF7g1bvvfGFY67hmAce7bhP967w5d226rRm7R0DvjM/TNO+tuMaJ3OOmGdld56TKMYKcxsYOka7sSB1tdpwnHbEW3h357fIT54C4C5refAo6bhbJve0ev5rj3wZ2r3IGlV1DfO0QADhYJFNWCxGAeUSL+NJFdYj5FcLM4kHOAkUEwdkrjocDYxZoe6OkL2zoA6YnbsJqFZosYxz5yjL1X+7C2IzYwi9CZhCRQsO5Or0McaBhmRUqif8bAHYlAadrHg1LIrA0krL9zhqW5KdvrIGnbiXKahmS4lSpYy+aoXHA/l2PXnjFxSep4UpAjZuSmpsTB3NWl3VQoYh7OOzgsOZUC5ff+CB2cb3ry4oC8KVphLYA8PztA2HnHV7hMsqXiMz7ROCWrYFsMWQ0boyVivXOtmrGPttjcukFTZxZEhCW2oI+ezYUvwgeA990ell0JrDQEwxZKNp5SaFNhgOCuZnWQshjmWw4Unq+IMNehNlEaEua3MwE0cGI2wQ4lkDmlI0xFgkPzIseMSjxdmSictImRbMAqLGNhZWPrAwkKWgUTCifDgwYq199y+2NCLkEoNPuqAeRsI3rCLYxVd4mhaR4tDioBYmOhi2RaiqTW6CJ4+FayDoI4hwyiJHUIQSwvcudiybkdmwXI7CZuYaS0EOw2nxWEKnIyRpfecSaJ/tAZaDtsGS6Xw5GrcjgP2JGCBsz4SrVQv96IctYFxcsbYlsQmXzY9ngS8qdPsOm2uh1qxNZV57qtTza4UiqtrzclFz8YF7u0Sfam0mMXkqLTwnmAtQ6pBaliwlRwxUWjrGmLtZD2sVK2bs1DqAGhmq36gLzXVdGE8Dsu6F4YAjYONJGKpgZtqS919BaAQR4t1liLVeUjVYJywaAKGhCSHw9WJgdiabYKjj5lRhZiqViBMVsVWzKOk1Es8GVhbxRWCTqYSOjVTq52lNYYLTRQrBCxvvn2Hi/uBr9w+oU+ZnRRuGMeocOgdnXOsYgaBgKETh0rNyfHO4oKhbf2k36gJv+3Ms4uJMQs0YTJNSOxyZtZ4muT4ysmGkzawaDwiyt0c0WlbDBicrWvgA8m0rmEr4+SvVy04j5qGZDIyidkb57HZ0DnPnmm4SImNJmKun7P0oeoaVDgbBk7LO1sD37UHfqhDNaWGLlAMGUOe0mwVxdlKLhAsD7ZbjLEMWejTdOCx+ojrKgayyYgIHR7jDTqJhIoKmLqwZQtGq9uABTorWDyipkbAF0FL5SJWhmLlYYtUoe+AYIp5FExjUCiGaCEYIaJkzERXsjQCEuwUiWSweOZOQaofdZKHwWEAOhnwmUd8cXupGHpiMEAyUrsIAr0RdslQVCpfnsrtHERJUvjV2/ex1nA2jKxjwXlLa6r1VxIlZaGzismFfR9og2dA2UmiL4lsqsg7GfDW0k3TgWUIJIEkmVSUdc4kV9N9Z7a6TRUVtBSKZgYKoShZH2o3a1LSWDLOhipQBxoDc+OYuUoLSVkQtTTOcLPrkGLZxEgeEtkpaqq7lEfRYgne0zmP1csD15OAN0qZ/tS1xE4KkrrWOIGZ2klvJHzu3gnOWs76xG7MzH09iC2bBmcNOrk/KJZj3+KDoUhhsFVD4mztxqup1A1Ldf2xxmBx9KnQ53pZTFLYM44Wg5RCTJXPfZFGdkbwQJyojx4zhTYJrVgitS4bDB0OFPbDjK0mZEpSPXSODs9ZGcmpdvHKFDZWAFNqdkprHfoMBx89URhBTal0Ux6aZDKZZNT90U8uckWVr55vsMaxSUKUukZCYWaqLaKRh1+gHmqq/bWiIsQi09etF12nWrVx1LXQY2vzL1VRrYjgvK1NQWoHNQMpF/pJvyRmusQag0rVNs2oFoxiaoOj+r7APDRU9V7leC/VYwtELeQsNeOn/nSPLj/G1H3cPsNJu08azphHr72h+lLYUvVwqvXflybQWUdKys+99ibeGO5uBnopdMZhFRbG0ZhqvGLFMGThyDfMgqdMnPuLGAm+6kFcY2lKFW07gS5Y7Kisx8gmJwYtxCTsNZYuOIaxoGR6ES7SyEoSD4vd/TpRe5rCKsvE0Q9aa7sxjivzliFnnKlc/YMUOHBN/X65NmHqec+QUj0xNj4wDx6176zp9q498HtTXSqKapWJaRUC1SFhFYgZo7WDZOBiGFEMWauIwxpb44C8olqN6SrvVWmwYCAK5ElR/ej7WoPqdKVQxU+WK2niSddk3RrIELQKMuqXqx+nk4jJmlqU3tQeRu011ChuNzkcKIbWeUzwZFMDbRTweMQYiiaKmCr7NrVT4h+y9rV6tpbLDv8TQ2gcBINTJZXq75x9TTxFwBip/OpJSHh7tUaoYnJHrSMN9ZmlUn3sa4dLWXhonGEshlLq56itddhZh8Fgqd/XO0e2ypAzoxY2pZBN9cxvrMNq3Sytcai17GRgyKXyHq1j4S2qhdEoYqCZnCWCrSPRg7Zj2c057zOblIiSqjuCQrJ1g9UC1oGdxL3TWY6s1bb0Eo8f1jms94CQtIquvbVTg6F2n2wB6ytF8K31GlVLyopVwYkDUwiu0iqiZIoKgsXa6qJiAGPr16gdKWXmA1knyoaFufWMWRlLdZTqJ2eV4AJLE0hIPZQZx8I19Lknlnpga6fGRhahL4lowCt0lXWNqHIcZtyczzkfIudxZJtTdTHDMJr6Pev7ra6d8+LJZMxkfiCXBfhkMK1rgqFgsQqtq4d7pe4/hvpMEsqDPqFkslRNx8NelJ/+T1aZPM94tH/XM76hCvPqEal1rlJuJkefbtLxpWkdTpMDnpuc0NB6+DamhnHZrKRpZ/SmXjjFGKIWOqb12k5zda10tcMQ2NnCUApJlNbWS2QvBXTyWZdak61309Wg2owqly5lTwrBuKqxQEi5BrrNg2fIGbFVIIvWZxxVeO3BOaLVYazB0k1i62ZqciUVipnOfNWdGGtNdagzdR8VlKVzJFuzl4warnYzxlwYSiYWYVSppgI49n3AaTXMCNax17TEURk0ITpl7lhLMoWUCtJUJ6swuTWiynPzObcO5lyMmdWY2KRMsA6HpZdcf09TnRmhOk6JkUcJ6A+vo78d3rUH/sZYOhuozIg8dRaYju3VFcJjMGqxprDLdVEwpjpVPPQI1mlBUIUs0y88uekUqutDPZgzcQndFAdfwz2MCXXESD3sF61dj671hGgQW+fPxtSOWIyGXiKNLXjrcOqoPeL6MzSTMEm0MIpl1nZ0TaBHEI0MJdbLgwUmJyDUYl31F612nKBZyJON3iWeDNrGMWtq6mgvCURpgyMlUwVeqjhbO40WzyYXsgrBVZoCAF7w1tEUy5ALq5JxWNQWhuKIYsAE5taQTSSJsNc4cqmOFYPAfNoUx1LYqrATQa3heNYRihC0XhA8nuAatkm4r4mFMcycrT/zFPktBhbWodQJ0soUrs33Oe4WeBJ9ueBB3NJOY3QN1SfbKHipNd7YgDHKUBLrHJF3Rh+8xNcJ6z2zpvLXNxmsERbe0ad60qqHDVNnhk5Zx4wUJWBYek+l/WUaPEUKUWpirQE29HSpgSJ0ztJ4yy5Xh5yDtiEJ7EpGJ+vLURJFhKj1wGWN5XgxY78EosmTDW3gRrsgrwpvjlsaZ5h7S2urA0vJmWSV+ZSLkhE2mnn/4oCry46lS4z5nNtxA0yySSsMKlg1zEp1YjsygZ2VyscVeceb3SW+PhgcDQGBmrSssPS+HoJh4sHrIzvMESgq9VBmJitOYylWyEUpWl3o/GSvrVRXneouVUOLiipLX6eQg9aP6UzVsIj+mnOfMZ55sATTUEo1ybCuepefbQv3cgR0uiSCsdXgQ4ypUwlTLxRRhEPTcOgagivImOhTQowDR9URFoHCowvy0nui1vCxQctl0+0JwhvLMjREKZzlghfL4bLhvFesrxeuIQlzETDKRcqP3L2OfXXvcr6GRCat69doC61xXGiqbmQGlk3AB8MmV3//Q1+dHFc2g1puNHPu5B27WKaALMV5w3P7C/bVsddkxEDrAvtdx+fOznltdVbPCBg658AI41D9/memNkKKqRayHz4+5ub+nPu7zBfOznlrsyWb6uwzamE0ghNLWzwOw3PLBdFm7seBszTWROJ38no+wWf1DeHhuGw91ATHmp+h9MACi502C6jrzIVUwVa2BXB462mbgKqyHoUuW9Qakq199oKQXaH0DucNc2sJ4nHOsi4b0hR+5ARKEfIoJFc7BaUIiYLzyvW9jpP1gIlCTlVXMLczikTimEi24G3BaJlSJROt6zCmCkQM0GBxyZKzMObELic2JdKUTMESK6mkLqwTTTAScNmQbUKskmP5Da/bJX7nePharnYDOZWpWy8MCDeo//0wAEGKcjEkEpBs9aV3anDOoapcbBJLpuA4qrd0loIaQ5TMrG242gTmYnANfGWzJpfaOWitpc+JJAUVpdi64XksM+f4+KvP8bmv3GcYhU1KZB250QaMCfQiqBhKTlgpbHImWjhsKo3jYU9giaUj0I9bSslkGRnGkahumlTUA2RC6V3Bq+PBOGIojE6qN/LDcf9lDT4WPHwdh1j9wRHBqSCuOnsZCh0NFstAZj3WA0e2islVVOldnVBuh4z1tZkhuZCL0GEZJYODPe+52TTMcLi55aubNWMpeBs4Ci1SEmkoDFJt7SxKY+ul73/+kffx+S/eoR/hLCa2GlnOfLXCK4VeLWhhMFIvD2JRlOyk5peosq+WubP0Q2IoA0OO9H0mOFu7+ICX6XJghWADb8YtUSLj1PVqp6TTy/p7PHhUfykzteCriRJQkiNLJhhoqHvzJmWsq3RbitAYML5Oosdcufql1LTuQtWVjKke/DtrmFlHIwGdKSe7Ac256qNwiBRSSQxSnXMeajeNMXz78R4n5wO9E7a5MGZlZgxelDIIYgtqISmMxdXva5SSp0DCiU6kIVMGrTkUQ2LXj4ifSLQ5U6TuwphMI47zvjbrRmoWhp8OW5f19/jw6BxYMnknj8KoxBtcVmypTQ3jDSIj5zninceo1v3TKovOo6rcXu3Ya1sSNWne5EopWw8JJ3Bl0XHUNSwkEGaeX35wr2o4tRqj7ES52A2MY0GKTM01S+sc/4vv/XZ++fN3GHY9p2OkL4krszmLxpGni60vgkphS6m1bgNRIkVrhtRB07Cwns02sU2RdY6sUqItsJVCojqhRSNEV1jgudvvWGtkkzPGKkv3ztbAd13S7ptvvsmLL774zf4xvuXwxhtv8MILL3yzf4z3BF577TVeffXVb/aP8S2Hyxp8PLhcA78xXNbf48Fl/X1juKy/x4fLPfgbw29Xg++6A7+I8LnPfY4Pf/jDvPHGG+/5qOrVasWLL774Df+uqsp6vebWrVtYe8klfBw4Pz/n6OiI119/nYODg2/2j/PEcVmD7y5croFfHy7r7/Hisv6+PlzW3+PH5R789eGd1uC7jtJjreX5558HYH9//z2/2DzE7+R3fRbeEE8TD98wBwcHz0z9wWUNvltwuQZ+/bisv8eHy/r7+nFZf48Xl3vw1493UoOX19FLXOISl7jEJS5xiUtc4j2MywP/JS5xiUtc4hKXuMQlLvEexrvywN+2LZ/61Kdo2/ab/aM8cTxLv+u3Cp61Z/Ks/b7fCniWnsmz9Lt+q+BZeibP0u/6rYJn7Zk8rd/3XSfavcQlLnGJS1ziEpe4xCUu8fjwruzwX+ISl7jEJS5xiUtc4hKXeDy4PPBf4hKXuMQlLnGJS1ziEu9hXB74L3GJS1ziEpe4xCUucYn3MC4P/Je4xCUucYlLXOISl7jEexiXB/5LXOISl7jEJS5xiUtc4j2MJ3bg/7t/9+/yyiuv0HUdH/vYx/iZn/mZJ/p573b8zb/5NzHG/IY/H/rQhx79+zAM/PAP/zBXrlxhuVzygz/4g9y9e/eb+BN/a+N3UkfvxRq8rL+ni8v6+424rL+nj8s9+DfisgafLi7XwN+Id0X96RPAP/kn/0SbptG///f/vn72s5/Vv/gX/6IeHh7q3bt3n8jnfSvgU5/6lH7kIx/R27dvP/pz//79R//+l/7SX9IXX3xRP/3pT+vP/uzP6sc//nH9vb/3934Tf+JvXfxO6ui9WoOX9ff0cFl/X4vL+nu6uNyDvxaXNfj0cLkGfi3eDfX3RA78H/3oR/WHf/iHH/13KUVv3bqlP/ETP/FEPu9bAZ/61Kf0u77ru37Tfzs/P9cQgv7kT/7ko7/7lV/5FQX0M5/5zFP6Cd87+J3U0Xu1Bi/r7+nhsv6+Fpf193RxuQd/LS5r8Onhcg38Wrwb6s8/3nkBxBj5uZ/7OX7sx37s0d9Za/mBH/gBPvOZz3zNx4/jyDiOxBj52Z/9WX70R3+U1157jStXrmCM4Q/+wT/IT/3UT/GX//Jfftw/6lPFOI58/vOf5+bNm3Rdx0c/+lE+9alP8eKLL/JTP/VTpJT46Ec/ymq1AuDWrVu88MIL/Kt/9a/48Ic//Ft+XVVlvV5z69YtrL2UZHy99QfPRg0+qfqDyxr89bisv98cl/X39HC5B//muNyDnw4u18DfHO+KNfCxXR0mvPXWWwrof/gP/+E3/P1f+2t/TT/60Y9+zcd/6lOfUuDyz+/wzxtvvPG4H+W3JL7e+lO9rMHLGnx8uKy/y/r7ZuNyD76sv28mLtfAd28NPvYO/9eLH/uxH+OTn/wkt2/f5kMf+hD/7J/9M/7Un/pTfPd//Tw4Sy6FmDNDjiyc53w94oPHWkOWTCkF45TGBFrvcM4iRvGNY+4ct+YtM2uwQDGGnVFSLmTNXO9meCyvnZ3zQtPRo6xjYpsL+4sZn/jADTrXcNDM2KXEybrnwWrHOvc0xXC1nfEzd+6xy4kQHDsRFjPP2S5SRHllb8Er+0tOUuQLZxe82u3z1nbDOiW0wNhnbs1bXjnsSM4izhOawH5ryU7w0jBvA1dngeeWC46Or3J0zWFSZrWOxFgYY+Z//an/L3t7e9/sR/kti9+qBn/gf/m9NDOHGCFlYRgiZSj0fcI6MBiKgKKgQrCG4BzeWYwxOOswBvado/VgUEoWohFyVtQqh6EhGMPdfmDhAlEKY8nEAvMm8B3XD2i8o7WOJIWLPrIaEpGCFuHQNXzxdM2gBW8t0Sqdt6xzgaxc6RquLzrGLLy+6rkx6zjrBwYRjChjEq51DcedQ5zFWEfjHF1jcMFijaPzjqX3HHSew0XH0UGHSmG1ieRSX5sf+T/9y8sa/AbxW9Xf7/n+V5l1HYplFwvbfodDWO8GjDNYb0EURFEpWGuYt4Gm8WAcfhKGXZ155h4MkFRJxrCLkaLK9a4lGMPrqy1HBKJVtimzE2E5b/noi1en5x8YcuHBZuDBdiBpxorl2Ab+y8k521TwztAboQuOPmeyKM91Hc/NW3Yl8bmzgVcXHQ9SZJczOSm7PnNrr+GV2ZzRGcRZ2uDYC47sLa1xtI3nsGu4MW85Xi44OvKoCJteiFkZYuJ/+7f+P5f19w3it6q/3/cD30Y770gK22FgzCOtc2yHiLpJeFgULYpSsNYybzzOO4pVGuNwBZYeWg/Wggj0BSiZUZXjNhAMvL4dOMaQ1HARI0MqHMwbvuflYxosy9AxpMK99Y5764GE4orjSmv55dMLdqngrGU0hVnj2CRFinBt1nBz1rLLhdfOd7wyn3GWMruSKSLs+sLzs5bn9xtGYxFrab1l0VhooaVlFjyHbeB4Friyv+DKUYOqcrFJxKzkpPzl//O/vqy/3wF+qxr8rt93C3XKKIVtSijKAs96GFEMxtR9FUBE6Hxg0bW44Bgks/AByYUbbcsyOLyFJLDWAqWQgOtNQwBe322ZYxFjuBgiQxIOFh0ffeUGs5llTkOfMvdWPQ82u3o2jcr14Pns6QVDEZw1rCSzPwusxoKq8tyy4/m9GUMp/MqDDe+bzzkdBrYlk4vQb4Tn9hpeXrRsMIg1BO+YNeBbRyAwbwJHnef6PHDt4ID9ax0mC2cXiZiEJMKP/u1/89vW4GM/8F+9ehXn3Neoi+/evcvNmze/5uPbtqVtW7quwznHbrcD4H2HByzmcwTYjAMnuy1XZy1v+TWuaTDWsBt61mOP86CjoTEeY6DXRJsdmzJwEWCN4lGWTWBN5uO3brIeR7w6Vn0kZeHVW4ecSuSrZ1uyMSy7wGLR8taDNa+8/ybXrOPqcuTKfM2bqxPO1yPzecf+bEZTPD5AnyOpBdlCNhC6wNHBDN3AfteAMxQL0ShiFRMs1ltWUri769kUITjH1UXLaT+QdsK8Cbx6ZUl4vjBrAofvuwHFkocemwdsKAAYYx73o/yWxNdbf/Bb1+CBdeyFGdY7+lJYM+CccsGADQZrDSkJY8lAATE0zoIxJBG0CGqE7C2qikGxti5e3351nyEXGmuJRbDR8PzBgrVETrYjJGHeeuZtw9k48NzRPs4aDrvMxTBwOg6s+pGuaVjMG0IpWG8oFMQYKII6pek8y0VDiJnF6OtlxDlUBbGK9RZ1hgE4HzOpJIKFxdxTdsKwUzrvubHX8MrRnHmw7C3mUCxpjIxSME6AyxqEx1t/N+Zzrh8e4n3DeszcvThn6eFtt4Hgsd4huTAMA6VEioKzDtQwloIaQxJl0ViiFQxCwHEhie977gqrPtFZw5AKRZVXrszZOOXN0x05FZZN4Giv482LHS9fOcRZw/FizpX1wP3dlvuryKJtWbQNLhScgySJ7JScIVtDmHmO9me0o2c5Cs45yBBRRiOY6XK8ksydPrEtQvCWa7OOlWbyTum846WjBe7GPp1zvO+lA6QYJCWsFPCX9ffr8bj24MM2cLToMNay7gKnG8tB2/KAnuwsxlpsUVIayQjWwCx4sLBKCauQTLUCHBC8GmZYtpL46PVjVmMiOMuuFEw/8v6DJetSyGsFY1m0DfvLjrcfbHnx8BhnLXtty0Hb86CPnG4jXdMyaxucK1hnGBVSsJgCaqCdeQ73W0JfWI4ZnEWLIQtEBJwBDxsV7u5Gtrk2bo5ngZ5CGgxz53jhcMaHbu4zbxwH+0vIwjgMaIoYVw+cl/VX8TjXwJeOD1kuZ2RVHmw3rGPkuu+4fb6mV0UNOIUimSKFo/0lV5Z7ZCm8fnZKEaEvmbVaRs00amixrNLIx29cY1MinXUMY6FslFev7tMjpLN6id0LgeN5y51hy62rx1wxhoPZnOP5jJNtz5snG2Zdx7zt8UWwHrZZyI1Fk1Coh/a9RaCJjlnrwRrUGmJRBi2IM6iFVSm8uRtZp4K3hoPWE60y9srCOV65ssDdOmThd7z86j6kTL/tKXEE887OgY/9wN80Dd/7vd/Lpz/9af7kn/yTQL15ffrTn+ZHfuRHftvP+zf/5t8AsB8aXtw/wDvLut/RGc+VpSerko0jiyI5sU5gnOV0M7BKI13jaJceWxQzV3apMObEcdvwHQdHnPjEdz93DVX42dff5lfvPuD2xcCNg0N221M650genDUMfeRXbz/g93/7B1k0LcFYrAqaIoGGw4MFHyyJkhJZCtKv2RhlZhzWKjstvN0PjLvI82FOyoWhCDELVsBYQ2gsp6OQjcU5gzUW7wwOy4VkdrsBVKEo/Sbx/g8c0QSPt47GeVQf9xP81sY3Wn+//nMf1qAHDnzAGYcXQ7GBxUwRUdQBRnEmk6ICltWQ0CIEa2lDiwfMTEla6JMwc5ZXZnN6l3n1aB9E+PJqw5fXO05T4rhriCkRsGQUo0pMmbdO13zk6jU67wnW4awhF4GZY9kGblInXYLCGBlFCcVSHEQVLsZEjJmj1qFFyCJk+XWFY5WLIhRV6nJhcNYgxRJzJGZBtFCkMI6Fl19Y0BiPswZrLbZcbnQP8Tjrr1PLldAybzsOXCangSvOECVTXIexnpRHYh4RtZxves63I50P7LUtxinaClspxBQ5CJ7v2N/jzES+8/oxMgi/eO+EXzy54M5q4Mb7F5BGnLV4Ba+GVBJfvLvi4y/dYtF4Zi7QGYcVKMVzsOx4WTNZMmoEs+1ZaSahGKMMIpykRIrKrVkLo7CNhT4VVOs6653lfsokBWsMFkMIli4b7pVIP2amJh59L3z7B5Y4qwQLYizZXi6Cvx6Paw9usVxxji54tsaQd5HjJhC7xA6LGo93kHVEgBgLMWYcZrp4QpknRrWkUjj0gfd3C47miY/cPERy4Zfur/jsyZoHu5Gbz10njTtaZ8jO4I1hHAtfurPme154jkUINMbSGUcwAwrM54GXdIlO61fue0ZTD/9DgbEopzGTBuFGO0NyZiiZIRdUDBiwjeG0FLKp+68x4L2lLbAuiTEV5AyKwtgL3/bBQ1oDztQJqJHy5B/qtxAe5xo4c56XDo/pXGDVbfnCxQU3Wk9W4f6YiEVp1JLTSLSGbj6naToYI7YARWszlsy6CMc28KH5HstZ4HfdvIJK5rMPzvjCxYq7m4Fb79vndtwQrKd10Fjox4FfffOU33X9FvMm1POZA4eh7wsH+wtekozmjBil9LAzMHeeQQtRlLMh0++E59oOV5RtLmxSRrJgMOAMd8dMouodjDXMgseqclF6YizoyVSD28wHP3KM8+C8wVmLiLyjZ/NEKD2f/OQn+XN/7s/xfd/3fXz0ox/l7/ydv8N2u+XP//k//9t+3p/9s38WgDfPLxhL5NpizvFySdN47p5fcLodOI+FJIIzSreYQxKaNtEuHW3jALA4EOUD164DwiI4XrhylY/dusLMg/Oe/vW73OlHgneMGC5iwXnLkTcctZ5QLBsp/JfXv8T7D6+zCC3BWfb257yx29B2Dcdtx1qVuzFxbxuZzTwfee4qxijWgYqyBV5u5tyOW0iGMkJSYdY4Dp3jpGQWnUd9PWg5b+kWHt8nsIZ1zvzS/TO++GDNlesd77t1ldYqzhqMuCfxCL+l8Y3W38PPfViDu6Fw72LN3AcWvqVRGPrILo/0EYqARTCmvo0cGe8d3juMBYtFxHPYzcAprTPsz2Z819EerXN4J3xpvWMVC14gYiiDw6LMvGPhGwC2qfCrpw94cXlA5+tBe79rub/esgieofHsorJNic2YaG3g5YMl0RSYul5RlKuuZV0SxSgJQKABlr5hkyPBG7AGa+r4vWSDWLAKfRTePB14sIpcXQaeuzaHaaOTy1vnb8Djqr+zvsffv8/xfMHefAGinKcdp9uBUSOKQTSTnMES8CESnKHzDgM4LEEcLywPwQoLb3huecAnbuwz94JrPT9775w7u4jDkAn0w4gPhn3nOGgD2jtWkvj5t27zgcMj5j5gLSxmDjcIi0XHcUzshshFjJwMmVlj+eDRkmQywVmkwIUUXmkaTuKAZsgRVBXvDXNjKRR86x7VH1YoTiox1RpWY+YLd9e8dbLj5rXAy1dneAM4g0vvbLN7lvA49uDTPkJZcdg0zLsOCpxvt5wNka0WVA2tcWhjcDgGEq2tB2HVSnkMpeWFxR5qlLlTruwt+L7nDtmbTh7pwYYH/YgK7KjrzCw4Gu/YCwHtYS2Zz965w6uHV5hZj7eGxcyj28zxbB8ZEn2JXORCHwtNa3n+aMGYMt4ZjBp6U7jZeU43GRVDKQZRJVjLIni2qU7dQzOtfcGQssFgUAfrkvnSyYbb5wPXrra8fHWBloJFsfkJP8xvQTyuNfDO+YrUJ67NFhzuLXBiOT3f0sfEeuzZ5UxrHAdtgyWw3m1IaURFCd7SqkMDvLg4QI0yc4aj5YLvef4FDhuLKw0/f2fNvfWIimW0nn6nzINn0TgO28AYlQd95Be+eptvv37EvAnMrOOoC7xpDfvLOdu+p1dhlTMXMeNaxysHC0ZTWRtFDD2Fm65jXQYkCyUqIobWOfZby5kKMzwzZ7AWaCwlFYKrF4A+Zb5094J751uu/WLLy7cOsBkaDPkd1uATOfD/mT/zZ7h//z5/42/8De7cucN3f/d38y/+xb/gxo0bv+3nvf766/z1v/7XubKckYtyb9Vj1PLBoz0+N/bM3cC9OHA6RII1vNItOezmfOj91ynOsksD292Ga03DleWS+axlvlhwddlytAd93BBjQwhKo4GrzQIFYhy51S5plnM2cSS4wMsHx/zh64XPvXnK5++fUbQgKaPJ8qvrLT9zche3yRwFjw2W1ZCRopRZxBvL3YuBN1c9vSofePGAe8PIn/ju9/OBm8fsYuF/+Jlf5cb1A3anK7YSkSKkpNw/H/HW4BuLFMV5S2gcicL//ae+SOYL/MDveoHf8+p1DmbNk3iE39L4Ruvv4ec+rMGD5QJrlb4kUswc2Rl3SDTAJiV2RXAGrnYNrbM8f/0YdZ6xZMZhx8I6ZvMDWg9z6zhsHTf3LFEjZXSV3qCBuZ+BKZTdyNGs5WgWGErCGcuVtuNDBwfcPR24v9qh3gAGW5SvnA+8cb4ij5GZszhn2e6E6BL7weKMYbfNnI+J0RVuHS843w587NZVnt/vGEX5t195wHI5Y9hCEgGUVODstOoUnHeo1NEpxrBB+X//yl3s5yy/+8UDPnjjgFn3TZcCvavwuOrvfVdv4K0wpETcXPDqXsdXT5SjkPnKesPpWNfA9x8uWQRPd3iM+Mqf3+52XGscy+Wcw7Zj0bYcLwLPLR2xCFIy1hmCC1xp9xAvxJi4trfPjXnDNkVC8LxwMOcP9df40p0NXzlboxScgFfHL17s+PnzB6RNZukDzlsuhsRQ4LgLOGM47SMPdolklG+/OefekPjD336L911d0OfMv/jFt7ly3BFXI6OUuhYX5c6DnsZZus6RCmBBvHJWEv/w332FEOC//sA1vvulIxaX9fc1eBx78K2DfYIxjDkTxx2vLBtOkuEgFHYxsZZCbww3mbFPYH5ln2Itu5TZ7HoOLCz39pg3nmXbcH0ReHHPU0Q43xWs8zgCx92CgjDGzNW9JTdK1dJZa7i5WPB7j6/w5Qc7Xjt/AxcMwVpMtPzyxYbP9zvGdWY+TcYvhoQvhqOmwVnD+Rg57xNRlZeWS050x+/74DVeOdwjRsO//Nzb7C0Dw2qkQVBVisK984h3hnbmSRmMBTz0CP/kZ76KAX7v+6/xXc8fsde1T+WZfivhca2BH7r1POqU3TgSd2s+MJvzufUaLYq3FhcsGGiDct11LLoZYi2bGCmmcNx4ZvNDlvOORRO4vmh49bgD4MEq4Vwhi2EZ5ogXJI7cPNjnJpnzcQAMNxdLPnF0hbfunfH2+gJCVQ1oLPzSgw3/eXMPWQv71uOC5WLINKkwXmuwxnK6GzhZj2QVXrrZ8fbJwB/98Ct84NYh25z4f/3MlzjYn7HJPc4UoNbgndWIRbDBkouiFmywXBjl7/3bLxOs4w99x02+5+Wr7B+8M/2IUX13tedWqxUHBwe88r1HBDzPHx/w3a/e5Ch03Lk447WTM167f87pdsQ7w0tXlxANR4s5YgxJCqoZ55R519GqwftAFyx701X85t4hyWY+8+Xb/NLbJ+y3Df/7P/h93B7X2JzZjJGm7fjeV17m7PyEt1drPnt6RpKCKcrpJnF4dY/D1rO6v2Y7RHqUIRhe3Fvy/MEcaw2/+uCCX7p3zrwJ/J7ja/z87ftcu9HxwsGcfRO4d9LzP/uOD/DLt98iFMus8fRa+NevvVUnA2NBVWidZe49xivzYulTpp17nj9e8urRAX/r//oLXFxcsL+//01+eu8NPKzBj/6xj9AROOoanj9eMDczztdn3IkD9/uRXS5Y4Err0WJZNgE1hoyCKt4p3lXhbmsDnTd0vtbgcZjRY3jt9IK3L7Z01vH9L18jGkNKiV3KNN7xvitL1tvMyTBwe9iRVQHDdoyEpsE7S9omUs5kFHFw1HUcdwFr4K3twBvbnrZxfKDb44una64feq4sGhrjuOgLH75yhbc3K4yAM4axKL9yb4VBEVc7YVYhYDHO4KxAgvnCc23Zcb1p+G///k9f1uBjwsP6+9AfeJmZa7ixv+CDzx1yxTbcPd/yhbMzvvzggvPdgHeWl47nWHUs2oBaSwEwSuOV4B3W2CpmC549X5f7K01gM2b+890Tvni6YukDf/53f5CNM6R+wypF2rbhdz93g5OLDW9d9Hx5tyJLpeKcxcxohYW1uEGISRlUSa3yXNtyZX+BNYavXmx57XxL11i+c3nIz9875bmjjuf2WxbecrZOfOKVW3zx/hlB6/RqlSL/8fUTDKChalwchrm1eGOIWSgoV/YbXjqY8eJixt/6v/3sZf09Jjysv498/0vMbeDabMYrh0v2jOdi7Hn9YstXV1vOY8QZw429gJfAsqmCx1zzfbAO2jbgTe1iLpzjwFb633LhiWPmF0/P+dLFhoXx/K8+8CIXxhFlx3aItM7zkRtXOb/oeX3X8+ZujSgYqQf70cJe65FdpRINquTGcHPWcLDosBje2vS8sdkxC54Pzfb47MkF149bbi475tZxdzPw8eeu8trJigZw1rLJwn9++xwNgp2MGQzQGEPr6mCzj5njZcvzhzNuLVr+9j/67GX9PUY8rMEPfM9zLNrArYM9PvzcNfabwGt3Tnhr2PDGxYrzvjZHn9trsXgWzoMxZBUSmdZbmrbDq6GxlmXjuNpVVsS+d2w18Z9vn/LFB2sWvuF/890f4gIo45p1H/HO8x03rnByvuHubs1X+p6soAXOtpFuv2Hfe9JqYDtmtioUb7m1N+PKosUaw2vnG754smbeBH73wT4/+/YZ739+n5eOF7RYXru74g998EU+/9Yp3kDjLNuU+czrD/AIO600YqeG1lp8AyOCSYbr+y0vHy14cTHjv/vHv30NvmtbI1tJeBUeDFu+eHpCFxxXbYsphq7x7Bmto73WE1PBV1I81lgiFjXKaogYD1YTDEpJibFknj8ZuMgjb6w2xFIoWRlyZt1HnBaCcxx1LdbAcjnj5a7hXAr3V1su4si6FI5EaYrlXIT7JZFQDpqWV67WjobB8NLhAkTYJmVbEq6FXUq8cb6lVUerhs/fu892GHl5b4+bh/uUYPjS6RmlwFfONsSkdTxq4bBtGTThvWXVJ4Y7Ky4u4jf7Ub1nsSsDgtBkuIie3krtKESlsQb1FmvAOYNmxSBYqmhXrKJTd0xDpdDsskXH6rBzRmabhfPdQM4F8XXMvCZhtNC4Omq21rDXBrrGkEzhfMhsxswuKQeNqdMGVTYiFISlrYfwRVNdNK4ZpaBkVcYi2ADbnMlbwaklWMedzYY+Jq50LQezlmLhbj+QSmE1FkQUowYczLwjG63i+Fi4fd6zssM3+1G9J7HWgVEUnxx3dj1bIsuJ19k2lrnxeGtpgkUiTKchsAa8JRlljAnaSgs7Hy1GCr0kruA570fu7Pra8bdKLMIqRiRmGuc4bBuctezPOpqmYTgrPNj0rIbELpWJPuQ504GVZGJRlt7z0v6S+azDGJDJRagvwq5kTDCc50haFWZYOmv5yumabSy8stdxvJyxRXlrvSUm5f6Y6oQJBWNYBsepK3iF9ZD4SlTOzi7XwCeB3mayUbxa9qRhS2bPNQgbfDDMjMcZaJyhFKEUqpDXGKQxiKn7ePCGnRTOCrytlWt/uHWsx5G7w0AWQYwQi7DOEZFCYxwHTYtzjv15y6uLgJwpDzYjq5jZ5kLrLbNieWASK1O1SXP1PLc/p2sbjKk/g0EZi9KrYBrDughlM9KJxVrlK6sN25Q5WrQcLVpGY3hzN5C1cDEWUGHiKBGsZXCCtbAaIvl+4ezicv17UliNPSln2uC5PWy5iIa2bZChYLwS2qq7dtZAEgTB2Kkx5R1FYDuOuMZCMlwkOMkwinKsltOx5/amJ6sgWg041kPC5EzrHHuzFmcNe/OW2cIznFlOtiOrMbEbCwdqaRTOVDiVTF+UmYGbiznLhcMYwy3pKFIYEvQiaID7Q0//INGIRbPw2v1z1mnk5b0FV/cXjMbw1c2OkpVxvaNM9FlnDDPnyC6DU877SEnCaTu+o9fzXXvgVyMUo6xiz5cfFJw3mMUxJQutc2ilG5NV6Evi+myPWTMDY8mmWg7ePT1jRMlZGGNhGCJCIQyGs2EkFuGg67i2t8fnHpyy+v+z919NlmZZeib2bPWJo12GR2SkzsrqRnc10BA9AIawIS4wczFmNOMNxQX5x/gHxoz/gLQxDgEbTqMxaFXdVdWpVWgXR35iq8WLfSKrAONFAtbBqi74m5aZnp4R7h7n22fvtdd6RT+ymlUsnEbnIjTRRrNZ99xcD2xGT58TMWVcElzWWGtR1kJMqASnTRHZjcGzdI4Hk4ZDEB4ulogWNnHAZI3DEHPks5fXrGqLs4BK9KF0Ri6nLfshsDcRpRS10wTgEBMWRRChH8vBe483BC0knegI3IwDRo/MVUXOYNWR6K6KLWfMgraGqnIorUGV8fB2P5CEcqilTAiJqDMqBzqfiElonGXa1LwcPT2J1mpaFLqcMVhr6QZP1yV6Hwkpl5FmLnxtZw1aEikLkhVTa5jXjpASrTEsK0fKmfOmIelMlzzkojFIMfF0t6c2uoiHKPoSpWFZuWI7RxFTOq1JZEIuHf+YhDFmdveitTeCXAtBRbZ55JvtjkZp3p8sUSgqa2iPBX+iNCzm85amqVHWIFpQWbjdbMmiGFOh7Iw+ECSQpGI7emIS5lXFyXTG19uOQQKtUcyNwaHJIoUqdhi5uxvZjp4+R6JPLFzFvHIcbESnjJIMWXNStywnTTEpcJGTxjFL8HA2wZPZxhGdFRaDl3ScMBiMLi5WMWeMU5xVFX3MmKOYt9aKUXKxZJRCPRtzZpPvC/43AitEndkReTYOOKV421iEshfUtjTdRMGYIvPZlNZVaGtIFiRlNt0elMEnoY8JLwFRgoyOzRgISZhox6Jt+bYf6FOk0pa50VhKgJC1hnGI7PaJQ19suiULE6WZKsPGWkwWcgYyTF3NSVPhY8Jbw1g5fBIezicELRwkYqRMi2LOfLPtmKniFoWiOA45xcpUxBgYSWgFTim8ZEYRMhBFCD6yG8Ov9TH9NiOaxKjgbuj46lZRKXjUrsgx45SicRalFJ7CiZ+uWuqmLlRUk5GQWe/2CIpRhDFGcowkIIpl3QVCECa2YtG2fL3d0/tEYxWLqphkaF0uGfv9gc3Gcxg9ISeSZFyCxmi0NShj0ClDgplxnLYVISUWznFSV3ireDifsc+JvRQtiUbjU+CL6w2TqnyvDPSSwMCyrhliYu8jWoTWaCKlkSIi5FRojnv/w0j8v7EFf5YMVtGnEb8NaDTVoJnZiko0koQkwst9x+Yw8v7kMavVCY2r0CK4nDmsN5CEMUTGMSJJOJ1UtMoRlKKOlllb886jC/6nr7/mhJqP6jNiDEgaeOeq5Bn85Wcv+Dd/9pRqBQ8eNUxQLJVhbh3vzKe0WrM+eCQJeOF8Med5f0s/JkZRXM5b/uXHH/D5k5f82yff4ZTmajLlk9tbtqPn7WWLNvB8u+Xz2w3fbA68O5/xeNKwrsvFJ0vmy80e44vQKGqO9nf3xdabgnEaLIwqsk4KEgwh49BoMeicyDozxMwhZE7qmnY2oTIKmxOSM8POMyQIWQixFP11BbUxZGfQKlI5w9lyzqf7DTOpYGaIOaEkc6UmYDTf3HV8+t0WKmE6tzRaMUfRWsdZo6m0oguBLJQNRzXc+I7BHztqdc1PHi45va34ZL3BKMXKVjzv9hxCYlI5EOGuG3kxjtweAr9zOiFWrtjXaUCEF/2IShqTIeuMaEj8RrECf3tQCWIyhzQy9hGrNVbXWGNxWKpchPubIbA+DLz17hUPTk9prCWNAy4J/frAOFqGFOh9oPMjMwe1c8yUoYqeSVXx1sUFf3r9krPacDGfkceMVZ5Hp0JG+KuvX/HHP3+BnQqn5w6XFOfOsnQOZYSJMux9IipQaE7qhttwwMfidX01rfkX713x+FnLn11fY5Xiom74ZLfhLo6smpacEi+2ez7fdzzZ9fzBRc1F5eirYvUokvlqf0AlDVHASuH2y71o901ANCinGUW4HjzaaIzu0Vpjs8bFjHXQpcjaRx7NLzhbzKiNIaWEhEzYdoh2xBSR4AkpUrfgbE2bHDpBYx0PTlb8xeaOU2NZzRwpCnYIvK0has0vnt7x51/cYerMamVoteKkcswbw4PU0GLYSyCSIWlOTcWr/oD3iYTiclrzX711weXthL/Z3GEVrJzji82OPgqXrQU0rw6eJ/3ATRc4PZlw6mC0huPdg2+7DkYgU6qnCnK83//eFJIOeJ3YhMTwakRpTVoZbDJMssNkTdKwTZ6+D1y9/YCTkwWNtagQQTLjrkOSw0vAx0g3DExrg6kqJqoq4vLKcnmy4t+/vOW0rphParxXOBt5bC1Y+OTTNX/6s5e4qeL0sqapoUExNzUPp2XitSMQckahOXUNN2OPHzM5wdW85Z+/+5CH04a/vLmjNo6Luuanz16w85HLeUMGnm52fLk98O1mx08uT3lrPi3NGcmghK92B0w80nycQhsI6dfo0vO3AaEU9AiEXGzZ1kFzUjta6xhGzaYbSVlQGYJPxJi47bY8vX7O5bxl13XEqKkzNMpQ1zWztuXJuKbXkSFHtgdP9yQSfObbw56XuUc18OOrU/7l/EOg4r/9o/eIMbP1A5PWYKcaetiYjt3gCWMqFoyN4toPLPqBT6/XWKf5yaML6qyIKXE5n5C15kXX41PkkAJjiCQJdH1kzJmEYo7m5W7PIRYe/zYGdpTN7KJuQQtDSsWi9L7YemPQTmErQ07CGD2CUOEKb9kpxqDwPuJJxFzENjoX8dnz3ZbpzLL3A7pXKAFrKKNw59jlRCTiJTH4RNjvCT7y0gdufYetNI+XLX9YVyDC7z1eMfaRXQzYWmEmBjoYbWQIiRwFK4rshHWOLEPgRdejreL9xQKXFOMIJ02NoNmMgRSh/5WNIsRc1lTKVGTWfiSKJiQYcmbIiWhglhTGCkkUOYO6t+V8I5BUuj2QESfEpNnrkQeN45wW72tiSnw3jqW7mTSIYrPv+Oq7J5yfTzn0e8YIOStaodhqGmGfPYMWOgnsx0hcX7P3A7e3mW8OHbYyfHS24I8mFSD817/7kN4n1qGnbRT1xMIIY4hcH4qeRRlFNdU89QeWvePT9RqtFX//fEVzdJJ4sGyJt4a7oYjYupTBF8bEPvhCvRgjFsNtf8BrS0zCYQyso2fUmVUwUIEkjUTI9+vvDcEUcaJKRJNRGAaqEkIFxJDIIjwbt+UCFoWYoRt7Xr664exkStcPyGEkIlglrLTGJMPOBKKDQ4jsfCDcKTofWI8D9dBjas179YJ/0haB5T/+6BIfhJ0fcU2xLqRT9C5xu/MMMYFStJVmkzvWwfDNfkA7w8cnM1yCLibOpxV/tRPuhkDvhT5KyRJA2MeEl8yQBJcKJTgoTUyKPuTjGSxMUGhrEAEJkO7X35vDKOQ64VUmpIDKisQJ09piLExyIubMbjuQQib7hPjI9tDx7Pqai/MF3TigfUQnmCVolcOIsAkjg0v0MYIPxDXssme39lT9Hqzifb3kH8/fQoD/ze+/S9cndmFkUhvMRKhGR38MsIyxTH6kVrxKPWe949PrLdpofu/qnAboRs/5dEJ3fcP1fsc4jPQ5k5LCA/uxWMb6kKmz4a7vMdkQMhxSZJMCHuFR7RABnzIplmn7D8FvbMEPpdiX4+hCRLjbdzRHT3STNdOm5XfeeojRin6MyN5z0rZMHj7m21ffMbc1t+NACJlGay5qx4fLCf2m5/rYcU0+sd321M6yWjjc3NDUmofNlJyO4o75jH/1Dx/yp09f8ZfXa/ZD5OZmpNoYFrVl5hyni5a3z5b85O0LLleXGAPr4YDTcFXPCOOez9c3nNSW5C3rbmSiDRB5tfdUdqCLmdshcDar2Wfh2o8MOdPFROcjYiDNM+s+4JxGG4XcT7PfGLTW4EDZIuYCyPtMJ5BChJhplOFyscRYQ5RE8sUH/XJxyp3f0qIZjiFcJimm2nJFxQvdszOaGIUUMuOmAwwTpzBGU1vDxFg8gFLMq4o/eHfFZ+s9X+97/Diw3wd0r6lqS2M108Zwspjw9mLO+aQmidCNARuEVaNJaeDFbmRmhZAz2zBQY0lkdj7iFMQsHHykbQ1Dhr0PiCh8TPQxkB3kSjMMZeyN5j/09L/H3xpyjGg5Ug0oRe46D9RJOLU1p1WFsYbT1GIfHoOQ+sjKNXzw+C2e3j1nompC8vgxYgROG8t7swVfpEAMHhc1OWR26z0Kw8mkwjqYOceFrUjHAeJy3vK//XsP+OmrW36+3tKPAzfrAdsbKqeZVo6TtubdyykfL055cLJEa8XWdxgjnFdTsvd8ebdhauEAPN16KqNxWnM7eCaVxafMwUfOW4vPwjZGcoTDGNkPAbQmTxS9j1inMEaR/P36e1MQJWR1tKdEuDMBE2HZOFZtg8mK2aTCnBskgxo8C2epz8941q+xytJJoYDZDKvK8mg24TuTWasREyykxNANGKe4mFiU07Su4kLXJF8W4Ko1/NP3T/jruy2/2O8Z4sh2F7DeUCnNVBuWrePBacPHixMuFhMERRciTVac1xX4yJOxY64sY07cjD1ONDHDTR+ojCahCFlxOmsJKbIfyrk75MQwBMQI1IqDh8oV+8R0T+F/85BcpBTA0+6OUE05nTacVBMqLMtFi9EVMXnSMNBWFW9dXvDc3zDRhsOY8L5ofy6aircWEz6NnpxHUoI8JMJhZFHXTGbFhcdVmouqgZRRwLyt+G9+cslPX9zxi7sthyGwfb5D15r5rKI1msXUcr5s+cnVBe+crLDGsvU9zsEDMyH5yDfrLQuBPma+3u+ZW8tm9Hx7syU1LUmgC5GLZYUA686TlLD3kU0fwYCZKe58xNaqaAaHv+MFv+RCYM7fd7CFQGLIkZVpqJRBo/jxw7cxRvPk5Su0ZMZhz83QU4ulndRs+4C2ilXlOK0d/dCTfOQPFyfcVCNPdh2HMTCpHBfzilElzpuaB3XNbt+xXNaAYjqdEdwdz8NIHyJJC1kSM3FIMV3HqUSdKta7Pbt96fxnm/hW7rhaLTiMI1UF84WDCkxUWGVQokgC2mpmbc2Zs4w+MVaJHCNRhBWOi6bh2TgwkIoHfIL0Ax/0Pf7TEYEqK7QoRB2nTUCVwRqFKIVkzdVsiZpU7PabQuMZPWMsNJimcfjoQWlqo5gZIeWivbhyjr4xbEzEDwlbaebOMpKolMIBh96zaitQiqa15F1JsRwkEgEjEZ01IoXzXwdhgqEbEqOPhJjIWXGdEqdtS5cixhpaVZF1IAfBHZ0zMpC1oq4sM2fwKRKjMOQEItRimDjNnkyyGZM1xB/uAXyP/zQkX4KztNMYB8rAkBJBQyBxSAOpV/z4nUvqegooJCV23YHtZoNLBlc3bPoRo4rgelE7VE7suo4P2wnd1HI9evohM2tazqaGXjwr55gZzc1+x9lshrWG+aIibxXXKdClREARECoURmmsMtTBMbeGoesZ+kT0mqTg6eHA1aJl7z2NVZxMS4cuRUFjUAheCi+6coYHi5abw0j0no1KRC201rG0lk0uQvgExKCI9wX/G4HSvwyiUsc9IpDL2Ueii4GQ4P2zc+rakVImx8RhHNmMHU1U6LrGh0L6q61m5gwqRfZjz3tNQzcx3JhA1wdOJi1LZ9mNA1OEViLbfc9i1qBwTCdC3u1Ze8+YSrhbypnKajgmNk+yZm40u35g9JmYhCFHXgyZ00XDdvA4A9NWk4ylzYYhlVojqfLnUxbOGsfdIZNSpj/aFdfOMNeGDQHlKN8/ZML9BvhG8UsfSUGAw9hzUldEZTnEnkPQvPfgEjtvWb9YI9ETQ0efAxOx2EoxDgMKTWsVS6fJKbEfD3zUzNg1kVcy4gdhMW1ZzRyKxOm04fFixqEfmDQ1OY1M6ppsDbcpFrtkK4gWXEgYFE0Fc6tYWcd2d6DrRkJMSBCeyJ7TuubWeyaVZqUqslXUolhQozWYyqCMYpoUc2fYhYB1ECWCFhqteDBpeOVHgs7oqJEEYfw7XvBTLi5opY4PXCMIu+hZ1TWVAskRYzUpCq1StHXLzo/c3W1YNBXzqqJuNT4JyQoHW7x/n449nWQetS3/6PE5dVMRvKV2ib+5u+G6H2l3e94bOmbzlsaC1DVKGWIQKmP45x9fcXvovw8aSSJ88uKO233k4mzOZntgM5SuxU8uzlksFnxsFM/urlFpR9CZjYKYAiR4kGqu5nMeLhzbw45djPz47IxvdnteSkcmcaEd38YOnRR11tTaoMw9f/VNQVImh+O49rjriEl0ZJbaYFNR2Dtj8JKp0RhtGELi9tBha8NMGw6O0hnSkLQmK1iHkTEFTtuad5YTJmcVQwQtmafdgS5ENv1IP0TmbUWlFbVxaDQhZJRS/L2rJd0YQKXv3yfPth37kJhNa7ph5BASWmnen09YTCoe2znXh448RLwS+qOoHWBeV5y1DdZotn6gj4mHs5bb0bOVQBJhaSzbcYRUBEcOjbufaL8RKA3aaLTVYIs4MqvMnRpoqKmC4IeExuFFOG9b+u7AMHSs11tqZ5g5h6sVySi0UeQaotLcBE9QwlXb8PHpnEnV4LOh0ZnP14FXQ4+2cHVoWLZTnDM0VQPKMIaMBv7pew84hIAmY5RCk/nyZs227zlZTNl0xehAK8XvrFbM51M+dIrnd1vIBwaT2YkmHIrDxEljuJy2vD23bFMgG80HqxlP+pI2HmPikXOsfYSscMpQoRGl+PbX+6h+O6GOjidaIUcOeyKx0SN1qqiS0PuA0ZqA0BhDPwb6w8ih76isYaZ1SXymFEa5gqjhZhwYc+CynfDhckZ7WZGThpjY9QO3vcdqzaPpQNvWNLWiEgcovD+uv8fnbLqIMQmlFCLCl+s96yEwnzR0PtCliLaGj6dL5tOWDy28POxJOTAijJLojlOEpVOcTWoeTBz7FNEm8f6y5dXouRsCKSTOtGXtAypzvOgasoGnv7aH9F8AjrWsQpV9YExcb/fUSiPWEXzGakMMCS2p2FqPIxs/MnGOuavY1Z5kE2hFrEC04WYciTlz1bb83uUJ00lLjAarhW+2a77ze3xInFrLtJ1jrFBlTRZFPxSa+X/9/gPuDh6tc3GnQvj6esehyzTWMSbPIZUgh49XK5bLGT+qNK82G0I6sFfCLqeSYZlAZ8XVYoZtHS+2e7KPfLic8mLo0UmYVcKVq3jRD8U1yqhSB9bCyx/wUv5GF/yoo2+IEuToITLkiJdINsUSce9HlGiUVUSdGLNHQmA2aZhoRVCZPZEhJfoxsdLCOgRuvOdq2vDRxYq3Ls/Y7GH0Bz5Z33HT97jKEiQhaHJOZISZc7w1nVJVmo/OlnwTFZVJZCXc9J7Pbnd8drvj8bDC+8A+eKZNxT+4qqibmsd1jc0DUxNY1vDFLrIfCgdtUU14a7HC1RW/GDuU1Xx0fo6zjpgzL+OBRMahmFnHzDlqXcRR93hDiCV9Ub0uaAXEZrxAUpZaFMoW0WqWhDbl1yRJpBiYWEOlFIlceP6iiAFGKUK3XRIWreNiUvFovmQfFH0/8qI/sA+RvdfEY2R2kpLKV2nDsqnQCt6atVxnjehARuhC5mnfQ99z6ltiKoLi2lg+WMxpnOWiMmiJ1CYyDZmXKtPF4lYxr2quplOc0/R3EaUCV9PJMSkQttmjUJgElTJU2uKUJqn7iv9NoFjLaZTRpeCSDDpzwHMQDRl8DGz7DicNg9Xs/J7dcCCNnrZqaQ1ELYz6KP6PwjgqDjmxHSNn05rHywnvnJ2yHSH0A5+t19z4ET2WdaGUkKXswVNb8aBt0Ebzo9MFrzYDmUAmsx0Dn252fLHZ8WAYGWPkEAKtNfzO6Sl1XfGocZgUqHVgWmW+Owg3XRG6Lauad5YLJlXFX97e4Kzmg9UJbncgBOG673BaYUUxUY6JttS67Pv3eBMophVypPOULn+mI9NnCwIxJbbjiKW4kx2ipwsjyUdaZ6kp06hBpaI3S4E+ZA4psk6eVVM88d85W3LoMrv9wOdbWIdC1wmS4DhdBaE1loumwWl4fznlaRpR2hOVsPGJr3YdX+06LudTRBJDzjR1xcdLTeMsj6oZhkCrAgsjfNsnxlGISVhUFY9nUyrn+Pl2j7OW95ZLqmEgqwObOOC0xoqiUYqpMVRGEc192v0bgyp2vEpee8gJkjK7bmBfNagKYkys+w4VLaIK33/MiewTk6qm0YpRJToVGUURfKZXmkNMbGLkvG14vJry7tUF261wGA58cn3Ni6FnTJHfP1shaFCGLJFWa86bCqc1H53OeZI6MImkMusx8PlNx1frjkVdY5xiyInKWn58csakrXm7cTgJVDoyqTJf7QJDL4w5s2onvLNa4VrHq90Bg+L9kyX13iIRNmEApOSSYJkby6SyiAg//wEv529uwX9sXBf/ZUDL9+SerQ9YNMu64enNmtXpnN5Gtt2G8dBzPmt4azElj5G7ceR6LFHLShTOHnBWY0Sw2lA7x6KZM22E/U4dNzdw1lBVFkHYdgPjOHBaW/7J2xcorbne7Hn1auRqaalahdbCXSijve3zO8aYcErxeG7Z7zPBB6wxPDqd8fapovcjq+9GnpqRwzjyztkpl4slY46FAz6b8eBkRVtbdmHki/WWF27kpKn5YDqhdZaYhZvdPYHwTUFElYPmdT2rQKuMonDarVimrmIXPZUprkm9HxizZ1oZTp0lpEznE4cYyVIKJ6MVpjom5lLs4aa2iMo7pVB3AIIxxU+dlDnkcjC1zvD++RTE0HWBvo9Ma01twSthe7wAjpuBMZdO2GmjOQQhRtAmczmveTDXDGHky43nTlt2Y+DRbMr5pKWXTGscqypyMmmpraOLiRdDz05KgM5pU2GNIQP74X7K9CagNcUdRJcgtxRS0ZUAAwkrCqMyX9+85PHqgi/9hm2/o/c9i9rxaNoSfWIfInchlPWXwekeXeniZmY1Tes4m7YsJ46dNYgBUDhtqGuHNtCPgXH0nFWWf/jwjKyh7wO7TeRkYrBWMxC5Pa6/7c2O8RhM92BSs/cB7wPaaC6WFVeLGd7X/OLFwFfKsvaej85PeftkwSElKmO4qBxXixWVrdkMie82PTcqMreWd9uGRhmyEtbhXsj0xiAgSb4/h7UpFJ8xyNG4RvHNdsPVcsFBIoc4MOjI1Gmu6oq+i3S5FFY5Cy8PI9YplFXYbDBK46xibh3zlWJqBXUDEsE5RVWVCUM/FA79SW35ydUKC+x6z3aIzGpNZcHpzO5oQjBs94QsOKW5yIZNDMQY0NpwNat5eyYMvqK+8bxQgX2fef9kycPFhC6WHJRVZTmdTTCNYxsTT7YdtcrMneHSOSbOoDRsh/sL55uC6F8ev6UAVGU/pIj8FWXS8sX1NQ9WK5QVhloh2XCC42re0ncD22FkHQIpCTlCU3cYp1BZoXTRAs2NY76acN1HsimNPKMVWitiHIk5cNiXOvAfvnUKaPZdSXI+aw1VZdibyOa4BneHnpRLRsDlRDH4QMxlT3y0anl7peh9zfJJz9OcufYj716c8PDkhH3wGCWsnOVyvqSxNdsh8eXdHjEj08bxjmtY1RZtNOvx77gtJ/D9KEcAyep7a6wEpARjH/h//NlfYlqY1oqHkzlvL894561Tqhi4HQNnbU0fY9lwpDzs82kNChZNS20rIBLHgDGQlPBwNuGj1YJ+GPnZ869ZpYbn13dslcfXGo3lYV3z0/6Wy/mCuWsRbZm6TeF5jxkdywbph8jLzZqGMw59oBfHzc5ydxh5cP4W82rP9XaLEcUQAqIyJ/WMdycNKSYW7YRHixWP2g0nleLR7Iz5pEw31j6w/oHcrXv8Z+D1+itNhgJD4XumVJTzfeTLuxu0VrStZm4qVq7hZN5Q5UxImXllGFUJ2soJEoqVrpAsLLBMsOWbjAesBVGwaiquJg0qRr5c75kpw92250AiOoUiM6006xCpnGOmHaINTbZACcKRLKAVOWX2vseYlj5lcnTsBmE/Js6nS6oYaHVHzpo+ZJTOnFjDRb3Aas2yqbhoJ7zcj1QOzqopk6psxH0SvLov+N8ElAaMlAXhQbwQKPSXsbG0dQ1B+PdfPeWv2pcsZsJSN1zUU966WFELjCTOmopOIlufIGsEOKtrlFKcuZaVqdHGwJiZ1OXBPmwbPp7NSTnz1as7mlTxcr0p1oeVQoxioeHZvmdSNcybipVqqHU5UsIQUVEwaNCKdT+gSfje471w8Joex9X5ioUeeNL12GTo+4iozJWdUFVLlE6cTx1vzSd8Wbe0teaDSc1ZY1BKs8uZode/vof0Wwxl9LG7KpBy6XIaU6aYBnAK6y2fv7rh6+2aaSPMlOPEtlzNl2gN3kZWVcWQE7uQIBau/Om0QrJmZStmJR2TofMYrVHAZVPzdjvFB/jmeo1Vhrv1nl4SqdIEozgVzbr3NNayqCzKWFpTfn/0cmwaClEn7vYD5sGCcQzsAxxGy5A0767mzKXn2vToBMOQQAvnpmEy02SVmFeW86ZlVTUsKs2jdsrKlDqky5ne3PvwvymoWLIE4Zf1Pqo0ZRPFptKi+eTJS75Y3zCZKs7shMtqyuXyhEorNglO6upoH5vIsRTzD6qGaGGGwyUYxwHGgYoEOXHZVDyeTuh84LMnz1k2DS9frNmpiK9LJs0yal7sOmo740FVc2YUjTk2ZYYyjRAEbxKvhgOaRE6Z9SGx6TNjrnj30QkTt6fd7CEluq4n58RZ3bKYt1ituVi2PB6nfH1X09aG3zEzzpqiXdnFRBr/jttyKtSxyDqOE48KbaVhH0YkZrKpYVrsDsMg3PYdp3rOydunpBj5119+zt1+IGShrhytNWxD4A8vzvjHbz9m1TQ4rem7gLGatnb8X37v90gp4WPg9m6Dqxz1VcvL22t++vyW513Psqn4R6cLfufHK35xveZnL9dl3OlARvATMF5z2TR8fLLi3bMTjIWpgj9/+gJrK3706AGV73E1PHrngs9f3PHZzQv2ZCpR/OLTOx6fTDmbNJxPF/yf/8kfEGLkf/r0M170sOkCja64ms5/zU/qtxsipdJX6pcXK6UV0cAQEymVDoA2Qh4yPZ7pxDGZT4nA5zdfchcDEXDaUltNlxKPZxU/Pl2xdA1OWcYR0vHd+C/OHyAZUk7suxFqQzWveLnf8s3uwM5HJkrzeDbh7fOaJ7uBZ7sBlKCcQALvMmTF1FkuZzUX8wm1sRiV+PR2iyjN5bylCgPTSfEIfro78Gy/JWhorfD19YGTWcuiskxqxz979wE6WX5xfY1PxcHHacPFpPn//4P5LwAycqTSRMhl2plTObA2akAqYaE01JFkMod9CURbLabMz0+AzJ9894Q77wkIE+toK8cmeT5eTvhnj684m8xwtqIfwRiNMYn/48c/IsWMT4mbXU9dw+n5jJdd5mfXG151AzNr+d3ljB+/2/L57Z5P7vZkq6CBiYdXdQILS+d4d97yeDJjYhO1gr9YbzHa8d58SXMYkSpzdTblu+sdf76+ZUNmouGrzcDF1LFoK1ZNzf/hJ+/SmJp/881XPMuJuy5hteO8aX/dj+q3EtoUJ7icQVRJL9VZEJ3pTCZbxcSBrkGbxDhmnJQ1UM9bLPAX2+dsh0gG2spSTTT7FPloOecPzx9wUjusVoxduWBUVPz3775zbKgI2y6V9XdS89lhw9/cbLnuPBOn+fFizrtXDV/f7PiqzySrEQs6gncBomJWVTxa1LwzbalNxjSaTzcHlFK8O2+ZpcBiAu/NZny66fhis2FAUaF4MgycT2sWVUn9/e8+fIhB8++fPuFlhs2QqLTjrJ38uh/Vby8y/2GL/zW7y8BuHEkxEW2NagStM2kAr0MJwqwqtpL5y+6G230gijCpLa417GPgndWMf/TwgpOqwWpD140YUwOO/93j95CU8Dlxt++pK0c1r3m5Sfzi1YaXnWfqDD85WfKj95Z89WrP18MBjMLVGj3CofaQ4KRp+Gg1493ZjEUNMcFPn22xpuJHZydUQ+BqMePDBxO+eL7jf725YScRkxJ/0b/kYjHhpKpZ1TX/+598hBXDHz97whMSdzuPU5aLyQ/bA39jC37ssaOfy01dUehcqNLwikrwVjC5UH1ygIMPPHu15m8+/YLZtCopfEoRSSiBqa34cD7jJxcXLKsKZwzGaLTRQLFNrI0hKQ1Z0NnwfN/xZz+75cWh5zYFejKxG9nNhCSZzRgJZGbOcdlMeCkdjSjEai4nLR+frDhfTRmTYbPt6caIHzwxBk5FceIERkMSyAkOY+Bnhy0xZnwsgWF7OxCU8MXNlk+udwhwUTWczhsm1W/uI/ztQBEK5VSKem309wLcjCErjWrLGoyHQru4jT11vqZ2NaIURhQ+R9BF5PX2tOXd2ZzWWIw2aK1JJmGiQZsExiAaQgIVDVuf+ObZK14NA/sYGaV0CXxMdAr2PhJzoWe0jcUPQksmozmxFY+alpO2JuTE3SGwj5mQMzGNLESYmQS5JmdIufhRf7vvkZQYfMAphRZNCsKt3/Hd7gDAzDrm1v7K+OMef5uQfOxuKYo1cS6fQzJCJqmMNxqtBcmR6A37MfAybPjKPGFRNd/rn1KSYufmFB9P5/z++SmLqsUajdKCQVBpxGKpjSWpwt+ucuLlJvLXN1/zdBy4G0bGmMgBxjajiNzFgI+ZiTWcGsveRVosGeFiUvHhasLVsmJIjt12ZBc0gwqM+w0nQThJCq01OWskwzAGPh32CAbnNVZHKgwpeV6GPZ++3CPAzNU8mFpq7jnUbwJKaY5SSVQGjUKqzOtRe+myCsolkioX1P3geTnsqBFm2mKO3PuYih5uogwfzab8eLFkZh3O6OPQIFP4D4HGKLI26JhQkni5HfnFZs3zrmczjviUkGToXSRnWOdEkEyTS5jWgVDsZrXitK74YNZyNa8IQbPZD/QhMBzplZdas0yB5BRkhSTYRc+t94hRzLzBKTAEYlK89COfbwqPemFrlpXF3k843xh+adDzSx3Ha2QFkeOE2QnRRFSvWfsB1SkaFNPKQiiujzFnUJpppflRu+Dj8zMWrqFyBqMVIoaUMlpnKqO/p3fboLjd9vzNfseLXcdtHxlCJidh2weaKNz6EZ+F1lmmtqITTxMNGeG0LgGtD07mHILhbjOwHRIDHVEpHhvHLEMWjUixuV73gRdDR0aY+IpaaYzWeNHc+S2fXu8RhLmtWU4ravvD9sC/E9WiovgBq+//C9CgrKIVTc4lYtgoRcyJ680Wq6dUxqCNQqUSTLCLkckYWLYNVh/txlTxPTfWITFhrEVJSZdsm4q063l6e+A6jAyScEpjgW3IPEs7epVRulCBajTlKBYSmdoaFpVj6EaeHTn9Wmuu9we+XG+5UIbfOV3QBM/aB7YpMObIwhi2WZgrh0ExjL4c5LsDAwmDZmottYbO97+25/JfFn6l1XC8dIoqPHynyiQg58LvTzmzGXpWaKwBraQclgJjzowpM3E1Wlkymnxcg42z5Cwkl8kZtFbYqEgxcXMYS+iG5CJgEuhjYiOxbHi62IQ6bQmqdNSSzjirmFjLOAZeikKSQqPYh5FXh56pUrzX1DiX6FKmzwmfIhZIRtNqh82KEDJdTtwOI0GV6UHxUIfx3pbujSCLQD4aE7/OI8nlb0TKGjQwcYYkCWJ5tjFnNvueZqZprMPGhD9e5voUGZLmpGpw2oAUj3WjNcZaJErx81eCzYbGakKX+W7bcRPGo0VreR9sQuSFBAZVYuCzEhqlOZQfl4QUp5a6ovOZePCICNYoNr3n2+2BRRJ+t50yV8IuRPY5MUqiURavhakymCQMY2A/Jp4MHd1x/Z05Q20UQ7zn8L8ZlEZGklyaHmjsa7ue1+vPKprjRS3FsjelnNl3A3Vd01iNjeATxeIyJboYWdUV7qgVUWiMMVhXLolGBJUzDmiMwofI033HbfKMR090QdiHxK2KjOTvew7uNTMgF0vvymomzrIfE0PwgKC1YTcMvDoMvMTwYV0zIXFIkUOOjDkV6ZRWtFZjEEJMjH7g5dgxqowRaKzC6szO36+/N4rSeyj73q98TnQx1RAttE6RFKgESoSUIvuuZ65n1NZibEAFiCnTxchEa05djVXHPVAZjDFUlSalMiHIWbDRUCfLOHiebzuux5E+JUQLohXbkLjJnlHlMulXCqsUHWX/ThSb4Wll2fee0QtIxjjDput59vKa59rxYduySIX6NpIJCM4YomSWlcMpzegTB9/zdDgwlMBhzgABAABJREFUqIRKULui49oMP6wO/M0t+F8/W8WvjHT4fqSjAKsVS1exC4GgM60xVFYx5kSMEX90phDKi3/wkWe5Z4yRypqi/9DlYdvK0R39fUEIEjmkyN3o2Q2RLkWUoty0gG0KPAkHEIXNGiSWLogoomRSzqXwz4nb7YG7FHj39AQRTeczz7c92RlWTU1rhE0MdFIcf64mNWmA1hZR6CFGnh86tv1IVWnmqsJZxZg9Xbgvtt4shFLsl1Unr1efLtxkrWBmDT4IXoEx5U0f8q+sgeMFIQv4nNj7cotPuYi9FYJVRaB2GMqvEYQomT4H9t7T+9LFUoAVhc4lJfdOIkodudKiaLMpXd1cNpuMkHNm3Xv6LnPW1ihKqu56GBmNZmYMrSgOKTNKJpNZVIY+C7UxtFozpFzeCyFijcIZhzGKQLwv+N8QciqTpO8PO5WPBf/rX6FQugio+xAIWmG1whpFSELIJTQoaykBSknovXCHEGMJHlRKo5QgBqyrOPg9Qyz8yZgj2xhZj56tj4yxTEorVTzPNylxkzySi2vEIIlaFCaXnzflMl3Iorg9ePwwcj6tMSiiz1zvB3qElbV0KnMXE7tc7GLP2pp19EyVZqI1fUw87wdufYeyigaHtWX93fugvxnI9y495bKpkV9uhQiiFMpqTqQq6aDqmE6uFGPMxEoQDVkf978EfYjcqlJM5RxJpdzHGkPdaLb9yJDKKCvmXHjXY2A3JgbJKAFXfhL2KXHnAyJl/emkMMfKP8sx9VQVrv31fmRIA+fzol1JMXPXjQzHqcOJymxS4CCRpDLLxtKlkh3Q6mJFez2MbLwv9FwM1sCYI52/5/C/MQjlcnks+n/5+V/mMykD503FLkWCfl0EU/IfcgYL2UCOHPfAyK0IxEQ2iaQMSoG1iqZ17PaBPkUUQiRziJG19+yGwJBSaVpQnIN2MXCXPFkEh8HnhFFHnUvKpGNzJmfh1bajj8LVvMHo4sB3ve+JaqTKcE5mk0sdKArO2op9ikyNpTGGvU+87HtuxxHjFI0xGANDDgzD33HRrkqqcHiOThU6q18+72OXy6L5aLXkm+2WfRtopNzmq7q88JsU6CURVek85CTsdeTJ7YZHqxmzpimbmgbVWA5dx/W+B4l00fOzV7d8utmz+f5Q0+VBZmEdAzsfscdKrkOBqWm0IXkhZRhC5LrviUHx13c3AISU0UEz0455U/Gy26NNRXIK4zSVsiwnjlA7bGU5m07pdwe+2u3wEZZVxUM3pcsjXRiw8V6w9mbx/QmHSJncaIoyXtlyYbxqJ9zmkUMl6KyxKKzWZBXpY2KgFN8gqGwYc+K279ACCodShhAhOss+BHb9iOTSDfum2/PyEOhDRKMwlO5+yEKf4JASToHOgpYybdJasIX2jY+J9RgQrXm6O5BiBqPQWTNVlsZprmOgzcW+sdA7FPPG4IKiNsK8dvjeczeM+BxpsCxqh5cy2uTepOLNILxupgsS5OiFXkS8IhowOOP4cLXk6ebAfhKxWVFri9aaQWU20dOlRHwdUxk1e514ti085mmuqLJFAFM59oeBV7sRhdDnwF/drflmfWCfEhpNhUJnRY+wk8TeJ2wWlAgeReXApqI1zqLwIbPpA1kUX/R7fhyWRMmYpFkox7wSXvqRNZGoFaPKiIKTiUUNUKFZNRV9N/Dd5sCgIxNqzuqGkAO3IWDSPaXsTSBJKRD0kWYgr7NIculgCBpjLO+aGc/6jkMDJglGNGRDILPNiSFlImVCnyL0OvFye+DBtKVxkI2Qybi2YdsN3OwGdE6MKfDz7Y7vdh0HEiqrEoSYYSSzrxL7IeKO9t1eZcQIr/3PFOCTcDcGUlR8uz/g8wJMwmRolWNqhZe+pxNDTxEUa604rWuqANYYlnXLqzTy9LBl1IlWWU5thc+JPubvX5d7vAG8Hqy/fo1/tRGcgaywxvLRasXX+x27SaFzVWJAKbrk2efAKJn42voxwJ7E9W6HkhlNVZFzaYo04th3I8/XezRCyMIn2y1PNgc2KVJO7GKJHFJmpwPr6LGisWS8SmTlyppI5cf0IbHuRoas+Wq7wccV4gSXNUtVsaw0T4eR3mS8ZIZQnHwuZzV1chilWNQ1h9jxdL8jCLTOcFa39CnQhYj9gayy39iCnyNPGgrtBn3sbB27RzFlRGn+m4//AX/z7DM+CXeMA5zWDW+fzPhyWDPrLVEqdpSx82ATEfjLF684W8yYaU3nA8+2O3avRj5cnPLtfsOnt2ue7DtejQNBSqJt1OUDlYEB2q1AED5czlk0rkR1DyM6QpMqKifsY+ar3chbizO+3n3Htzdfcb5qmTcOlRR//XRL3cA/fDwjm4xK4FzFTy4eMpvMqGvDZrvn2+0Bh+XHyyVehD6M+JyptWFWuV/jQ/rtRnHlLC1WRemuOixCJuuEVApUxR8++oDPv3vBN+GAD5nGaE4axzoN1NkyFxiVwmshIHgjPDn0nMwaxCSGGNn2iWfbjvNFzU2MPNt23PYD6zwSoVAmXu92x5COYRRMhstpUe6HLOyGiM5gk0VZxZA1r0Lisqp41QfW+w3TqaZ2xW7oxcajjeKD0xajM1mgwvLudMGkciwaxbqPXHcjWhSP2yUiwhA8UQSjNc7cF1xvAhKOIjU5UngoFZjSgkqAKCbTln/5wXv86Sdf8kXaEb2wdI4Hi5YX48AkV5AVBwKDy0QLI8Jf391xvpgw1apkQmwOjC+vuVrUPB33fH174Nm+51nqSPpoha6KhR2iyAO0+0weMw9nE2bOFo3IMCAClpIYeRcTn/c9j1crPnva8+XLnuWqYtoYtNI8uRvRWvh7D2cknVAqYq3id6dLFhcLWpu43Xc82/YYFB/NlmgxDN4TNDhljtSQe/ytQwQw5d8pI0mILqFzRCuDsYZ5PeGfPrzibz7/hr+RLUNOzKzlwazhNnkmnSImQ6+KkUA0QlDCX99tWE0aapXp0sBu4zncCu8tWl70a76+7XjRea6zL/teLvS176f9vWJmgJh5MJ0wtZYgxQc9ZaiOHfhtzHx78Lw7m/N0f8vLzSvmC0tdGwTF821Ea8XyYsZMJ0yKgOaDySmnk5r51HB76Hm17dAJPpjOEREOPhCyYJWmul9/bw75tXDzP2zwI3AcalPXLf/qJ/+MP/nZL/jk8IIxZhZ1xYNpze3Q4UbDYrR0KAabiVbACD9db/kXqykTmxlT4HoT+Wxzx0cnM27DwBc3W553AzcSSIXEwfEeUX4eD9EYZIT3TqYsqlIHPu978gCNcogV7lLi88PA4+mCbw8Dz2+es1hUtLVFieKbTX904plgNYiNkIXfnZ6wmC85mxputgee7Q6kBO/NllSVsBk8SqA25reLwy//Pz6yR5/8z58/oRozH52eoaoKbSGHkTpbLmcVL4cef+RbKYFGK36x2/E72x3OGZbzKT8+PyOmSEiBSltSKn78by2njMcUvs0Q0Ko4smz9SEawWaNSoXZUOB5Ulm/SnpOJxWrFo8mCD0/OODub86+6B5zMZszrFmM1XRr54voln7za8dmLO0xtqJ3haqZZLSr8mNl3gZvDgW4M1NkxMQ3r/oZv+47ztgY0T+59+N8Y8rHjrURQ/1ETR7ygQxkdPus2CANntUM1Dq0h6YDxhmWb2G3LIZd1KdqcKJ7sey7amofzCcu25sF8CkCfSjU/5ogXYVE54tHXd0zpqGeBgylaDgLooNCiaNA0teO272lbi9HCsnJcNBNW8wl/zwdWlSucRq3xJF71Hd9sDjzfHFAOjNYsXMVJ5fAedsB2iPShJAlWleKm79j4kcZZEM3e31Mq3hz+41m2QpkSytUYwwzNd882VBJ4q2kJjUYbSETqGs5xfNIPZcp0jJWwGj7bdbx36FBOcTKt+XC1AoHBe7RWdDkySOJy0uJTJGMYfEZL6Z/uKWFvFQpb8sCoxXBppryIB06sw2jF+WTC24slD6dL/qurkfPKMm8rnNEMKfH1ZsNPn6/5+uUWKrBGcdm0nE9q+pTY47mNgYMIla1YuoaX+z1PU8/clMvM7geOs+/xnwaVVGm8qVSKq9eTTv1au+SoqPju9g4hsqos0RQTgoGMMcKitlyPgaABo1AIKik+2e15uJvwvkw5nTQ8uDglpkzwETDF7jInTmtHzkKkuKIpUSil6E0kIpiksEmjtaLGcuEsr0LPQlcYBydty8P5grPVjD/wPeeuorElOG6UyDf1jm9vdnx9u8NUgtWas6rmfKLZ50wci733kKE1jqmueLLfc516psbhRLPx9yPON4v/qLv/Ggq0NWgNnz97ghkPXLiaXiWU0QxKoIIVluthYFT5OJUvX+tn2y1v3cz4YDXjfN7w9tmSERh8IGvNIUEXhOW0IqSE1BS6WfGQZKSEybms0VlBhko0D13Ld6HnxDmchZO65dF0yVurFX+w2XP5sGXuaow2DAS+O2z42fMtX1xvSkbFccJ0NW/Z+cCawHXX04XIxFScVjVPthueho5Z5Wi0pffjD3ol/04U/PDLZ/16wjOvGj5YnaLjQG8CD1YztLXsYuDp4Hm+77gJQynMUUUMeUw2zQH+x2+e8vHY8fcfXXI6nSJZyCGzcjU/Pl3wXpww0Y4xJRaTlm/3W3zK7Hzg34drUiyuF4cQyMeCLGbYjAEfMhfzhrNFw4dXS7S1fFNXnEwd07pBAXXI/O7FOVfNnM92d1wnT7YKayqCN+z7gUPq+WK7oc/Cu8slB0a2g8cqMFIoTv5+nPjGoHOhL/yqiETML1/v1lku2xnjGMBpTmyNQTPkxKsxsYmBg49Hrr8iIogoKquQLPzN3YG9ZD4wsGoaUiqCoamyXE1aVk1DbRTiIzPX8Cp2hFzEul/udmXNVkKXCl9aKUGp4netYmY5scwbx+NljbWK60rRVKok86EgwmU7xWLZhIFtijglWFv0AX0sXaznhw4vidNJgw+RfQjFXejIl033a/AN4T/krqrjX9oojLEs6gmPFyeMhx3JZS6XcwTFPntejSPPDr7ExxtBHQu2HIVJVZGS8P958pKX/Yzff7BiNWlJOZNyYmZr3l/MeDhpqE1FSolVY3nWD8RUxJI/9VtSgmyFPickcKQ7qiKQjCOnTcNZM+XD5QrnoLKZxcSwautyQfUeO5sze2B4MnRcx5FGG5xVDMnQ+54hJ57uegLC1aJhyIFtilTW4rQudJP79ffmcKTv6F/teBzNCqbW8GhSEw47mMKVaZEkdCnxMoxcdyOb0cORZhOykESYYZEk/LvnN9yceH5fr1jNJ+SUSSlxYhwfzKdctQ21MeQszKzlxTDgRTikxGdpT0hFAN6lRPreq73YHo8MnJqKk7bi/ZOW1sETI0xrw8wVjrUL8G47ZXVmeRFG7vJIhWCMIeTMOHp2PvPtoaOTyNmsKlRaIrW1OAUqZ1K+v3C+SRwHnK+vm78i61QsJw3vX55z2GwZa8+js5YQM7sQuQ6eV4eBdYilQ68oe1wUZqYYFPzxi1fc5J6fuFOW8ynRC8nDyjR8OJ/xsK6Z1KXpNq0Mz1+vwZj4LGyJXtBOsQ+JmIrKTwkMPhOC52TiODlp+PBsRlMLzVRz0lTM6gkiGRcyHzRlD3wZRq5zoFKK1lpCgN4PrIfEV5s9Q8q8tZiwTwM3aURbjTUlkynlH7YH/h0o+I/zk1/5uHGOZVOxaDVdDPQ6klMk+sTt2PHFYcuL0CNamDYVE60ZY2K7GVCquJncdSPfXO/QSbE5BN6ZTEgpcTf0vOp7Nt5TKYtD8d5yxeLsnDFFtoNn6hzPtz1nTc1pWzHGxHU3cDd63mumfHB+Wh6CZP7m5UtmtSPqSAKMMTijcRaqZJiYmpvY83QzcDt27MbE3T5hVGaXRm6HkZVr+GA6ZRDNS2eJIROiMJDw9wTqNwZFfm1KByiUElIqHrEmamZVCaTqux3BZCYJiJnOe67HgU0MYIRaGSwGmzLDmCCpklDrIy/3Iwo4jIkL2xJypAtFKHSIES2aSoQHraZ2E7wIXcwlaXJMTGrDwlSkLBxi4BAzp23Ng2mNtmUG/mx3YGrMsSerUFpjdREMV1GjGwgSue0CO+/pQ6TrBWUyPgudD9TWcNZWpJRptGYQKcJkhPF+Db4Z/CovUwMW3NxiGsO0rli5mrOqZnN7zdYmlhpyShyC59ux5y54koGpctQIY0wMY9EzCbDtPN/pA0ixgXvctqSUOHjPNgbWPqBVpNKaj9ycVdXgs7DzkcYYnh8GFhPDZVUTknA3BDZj4Mq2vH0yxykDCF/drZk1miwZyYUTXhmNrSuMAatm7GLkWT+wGUb6EXbDCxyZA5mND7TGctXWxJSZ1Y5tjoypWCMP+d4W8U1AMoXbnBUq60KrlTLxrLHMleHEGTY+0jWZc2OJEbqQeOYHtimQbMZpg8oljHIcQHQhJ25T4AkHSLDuA1fWkVJmFwK7GNn4gNYag+Lddsq8cqXYCpGZqbgZPavWsmocMQnbIbILmau64dFigjGF5vDt3ZaFM6RjaJO1GkvZA1XMOK3pDonrw8jN4BlGwcfi/NOR2YbIxBgum4aYEvWoGXJZdylnxntbzjeL7xsev/opoa4sZ4sZ756fcnjygt4mznTZKm9S5LvxwC57koW5q4k5M/hAP0SyKplOuz7w3V2Pyms2h8SDqil74DiyT4Wfv06BSmnemS6ZuwqPcAiBGYoXB89i5njQtKQsbLxnM3ouZzXvLOfHIDnFN+sti9aWZo0uydDGGGrnCKOhspphm3nReW6GEd9noldkI/QxsB49U1vxaDrBp8i0cuxDoI+JnkTIP+wM/o0t+AtzS6G+v9cd/ynCoqk5nzVMaghJSky3c2QvxCTcDAOejLaamdJYaxkxZImkETimhO72ga/ClutDx2GxAOCZ73nSddx6j1aKiVK8N53z7vkK0zScNYm353P+ur7l8WTCoBPPDgdSELQoPl4u+MmjCzbDwOfXa37x4pqztkJZsMrSuAnO1hhrjo2SYsfoQ+bFoee7Xce313sWrfn+vK9nBqUSjdI4qyEoghQRX/UDuVv3+M/Br7ZXi44kxfJUJjhWtuGsbvn2sEYcOKURKQK0QwxFqGaEVmmcqCIuzJmUip0dCN0QeZ6F9ejpXXF7WBO5DSP7EJCsqLXibKy4mDTMjGbmhJV1PDv0rNoKUcI2ePYU+7yruuGD1YyDCM8PPU83BxZWM1pDLQZnHa0ro1DRRQBUeVWce3zgeshcq8CkLtHjACdNmUpoVf6cBwnfu2Doe934G4EIKDmaF6hiQ2xnDlsbFrbhvG5Z1RXXudB1amfIUSMB1sETVQKjqZWmAkxS6JxJoThbAOwOga/Dnlf7nsN0BsAdkefjwI33JTDJGD5qZjxezrBWc5ozl5Oan91suJxXKC3cDAGJES2Kd5spv3d5yiFEvlkf+Pxuy2pS9rtaLK11mEahNFiraWpFoywxwM0QeNlFnh5GFtYW+oiCy0ZDA1ZpnNHkWNzQMoK+3wLfDIqD4DEHR3+vJQGYGsepa5i7ijspjj2NNcQMBM8uBqLOZEUxFTi6mhA0SeWiBeH1+tvxat/z4TFAbaMTL8aRtfeI1tQY3nOBh8sGazShgasJfLHbc76oECfc9R5SwqB4u234+GzJLgvfrQ98dbNlWRlSpWmUo3E1M2cwymBEaJSl0poUy8X3WjzXvWda23JJQKGa4tCmdfFDjzEypuKm9nrSeY83h9evsPzKJ+bThquTJY+Wp/ziyTOcqWlcQ1YZ7UuRnBGyhpk22KPSN6dMEjAOyKUO/NrvudkNvH8MsNpS1uDNOJJFaDG8Xdc8XMyxVhPqigd1zd/YHZeLGuN0EYdnISd4r2n5/QcrDjHz9d2OL2/XnDQV0QgzNVDXjqmzWG2QrJjbhnZ3IIfMeghcp5EXu4F25op+5tj0ExGsNlRKk5PgUzrm+/yw1/E3tuB//YTlaAH2erytBC7mM946WbJoKoYk1BPH25dXGNHEF46fr29ZOcc3cSgCo5hwEWa1YReLq0imdFnFlc3o57drAJ70AwP5GPqV6ULif/n2GaYyvHO25KSdQFY8ZmRmLX/+/IbP7rYMY+TRpOWqmXLoRg555OXY8/O7He5O4Rx8V3fMq5razL/3/x+UsPeJzkd8zIhWDEQYM1euIWshxcSrvgfKba9TwsIVf/Wqvj/t3jiUoHQp9HMus8VFU3M5m7Jsaq6tZlIZVq4uIVs7oR16WoRrGck5oTOYLDQWhiwcLVeQVMJeFIpvuhJodZcj4XtnoEwfMr+422G15nLWsqocuTLEFKmd48v9hud9Tx8T86piXjtCzAwUO7FvuyKMNEaxNSPWGJTUwFGIritCzHhJxGO3PqhAl2ClajLFxnPTj4DQxXKxbqyh0prpvWrtzUArMKXgVRqUMRhnUcZwPp3yeLHgdDZh0lZMasPFYoFRmmGjmHcbsIWqECQWwzMNTQNjKGT+nKX45WuQrPlkvQXgJqWjW46QRTH2gX+XbjGV5u3VlNO2Ik0c+5iYVY4/31zz1eZA5xNnbcNF2xBFGCRzEzyf7/eYPVgLL91AU6my7tBYDFGVDlXIRTSulBBIbBEucoMoIabI7Vj0Susx0OVURt/G0Nr7G+ebgCTQqhS6WUlxvsmRrBUn7YSr2ZJFO2VeWVaN4aKaokUx7mAybkEolLIcX8sAqJ1iiHJ02jsmSWvBVPD5pux/twRGiluTSooQPH/ubzHVGY+XU07riiSGAWHSGP56u+bbXc8wJs6c47SqGEahU4EbP/LFoYMD1E5z4wYa49ATjZBJEtC6Ih4tiePRPnnIiRwSK1OTFAwh8aofix1oCAwxgqiy/9n7gv/N4pcsD4V6fXTycLXkw4srLmZnfNNWnKxmPGwXqCR0zjC7uQPgVRjZpg6VFZLBNRrlj0LwY4I5ppjDfL7ZA3CTPINkEsU0oQ+RP312xx9Zw+PVlHnVkBrNgcxJZfmz/R1f7zv6PnHuKh42NSEk+hy5Hkc+2RxQdwdcq7muR4xzXKoJiuKw56xFkiKkTCCTTaHuBp+5oExQex151R1A4K7zHCgX3FZpFvUPK+V/cwt+4LU0+/vGgoAk4XIy453FKatKM5kDtOQhEnIgZY+ri0/vmTjODLRi2I+Z2zyWAzRTfFQRFlXFP3v0FnVdvuP/84vv2MpIUpmXdwMG+PLQ0Tx5jnOGkwcNPibeqhd4lXmrmjDUgZs8YHzZAP7nb5/wsh/YhYiripWnzprb0WOcZTZp2Y8j/+6brzlZrPjkbssmR8RBpRXnWDoyYxTOJw3nTcOkKrSSk6oBAoeUCERm992FN45fGnOWYlhnxePFivfOT5hWitPJlBqNyiV0BslUR3OLWba0rpjEBSsMY3mDk15vYJmJrvhwvqQy5ev/9HpLLxHRme0YSQLrYeSzzR5rLO/aGk/gdNJA0ky1ZaIcWTSMCtNmfr5dsxsTe0kYLdgEBGGnA0ZrJrVjCImvbvbM28zTw0CfE8qULIlJVkQjjAhLa1k0lkld1mBCo3B4BC9Hm7J7/K2jFPmgtEIZhakNuir0sPdW5/zowSUzJzw+mWBMg6CIsQSyTKgRJcxdwgFWSvjgVgEGSGBj6brObcUfXp5SVxlB+J+f3XGQCBrWuzJ1+nbf0z67xWnLj84K/fFiMgEVWamKlQlkHZFBU801f/z0hptxYB882pRmjY6wjpFKV6yqCV2I/PzFDaeTli/3I3sEqcp7pT227bssrJqK09Zx1pbj6pAypJI4nTSkdL/+3gRUhiyli40Udygoy+ed5YyPzhc0leJ8NSWlo04ul4ZajUWUMKkrcgxoXew3vRZ0VDBybKoVfv4fPjpjcmxT/pun1+xzoV3c7QNaFE+GEfdqS+VqPp5MiUQu2gmgOMGyM5a10cSgqLD82ctb1n5knxPaaSQJKijWJGqrOamLBfIvrnectA3fbAcOKSK2cLBtLvt+zMLUOFa2Ynm0g+rNiEmGURV2QeL+DH6TUBpeF/3CawmJ4uOHb/P333uP1dTx+OScidbkkIg5kAi4SiMIU3GEoRBa0UenHa2QWILaSGUC8E8enFNX5YL7//7mJbscECXcbkuw2jeHHvvyFuccv9vM6FLmYjLBpMRJrtjnxCYHYi+YU8effHvNKz+yixFrSx3oomJNoDaKk8rS+cjPn99xsZzw6f7ATkqIoZbys0mGXmfm1nFW15xOKwA2PuCyIaiMMUczox+A3/CCn+/H2SZrzpdTnLHM2hqtLW015eHFlJR6VKy43e2Zmop/enaFaM3/8uQ7Xt1FjCSyBucs81lFTkVkM2Rh4wIv+g1vMeV/ff4ClQJnyqC0pTnV3B5G3nYTZpXl3339jH/92XfMW8d//6MPmdWOf/72u/z+hefpdsfn6zv++NUrNmFEqxKp3BrHqq4Zg+dn6x3/t5/+lNpojCg2PjCxz3g4n+GswYXMBMM7s5ZdTJigcEqxHj2vhp5GK6yzOKMJITCmRL7nT79xKAXaCrZyLMeWjGdZN7R1jVGR88WMwp7I7PuReaj5g+U5hzTyyWbDOBRvalFgnWI6bdinAR0UgczBRXZpZIXm832PUomFBpRBVYbRR04ay8RaPr3b8lev7mgryz++OMeazI9OTnlnltkMA8+Gni/7kT6Ui0JrNEtrmVmFD/CN7/kfn3+H1QaNYvCJaq9ZTeoi0EtlBH/qquK0gUZpwz4Im3EEndDaEU2ZCChgvA+afCNQVqMbjZ0YqnmFbSyXaobpNEupqLXGaHjr4rTQGYzmbu+Z+4Y/urygi4m/fHXN6DNWwCih0YnFSYvRmkFn9uPIIXtuxj1vM+MvNmtcSpxqA6Kpa8NtGHlgayqt+bffveD/9dVTVs7xr95/i7qq+aMHj/iD88SroePzuw0/3W/Y9gFJmblxXEwNE+fIOfPlrud/+Pobqu9KXsV29DiteThrS3BSKMX+pWsYAasK33/nM7d9j9gEtSaQGUPERlD3msk3gkREo8uEqcTS81ZzQkvF1DZlGiiGq9MFKUWMNqz3PQsf+aPTc/qU+bPrV/jeYLMiIYhJzE4bqAxGK3b9QJcyr/qeh6bmr7Y7dMqsjEaMRs8Mh37kop0wbRx/cXPHn7y6ZVVb/purB1Ta8g/OHvDjk8TN6PnmsOfn+46tRGKCGYbz2tLUltwLXx4O/N+//JLKGoxoDmPCVXDZtCjR6CQ4pVjWmoDCYWkag5fMk00gkJAKBiMEAacUSe4nnG8K/0E/U5Wh5/nlHGM102lFiIGu8zw4aVHHNXi99bQY/ujklF4yf31zR58VE6MRDbcx0Jw4lC6UwRgiQcFNGHhoGn56fYtWmQvnSnLuRLP2Iw+rhlnl+HcvX/Gvnz7npKr5b995C2tq/uHlFb9zWpgYX+23/OXtlps4EnJiZg0PJhW1c6iQ+PSu43/49Evq6rgHHgLNxvD2bFocp0Ihsze2FPxVhunM4oHPbg4EPKEyxFAmoznCNv42iHaP/DkRQcjMpjUz52gRTPBo3eJHjxaFU7CaTpnUNW+dZYjwb58+Y1SBPgRiEpIGtEZJpqotC+dY1hXJap4PHZ/e7BADc1M4UjsJKKWwRvNqHNFKMWssl5MaI5bo4fPNmu+2W+72B5QSWiPseoVPQqULh3sfPZuDJykh5kTOGS3F3WSeDPvBE2MiS6bPwnfrgU6XcblRFSlm9nHkqm0A8DHT+YhWUqzp7vFGUQKvivimrQBxWAs5B0KKSM4olTBimdmKamqZt0KINZ9tt4ScOMRi4SUWdFd2MW1KSFKtLVngMGRe7gaSzjRKYVGMOaOOwTJrH0CV9MeVs9hU2lAvhp7rwXPwI5p05CpCJKKzRpKiV5l9KCPRKJmUykg6U7pZwxjJuYQz+Qx30eM1tNpQZVeSqmNk0lgMAkHhj+2W5t4k5c0hFWoFgPhEO9fYJDRWo4HgA0UbnlHGMG9rGltxtZoTYuJnt3fcZI8PiSSZqEoCqasszbQqtKwkZDTXfuTrdU9WmYkqh1EnJTJeAbdD4bPW2nDqLFaEHCLPc+RZ1/PqcCCMHncsDoMWHBmdSyz8NiXEZKJATkU8HIBFNhx8LG5PSjFK5sYHAkLjLE4yIUGXIgujsFkxjLqE1WlBqfsO/5uGOlZes9ZgNUwqRa0gxlJ0uJRR2jBrK2pruZxDHwd+fnvDJie8L6mjJWRrxNaG5aylrSpMTgQRrv3It5uOpIVWGayCQWWsNpgsrMcRYw1T5zhrKpBynm594nk/8urQEVJAk1FZSKp063OCcYxsUwJXLD5TSpjj+2EeHV0MSJbj/gj7IRN1hsbSigIR9jnQWoWh2NAmyRS9+H2H/41CwWu2RxaY1zX1zLKaT5jWLSoFJBuUSeRsmDUN7kxzOV8QUuaT2w1bibwaIilnghKwGq2FdtrSTBwzo0lGc3OIfHnXl4A1NE40A0KtLdYYtkPx5G+d5WxaF6eynNnmyPNDx8vtgSFFrC4skkBJ2U1BCJTUaF1DUJkhS3FbNNBmzS6MpCOdPOVM71Wh0jWaCMQU2YaRiTXUGGJKjGSyEtwP3AN/gwt+KY46v0LryTFzsmiYVA6ly7jx0HtmTV2sDyVTWU1tLSnkYumFMOaMz0V1vx1GnNFEpWhEE3SmHyJ9yowi1FqRBfqQikuKhWvlGVX52s4ofEz88ZNnALwKPX30mJw5qR0zWzNbttwMQ0mU1OWhSxa0CJXWR04kWK1JQej60uUyOKJktiHQVgZrDUopQk7sY2TImetDz26ITGxxJ5ib++CtNw5VKPcKMKKZ1ZZGg0qRGBNDSEysRrRGlGB06SZEJThlyESCHNMms2LvPUZr0lGAkxG8LrZeMUsZN2ZFSDCmjNawN0I0YLTCYEk58+lmB8BaEn1OgDDTipnStE3NLury9VBlDiTlY3N8X4mSMjaMmUHAKE0lxV62F6hQGKu/vySMknFZGH1xEnJW01pLdX/evRkcU8ZfqydTLJ2fs2lNWymQREyRwxiYukL10QjOCLWzJJOolCFJsc6MqVjkpGHE5YTPuZj/aE0fM4myTzqjEClNiy4llBG2OpJ0xupy+Y0i/Nn1BoBewyFGfAy0RjHF0EwNt0fLYitl/ZBzoUsc10tWgrMKlYqVp0FTowr/PwmNUzitUUrhc6LLkUoMqc/shkRlNBNtaO4L/jcKJb8U74vAqra0tiTZppQYxoDR6pfrT0NdWawWrDFkyiUu5eLOkwaPzYYspenRaoOXUhj5DMZpclaEIGU9OtipSE6lseeMYYyZv7ot+99YQRciPkQao6iNoTU1dzoQY0YBkeMFALCqWIFkiq1nFuEwZrQy1EoRjhfMxunvC6kgmTFnXNKEnOh9prGWVtvvGyz3+NuHHG0ujypOXueQPFjMWdQOQ9kDuzEwazVKCRpFZSz15EhxPP7eIaciclXAEDBWk0XR1I66doxkwpgYk6CMImaIvrgxVRWscyDojDUaYzVRMn/56haA0cEhBnwITIzGoZnPWq4HzRhLIy1kYZSMVRqlFYVAKTin8VEYuog+1qU+Z2IWqlrjaoPShd/f54wTQxgChz7SNo6mslgNX/2A1/M3uOA/4rVRShYOh4H67AztDFFnhuQx2oByJdQoCflY2GeVWDQO2RTmtRwdSXyMuLpGBAYf2UaYZU1lNMpoaquQKAwpE1L55q8YUVpRJ30UXyruuuNmozPOKs7qipO65qKe0rY1t93A7TCw8R4vmb2MKAGj1PcknGVTM46eMWbmVYU2JQXTkznTllpZkghjysQMYxJedT0xw+/OT3lnMS9d2Xu8EchrjygFon7pG9UYCzkzek9KGZ9hUlQ/37sIFENCzcQ6UL4I0I5f1edEe7TSlJQZU6IXVWziUFTlWxKyEBMgmSzFDtRmjVKwVoqDLyLGYKQcnNbQ2JoTralry9ZHdj7QpUzU4MWXn0oV0bpSMK0041gOs9YaNMU+MQE1CmsMAgQpI2wfhWEsAsuHTc1Z3RSr0nv87UNTyJxKyvPPmjHk4txApAsdOZT1M6kqQCMSEcmIlNXWOoOiNDHy0Us9xYhzmr7z2KOL2U4lJkajNFRaQ1b4LIQASCbqgLLgMGiVuQmRrw5lD6QSjIHWGmZ1zZmumDSWmxDZDIFuDAQlDKHoC/SRc6oVTCtDSBkfMq2xZW1KImdhoi2V0kiW8mtSYp8U3id8ylw2E64mLfJDCaz3+M+GFGYtnc9UU41IYogeCZkYM6kuqjhEEMmgMhpDe2xaybFpIgp8ylgxHLpiIKANdDZTm1II1dqgBfzRUUoUBJswWRNTQoWAVbAfj2FDbdnTWgwzV7GwlpnTrIbIegjsY8QbMDFBLg2PTJl0TZ3Dh8QwpqNriiKRSQpabakp6y/mTMiZQRRDjqQED5qa8/v9782iHLv8aupWHwIzWyPJc+i35FjOr7lq0Sp+P3DROqN1pnHmGNZbGq0KGI9NumHwpJgwIdM6RX2sN2ttkFyaxSFk0IpeFWe6CkGFyE3v2e6K0FxqhTYwMZqlq5iZmtNZxbKveNWNbMZAMoWhjghWKSJ8vwZ3PhBCZlHZ75s0SQsTa2lsKdNDFkIW+pQZYiBG4Z1qyuV0QvCBP/0BL+dvdMH/+lmrox/w9jCwHzzbdsDYiNKJRTtDxJKzP7pZFAcKY+DRouUX1xsqo7Cq+JAThMvFlEm23O57dv3ITVa8PW2ZWIeVTCCRtOAqU26FKmKjJgchByFm4cFkAgK3eaSXRK/garbkreWMuq65Wii+Wa/5cn1LFuGVlMUmR3eC2hg+XC742foagxCPJpxeCckW9fgQFfsU8TGic7FNrDBMW8Xj1ZK35ye8Ohx+rc/otxlZl9Q7pY6NVgXiFH2E264neI8VQ1NXCGAkoLUiY8gpIzhO2prv+h57jDmNWiAb5nWF0YpDH+l9YJcVJ02Jg6+OHfWsEtYIQYPXGZX1ceycyFl9r8yPOuJV8ZNetRXnrqWpYRXgRTfyou9ptaaTeJyMKkTAasVpW/OUHlQmH28lYuR7EVCihHCNKZFFGIuGk9YaLquGi6blzodfw9P5LwC5OEmQSiigQtgNI3tb82J3x+gPOHFMbVXWnYTCNRAhFz9BzhYWs1E4o7CUiU9OhvNJCajpx0TvI7sUmE4nNNridNGWRJ2xRuFFEdUxWVygQ3iVI5dVoRhu1MhBCpXsQd3w9rKlqRxvRcU3256v6Jgqxf6QyDlSHNcyVmuuqoZv+kPRb5b/U9yBXNn7c4YuZoYkpAyHFHFWMak1b82mPJ5NWff9r+kB/XajUGmPHwPaCJvgWY+Wlz340FNHQ20cSSsy8WjRq5AUEDRns5ovt3tc1phc9jUV4WTWIK/X3xDZOM2DSUNjNZUU2+mkwVhFyIJSR+OOWKZVd0pxWrcgsJWBPhfx4qmteDBvmDrDgwa+O/R823VMjWG38+RcxMc5gxXN+aTmydihMiQpSb4IUIEkg9gy0ffH/e+QIk5pbK24nLRcTWbc+XsR05uGet2n18J63bPddDxpXtH3e2pVM61rtG7JaY8xlOZbKqOBx8sp3+17tNY0SpGO06TVpCXFRD8Etrse5TJvzSdUVlNRdEKiiu3vmARpi2FHjNDlyCuEk+Ma3OtALwmH4mTS8v58ia2Lm1WtD0TZo4zisA9sJMCR0m1Fc1HV7MSXNXh8x2UFypU920XDqMqlBoFu8CiraFvD4+WMd+crbrsftgf+xhb8yhSpchYhHUMF3jmbM6sscUjso1BFWMsdbpHZh4FdHDBa8aCZo9H8k/fe53qb2A8DfYp803cEA7XSvP/ohGbv+G67JRrF77x9xf/1w7f5q8++YBh7uhj5+U2HFs3nfo+BklJpLD85O+UffPAB4+iRFJhXjnld4WPgi1d3XExaFI5X+wNf3q7RwD++umB+uGPtAzmBEcPLV3tiAyGASKIWy9QVPuFOInPKOHwQWIeRde95eznFS+JPnnzDn6Rv8P6+u/CmoHPGHEfZWQvGalosdaXYBU83Co0xrFLCVI59yvQhIghzV6hWH13O2XnPUJdRYbF2E0yCt1Ytt63nehiIOvP++Tn/3fmMz5/eEUaPT5mvDwMIPGdEp9IabbTm0XTCjx6syCnjfaS1mqmzCPBs2zFNxXbq4D23/YAC3ps2OF9s5RDBJM3NPpJrTc6ZUaBSmlYphpTocmKGkHVJYB1TYMiJk6ZCsvDJbssnm03pgNzjbx2SM0J5NvTgKscllhbFi5uOG/asasOFnVEvHH0yDCFglGLZtBiEf/z2I/aHxK4b6VLi6dATbCmmf/TojNtx4MXhQDbw44cr/k/n7/OX377i4EeGnPlyO5BE8TIP3/9MU2P4eD7nHzy6ImWD9wMTB/NakwW+WHdcFLIY6zDyZL+lAj6YtlR95jYGMhormpu7Mv2KlD3Qak1tLGMM3IWRFSWlOpMYJaKTpmktOSv+/O6GP7++Id7fN98IXqfaK5VRKgOGSwx1gme3HS/JnFnDSrVczi1Ps+IQEloyp1WZDP7h1Tnb3cjBeYaU+P+y92c/m27neSf2W+PzPO/0DTXXnkmKg0TJkqI25XbsTqsNuB0kCGJ3EASdsxzaJ/aZz6wj/RWGfWQENoLuIHAbDSjphhy3ZNm0LImkOGzuucZvesdnWNOdg/XWphsNB5sAi6TIuoFNbO6qXfXVfte3hvu+rt/1dBgJxy7rlx7c4WqaeHbowWi++OCE//P9X+BPPnjKMAbGXHh3P5Fz4ZqIQYMUZlrzhdmMv/D2fXKGYZhoDcydJqbM99cD9xYN2lpucuST/oBD8eXFnI9Gw1WKx8sWXG6G+ki2kErBKUNjDaMUtgTOUeijpnrKBZLCLxVjzPzx+pJvXt9QplcTppdZ6vgGE1XP4VPfkUPhow+ueKLgbN7y2sk5drXnEBN9KBhRnDqHzpn/9M2H3OwjuykwlcKzYWRKNUTuKw9vc9n3PNntyQa+8HDF//U/+xX+6Lsf0g89Q8782aanCFzEUIlBAnNt+NJyxa9//nXIcLM90GpYNQ6F5YP1hju5Q4ywKRMfH/Z0xvArt5d8sB94PozEUuWNF1cjqoCYwlTAG0NrLX1K3KSAsQ6tFTFnhhQhwrJ17EPm9z7+GMsnyGcEF/zUXvhFV70dBUQplIVnm4Gkr+hay7KxJGZ8+bU3OD9ZwHWmUQpjDNo4csp87+OnfPvykk0IOGPolAcJfPx8wwfXG1KGnIXOGvL5yH67592bLfthrEEGkvhwCPijTH7lG05NQynw9OlT3r/e8Bdev4OfeTYh8K3nT3l3fcOD3ZxbTYfXhV+6c0qnPKezGbfPVvzeo4+5GAa0Fq7HQGsMCYVGmCvFufb0yjCGxGAjoqtO0idF0cJffXCfZ4ctHx0OHEpi/opB/WMoReV5wfvXG2ZO4UXToFk5x2u3O1Yzy+EQ0ccRtjGalDLP1gOPdwOHlKpGnjrSXu8HLsNAFsgFvMkcupHeGp5ue/YpIlpIurAZ8qepkY0xzK1FRLHdJp4etry+nOGcZcyFj7c9T6Y9HQ0n2qG04sHJHK+ooV3i+PbNlk2owWB9LDRA0dX42YqhNR6Xp6ppDBmlFDkLuig08MVbJ8RQmcBDyJhXkIqXVkc1Y6VABc3Tcc84DWgUjdVEOt5atZyed+RNQhuLOa6/nDIfPbrme9dbdiFiVV23pMyzXc/zcaLk2shotCa1I2u/58Pdnn2YcErRGM0nw1h9JUpYGseZ9QiWm77n483I5887usYzifDtyy3f7wfO+55brkUJvLOa0xbDva7htZM5v391zfOp5jMfQsTpFwdRYaYMK+04KBizMB0nn7kUbKzSkN+8dcYhJD7eH9iVhP+sqTOv6ocqfeyrVg9d1U4/LxNTyHgN7bH7+NqJZrlakA4DVgtKmRr6ECLfe7Llvc2ewxQxKIxoVCqsNxN/OD0l54pH9Fozzidumh0f7UZ2U6gxFLpwNR2xnrowM4albUjacbEdeHKz5a2zObb17Erm3asd7/cHnoeGs1mLVoq3Fws6I9w1c+4uZvzr6xuu4kSmavdbNOYI12yVZmUcQ870AsNRZxBLxcpq4JdPzhhj5mk/0oeEda/W38sqpf6D7v7RA/Jss2GUicYb5s4SdOQrb9zlbLWA7Z5GZYwyWO0IIfLtT654b7NhN6UqYVSKHISrmwN/0A/VeJuFxhjSaaG/XPPResturOGrHnjcTygLFMVCGc61B9HkSXh2veak8Sy8YyqJb1xe8P2p527fcLud4dH84tmSxhte7+Y8PF3we4+e83wcEWo6r1cKJ3WC2mrN0no6FFMuBFWqjy4LegJQ/PrZKWMWPtoe2IWA+4xZED+1F/4Xs8RPh4pHc00pmXvdirO2xrKfnywRKRhTs+cLMOWExIRCMXeWXa50k7nXjFFxp3gOpdDnwpQK5mjr8bp2ZnUqiBQ2BGZac940zBuPyooUhJt+5LLfs50mzIXitWlEG8W7+w37lBhIZFNYtPWiX/GHdez31mrFG7MZMWZ+L13yoOkYcuKQMgvvOW1axtQzax2bFMgC3iiWi4ZI4evPntFqQ8xV25j0q+7Cy6osBY1CK43WYNDkoZClMHOGFk1JhfmipUg1zVZ8XZXCFECljNeKgxaKyhhxiC20xRCjqi57+VSoWDFg1uCPZKpDyTitmFuHtwZFlYSNsfDBbksfJ5RS9KWmVz4dRw4JrM4UZZkry8pqxBRyrJOy27OWU++IufC9YeRMWwapJqHWauZOk5NCW1vD4KhG5KX3lFL4ZL3HK2GKhSxVD/uqXk6JCJR60VW6HlTZCWeto7EGEeHWSYtEQeuCUQVEM2ZB5YlShM5qdlnIwEJZklGcoQlBGI/aZIUiSMFoobOOXKpReB8S3tb1N3MWK9VkO4TEn12sWY8BVGQXOkDz4SEwpMRYIKrMzFYamhaIR63zg1nLqbPEXPhW7rnrPWOGkIW5qc2cqWSWWrHJqabpapjP6v7+7fWeVjRjKEiR+rW+qpdS6j/436PDB4OwtJ5Wa5QWVqsOkSrVekHzSaVUGlQptE5zyFXO2ipLMkJTHGESJqnUnBcJvlZpOmNI1iBk9rn6Q5bO0jmLleqj68PEd65HNv1EUpnzqUOU4uMwMubMLiTmOrF0jlU7o6jCVOo94MHCcydZchb+VA7ctg1jiUxSm39z6xgzzIHdmD9df7OZw2rNh7sepypUAWV+cEd5VS+lipRjQNtREm0EjHB33rGwFqUUt06WSIkoOSYfKyGr6t1wRjHzhr5kEGi1Ic8Up9kSp8IopRLngEBGKeoeaEqdfOcMWjh1Dc5pOjF40exi4N89e8quHzn3jltjQ9Ga9w4D+xhZeUO0kZVvOG9aRKR+DcAbq44HM09KhX9bdtyzHX2OBISFs5w4y6FEZjh2Q80QUAramSUB7673dMYSUv0zyWd8c/70XvhzHd+gqpNfKV1TyGImx0zbKe4tWhqrmLY7VAo4ZZhy4WbfY7LieuyxGJwYEsJYowNx2uAKuEKNbge+e73l4dme213HHe9rnHLTUtY7FsbRKcuy8xQvvHu9ZpMnSipc7ntKqlFE20Ng1jn2ORGVICh0Ucw7z6zpyDmwzpGh1BRUg2ZbEq1V3GtmNNowSaGYOrZKk1STkgLvDPe7Bafe0xbFtC8MuaA/6yf9qn7oUiiUrhx6g8VoR3ERZ2tqbWsUy8bRGUsMQ314KkMu0E8TOWVuwoQqVfuXqR17TTX4mFxNuIKgCjzfD9xrPKeN58w7ShFa47hUE42xeFMPQ4rw7DAxSEVp7qZAKgWUYj9EXHN0+ZuK/NIKvHEoa0gJmlzHmUnqQdariv6cW4/TVWcrRjPzFomRlOuPe2tYNh0d0FDTdqPkoxPpVf3IS1UTt6ZqOUuqSDnrHFYp5lZza+aZect4GOoeqDUhZ7aHiCqJyzChs8ZlQ1ZCMHVPtUqTpWBF1wmqwMf7ntf2LXe85bYzFAWrWNDDyEwZvK3TJQp8sus5xCo7u9hPjLEgSrEZIvPWVKP4MZXaolk21YqecmCWPaUoSkmVEERFip55z8waRIG2hrnxhDgSckZpaJypATTO4KXKKqYor5bfy6oX56/SGKUxyiBSaFE0SjN3hpPOMPOW2I+oHD+9CG+HCcnCOo402tAqW0llBjQGYxRGFFbq56eN4pPDxMM+cKd13Go0WWAZMnoYmCtLa36w/p7sB/ZTJKTCRT/Rx4Kg2IdE5x2hlKqD1pX05L3DakgpMkuJvkAsdS8+qJphcWIcrbZkathTpx1TFGLJNSVYK5aN5dQ4DJByJJZXOTgvs0RqaJ+oH1xqY65gFqMUq8ZxZ94w84b9ZoeUugZTEW4OFapxPU0oavZRKsKoCiKCsnx6Npv6m/HRZs/nT+fcX7Qwa0hJaPoGDnuWxmOt4tQ1WNF8sNnyfBqJKbGzhqt+AKXZxciiMYylHBsn4FT9PsEbcoqsp8CQpQZnKdiriHWwwOLQTKWgHczxjKoQYjUjO6+ZG8uDpqNRiilmQpHPzIn6qb3wV9JE3XCMN1AghEI/Rq4PPQ+XDW+fzUAmchyPBDvFMI58+OyKuXFcD1WD740jSWSXIogiunrZAY760MK3rnbcnl3zlbunrLytl60280k/VkwTmVuNYebqxvM0FGyGfkyUUI6zd1idNIxjZJTMPgRiSvjGcLZYEqNiWGeejCP7KSBZeF4m3pzPWDWV2nIz1mnBzFvQDaZUo1Avwt12xi/fv8121/N4GiBE3KvQj5dWSimU0WhjMDiUctDUl2JUgvOK104b3PHya3Tl+owhc7k9IAI3MSKlXuwLhSClmnOcrqmUqOqzVIUn+4GVc7y5mjF3mlLAW88hFUIuaFXw1uGN5kqNhFjQCGNIxJiP8o/C3FqGWKc/I5mSM8ZYlq0jCqQyskuZISWkCBsyJ9binaEUoY8RZQyNsxQtqCyfduzOWs9r3hNiZJMyh/xiQvaqfuSlNKh64TeiSDGDrgfekDK3Z463T2doBblkjAIlwjQGPrnZ0RjF1TRBVjRiGcn0L7IWbCHrglTsM4Lw/r7nznXLF0465t5StGaZYR0L5ELO0HlDazVPRTHEijzcjZExpiMqWbH0HTdDIJTMkCCJMHcNy64lRiEfRra5sM8FimKdEqfHDq5Sij4njKmXtKXOSDliGxXc9g2/dLJgPwWuhsiOzKsd8CXV8cJslMZpCyLEUsi5IjZb53h91WKVYkoFqysSsY+BJzc7LIrrOOExdNqRdGKUAmLIvoIpVKlrW2nFR/uRO77nnRPPzDZk0Sx8YZsyJYCUmlvireI5I2Osl6lDyIxHL5tSitXCc5gCRcMkmZIrHnnRdEQFkYGblNjHjOTCjSqcWU9jLEpURdEqcFYzkyqZLSJIVsyV5kurJYeQ2MbCIb7K2X2ZJeUHdKcjBIqUCyFk9inwmm/5wp0F+ogoVkqwWnGYAh9d3tCI4XIaEVFoZSiS6Y9p5LSKpIVSG/iICO+t9zyctXzl7inLxhGT4H3LTUyUIpAVs8YyM7aGpw4TlMKoIhul0FqjvOW89ezGTCrCEOo523rNWbukhJHvF+H5FOljRFLhskzc61psqdKdPkdsU/1Mc22ZmYqLTQrOneOrt87op4mrENjGhP6MNrqf8gt/7fSYxpCnjBRY95GTecQ0cO+8JcUB/BLTaMZ+4Mmm598/vuLuvMU1Gu8M88ZSsnDYBSiKg0uMuZBiDbVRTrgJkX//5ILP3TlD+4YxZm5iYJ8iF+PAbetrGEg74/Mnp3z/sMeJZphKDU5oLGdzx9J6zjrHNE6MTGhtuEwj76QCFB7t93y029OHRB8iXmlWS8dmmDjkaiY60x2lFO62joeLJc/6kT+9vEZy5u5qxdN+Rzp2Za15peF/WVV0xfMoI2itgELRhZsQMN7SNQ0PFo6cJ4zp8C4zhcDNNPDedkvrWrQyWFuq/KIoxiERgaYUQhHysduutLDLiffWAw+WHcoYEoWRTMiKi2FgZS22KJbGcbvpeDYGHDBRcFrhjWbRGhbe4YEcEvvjn2UTEw/iDANspsjzKTDmREz1wuSNow8TsdQwmaX2qAQrY7jVeXYx8sl+JI6BuydnvJ+3ZBRa6qj/Vf3oS3iRNKnICWJJYBSP9nuwCz7feV67PaOkhGtblFaM/cjFYeRblxseLBo0Guc0jTX18BkiShRic33EpXqoYhVTyHzjestbpwusbxlF2IWJfQpcHUbm1uCycMe3vD2b86Qf0KqiWkWgc4rTrh6G2hZiCNwAymgOMfFQIhq4HCceDSOHnIg5QYbOarYhEI/yiKVxlBJZOc39pmMTM+/vexTCg9WC71xcHycVlc3+ql5OVUrZC9xw7SZ+PPaYxvC5bsbDhWfYhWMHvWEcJy4PI9+53HA+a9DK4Bw4I5hYmPqaxyBHDn+FNlV56qEUvnG158HyFgvjiBnGkhhD5nk/sXAGpHDqPPfmLc/ChBIhRCr73xoWM8PCGZrsiSGyUQGlNJuckSgYIlch8iRMDOHF+tM0yrAd6vmrpVRJR8rMreJe09HnwidDwBfN3XbJ+2lb5SNSUK/2v5daL9J2pRyVXwJXmwE/c0inuX9rTh4HjG9RThGmyOPdjj9+suZu06E7hfYarw05CP0hUXL99XKpxCapA3I2MfL1pze8c3bGsjGMRA6SGULm6XigUxaT4X7b8vZywaPx8AN6nqkZUF3nWPiGpiTKlNgQ2RjFOo+8oxUthYsw8mjo6af8KXjFa8OupCqtVIqValC+sFSa15bzej/o96wwPFgu+U6YKErQSrCfUenx03vhz0cZfxZ0rjxyVeHm/PVf/AX++ldfZ9ZGtjsNprDejYShp58G+pjYhMTD5RKbAreUYxk1z5VgjeaSykRtW40tikBBKyGuDH4OxQgfXO35f33vXYZUO2c2Gd468dy+tSQX4ZeHU7yYSigxcLJo+cU756QizP2MZ5sN63FgkyLPDwce3ewIJnMx1U2l0ZrRanRSfDIccN6wbD0L49j3hXvO8NXzU+6drHg7F946PWE56/DNgrdv3eX5kNhNV1xvXyHpXlYZU5n3koWYIiJS+c0588v37vLr90+Ym8hmW39+PxTGUI1g+ykBiZOFJaRqVvMoRBeaohhMxQ9aRfWGULtdyRdsU9f61SHwB4+uqjSCwkEy5x0slzWZ90H0dGKZKGSEmbO8czIDLMbD5kibGkS4CiOX48SI0OdwlHO8wIQqdjFinaKxhlY7itI4p3jQddzqZkQRzucTM9uA99zvFjzrJ67HwCG+Gmu/jFKK40NTKFJTaovWoOEvf+EB//nn7rI0meudxqTCfpzqXyHRT5lrEzldNNg2MwdsVJSh4j331GwG68GU6jkxSjMuwM81OHi06fndj54wxBrQZkSwC8PpSUMW4Y2hozWV1y/AsvV88WxZv/gONvuBfYgccubZuOfZfmBtJraTEEWwFKKuYXSbEsFoZsay0JYxK0614vPzGffnc0KB17oFJ53BNpbXb634eApchMQuv1p/L6M0oI+NpXopF0wLFOGrD8/42oNT5mYiHArZarZ9oB8C2ymxmRJWGxYLzzQlnIIzbel0Nf9euZot4a3BHBGIFEVYQjd3aGN4fOj5/3zyiBAF70wlmFjH7UVHEeFBmPC64qoLwqLx/MJx/dlOcz2MjJKJGq5i5OsXl/Q6sguZnAWDIh7lbBsixipm2jKnJSVh5uCtbsHdeUsA7oXMiW1oGsd9NeNR33M5haqjflUvpQpSpY3HSVPF+ta74V//4uf467/0OksbudoCfWE7jMQhcugj2yEzM5GFbXElslSaxjmKK+BrWFbWgjNHZKyua7CfCWomJAcfbwb+u+9+yBgy1lfDb9sZbt9uyUV4Y1zQqjp1AM2ybfiFOyvAslponh16DiEx5MyTceLy0XO2eWQdMjnXhkXyIEFxUwJipAYKGgcGGqv53GLFw5MVMQtv7JcsW0/bNLx+tuKDoefZMDLIZ1uDP7UXfm002ijuL5b8J2+8w3/5q/8Jjx8/I0xbyCN//I1nLBrH6mRJSolOG7T2zJoZd88XNEXxFx8+YBcjf/zkGRf7HtcZtiXz5cUZKVb++YGMaeEke5bW8C+//YSUhO001RTBnPBWs2HiuhwQv+Cr9+5zsd7y0f7AloBDk8PEv3n8nJshcO+kRUVIJTNJRmN4nA/EUPWANQQHGqc5uIIXwQiQq1FOG8V1CYwJxlRoW8eb/oT+MJLzwGu3z/jc7kAeA4+Bb3Hzk/64fibLWA1JsVKeLyxv8RvvvM7jiz0SDsR+5JvvbphbR9sakKoDNVrhjGHVdRjgy90ZY5d4f3vgyWHEesOYM6/ZhpRhUplgM0lDg6Yzlm882SIZ+piJJdUHqVYUU+h1xjfwzsmCvs9cxoFDrjjDoITvbXbELKy0J+pSef5S8AgXKZCzJlHlOXIM+opGsIB+kU6namjJUH5gml8ay8Ir+iK0wOn5jJ0EnFZc7vuf4Kf0M1xZULnwYHXKX3z9bX7rL3yRD9+/Ik0Hcj/wR396TdsYzuYOpMEYwUD1l3RV6PJrt28x5cg3Lte8P/a0c8uexJf8CSFm+lwYdSE5oS2OE+P41x+tKSWzTZEpZyLV8JvJrBmgbfny+RmXU+TisOcQCt5ogkT+5OKSIcC81dW3IoVERhvhw9CTcz0cy7Gra7Vi0kJE8KWgyIgonLEMx9UXC8ydZeEM0xEBe2+15Mv9RFOEJ/uBP/uJfUg/u2WwGDHc7Wb8yt37/KW3P8977z4jTRvCxci/fv6MmTOsWg8cpy2lon3b1pHR/OrqnH4hfHuz4ZP+QJlp9inzC+2CKEJIQkCYnNBGwwLNH350RcyFTYiEKESgkEmqsNMjpmv44umKmzRxcZgIWuOsJhvFN6+3jLmw8nX9v4AomAJXOpJiJsRMPq4/5xUBSCqjkiJqYTSFzjWMCMloglK01vDQeXICawqvn69Yp0qDud4PfPsn9zH9bJeq/raHZ6f85i9+if/t1/4i3/3GdwlhS44TX//jZyy8Zz6ziFSkpeiMdZr50hO18Bvn94gngW9c3vC97R7bGQ5T4m0/I8QadBoRJl9wVALP//Cdp/Q5swmBKWWSEqLJJIQbJpRf8tW7d7neBD457NgjeAuDyvzpxQ1TLJzPWrSp8I1EPYM/jj1jzMRQ6hpEoY0hL6rcd+4NThtEKTrrmUxCTE02n3nL26eLOpU38Pk7d7g5ROwEz/OBDz/Df86f2gv/ctZy/2TGl2/f5dcePkDCgVYP+Max3fbs04TSQhdz1fCNQ700i2JuHKiCdZbbjefNk1PGkHnW93ileft8VdOVQ2EbIhsm3jQt+xB4MkzkBKlUPbbLdcNIUhimSD8WCh0PVgtiKVwOPbkoWq15liZu4sT55HiBGXIYvK54Ja8VTTE4rSlG8XyaSEqYVCFPkRAygzXM3YwxKE5OamrvEBOPN1u+fXHN/7pxvOU7bs/nbBY9l7tXl62XVU5pTnzLw3bO64uWeBjxeSIXYZwKOSVMK1jryVkzylTlEWJwxqIQlDXMjOV0VjiUwmaaUEVxq+sqaqsUxpI5SOa2dvRk9iGSc9XLHpOykFRDOcZQOEyKRMd5N5CJbIdAUQXjakL0kDNuVhNWq/FTo8UwMeGoa9AohWhYS67ZTqowlRrwlEth0TVk4GTW0jhLiIXrYeLxuMcbw/2mY9k4TjrPpp9+sh/Uz2i1TnF3MeNL5yt+4WzBtBlo1Ugyhs0hE+NIEcuscxADfShI0Xg8K9eASNWAesfDReQQE8+HERsVD846QJFioY+JtSTum4ZBVU1+zHU9yDH8q1AIKPYhsx8KFM+dpoMcuBwOxFRQ2bCPkUOMvGlbUIoqZASNZsyFRitaURitQdeuVrZCUJmcFIlMtJkTpYkFTrs5i8aTSuZqGHh3feAvWOHh2ZLTruPWLHH5av29lJo1hvOZ5635jNdty+HqGpN6pAhhCIQYkNax8J4YYTzy7ZV2nDQtFMFay7kz3CuBXiLrEPHFcPtkVsORkjAmYSuJ2zPNGBM3UyKmQsxVwqGP+1/UdXK6nzKC507TksXw/npPKgklhj4WDinQ6gatamgiRh2lZ0f5olJYXae3V6VO+4tkpggRRbbCrG0oRXG3a5g7TyjCdZh4PEz4xnK/8Zw3jsOs4TC+Ct56WeW15s6q4yv3z/nK3TPG3TWNiWhrWR/29DFQukzj5+RcOARBiWCxnLkGTcFaofMd9+eJbcw8CXuKNTyYL0BUPc9zZiuZN5uWfQo8nSYOKRHz0eBbQCaICIc+se8zlIa7845BIpdXO0KqP29Mwq5EltZhHRRVk+tbreljworCF4XVBuUU1zmCrWGY45QJFBovrFxDLpo78yXLxhFy5vkw8N56w687w9x77i7nbMeJ7fDZ1uBP7YX/y7du88bZkjdOTlk4y83NNZbIkIQQIlIKFnVMbFRs9wPhaFx8a7niYuhZ95HWarRSLDvPpDJ+qiMToxReWRptMVHxtK+jl5sYaZXBaEhJjqa5YzBRKGz3E5eXW+becbub8aAbGFPEILRYKCMag1BQpaAk40UIudSRlIBStaOvFBitKqVFFE4pPDXSOQNN02CsY7Mf+P71mg8PO35tHLnYbNBaMZ+1NC9CAl7Vj7zuuY5bbcct12Cy4mqzxZBJqZKiSqn4ADl+poc+Eo+u/AdtxzoE9ilXY7VStM6SyWiBxtpqGC+CEw1FsRlSTW1OpapCpWLIUGCoesOYMocxcrMdaKxlaRpObGKSjBJoMOylHn6o+mitClNFyqCPX5+CTwlPqsI+QRTmBRHmiDpsrMcpzS4Fng0Dl9PELow0B1AIrTPYz8gAflU/XH3x1hmvrRY8nC+xuXD5/JrGTBVhGSMlZay4T/EV20Ml2gjC28sZV0PgEBONOBSGzjlOpOCk0Pqa9Cym+ktKNFwNgVGgT5XZDzXp9tiHQgRiEnZD5OKmZ6EVybbcbhPDUdbVaMO6BOxxUqReXNikohq90lW+JgpTFC+AtEUELfVhYKn5KBnw3mKsYj1EPuwPPJp63gkL2sOARjPzFVf7qn709UY343bbcls1yBB4tu1xVN/PGFKl0zUOkTp12Q0j49Hc/85ywcU00udMo6vxfOZqfLIrVX6ojx4przIpFW6GiSEV9jljyn8QuMTRWF7q+tsOmcv1xEw7Tgyc+IpxVVJzSrap1GklR6wtGVH139XUQboGXsQ3qBc/r1R6lUOT83H/8w6vLbs08WwauZwCuxCwB13/TN5VqMirein1+btnPDhf8cbZKY0oLp4+Q0sgpcA0RnJKqK42qYoI60NPytX/+YWTFc/HgT5kvDOIUcwbyx3dshdh7jxHgidTLpQ4sZ0imxjY5yodclpx4LgGs6IoYYqZzSHw/GrLovHcCjNutRVHrKRmOVyngjUafcQqqyKIVPmjKcdUceHTda6OpuGUFa2uFKwXa7BtPd5oNuPIJ4cdH409XxhGLnY7tBEWc49vP9sa/Km98H/1/C7n846lb5Ei7HcHbi8UKUxITsdERkfOBQOMY+DZfmDuHV88P2MTRy42PVkyN3FkkMKi81gK62msmEHRqKJQWfjWdoNW9aLTeI0zBq8NSVcEFKI4hMST9Z5ZfMKb91as2hnvLCOX44F9TJxZz8041EueAlKipFjjkkVIRZik4HKhFX00nGmotFA6YzhxnnAkCA0loYLi6tDzyX7HUBJTCHxyfclqscA7y7JrfpIf0890PXQdK9PQiiVPwm4aOGkVMeXK6D9iE8vxwBtDZh8DM2u433XsUmQzVFrELkeC1MuV8oohpyNy8cU3v/DxONRv/gKdsThVL99Z1TWoVN2YboaRx2XD/eWcmfXc6QqbNBFyxhvDNmlSPqK6pCC5dvGl1ItVREiicKXqIjU/eAQ4XdGfclyDUwGTM/tp4jpMTEkYc+T5PjFrPFZD614deC+jvnLrNne6js448pTYHUbunCimUMg51aaFMchR5jKEkfUYmDnDG8s5hxi5OYxkIk+GiUMqzLxFZ+hzpUXZAhlFUfDe4VA770pYWYvXGqcMWSJK1QvUlAqXh5EP0pq3Vh0r0/LGTLiaJg4x0im4oiLpLIZcKsGqUDtvuQhBhCTgqBd8XeojRYui0YruP2CbD5KwqXAzTTzuqyZ7ypmn256VbzBK0bmf2mPsz3W95ecsVUOTIaXKvL8910whEXPGonBaMcV6ORrCxE2MdM7xxmzOJgduDhOiA5chMOVC5y0qC1NK1aOSFSkXYk58sD+gqI2Kha77X6M1kxz3PzQhwfUh8HHe8dpyxlI77s0a1qEiYhttWSddL1ZKU8jklCrBrAgZxVQqDtGJwhybLpIr5c8rzUyb+tIFBgq6ZHYxcjUFplQYSmLc71naBq0NbfNq/b2s+srDu5wv5py0c0os7LZ7TloI40QOCaOgVYp4XIP9NLIZAwvv+dxqyVWcuNoFkkk8n3oOJbGwDmWhL6meeWiKFGJJfLAfiFLISlgZizOG3mjC0Wv04gx+vu/5oFzy9p1TTn3HG4vA5TgypUyjLReTIqiClZqdkmIiUy/5pUBQQqbgssKYSqAqBbQIVr/Abx/XoGR8KmzGkSeHA31ODDHw4c2a1bzFWkXbfbY1+FO7Us+aWe0kxMTp3BByZhqr9KWzhtYbtFbsd8NRcqPZpUQoiXFqGNNE7IX3dnsu84jycH8xowG+ub9GRJgVg881tCg3VU+qxoI3sPKOhiWP84FtqUm9F+PIbpg4HAbevH/CovPkPGOSzFQGfCk4bfmTzQW3TIPKhTHWUUvb1LCsIIUIIEKnLbFUSstIoleaU1O4bTwCvHtxwUzBs/2BQ47orBjGxKaMZIRl0/JwPv8Jfko/2zXLltxX7d6sU+hSiJPQpwhK1fWiCv1U8Zr5iEtMUlg2hl4mwk64zAM3kigazp3FoPlwmKrkgor3OuRIcoI3BT0pnK6XflNgkwMDGWM1u5wZ9z1hzLw27+haywmeNFXjrlJgouKTcc+JM5RSGGI98IwTiIokQtJVw9oWi+hELoqohKAz2Rjm2iDAo92WDlhPgUOuE7QUM9uYWAGtsZxZ/5P8mH5m69zOKVFIkpnPKhf/0E/0h3r5abxCG2EYqqwv58IhFnKB1ES2eSSvhQ/HkcdjT9aZ+8sGj+Xd3TUCdMWCKK5kIjeC1aBSffgttMcYw2XM9JKx1rCJkT5kRpd5+2RGN3OcqzrBDCmhsuCV8L2p5449NmtS3QO91nX9UPMbkhK81lX2UyCSmRTMMJwdH5GPNnuWWnM5TBymAsWSY+Y6R1IptEZz1ryacr6MmiVPTolshHZm2ZfMoZ/Y9RmN0DUGbTTbYQQqf7+PQiqRwY7sx4kwBB6lxEWcECPcP2mwGL632SJU35IU4SZFigWrCypJzZkwlkYprmJkoGCsZl8yHxx6plB4feVZdS1ZVWTihogRaHXDJ2HgzFpyKuyP+5+zhlzqPhmLkHWdSIkkcqoG0aRqo2Rm6/Tpo/2eFZr1mDhMGVH1wdDHQMoVTXru25/o5/SzXA/mt8glISnR2IrF7PuBsY8YrZl5TaM0+6HK+qQIh5zJIdBPA+vQM9xMfBwCT1OPmMKDxYxZ0fzZtgeEOTXb4XmaCMdMBqJgjWJlLW0z41kc2atMYw3blPjuzY40Jt44X7GYW+6VGYhwJVNNLjeW7+w23PYNYUrcHEYE8F2FLkQyUwEnuqafq0JKhaIhm4IoaKhr8JOrK26s5lk/sh4ziGJIkafDyJ1YmDeWW81nO4N/ai/8y9WMbz99wvfff856GNlJ4EvNipPVjHtNw2zQXFwdaBoH3nJ+0jHYws2h55s3e7xr+JeXTxCtOYRIGgt9itw663AF0l64DBNDyWir+IXTU/ph4FkMBJsYc+TpbuLZMNJ1Cgs4Y0kifCv0/O9mHXdWt9hn4TSBLpavXzznab8n5cLHeo8YwIAkIfc1Hl6MQlnFjsy+FL7g5qxjPbymUPgo94yNYjv2oGDZWaacMDlzkTKfu3OGs4Zu2RGTkKftT/qj+pktbz0Xw4GL9ZbtFAhFuOcdXetZ6ZZc4DBMNI3D6IbZTDNpxSEGPh4CBsv3h3qwhVJIwPOUOXnxzRmFbR5JUi/q9+cNMQhrmRhJaKk83l3KGAs6CQpDAR6XCWaa03lHvNKcZAPZ8l6/ZjNGCoXHEpEaUIEgSJQaoqUVShSDwKQzd5RnIBOTEApcSaQ4RR8iSiC2mqlkyIW+ZB4sT7C2msljhvJKQv1Saj7TvHe95r3LG66GiUFnvuJWzLsZ561BBjhsE7OuoVnOmM0VDTVo5l9vI1obvn6zrusvJ4LKPO6Fs7nHFk0+KLZpIlBAC6+3MyYyN2FkJGGt4iZGrqeMbUAjKF0TeT/MI2bVcme1ZHy25iQ25Ch8I1xzlars7ePUg6kpwSVlSoTpqKdQGpIujMAD3XIgk8UyJbiQDDoxjDU5c2zMsZmT2VN4c3mC2MK89cQEMR1+0h/Vz2S1DXxwc+CD6zXX48BoEm/bOau25cQ6UkzcbEdOu45m0dFZhY2Z6xDY5B6D4Vv7HeIh6UwS4elQwymtAjXAIdXJpwD3m4aBxDpEJhsxRlj3ic000izqo05pRRThURows4blasHhUjjNGlUmvrPbcpMSgUx/DCsSWz15pBc0FUBDUIUkcMs6eoQS60PgIk0krdilQNM7stdsSRxIpAwPfIdtOlpniUlRPqN++lX98HV+Mucbz57znY+ecbMfmEzi7WbB6azjFEOYCvvDgdVqhvcW8ggZLsLERQho0Xxju61+EVWYJPNo3zNvPQ6wk+ImT0ylUIrw5umcTYlsD4GgM4NRbPrIegiYRoHRWGPICt4bA37WcL5aMmTNSgxZBv5494zrKRA1bEOs+rEWUsjIUOVrWMAosqoBcPe1Z6urTDjEwnOZuN0qtsOAd4rT1nATJ7YxkBC+eHJG23hmM0tIBXfx2ZoeP7UX/m8//phHuz27mLDasgyZRdNgraYYhyiDlomUC+vNnmx03TxiYpcKbVYssLTW4aX+mE01XRdgtIUZmjMsxlp+7dYZ677jc2crtjGynxJnXct6HGlsFVkpTU2mTJn/77vf49ce7ukHAQydbXnNz9n0AxOFlXYEhD2JdKRnaBTGKhRgkmLhHL/54B6SC9++2vB4GAjAmAtXMbAZe26CYp8iu1JQAv/N97/Hb73+JnclYa3hdPGqu/qy6vH+mm1I7EOuSX050+GwxoCuSK+SNUzCULYkYJJC5BiUZQwN1XVvJdGXhESgqQdXNjBTDoOmqMLbfsHORW4Vz5gzIQmdbljnA95qjv4zAGKCbzxf86XzQp9r3PjMKU6xjBR2pdBkQ0YIuiBS8Y4ahX5hECjQJMPnTyvK7sk4sI3xxSSRQ07si6IfNCGVml4J/OuLC3717il2qimqp+2rNfgy6v2rDU8PA4dQcGLIY6JbeWZeVZJYrlIsM2Uuhwu2Y6CXTKSQhXqxMpqFMZgkbOs9Gqs0RmtSU1h6g8dhlOGrJwvWOTMtOvYpMYTMsnHchEBT07nQuqaelyT84eOn/EqKTKnmQCyN5RaOPZEEtNbU8KNy7Fwdzzmt6x6oCsy05dfOTzAZ3t0PXIZYTeS5sC2Rk2zYDpmhFKJU8ev/++lTfv3OKZY6Ibg7/6k9xv5c10eXNzwbevYpgmh0VCxmDbPOEGKpwWsidFPictiyC7GuPwWh5DqJd5rWOGxO9DljgsI31bQdvLDQGpcVRWk+v+jox0A4a+hzYozCWePY54Axdf9SgEEhCf7k+SVfyaXq952iLY6l8eynTABmpgYHjjqjUSQEg/6U664KtEbzSyenEAsf7QduQqxG4azox8TaT2yCZSwFKQUw/OH1Nb966xyPolWa27NX+9/LqveeX3Cx3zLGiBWIsbBYGFoPF9cHcp84mTfMWsej7Z7r7cAoiaylpspbQ+M0i8ZjY836MEFwLXgUwQuz4jg9eo4+t1owhUToCvuU6WNm1Xiux0BjNRSOvjiF5MK/+eQRv/z6XUKqqPUT77ljZ2yHRCp1IiCmSnjEQN5JlfKWY4q6UnSN4ZeXZwjw/n7PdYxI1hANhz6z8YHrpDiEWD2gKP77x4/4S6/d4x6ORmnuzv68X/ifXRFzpgFWraHXLTfTSEoT9sTRdR7tGnQp9DmwHwYOMTCUTAIG0TyYzdiVjFbVWLnvM12X6OYGZeo39VI3vH6y4l635M5syYfbK3LOOOuwS8NNbNhS5RcmK6zSYBR/cnHFmAtv+CWtMuRcWDaaW02DBIXSIJLpRHPiG25iICapZkgFRVVk3f3ZjEY5Fr7l+TRwFSd2Q+Q6GqaUab1HimY7ZJLAh+s9H61uWPjbLI2npM8Ysfaqfuh6uu3JIhilaJwhiuZQIrnPiIe5sWhqp3KKmSFnxmMaHhpshJPOMKbaUVdSX/MhZHyrES0YJSys5qRrOXWeExyX/QgiWC24VtMXR08dS4tkDNX/8VG/J5M50S2emtw7c5Z5SiCWrEBJQWWFs5ZDicinl/+6caGFs67Bac3MW7Y5spdypEppUiy0tho2x1zIorg8DHyya/CrGXOjjzkBr+pHXR/crBlCwYiwbDQ9nqtx5HIaObUtS21xqmYpbPrAdgyMUlOgi1ZM+8LDWUOfCrpoVFaMY+YwZlazmjdiiuJUe+7PWu4tltxXmY/2O6RU9rnxNSp+z4RQalChUmgD393uSLlwohytGKTAaePZlYTXlqIU4YghXjlTOdMC+egPsUpRVOFh1+G1YdZ0x+5wYoiVdDEkwde8JcYipKR41A/c2Tcsna2BYp8xdOZV/XD10X7PIUSMCLdayxA01+PITdYsrWOmDaZoJtGsQ/VwTBSigiKQcuZs1jClus40MKaMjYbZTCEUtLYsjeO8czzoWsS3PO4PFATjwHvPjsRwRAkjcgzkVLx7OBALrHyDVxWsceocgys0KDL1MeCUZtkYNmNGdCFLJa9oNAXhofU4ZzhxDesY2OXElIW2aKac8UfDesj1z/VsSnzcT7TGYm2dOLyql1PvXl+xGyZMFmatxQe4GgObnPEK2plFtGYIwtUY6ENkomYvJA1DytyddUz52OyieqBcKrjOonIFYqyU5d5sxmvzOaoTnvU9WcajEdxyrSJjjhQEkVKbtwa+tVkzFeG272iVIeXC7c6zDZ4dR5xnEqwIc+u4IVSz3IswMaqv6eFyjjOaZdewDpF9TEzAOlWMt0NDkUoNKvDB+sB5s2Zx9zZtY0nlzzmlZ70bMUYzs5oYjnIDXVAZck6I1BCaUoT+eKg4bYgiNa5YYN45lCTm3lG04mocGGKBAUKoLNSkR+gN/sZwezVj3wc2Q304KK2ZzRtWfsZhnBimSIzVfd1h8aJpnabkwlAiy9azai27nCkIDcJMGz6/WPKd3Za58RxKZCBTtLByjkXb0OBqcEIcOMRIkfpjThs6ZxmKgNVYKqrx3c2Ge4slre14lTnz8qofqyzCmdodSrnQQ42xNoI2gFZIKUzU8ZzWCiXClAq5CDOnEeqaabQl5lTTREOhlEyRQiqQTEXPrRpHKoVQaldTaYVrDEtlSKWQUh0JWq3QYpAMziiyVEN46x2zEAhSCT3qmCJ53jU829euxkQhkkEd+ebWYXXFhx2mRAyZUhSdtTikmtcB5VQlDEjh+dBzu/W4xhLzq0fny6j1dqKI4LQiKUUs0McISnPuwPs69clUc2E2dYqoBEKuoIC5rdkfVitmztTpUyoMY+2851y1zEXXSeXdpSXESmE5FKnhL16jpa7LKR9/PaNQEYgw644Us5RZdp5lmhgLJAFbNI3WPGgbJMFcWXYSGcmgYeEdy8ZjlSHqxJ5EGDJFaebe4UpN4S3HS5Wh5gE8GUcehhmt4VOi1Kv60dbmEEhScEZVWpjUCSYJTp2itdX/UYBJFeIxGFNxvJiIxntDlILVmtY5QokkKYwBShYOKVGUkG092087z5QLQy6MSrA60XqLlUpiCaWQSkFpXdNFBRpTwQmTZBatZxYTMdW7gRFNoxX3fUcZRxqlGQhMZIqGmTXMtcVqQxBhmxVjrPvfzDmcdjTOVlN5AkrViT8fJu60DVbrH8iEXtWPvC7Xtenmjk00JYYpFzKKhbfMra3ceqMJujCZSugRhCEXdFG0RhhSqsoaawkUUpYKP4iFnHKd1luFbBR3lw1jSvQps88ZpwpNa7ERUhZCKlUaazRKNJKFxtR76Zgy86ah9YYh18eBFOiU5bWmgVHRYRgojGSKEVbesmw9ja7whKFkrmOmoJg1FlMUM2soSlCuomyTFB4det6aAq1xTJ+x8ftTe+GPUyb5SnZIsf4z5TRWQUmJmCZQhpAL13FkjmPmPEorbkIEKfRSQb5L53DeMurqyp76TIyFIWaeM/G4DFwd9rydTlhvBq7jxFYSQQmvL0946/SMJ+stz8KeUTJe4O3ZirfnK85nLdfDQIrCvO04mR24OiarmaKYGcODWceTceQtteAqTVzJyKgyK+9Y58gc4dk48PH+wMfbPaeuZWYcM2dZOk9WitPiCSnSYrgcJrYxc0+oPKdX9VIqRcFYASmkVFnNRtULjKJeqBP1AOiPcdjeaFQp9KG68nWqnXdrDVo78vFykqaK2exL4UYlTBq5Ec/dZUtKmV1KNWZbF05tx7n3HGJkl4VAwgK3TMe5bVg4x/5oYly4lrlz7GOhUkPr13TmHXudOcuWnY7sa8QRM2NrFxbY58RNCKz7idZ6nDG06niwo5jrTIgJJ/Xi2SdhafmU6POqfrQ1DbUxUKwiFUUsCovgROE1eAsJRUiFvS4oU02Iqgj7WLtR+yO9xBuD9ZbkSjX/D4VY6jq7JPAo9jzbjbxdZkx94CZEbnJiNJlz03GmG/oQSRIZS/0+uGs8933L3VnDzTiyj5lVO2MZJq76AYrUDpnW3GkatmPivnRclpEbmQi6dr0Ox4ySXQpcxZHLaaJRntY4ZlZYOINGcdCFQKGzil2OHFL5AWr2Vf3IaxgSxVYhjRwRgU7XfA+HxhtdA9lyYdS5oqTRaCkcYn1w9jkTitDY2g1/kRoepoJEoU+ZawJPi+J5nnhAxxQju5zYUUgkzp3nVHn6VPNJglSJ7B3nudM0nDWObYz0GuZNw3Ka2BwbYVoq6vrcOm5M5JyGTdZs1UTQmU5p9jnhBdYh8HwceT4GlsbTWkdnPfPWYBVMx9CuVhR9iuxTYmHtp4/RV/Wjr/0hoqwGq45XnZq6C3VfmVmNWE02hUkXJis156PAFAuuaNbTRAyF1lnm3pJ8RhVFGHINYkuFKxV4IiNP1wNf0EsOY+AmBDaSSFI4bTuWTcMhRHKqlDEQ7roZ99qOU+9YDxOhZM7nM+atYz8JEkHIdQ/0LdumcEsarkpgTSCawsI4DjkBVXp+FUaeTwMz2+C1pTW1EWiKZiOJMSRabdjnyDZEepc/85T9p/bCP5ZMSYkkllPXcLdr2OeJbUlspglHRRwNRfik37HSnvtth9IKsYpdzjQxA1XO0xnF610HwPV+QrTUFD6qiewmZ/aXN9XMdhwbkgplnDhsD1weevY5ggNvNSe2YaZ15flK5abaVvOGPmebhUfjgX5MTCnxuN8TXWbIdeSZpJIqrkLgv33/Xb4wn/P4MLANic5ptDPsc+aBtZxYz9LVDux3r7fcW7WsjOGsndF4R3zxGnpVP/JKSYi6Msln2jA3loHCVCL7rCDKEadVuJ56HJZVYzG6avSnIqhSQAStBG8U57Zq7TYpAJWYA7VLNqbM431fMWFHvSoRMgXjDEMZCTqjHVhlmGuFNbrquI8Xq9ZozldzDvvMTUhMpf513asq56FOx0RDArZj5A/Xl9xuWzZ9qCN3pdEOYpFKQtCGTlk0mifTQNMoljhmxuKtedXhekl1SIlkBV80J8pyq/VEW9iHwG7SOKnSnVyEJ+NAGxV3fYPTiqwLQyn4rJBU0MrQWkvn6mH5tA91GgBVpyCwzYE/2yT8cQ+MQAhCshnVWbYlVUymUcys5nZjmXuFLqCLwilD5y0PVys2KXEdIkOuGM2LaSDZQiipPnqVJlO4PiT+hydPeGO+5GqoYTedqtkOUxYaZ1lZxwqFL45Hw4GVa+g0rJylcxXN/Kp+9DWVTMpCovozVs4TlNCHyFYbrIDWQi6KizTRFuhsgzcWJZlYqnxQodGqTiLvHHNjroZINuU4CShIVhxK4sP9AXecGgiKmAuZjPGefZkYtdQkaWtYOI+navG11Anqwhtem8/ZSuB6yBVlnROPR4XY+oBIUihFUbJi20f+pVzyejfjYgj0Kdez3FkiYB0snGOJxpXM5RToGmiO6gNvX3X4X2aNKZEQglRk+e3OsdOJXQwMSbNQ1Ry0nSLPwgBJaLTDKoUywkRBUqEtBic17Mr7ijK/3geSfhFOWc/bQ8782fUGjyFLoeTK3U82Y1rLQTLRFJzRtNaw1IamQIlArpj1rjF84eQE+j1P+p7dkBhj5ONxovj66+Xjnptz4XI/8T8+ecLryxlXfeAQM62yWGOIKdMaw6n1nKDQovkk7Zm1lpkYVtbROUuOf947/EoIUqOMrVa4LPRTxnvDQWUK9cBa6Y5z3+ClMlMbp3nNNAwTrMeRJ4eBgvDO6ZL/4s2HAPy3775Pg0Y5oTMK5yy+M4RB6I8bAkUwWXMTI+PmwFjypwEd2xj45n7Nm7dOud5PfLTdV+KPhS/evkVzveYNP+cWnt008XQzsCWR2gObONFPGZRisfBcbyf6KWFMfbkWBYXEAsuHhz0fTHveWCx5e3nKdoz8V1/4IgqP8RByYD+9IgS8rJp0xWNlOIZXFVIRtFYMuZCJKKBxnibZGhykwBnNSWMZcmEKmZuUkJK4O2v56skZAH+4f45DoZTCKEEZsKaGrg0ZshKKSB0jknnOgZgSiFAEppJ4ZEbuL2YcYuJqjPQpUVrF7dMFfnDcbgwLYziEmsbbI2RtOJTAFAuIwnrHszByCDUFVWtACVMRLIrLELlOE2dNyy0/4zBG/uLJLYzVeGfJIozxla7sZVTQhZAzWTSN0XgSU6w+jnVOhFRNX2dtxwwLuqAbxcxbHriG7ZDYlImbFFF54k2/4K/evQPA//P9x8yixahM8AWrDaa15CLsSiZLpmTBRxh14maALBkQUiocRHh/OPDO6Sm7EHk+jtzEiDSOt5cnzIY9rrGsQmI/BS73gSsio870pTDmjChh3no+Hieucz3YrK5BFBlBG8XTceIiTdxvW15vZuymyF978LBe9Bz0JbB5tQe+lEpScxcS4J1h1LVZJaLYlkLICZ0rarjF1OaXNXTOoG1NVn42RfoSUFHxum/52mnd//77/nlNHLUGrTTG1MtSptLsslS/m83QmwJ54sUuUwSGWHhvv+funfsMIXE1DqxzIjvhc8tTmrjnttPMJltlurtIbxK9muhjYYoFQWhbzdWUOWTBqRcJ5JoINFqxGTO7NHDuG25bT2gSv35yhrUa5yq175DST+YD+jmoSM1sKEiVJOrMEAu6wE4KmYQusBSP1ZqiC21jmVmLioahZB5teg6lZkS8OZvzV+/eBeD/cf0RCDirQGuMMtiVRhLsU00bL1lwSRGmxNpoJAkUISthLIoP+gPvnJyyjZGn48g2BugtXzy/zXuHHXe8Z4ZmO0YuNj29EzY2MKTMlCrmetZZPtkPrFPEO4u2NQslk7BW82QaeVpGHrYz3mzmjPuJ//zOQwyGtvNEKWzzZ2v8/tRe+B8sGjrrOZTMZRzpY+JL3Yp1Dgx9Jg/V9HU2F1SGsUTWE7zdrvhPH7xGzJl/8u73WM4cQ0gcQuLRfuB/9eabPGgvMQj7lDikVGkRynI1T8gh1cRba2m8oaF2cE+1Y10K25xoMDzve/7Fe++zLoGoCgh8d7Phe8+u+K//8m/QOsf7T5/x7qOndMbxbBjYTIm1RJLJWANOFP+nz32eM2s5P1vhvWPTj/zeh58wQ/PBYeLiMEGEM3H8tTffZLMbuDhcE5Uwlcwwverwv6w67SyNcUwlsymRQ9S85hwjwpggpErNWRkwRpOj0KdC5yy/dLJCZ+FfXVzQ6Wr+6ofIhR/40q17nLkNRYShZExJ6ARNaznoCEPGisJog2tqF1YXwRrLoVRUp2jDfgj84eUVQ6kHjkbxyXTg1mHP/+YLb+ON4fF2y6P1lg7DdRzoc2EbNUkLBoUWxdfu3GZVDKt5h7WGfYh8a7PB47jMG3YpUorQZcUvnpwwlcL2EMBAkEz/Klr+pdS9RYvXhkNMXIeJzRT56vKMjTKUpBhS1Vf7tuqYQ9FsQmbZNPxnD+6gU+b//v6HzCyMObMeIx9sJn7z9Ye81mwQJ+xlYiipptZaxRpBkmDROKdwzmAAU4Qz7Vhn2BwNYs/7kX/x8SfsJVNUpUd8Z3vg++01/8e/8GVaa3jv+ob3L645VZaPx55dFHZlIKoqgXMi/NWH97htOk5POhqn2Y6Bf/nskiY7Lk3gJgfSWGiV4Wt3bjGFyLMxkEUYSnrV9HhJdWfV4pSmT4l1jBzCyNvzBYOJSC6MOdagvm6G0SOpZNYxMvee37x7TkqZ3312SUGYUmY9Jj7YB37lwTm33BpxMOQ6gTSi8V6zzUIWsEXhTDWNa4AinGrHThT7UiW7m3HiX14+rSmrddDJ+9ue992O/8NX36Gxhvev1rx3ec2pMjwNAzdT5sBEVhmDok2GX793xtI4TrsGbzTbmPj32z3eWPo8skuRPEGL4UurObloNkNATZEJ2IZXF/6XVXdXDq9n9CFzPU5c70e+fP82Qw7kCPtQQ1jvnnu6taEvwmUMvOkt/8X9BxxS4r+JH9MPEFLh+hD43nrgL77zkNfnN4jKDJKZcpUfzpzl2lQazos90FuLy4KaCmfOs03xeCYWLtPIv/jkIybK0dArfHu945vPrvmvfv1XaJ3lo+trPry4ZKktT8c91yEyhpFswOg6mfqtd+5wy1rOFguMtlz3A7/3+CmnbceYalPjUTjgW8Vv3LnFLia2ccSOtRm9nj4bG/un9sIfjoQRFDhjOMRAQWG1ZpTMLqcashEtmxJ5s50zM5a5dXTeYQLcbTybaSSkzK4EPrzZ07RPOaTAl85O2aXE1TQiCFe5XmCqWhSMrsEfZ85x0Y+ga8paEWGSjLeG6xhq0ps2JIF9mricRv6n773HW6cnNFrxxbu3UQVOrOHfh3Xl+Qu4rDgplnfObiGHiZm2eGMZjaEPAWcbHuo5QdXRT6Bw0s7Z7wfWh4lNDoiuJJVX9XJq0kJRlRHt0Iw6ITSgMrFkitQ49601DDly5lucqWbXxhpSyZx2LcP+UNdNKlwfJj7w10wlcXve4LPiEKvJqFeRIkd3EnVa4LWm1Yb+mEwJ1KmDFJQ27ENCG0ErRZHK8N1J5NvPL7gzazAoHs5nqAwLJ7y/D9iSMKVgdB2N35+1lKHQKo1VmlFrhpQwVrPUjphqymBR1WQ5pToqH0Iil/JpIuCr+tFWTyJKISlBO01ImYmE0ZBVYSoCUVglx7oEXmvnOKeZNY554xCB15sZ30l7chHGkHi66/nO5RV9ibyxmNNmzXoKCLBNiaIL6ugLUkozoxJOtuMLIxUUBRlBlGKdIkYptK6ekCkXrlPgjz55xoPVHIfinZMVbYHWKP5sM9SE51wnt0vt+dzJijxKjZTXmlEr+hAwRnPHtExZKEUREE6bhpgSU0jchMhUMsKrCdPLqFEVkoZiqmRwKhUaoY0mKTmauDObFDlI5k7n8drQeUNnLVMR7sxbdpvIWKqU4WI/8u71hjEXHi5a+qjZTVVQsS+5/kZFHc9bRac0rdYMSWrUeD0OyUponeEQIw6NEo7rL7NVhX/76Cmvz+fYIrw5X2BE8A6GNGCo1jdNNe2+tlpRhkSnqgF01IoxFawSzpVHcjh2XAsL60kRRlEMsYYsvvA3vKoffY0IhYwYcE7TSyaEiYxQ1DFfIWQ2IbItkVttgzWKznsa75BUuDPreDRlJqlBrs+3A999csleR95aLBhzZjfVptY6BkRVoo/SYI1mbgytUfQpoaUidooCSg3n2oWIcRqt1ZHmlFnHiX/70Ye8sVphteKNkyU2F2YuM65zXYMJMOC95Z3TU2QfaDF4bZi0oU+BZWq4Q0s8IrEjhWXXMoTIkBP9FAk581ltJD+1F36D+RSJuDSWISeG4x96KhW35dEEKVil6ZzlzDecNA51vPw88DOe2RFxNRG08YYUE501rFpPCbBLhqkUxpQhg1EabYRW62qI1Ia+SQyp4I2mxRBSoTGaUAp3mhZnNIecmXKiGMWHN2tKTrx9dsbD5UlNYA2BQt1oVKl7V6M0M22JNr9Q01IUbMPEyjVVPqLqI8cYQ9s4Hl+uuZwmsmQaq4/mkVf1MkoXKBQMik4bJqmEnVKEXArpuD5DLmipGtW5MSy0QUvFrp65lrWdatdKa7SBVCJWKzrjAEUshShCThERgyiFUnK8kFsaXfXOoQhOabw+ki+OGte5tfXrKIWcC0UJz/sDSTJ32o6zpqEU4TBl9DGN8sUatFrh0UR9JLwc1+GUEjNrj3Hf9UJnDHhnuZlG9jGSy9Fn8IIx9qp+pKWyIlLQqpr/o2RGSSCGUSrJSWc4hIyIwlvNyntOnccoxQQ8XHQ8DS9oP3X99TFgNCydQ6na/Q8FQoqfhrS9SJI+tY7OGnIj9DFjjaHFko5rcUI4dxZtdKWJpUTUwkebPaFkXl/OuD/vIEs9MPVQzXe1l4NXun5vmXxstSiKUhxiYmWqhE5VWBBWQ9cYrvY9N9NYPTKqmkNf1UuoUulkGui0ZSLUC7+GKIUgNRtmHyMUwWnDiXOcWAeiENHc9p4LYylGav6DgViOzTptECMEU4gIMcsPAAAKjFEsjMXruh+Oue63TitSKej601hYgzaKSQolF7IuPN7tySnzoOs4bxtyKUy50vvI1PWnFdaYmnhvFFoZ0LoibUthqaBkjh4EBQq8sdyME/tcg8SUUF8gr+rlVK7no1WahbNMkmtyvFYEJXV/KLCfpporYzUr5zh1FkWVv742m7HrA5SaQaINHGLEas3Se0zMTKkQdWYKtXklVeWDN5oT7fDH/bBPdR9tMERVcKJJUlg5hzGaUDKShWzhk+0GkcLDxYLbTYvkzFRChYNWxjZKKu2vxZCVfhGPgyiqVLatyemqqCp7M4au8VzsezZTqPharZDy2c7gH6o9/A/+wT9AKfU/++vLX/7ypz8+jiN/+2//bW7dusViseBv/a2/xbNnz36Y3+LTasRgUThq1HpnDIcUmXLtKlRX8jG4QFvQMPOGhXeICDlnOuW43bXcnc+4v5zx2tmMM+frZV/V9NMhZfYpoRKk6YhPNBXVdce2dMrx+nLB7VnLeddw0nisUXhVDZKvnSx4/WTB3XnLnfmck1mLtbUjm0TRNR1d27EWIR87FADliMKTmGi8wxw79VlK9QtoxdM8MFD/XmkNWni023AdRkQpjDKE8PPTXf1xrj8An6vb31A7/FY0iVwv+6WQKTWQTVX9qSihVYoZGi11GuRFs3COVeM4aR0nM8fcGVqjoWgkVzxdkOoZIYJSgjaCM4qFrXjW866pGFdrmRmL0RqnNa1R3G48t9qGVeM5aTyttYhW9KVmAjTO0njLQVR9TBz/fIV6VyoJvDVHE/uxg5Yqa3iXM/GYBIyuPpPraWI7BoocpUw/Rwfej3UPTPXhaFC0aBz1UjPmzCFXEliSQkpCi6k6V6M5MdVPEhEabznvPLc6z/nMc2vp6ZyhM/V5V45c/KkUtAglV7OkVjWU6Lxp6LTlwbxenE69Z+mrXtbrulfen894OJ9zt+u41bR01iFKPkUMLxpP13p2QP70xKldskQhp0LjDEYZFFXHXQ/5Gnc/ScJQO67KCI/2Pc+GkULGH03rPy/141x/rihUVuiiaagYzFgyIddO6RQz+YjgtFIHfZ22LIythsSicAVOneOsaThtPefzSp/zSlGSkHNdf1HqTaekH5zrjdasvKW1hrvzllNvWVpDZ82nsIxOa+7MGu7PWm63DadtQ2OrDGifY6U6OcvMOdaxmpCPVhRqs7Zqthtv0dYgWlF0nRkppdmURNRQSQx1f7yYBnYpIMeGzwvy2s9D/bjP4CZV/K8q0GFptGEoNSdmSImhJLIuhJDwohBgbgwrY6EISQlLZTlrPKddw9ms4XzZVp2/dhiOk/FSGKVgpXbp0RWxXRu/noVxPJzNuNV6Vt4xdxata9N27i0PZi0PZx23u5bzWcO8cWijK3ihFDprab3nOkvNDZF6DosShEKaIsaamlNyDBksuSabX+Sahm6VwmuNs5on/cTVGBClaKyr98PPUD90h/+XfumX+N3f/d0f/AL2B7/E3/27f5d//s//Of/sn/0zTk5O+Dt/5+/wN//m3+Rf/at/9cP+NpW1a+pFKIbMmbNMWZhUNbIFCklLlUKk2uGKRZhyNd2OEvnG9prl3HLmPK2zdK1mvZ+4DiPlAE/3I48PB5IWXnMLbvSIR9OimBnLYlY3rq8+uE9UmW9cXfJHzy/odcAV4cFszldu3cV5zWYc+eJYOJhITrWzervpjpfDiWf7PVZpvDEoEpMp3OhEyhnfeLRowpjo+4lGK9DwlBFrNC2F9Thwud7y/c2OoIW+BFJMyM/PfR/48a0/gCKaooREoaTMnProiiJEFIk6WtamBn8shU+7/0UEpTUf91d455gbh7WKpXfEXGrqZB7YTKHGcDvFiXYUyTilMNRp0lwbAB4uZqDgUd/z/uHAUOrj9NRY3lgsMVpziJngEj0Z0XDaOpauYuOyCNdpojhBa9B1oEWfEznBzNdgjzFHxhDqAY9lS8IqyKI4hMK2n3jWT8RcMDqB+vmjVPy41mBRIIZKFRkVp6YhiaKXdEw9FsQojK2Ty4IgRWqXs1Qt9LcutviZZmUbvNOczSxjrI+Fp+HA5RB5Pk5EnTnXnp6McxpfYC6KhdYIwlfPbxGL8K31lj9Zrwk60VjDXeP5xdNbeK/ZhMDQFg55IpvMvbbjlmvIRZFL5mIIFK1RRqFKDQxbSySlTDOrk9mYEnEMzIoh68JFGbGAL4rtELjY9XzS9xVjFw2hCPnnTEL949sD6zmUixCisKBSokKpHPN8DO5TWhElUwzHlOQKHCjAdzc7Zo1lcTRkL5xhGANBCpuYuQmRqxjIWliimbSqQABdyXet1P3vF+an5EXm+4cd39ntGHW96Nxyll9YLXHasE+Zscschp5sCudNx5nz9XIvhYtxpIhwBLOQNQQp5Hy88Ksqxwip0OAAy7Yc0KY+bkM+fr19RJyQj1OL8nMmafxxnsECJCNkyaSxsNSW6OuFOOS6ByoLoqvc5xwoKKKoKgfSiu9e3OC8YdlYWm+4M/PECCFHrqYDF0Pg6TCRtXBHe7Ym4VHVVC6aua05DF85OyUr+PZ2w59u1hwUOKu51zV85fQUYwybGBl9JOVC8IXbruPMe1DVJH4xHEiqfs8oo0ALKRYkFGTmKBRiiAxhxFpD1oprGaoiQBnGWNgME4/6gcFkTD4a3V8Wh99ay/379/8X/3yz2fAP/+E/5J/8k3/Cb/3WbwHwj/7RP+IrX/kKf/AHf8Bv/uZv/lC/j+oM3huMCMpl3los+fU33+BPPnnMh7st17FynC/6ntJozhrHmAJ/cnlgfH6B0ZptSKzaGnv9pO/55vMrHrQNCsWjix1XU2DMCYPiqes5xMjpmWPeOgaV+e8uH7GPiYdnp7ROEVOGAnfdnP/bV36RZA3GFLxRvDHvGLLm480lgcSJaXi+3fLHTz5Bj4IxQp9D1R5qi0e4CCMXhx3NWOUXM98yt46Vb9hsRtQotdughEMK/I/PHrEpmXEIfBgTMQvdDzek+XNfP671B4BX9SCQ2lk861q+eLrig+2GqyFwSPXheTH0KK1YYckZPoojYz9gdGEfYKETWYTNUPj4as/CWxxwuRvYl0yQApNhK5miIrfmHqcNBxH+qF8TSuK/7F6jPQbNaeCWcvzle5W44jFYDXe8YwKupwOlCDPt2I+Rj8KuSn1KYZzq1+JMHVFuSeynkZQNfYk4Y3DGsvSGfRzQuWYNBCkMMfHN/RW7kIgxV2kZYPOrNQg/+jVoZ4bONlWC5TO3fMNvvHOP7zxf8/H+wE2YiBQe9WuK0py5hmnK/On+msPFJRa4iZHFUB9zm5j5/pM9p7O67T+66tlKYqRgs2HvMv0YeW3Z0aDYpcTvrp8RivDayYLOWLAF6+GumvNff+4NsjUYY9AaHixappy5PjhCKSys4aof+MazayQloinEqd7OvTGIgm2MVZ6TqRd/Z2ic4Wzh2A8ZNUJSQrDCVmX+4PkFu5zYT5nn47ZK5V6tP+BHv/5c51h4hypCmSK3lOGrb97hz67WPB97dikREJ5PE0ob7uiGFDPfm7aE3RZrNLsoaJXJuXAdEh/EHcu2BQpPdj29ZBI1G+JgCjnCA2/wyhJK4evDhgC81s7Rrl4Avbbc0Zb//ev3AIcxgkG46x0JuPaGXApL69jEiffW14RQu/CFiLKKltoV3SBsUmAaKkbUHve/VWfoS0DnmvJcTKVmvdtvODSJsIdIpAD656zh8eM8g1WjWbQeh8IG4cx5fvWdW/zZ02s+GQc2ORFL4enUg4b7rkVC5rv9Db0WFqK5mCLnjSZn4WY98v3LPaeuevE+uDqwz4npmJ77jIlUhLeWLd5qBgq/d3hGnwr3TmY02tTJvVLc1TP+L++8BYAx9dFxt2tJ88y23zMZOHUN6zjyvfU1ear6r5gTaOisBQXrKXA99LS53mFba5kZx63GsNn1qFildaPUB+f/dPWEaz0R9plLGchFcJ9R0vNDX/i/973v8fDhQ9q25S/9pb/E7/zO7/Dmm2/y9a9/nRgjf+2v/bVPf+6Xv/xl3nzzTX7/93//P/phT9PE9B84jLfbLQChBIZJWBjH3a6lcZblrONLd8+YtYrtOKGK5qpEvLf8yc3NMfHM0DSWGAI3MWD7SvNB4I7puD2f8fVnl9z1TQ0viIlJp6qBBR5tezZjoLGaQEaK8G8uHtEYzUeHnqsYuO861mHAl4arw7ZquY0hSebDw5bv73acWU+fEtdTYGU9b85nnLSOqzQRSsGI5kQcv//0SZVSiMI7w8w73nErPgg95pgwuRkntv2E95YlhkuV0Y2iEUWMPz/jRPjRrz/4j69BkUzMlW8/d4YOzcw7HnbzeiHPiQKkXDDH9YEI1misq52fbQ5IcpijCW1mHCtveXzoaY2vMoqUyTrS2BpVfzNEvMrVCKmrzOLDwxZvDFdx4lACS+3rGNNbng9D9XsYRXHCzRh4Pky09sCUCn3MzKzlxBnmRrFzNWPAZmjRfOewr0Z1qkmpsYaVabgOkaIVIsKQMkNI+EHRaU9vSx17UmVoP0/149oDSy5MKtIaw9IbFt5w6lu+sDyh1YpNsEiBaxKtsXxnu6WkauRvvEVKDSVUjcf62lk/CZaF9rw/7DjRDpuqtKIn4DE4p3hyGPBaY7QiUDtpf3R1zdJZHk0j25C5YxzrUOhQPNsfyEcTeBTho+nAx+PICYY+ZG5CYGYtt31L4zXkKiXSAo1o/t3N+lPvSOWbG+7Q8mEeULpOy3YxcJgixmhOnSe6Gj5nRJF+jmSN8ONbfzlnhlz9bIvO0TrDyjvems+Y6eqzQGAnmWIU7/Z7KAWnFc5bTFBs4oQyuuIurWCzolXC4ymy1Bb7wgxMoTEO7RRPh0inM07XvJpUhG/tbnDOcFUSBwor69iFhPeKoY/EnCkiJK14HrZ8PATm1NTcXYx139UWbz2aiBy78g3l0/1PtMKYKpVcGcNlyDVJXYRDiQxTwibFXAyDTWhdyVT55wwS9eM8g4sq5FgT7xeNpXOWlZnx1kmkcZp9TBSBzRRRSvPHmzWlFIxRWK/ZFdjkQEzVeyIOnNIsG8eHh5E5BiWKnOoatEZjFDzaD7TW4owmiZBj4VtX13TO8jiO3JTIifX0uZ7Bz/qeKSVEKZLAk6nncRyZYQkps4+JmXOcWs3cGtYG4jEJ2CnNv1tfHT3pGnuUSt4xMx6nCpMRgUOJjEPERo02htBWPKnPquYAfIb6oS78X/va1/jH//gf86UvfYknT57w27/92/yVv/JX+MY3vsHTp0/x3nN6evo/+3fu3bvH06dP/6O/5u/8zu/w27/92/+Lf95Pibm13O4avnT7FndXJ4BwMl+gtGHbD2yHES2GQNU7dcfgoWFKxFT11RdpqpNJUXTFcJpn/OXXHhBK4qObPZMUlHFobejVMZRDjlk0Ijg0z3YTysDVODGExM4k/tXVE2bKc3noa/y41iit6XPiZgwMOjHkwlAyTWO5CYFbc8/90HKRR4w2/Mb9u/z+4ycAFIQSYBkdv3lyh3GQ+iAJiUYbzuYtVmsWCNdYplSd3j9PlJ6Xsf7gP74GQ66BbQvreDCfcdo06CwsrUej2afIIdU0UpGqe7bmeFEKVV9dgENJn5q1TYZcHJ9bLgkIl4MQpF7SLIJoCKXKOWounGCzZj1GjElsc2TMBa+Fd/d7Wmu4GQPxaP5Rphp5dyUwBE1IhZCr7EgnxZmzrEphl8EaxVsnKz54ccBrkAxtNnyuWZC10ERNXxJWKebOYTG0qkpaSxFM+YEn4Oehfpx74JAjC9Nwx7V8brXkfDnHi3Br5rFmwWa0bMaAw6GMcHmonXOv6vqbSiYrYZ0iOlOhBFExs45fPTknkng0DAxTxitLoxSRGtueEZQWyIJHc3EI3NjITYqMOdOT+Dc3l5w4y2U/EqSgTaWrDCVxOU3slGEKmSlWusVaheojSJ6bEtAKvnp2wjc3O6A+HAWYW8Mvzk4ouj62D/GIDTUOFHROY9HEVLMinPr5WYE/zvU3lswi18nRW8sFZzMLOXPmHe3xwr8NAasqYGOfIs5qHJoQCn2p0p5tzvUykwSSkLzwi6slUyk8D4ExlprciyJSDcGTCFnqZdtkuJkyKpU6ES2FaDTf3O/orGU3ppoWruv0c5JYfUYCIeRKGWs1FMVZZ4k4tjGjNXxpteLDI1Y4K4UkodGKz/kFohM2V4O8kerbKwW8r7kBFcRgMO7VGfyyzuBJhE40567hc2crbs06dM7cci3NwlQ85RRw2ErZyaFOqdFMY6bPBaVrqKXS1HCsKJRO8csnpwySeXIYGCloC1Y0WeqaCVI9KrlUQMbzQ8C4yE0OTLkGcP3R+prOWp4desacQVXvx1gS1yXiqdPwmEp9PGa4O2s5TY6Sqgfkq7fO+ObNNQBFVQ9JZw2/NDtHp4QLmiFWqIHXhpLhxDkmk+qjQWmseQkd/r/xN/7Gp3//K7/yK3zta1/jrbfe4p/+039Kd0yx/WHr7//9v8/f+3t/79P/v91ueeONN2oarVRCxarxnLa+XsCtI6aedT/xrB846EwumblyGBFKErRUHWFnLZNUbj4F1jHwdDjw+uoOV0OqpgxvwdakNHvU6llVX3Uv/mM+jxN6Eg4hkaWSI97b7bhjW25SYEipXn5U/cZvVDXtjqUeYKHUhXM+6zj3c4Yk9CWzP5KHQikV73W0aJdTzedPFlw+3RFjpvXVtCwFXj85YSOZfkqVamF/frpbL2P9wf+fNagKsWQo9fE1s/UzsEaTY6GPic0UGW1G5WoeFwqlVNpEJZkAUmVcomBfApsUOG/nxJzQBqytj0UVC6hC+8JQWSp6DAWbXFn9Y8kkIKnC0zCwLI5DyYwlk7McSSeVvhNyqRsNtZuglGFmHW9YR2yFKOVICKq4r5irJ6YIyExxb95wPY7k4wTDKIUqwmnrOcTIGKu57ucJy/nj3AODVEABwNI7Vq0DJXinSUNhPUQuDiO9EbSFhbKUUhARVKn7l5OaCN0Ziwhcx4B3E6/ZGSlXxKJzBtGCruHPdM6ilHwagGSU4joFVIKh1MdA0IUP+h23bEsfI305jsWPsfdGanJqSAVVqglXCdzyDbd9+ylpLRZhEiGUTMw1gTJmR1nC24uOy+FAzuC0wuuawPr6bM44wCAJLT9fjKgf5/qLFEKqIZSdM8ydg5RpnGUXI5spcDkGJldZmQtta7Ms14diyPn/x96fBFu6pne92O95m69Z7W6yO5mnq74TlHCJEnXN5V7utUKEHeAwGiiEIyAwIeNAYkAZC/CAgokZGRgYDB7Id+AgAEUYhzE23GsFqDNIQkIlqZqjOnX6bHe7uq95Ww/edY4kCqGqUuap0+x/RA5yZ+7Mtdb37Ld5nn+DASRkaqNJwCY5NjFyR2scIEqV9S/DXhJEY/YxhzkXJzCBVQqQhDFGEsWm+u44cJhquhDoYiiXzv200UTFEMuBiFwMOiZGOKgqDqwpa55kHMXuNZDxEVJORK1QE8WdquLywpESJZtHaXyCA9swSKac4RQpv39sYd/uPdjnhI5FjNtWhWKmQlnPVqNj1TvOhpFuH4w6UabUX8rYLPShsD5I0FIubCvnOB8Hbkxn7EIgK9BW0EaQUUALE1Uohz4nPKXBdY5DOaEPgZAyYxX5+m7LoTWsvGfnCy3szT3Yas2QQllnKc5SRmkOqpq5qXl6Wtz5XE6MqezBIWdiLhosc6D4UDPhwW5DDKlcZIwixMzTzZQwJPoY9xai3xzT4/dky3lwcMBHP/pRXnzxRb7v+74P5xyXl5e/7Yb38OHD/yTf603UdU1d19/wddGwI7JLkZACMYwgNVoJp9sdXz+75N44MJiIQXjGzth5R8iRRVWzJjA1ltrDkaqJAhfjyMN+y4Nhyvm6J8REWxlGlRlGB2SOmxa9t4Vbe8egImMeME5IIWFEo7Ow9pEjlRAthAhdiAhFD3CrmbB1npwKvWPwAamFRTXh2aMFWhle2W35py98GbXvqPlUugiiFNuQ+PDRhJ96PZRRZUqEEPA+cb2ds+jXtFmjpViDvl/xOOoPfucazDozpMgQIjFEUox4VRwgVt7xoCthaqNNVFF4qp7SB8eYI8YUrl+tFOTMkoqshBWeVfRsomPrAjllaqP2dp9Ftb+sDGTFEIt3cFCZDQkdICZQSpEpPu1VNqCFyL6Lsbc7PDI1/T4wyyghpoQVoTGW63WF1opT7/iFh4/IKDyxWN1lStIumWcmFV88LYe+nMHHiITMYjlnFR32zZE27zPV5G/Bk1wDs4JN9KzCyJg9IYyMxqIVnOwGXjrf8KAfGKtEZYRnzbzYA6fAzFpWEaosqCBc03Wxa00Dp6HnJE7YuEDMJYvBkYrwEjiaWFSCzgVGSQQSl/j9dKpklURdJhCNVIgSQsxsvacYXAg3TEvnAikXiocnUWfNga24PZ9gtOJ+P/D/fu0ugpSu7l4jlcl0wMdnDT/3MBNyuYhmSeSkuN1MOQuBOiggE9TVGvhE6k8KjWATHH30jNHQqHLxP3MjL2+2nA6BVBVrwGfbGRsfcCEwEU1MmToLKsFBNkSBFY5NCpxGT+fKBLTWprielbM5y6pCcqb3AU+xGd6IR6Ii7bnWIZe6mOZiqB9joR0Sy8HvUFmGUEwtjJIyRaXkPtyYTDHGcBY8P3N6ChTqkE8UW0Sl8AaebixfPI+klBG9b8qQWZqWVS4ieREp3/c+xZPegyOZbSpBV30IOO+plEGJ4rQbePl8xYnzBFNq8HbdsvGekBIHteXSByaqOPYcK0vMmTM/cNJ3LK1i03tGiaiqWFLHmEgaDpuKlHLRqahierHRHj0K4bc00TofsZIRVfbuPpRsHkE4kIreBbKAMUJIkYmpmduam22LNYqHw8i/ev11FGUP9zEhsdSVU5mPz1t+JpcmYglwAiLcqKZc+JHKRBRl2v7N4Pc0i9put3z961/nqaee4jOf+QzWWn7yJ3/yrT9/4YUXeO211/jc5z73rf/j6U2/89Jx9Clz1q0Z00BlFG1tqa3wbDNjrms2ODbKgxaWqqLPgRyLE8RgElSKW+2USV0TgcvR06B42jZcUxU5gQuZO/WMz1y7yWdv3uRGPSmRLkkIJLIGZSEEj6C5Pwycd45xLCcxv/emPu1GhiHh/X6zUorXux39mAjR8+LpA372pa/TqELlsbqMBU2lyDbz4nDB//feq4w2o5rytVEiY0q8fHnK65sdl91IdNCqb/wheb/gidYfxQc9aSHqshGlrFjHWESvKBrRVEpxqEyJYU8D21x4fK1S5JhgvzF1sQRkzJWlwuJ1Kpz4JByIYZosSmVChqkxPD1v+eBiypG2FKM6Ie6J9roYV2CSYes9a+cZXSIHIZKwSVgPkdFlfAanIZnEyTAW1yuJ3OvXfPniFFGZqCOiiwZAGQVaOB17vnhxTlAZtBQLO8ADp0PgovN0zpFipJZ3bJzHE8eTrMFMEe2jBKUUSivO+sDo81u6krqyXDcNVTKchYHLNJIF5sqQiRgyXkXO48jGBxZiqa1mzcCFGzBZuKFbDlKFoMkBrtmGTx4e8unrx1xvGnwpY0b2tpqWfVp4+T8fjh3r0RN9cVfTKC7dwOCKZWggMuTI/WFgG0pX/+X1lp9/8IhK7SPkEZQCYzPKJu7uOv7txSOCTmQLwWScFF3DG5sdD/od69ETglCp6vE90HcZnmz9QVDghTJlyZm1K1artTa0VUVVaQ6VxSbDmR/Ysc94UJpsMpKFUWATAy5EZspia8OqSqxSJItipivm2ZARUoQDXfHByYyPzeYcGktKIHkfwKRADCRVMiEuvePcj/Q+kkPp1AvCRQyMQUhZEUXwGU4HRxcTSSL3+h2/en5BowyCKRkpFnQlaAsPh5H/sF7jyWSdiBIJqVyIL/3IpQ9sxkDwUKvm8T3Qdxme9B6c9gFbaZ8PolRkFQNOoDaGibFUe+vMNmm6GBlVwlaaw6ZBG9BJMapSb33OLOqatlacKMdFKHTYGs00WiRDHuFIKj4yW/LJgwOObE3KIA58KIGD2ggpJ1prWYXE+eDoxkCKpYGrES6cYxwSzie6HNmlxOvbAReK//7d1YZffvBwX4MZo0CMoBuNVIrXdjt++tFDvM6I3dsYh8IaeTj0PBh6NqMjeKj45tbAb2mn/st/+S/zx//4H+e5557j3r17fOELX0BrzQ/90A+xXC75c3/uz/H5z3+eo6MjFosFf/Ev/kU+97nPfVvq7GKzL6yd4yvnF7x6ueb18xXX5xNe2e54NAxopchdCcXYNqHQDEIoN6SUeZg6dBQkBK5Xmk9MDtgQ2KxHdt4jwOgyp2PPrLYc5qKcHkOiUpr/9tln+DdvvM6oM7otm16IJSY8W0U3JNwQS9dBQWs0WoRLPMm+OYZWmARVI5xvt3zt4oQLPzKmwNJYPjWf87X1jj5o2Ach7Yi8tt6xEEOnMgPQhdLJeDT23GpafB+ogOv2/bPYvJ31B8UfOiN0KXB/3LEeR+6PAwdNxSM3sg4eC9TeApmoEoPat6lc6Ur2KUGCQUVm2nC7muFUT+9glzJRJ6oEOx8wVjOhLmnSMWJE+NBiCasVXkeyVuRMsV4kkyqhd4kYStKeABaNKKEjEKU0BOoAKitEQT+MfKnv2MaAT9CK4U5reTCMhH3CqkIYcuJRP9CIIapQbNFS6Q9choFJbfH7IKZlNXkcj/ddgbd1DUxC0pkLN/DCxSWvb3teX605bhre6DvO3IhWggoVRBimiSEkcspskkeSYqU8Kil0zhxazaemM7YEOpfx0TOIJ8fIOkUmRjg0NS2Fe18pxf/46AY/5x4Rqv2ld/8rptLVGlyxy0v7AizZKcI67utPC0YZjCiMhq0P/Mz9E1beMcaAqRSfqi1vDI7Lfaq10ZqNDry02lGj0fu2VM5CtML9sedAKgYJNKK4VV/V35Oov5xLANuQIvfGjodDx8Ntz4264m5fDCyUEkjlsOE0jDERJdPqhA2wM4XS5XLx6P/orGarEtu+dERjLjxtpwU7M0wCaBGGXBphnz485IunK1ydUeS3aD5JyuG87yPORVIot1LRpS57v09nVQqjFbIX5K5S4t9fbOhioU8YLTzfWk4crChGBNYoBlXWP5Mhk3BELAmty9TtUFkGCViBA/v+IZW93Xvwm0FsKz/y1fWK19aKs93Ijbbi4TBw5lwJyXIKEUVvEp1EIpENihbFWRrIrmg6r1U13zVfsCWw2rvsxQRDSAwpUbeaSSoH7zFHGqX4L4+v8wuPThhtItSZfWYWMWayoUyixlioRBT/fqVhlTxiiw6ppgRqUsGZ3/HqozUbX5q41mQ+2Ux5vR848x6UUBmhV4EXux1WBKmKZsSFjCFzf9iy1JboE61SXJs+gQP/G2+8wQ/90A9xdnbG9evX+cN/+A/z7/7dv+P69WIP+Hf+zt9BKcUP/MAPMI4j3//938/f//t//1v5L96CTlKCC1zkSw8vOK4sMWV+Y7Wm9wGJhePnSWiduKEaVkpxmUcehB6rNAuvmamKhkLHeT1v2DrPrLFUopAEo4/sxkCKwsJaPnTzmOuzKTlFnOv5zM0bfPH8jGebCQ/HgZd3W2JIHFYN/T6OGVXSIbuYGHXmeNowyYrtWDjeee9EcDkb8eQSFZ8Vn14ccTJ2jGnP01Wag8pibMMrbsVyYQtv2yd2znFQGWbGAuAnhqWtOG7tt/X5vhvxdtYfgA1FOOtC4G4fmZqaqBL3u54hJIjl4B33PfhlXWOjZxc9l5TI9ypprGhqrdEC2ziw9ZFGSpAXkX2QTaRKCm0zt6cTFvX+uebiAvTKsOWgsqxD5GwckZBpqclvpkfuuf5OMlHBXBsqhD4mupiwJAKKCwI5F/5+zJkPtQ3bnEs8vJQ04FZrKmu5v+1oakAKZWOMkVppZma/wYunUYqJvH9m2m9nDTZBkKwYQ+Krw4aDeiSmzIthyxgCpJIDMaSIRnjKNuwksPKO10OHMYZpb5loQ2MNtTVsc+JsN9K0FqIQEiSV2HqPQZjZzLPHc661TSmpEPl0OOLL3YrbTcOZ87zW9SSfmGpLComU9zwyBQHoSRxOa9qs6Fxk4yJUiQ2ZU98XelgqjZJP2xnb5Bh9MUuolLDQigNteehh0hpUBB9L3sqsUlR12bZKyI5i+T5q8L+d9WdzaR7sXOCF0xUHpiYmeDHtGH0J8ihapYhGcW1S0WvFFs+90GOMoe4TEzHUxlBpzS4ndmPA1Ka4NYkiJhhJaK+wBp5dTFjWhdaTY+JjxxO+vu05bixrH3jkHTllbILki8MdGkDeSp5ftpYmlobI1mWqShgU7KJHSaFb5pz4QFWzJRL2+gGLYpo1dVQ8GBKmEnJU5FzWQIuienPPzZpKgf0m+dPvBbzde3CdSg26MfNyt6HRGiPCKrly9srFNnVMJRfkmqr3lsJlnTJKM/GCSYWORsic55FtCNSNgQQ2gvjMNgWyVtS15kNHS641TRGbZ/hkdnxpu+LZquHCOe51PclnGquJY8k/eTOcMpFxZI4nNVUUeh/pXEnlHVTkwo8ImiCFQ/aJdkmfBtw+TLYRxYHWzFXN6+OG2lbkHIkh40LEVoZJXYEISUWmoph8k0omyW9lWb8zsF6vWS6XfN9/+wzr7MkIx3WLJTEMibOxp9sr9QFuTCdIzjSVRiiHp7VzKK25SUuKRZ3tc2IXPTcXEzpfbL0CmRJODBfDyNxY/sizd7i5XLB2nn9/93VOnefCj3zycMkueF7ZbDnpBp6dzZk1Fa9vNsVFYt/NmlcVB7qi80VU2xpLUys+vFjgXOKr6wv6GFkayzVT8Wq/YR1DsQVLmZxgYmte3qw4amp2MTDVhg/N53zy6AiN8PJ6xVHd8tRszkRb/nf/l59htVqxWCy+k4/uPYM3a/CP/k8+jivsYebG7usr0YXIGDNhX4OLugISTW2wUvIatt6hRDH1JTxDm8I3HkJg2lp8LmnSkUSQWEbfMTI1ho8sF8wrS58Cr663rENgGz23Ji0uJ86cY+08x6amqkvyrYsZjWAQWqupUHifEBTGaGoLN+uWGBP33cCYU7HbE8Xl6NkR9wE1xSu41RUPhp6p0qW7pYRrVcWzzQwtFeeupzaag8rQZuHv/sTPX9XgY8Jb9ffffJBdLGLspampjKCUcDI6dkOZZkaVWVY1FmE+sVij8DmyGjyShMYVPmhdGZIpQtqDyrKJEWMEFQtdIhvYdYF5pflDt25ybdqyDYFfe3TOiR9ZJ8/HFnP6FHhtt+NRN/LMZEqjhPu7gX6/zhqlOGhqGlSZhEYwKKat5uMHB4wu8vVuSxcDE6U5FMND33HuPXlveiAIc11xt98xqyx9jLRK8+xkwkeXB4hk7nYdM1Vxq2lYaMUX/m8/d1V/jwlv1t/n/qsPMEihMM6UpkKjVebCe7aDZ/SFn7w0BkEzn1qaShHIrEdPStAMAIIxRQQ55MiyrVgrAVXSew1SOqq9Z6IVnziYc1jX9DHyG+s1qziyHTx35hM8idPRcekDN6YzagUPu47BR4SMksxMVzQUTVOKuTg8NRXPTaa4mHmUHF4yrWgmKC6Sp0vA3ulEUhGqn/YDrVG4BI2y3KhbnmkmaKM5D44azcJoahL/53/6b6/q7zHizRr87PfeKoYUGWZ7m0wdS77INgTGvdB/aQ1Waaatwdhy8du5cq6aeY33Aa2kZBoROZ40XKRAvzd1mUjJEulcYFoZPnvtOtfahm0MfPnsgkeuZxU9H1nMGXPiXtdzOgw83U5pK8Pd1bbw95VgRFjaiqkplFsCNKKpG82H53PGGHnV9Qw5MhHNPBnOYl+SoCUjuUxK28ry+nrD3Fp6Eo0o7lQNH1osqJXmQT8ys5bjqmKC4u/8v371d63Bdyz5thHNJvuSckpJ7XM5M8S0dy4pQkSAmTX0MdIYhdWqRMMjtLUu3FKKAtoRSQomleG4auhiKJaDWtF7jydy1m9pK8PKeV44WxFF6G3goevJOaNEqLRmCJFnGsujUdPH4uSS90mrQyyuAdPKUleKJPCx5RF3VxuObEWnIq02eIHORTDFWq6PkbX3uFTs5pwvApBJbbgxbfjgcsHoM6fDQG0UrVE06v3T4X+7YUUR9pLUoDImQ0gZn/b8GVU485CpjRR7Vm0wRoMTRAl1pehS4ZamnPGSSJKwaOba4ijhNUYpsisK/Y13GAVdjNztBhIJpwtNA/bUHaXxKXJoKjaxpEznN0VnKeFyCctqlFBpIUnidt1y6RzbHKhSxkjpRvQhkY1g9q4EfQrEzN5ZIJeMCq2YV2XTC0nYJcFqodYa+/5p8L+tqJSizxGfc7kYZooN8ZtroCq0MxAaWwT8tdbUGHIOKKCpdEkoz5kQEwORoA01mnmjySGTQ8JYIdviwLMaRyamZJS8uNrgybgqcRrGoktJpRM/+sjNecu5czj2VDaEmMo6PaREjaLWCpTwwdmEB9uRA2eKV7tofMpcjpEk0CiFT5ldTOTkUShiKF28xioO63JoG3Ng60ZqrWhrRS3vH1vEtxNWhAF5a/8t4v3i/pTJb61/WUGrFD4lpsoUz/1cDltNrehC2XsLfSfiVaZSmqoySBJULjQa0ZFMZuNCcbqLkbu7nkBxS1tFR5EdCkYpQkgcTwznWuH2gm8yREmMMTOkhKWsXSh4tm555F1xxpOMQREj7GIuFrD79a4PsbR1gRiKzWKlikvRcV2TKGuzUVAboU5X9fekUCnNmBM5pzLIESFT1rKc855mWPbj2mrGHKmUpUHY5TL8aZuSkeRzmYD3EnE6YUQxVxX1Xo9n9w5jOcNqHGm0YhMCL603DDnhdeI8uP1UoTTYxhi5VbecVuV1vrkGhr3ovA+RVkqYIEr44HzOg93ASiIDiSorksushrIGVrok1299YNx3/H1MCJm6UizriqfbGeTEevRlD64U9T6R+nfDO/bAfz6ObPAMObF1oRyOUmadQ/GeV/tDvI80jUFhqHThPmehUHZsZtsH/J7ykLVw2js+erB4iyrRe18sOFNkkwIvbTckKVyplQu0yrBVnte3O1Qum1mD5mwYeMa1hceVMimWxfAsDlxGQWshq8w4RLYhkJMwbywfijMedAMXwVNXljqXYrQoIuVCESkWdiplploz0watNFAuNNfaCY+6DaoTblTvH/7g243eFwHQQGSbAlM0IcNACRkSipAo51icJpRgrcLHRBTBCqhacEMi7NMYswgbH7jVmNJZDcUBIKhAJLPxET30RBIxwy4namCQyEVwhcYRhQrNLjp8NMXdZ3+hIAm9i2UjlSK2DT7Th4DMhcYabpmGlQtsXcSa8j5UzFitSHtukNtHgWegQqhEo1XhSVoNjTXsgmcVhNnVgeuJYDU4dhLoUuTSOSZao7Gc+xGri0AjRsg5UWmFsro47qSEy5EmC6Y2bFxgSCUkyWjhwjuer+dolRlzwkdwMZAkc+4Dr3TbcsmMmXXwpdZs4G7XkUIm+EwthtN+5FZb82bIY45FtHsWR3JUWJ1JShEk44dimdxaxbPTltPRc+kjthJ0LGtznUtAomQhSCoizgSN0tTaIFoQgUYMB7bmNAyceAj6qunxJLBznkEVytg2OFpV9HKr4N7ixacEXpWGh7KGymh8LvVXZ4WZGNxuxMWysiglrGLgaV2TcnG48Snjc1n/dt5jXE/c2172ew/0TiVOvYOkiKlcFlfOsbTFajFnyLE03S6jJ4eIFkVWmiyR4CKKzMQonlI1qxDZhERjFDJqyAmdZD9lL5a0ORfdiN3bdWtVEk8roNVqbzGaip3WFZ4I1qOjJ9KnwIVzLE0R1l44jzGCaN6i1dZG8FZRWU2KCR9DSQGvYOgjQ8pElclaOPMDz9aLfd0UWuJOIEnm0nle7belBvdroBFFpwP3h54cMn4sZ7ZzRm6MDW/2vHLK+FSaI/jiHEQFOXnGMSIiTGvDc82Ec+9Zu0hdC2onJJWoRSEidBTaY5by3qxS1EqjlEbEoCUytZaLOCIeDuWbM295xx74X9luoSoL/BgjOzyz2qJEoaKUnkMWXMrc2/T8yc9+lKmtOLvseOX+BQA1gRe8ZyAzrQyHtqIVy4E1PBxHXu23nHY9GagnGqWE39hueNQPVFnIKnGRRkzQPGVbRomcp731XBAud5Hg076TZrjeNDzqe3xMGBQ7HxnGkVopNts11w8O2KaRs83AV8/XtMZwqAzRJZIWdBYaZUiS8TlzZC1Hk4YbkwlzVRNzEfYeGsOXhpFHoyO+f/Rqbzse9T26KROauD/oz1SFqIQg5FzEsFllNs7zPc/coG0N68HTZoUeSxfoHp4xZyzCVCs0inllWLvEeQhsvCeSqG058Jw5xy55RIr/8I6IjrBE40TY6ETIkRwz3VAuDELx858oy9Y5HBmVFX2IbCRglWKInkVb411k4xxvrEuiaoOmi2OJic8KmwxZZRyBmrJAzWpbalOVS8ACzaOxZ+cC4X3sFPUk8cqupxjQJJLP9HgWCoSIolizSs5kHdmMme//0G0qa3i07lBDhEFogDdST5cTjdLMlcUiHBjNhXec9QOXgyPpjDaZnBUv7rY8Gh0GRVCZPnnMWL5nJLFWheahElzsQnEyEcFWiqUqFxKXymY3psw2Oyqt6NzI8XzCmCOrbcfXLjsaypq3jq4EJwkYXVw5PIkFlrk2HBrL1KiSXAfMGsPXLgNnPuDeR8YFbycedCO6LuFXwWVGEm1VMkIklyYDMZM1XPiR/+lHblAbw+mmR3uPczBDuJcifYxYrZkbQ4NlXmkufWQ9+JJYbgoXPqnM/TCwTgGdNUkJHRmrDMeqYlSZdUrlkB8zm6HUopiSJzFXwung8V4wqnjtdylSiWIXHdfaGQ/ywGYcubfzKFU69H2CbEqOiRFFtJE8KiqjmWjFTCsaJYgqvuxNzpy4WGhr6h17jHrX4+62R9eqdPWHyEBgManKmHs/cUopEcicdyN/9FPP0GjFxaancpk4wjIavp4CfU5UUrr506S4XtWsR8cDV5yekpSJVMyZV8eOy+AwqUy4djlgkmIpFaOOeLO30Q6ZR6sBJwlR5XK4EMPF6PfGG2XCtUoDtRZG57k2a/FD4rLb8uKqiHKn2bB2I8oKVdY0ZDoVkRGaxjCzlsOqKtRiBQnNvLa8ttuyHgNBvw0+/E8Uap80ym8Gq3S+BFwNFC5WMImUyw/3xz78cW4fHvDFr7/Kf/+VV7jIjgqhyyWYwIXIBdA0FT9z7xG5Kmr7oDKLaHhwOmI0TMTwgECQTN1oZrViqVsao/nYYok2mn9zeg+A17dr/uidp7k5mVBpzbKu+Fd3X+GrZxcEIMZEjglVK37u7BGvvvxyiQrf87YfRc9mMKS6uLTMlGWuK+65LdPaUKF4br5gmwP/j3sv4157kaRgiWWiSlT9Q7/9Tjyd9wWSfrMIM28OzIYUwGeihqQhq8SYNCbBR5+/zs1Zy9cfrPi1uxf0PmI9uLAP45DSsVpYzQsXW1CF0xpUporCqouoWMI5Nqr8+5Upbk/zpDHK8lTbYIzihc0Kp+Dcj3zX/ICltWilaI3mV1cXvL7rUHthbsqZJMKvXm5ZPzjB69I1iCqxIdIkT1LQhTLRmpqKi1RcsEiK61WLk8QXtxf88vqMALQIFYaFrriM43/mU7zCtwuhdA9zlrf8kztKvseYU4lcNyUzgSR87EN3uLmc8eXXHvFLrz9iNUZMUAyxHKRzTmwJHNiKL15cEg3sQumsToPhbOfIyVNH4YH0RJMxjWZiYEFDZRUfmU1orebfrU5xCe73HX/oqWOuNTW11tyoWv7N2QlfOVsRpVAcU4KI4mfONjy6e0LMoYzYSWxTxmBAlZ+NiSo1dR4HGqWRBM/MJnid+P+dnfNTJ6cEInXUNBgOq4pHuv+OPqf3KpJOIIV7/+ZJweVEjoJLQtaAVcQRXA0fff4OTy1mfPnuCb9w/5RtSFSjpwsenQUdM85HamX46sWWXJXwtJQzrTOsfUApqEzFWkEiobTF2MTcGwT4wKSmqTRfGbZcdoHz0fH7rx1wWFdYEZYCv7ja8HV/WdZnKDRHMl/cdlw+uiAZRdJSqJoJHIagEmNINMowsTUxaqhLwvO16ZSoMl8ZVvz6LgOGiqJNmSlLfh/nkDxxaEh7Uwhdl5PgGCLeZzxl/ct1OSMmEv/Fd32Ypw6X/OrL9/mVu7/EKjiqrWYMCaPKOhpywiF88fQcqqJr8mQmYrg4HYgqU2lNt89a0LVCDBwkS5uEj80XVFbz7y8vuNyNnOwG/vCdG1yfNFilmGvDz5+f8OWw3hvfZySVJsbPnZ5x75WObEqyuIuJdUqskiapxHoMTIylrS07H4r2LyaenrUkA7+4PeFnzx8SbaLymkZrltrwKH5zNfiOPfALlChiAcglGj6VQ/ShqVBKcZE9wQhGK964d5ft+Qmv3DthQ2TnIge6og9wYC2t0uxCLMm1IsxURSazTg6FYI1QtwYjgouRvBdNXDrHNEdE16yio3OezgfavQvKl88uuLvbsahLuMPDXUfyCWXBIlgxKC/cXw/UGHpGBgpX0STFcVvjdCSqTK2KkwEBptbSKsu9TcdldOW2GEugTfl+4cQNPIjdd/Q5vachiXLzLFzAku+TSApmxqJUCaYpSXzC6cmWYeW5e76j95FdTBzu47TnlabRip0PpZtKocUkn0kxorNCVEJX6q2uAgI1ml2KjFExqzJ99oSQcXjqVKYFd7cD57WnsQrdJzaDJ8aEooTkTESRY7G4VVkRCXgpnTmTYGYrEgmvS1CcUYCHSVJMTc0mBHZ4XEzoBEtliTqhYxn7r97H4W9PEklA70NdkOJGkclE4Jqt0Fq4zEXX4VXg0cNTxtWau48u2YbIlsiNrOlzSRittWbli3e4oFioIhrvU9zznBOmKnX+pu1moxRDiAQdsLop9I7RM/gSQlghvHzacd5GFq3hnuo5241EXywStRKMUSiBy2HEZGGguKvlfXDbojYl5yRDow2VNtCV1MylMVw4zzoHtj5gEszrlqQSEoRL57jIV/X3JKGQohdJmRwhklhqg1LCOieiKZaZjx6cMVxseP18TRczg0u0StBOOGgsVaW5CCXISsdEnUsQ0pgitQhbBcoqxCT2Elys0gz7UCGjNUNOdC7Su5J5I8Drl1vW+xTWh8Bq50pAXKZki+zDEtejR2mF31M3EIEEM6UZKyElQ6UMtTLsSNRUTNF0wdNTBKIGxcRqUkqQhC5F+viO8j15T6E8Jimsqf2+lFMmSeTQ1GituAwOlyM0moePThg2W157eM7Ke7Y7x7W2RiJcqxvqSvNoGIpmiUytSuhgjJkqlcydtrFoUxp1EoVaFF2IZc9EsQqRmArVcmIt4jIvnmx4NHXMW4Micb8fil323rBDm0JDfzgOmKzocsCrokuQALPK4HIoPH6jaAzoBAbNHM2qd3Qqss0Bg6KNliwZScImRtZ7fd/vhnfsgV8rSmjV/oGLLhxRpcqtXQNz0UxNRR89v/z116iUcH/T0cVIS4lTXmRDqzRGafCR7eC41tQsm+YtfcA2RMSU6OO6Kp11nUBJptVFdX2xG7gYeOsHf2EMEzEM3rPJmdF5Tt3ACkdWCp8z1X7E41NkR2SpDJ7i7mJS8YhtteHp+YSNK2FeVgxHvuF63XAxjKxCYJSIVQplpWgOgIOqYlYV7uqvcfadfFTvWYhk8n5jkNJERXyhbCYpop1KCm8/pcRXHp1Tieai36ftikZQtFD0H7l4q48uMTGGmRiSJLxExhjfCtdQRjCpdEfVPmDPSLHH62MiSGZMmYkUN56QAoPLuCjsgmMXUxG1Q/GfVrLvCgdqVVw0Yk6oKJgMVsFiYtnFhIimEsUkKJa6Yrt3JHIqFt2CgA+JHKC2lrrS+PD+iZZ/O6HkTY3IfuNTQFSIlIRSk4U6CW0tbEPil197RKUUD/uBnhLFLgJLqUq3PIOK0LvIUWWZ1RUxJpxLbEMonuq5+JuThZxAUcTdOsFq59m4gJfiVDWnhN6MMbBxgiOxSp71PnE3Fl0nShf7z4HIRJc10EWwQdEgtGJYTgxdSGjRVEozMZYDZemCY+cjoyS0CKKFYQxkBVNlaZSQ4lX9PQm8SVt8y/VXCaRCYc25KCIrFG2jGZznV944pTKak2FkzAmjiz5obiyVGIigPAw5MLOKqRUCCh8zuxxRRpf/SUo6eUk7+s3p6tYn+hgIJPrkmWCoReFDYicBnzOrvaMZCEnKZEspSDnhVKJGE3UiUqy/Daqsf1WNS4LCoEVhg2NCESL7WMLHUEXjNPiICMyU0GqDXJXfk4PIWymyIiC6/F4peat7blA0VuNy4hdeuk9rDQ82PX0OSKXwOjPVBiuKHIExMWRh0VRMKlOesYv0IaJs0VAabVCpGGDkNwNIdGla7KIn6MwQIoe5wlaFdr4dy8Xjwg1sYiDuuSlKSkPQ58SQIhOtCbpM31UQbBImCLdmU9ahmBVUUqxhD0xFFwMXyeMoTIEsMPiIBg7qmqkt9shw8bt+nO/YA3+lNK3Wxbc+RVQWamMYCnWfIGVBqigCh6+dnCO5PIRGVHHsEUWtDNoovJSuUojlsJNyEV5WRpWDUY7knJloQyAz7B/XncmEGIXt6Bh8LDZlZCpRLCu7jxpXaKWY2ZoxJjoK9UiJ0BgFkhlzJGqNzQJZFzEHwnOHC54/WHLSDZx2A6thLB7tSdgmz0hCsmBy6WYsqrpoCESIOaOvBJNPDGrfYcoU9xpSUdE7Sv2Efeu/UsKQ4I3VDsnFM1xLOaQrJTRWgyre94k994/Cv9ZSHCeSLqI2cnFnMVIcfUSEQ2shFyepkCKh2PdjlTAxmhgzShSIojKGMRV7r7R3cDEiJF0WpUpJ2UCzILlsyNeahhuzmrWL7HxiCAGTSvLpkANh7z5Q2LswNSUTY98gu8ITQoXCqCLmH3Oxbq21wuUSOe/3Lg6VaDSZr59vEChhLqKwuhyeZU8n86k4RKUg5KocqIwSjBZ8zBTFCMysLd7oIaGUcGwrtIdtKHbIQYqgvFaKRW3xOWONLgclDGZ/uCqyW6GS0uEfKI4VBiFLmT4BPDNtuTOfcOESqzGw8SOGchntcsRJSWw1e2LTwlaknEogjZJ9VV7hccPk4nb3pihS9m5dPiWi/OZFwIrCZcXLl1tECy5njCisKftWriDKm0GGxeksSznYV1recjjbm6Qw0YaYyporJBZGoYLQp0SIkZADURLWwqIuBza9p2vYNxXkqqxNb54RAgpHxiqQfcdfZQVKc33acn3asnOwCYldDOhcpp9bKe5CIG/ttROli95pf+i8qr4nBw0oUWQpFBiVwVSm1IFkYhGTUGtNTJkXTi5LcFuMKKWwlVAZg4pFTBv3DntvDgUVZR81pgiyNaXRMRWNM0K/bzgf2wolit4FOlcYGZFU6La1ZvARqwXLPr8iht+swb3NpkIVMwUtZe3Lb1KR4M50wp2DOefOsRo929Gjs0InoZey5goUJgAwRQNl/RYNOn9zVfjOPfCLYVHVDEROxgGFcNzWnI8ZpYWUYXSJmMqmdOEcMZbI+ZtNERFKKoptlyKjd7g9V/rE9SUuXGUO2+IZfTIo+ug5MBavE8qXA9/zswVvDD2b6Ik+k2JCGeH2bM6RMaRY0gK11ny4avnK+RkvdOfkfYpfqzVZQec8yQiTaElkgipxy5+5c5MbswMOLnv64SEv7S5QEtmE0iUedMREhfYaJYrnDpaMOXBvt+Wk66nV1YH/SUFnzRRLlITPGRUzbWvJzu+j3iHsgz8EYTvG/SVMmOryAykKdK3KJTOW525Q9MmjQhGptZWhzSW11OfERBRJZwYpF7tr05ZL50vYXCrWiSJw2Na0WpHi3opWCzdNy711z/1xS8oZnaHOQlBCnxNKC03S5eKhM17g+cWca5OGlY68HjrOhxLw1CWPl4QnotJ+IUO4MWvoQmDtPKvouKrAJwODZqlteQY5IV5YTgzrfYcxkglZSElRieLSlc56JZqjfThaLWVk7VNilIjXEes1594VJygFs9aiI6x8ZoiRI10RBNa5dNJvT1oue8eGkgmQEmhR3JhOOKosPiaSCFpp7ojh1fWOV6InJFCpWMZVOnMWPFElJmiiUkRbhKC/72jJjemUs13mBbfiXr8hxlJ/o4o4ndFZUQeNEuG5xZRudFx6zzaHsqNe4bFDJ2iyEAQ6MhJh2lRsg0dUuR7GBCkW6uE6FrqOUYqFLfVnI4wEXC6TyWjKdHsbMiaWmlk0FiWJTQy4mFhWlhSFTgIRx3FV0eXMmMqlIebS9b8+qTkQS9i76kiC66oid4mH4vcDAqHKpYGyjmXNq5QmiyqXDmP48HLJtXbCqg+82nWcuaIJGUJktLHwuLPGJI1CuNY2uJjYEdjkeFV+TxAWRaM0UTJdKiLxxcyy62Sf1FyEuzlnKhTngyNQLDcXVanBGYZee/pUtJlSl8nUZnAYKRe3aW1QFfRO4WLiUFuczhgp3PhnJxMuvSsNj1SS7bUors9aZlIsikWg0obrVcvXLi55wPCWc14VC13t3HtilanT/hJjM2NKfPz4gKfmC9Zj5MXLFafbc0RgN3rGNuI1mKRoYqnBZ2xLnwObFNn5iP4m47TecQf+t6KUg8PtShiQJpOtYEs6Mq1YlBKSHjgdHHVdOv4RaEUzr2pyzrz2cMWNoxmjSvT7YKGplJGjTp5nljNuLibMTYVSFf/+9HUkQxVLEIOPsNoM7AZHiPvo5FS6qj/wvZ/hay+8zK4bOel7Ou+4Xk1ZVKXjFVOxM1tFYRcSlTLMpOIyD7hcRjNP6QkzPaEfPP04MPiRwXuaCKvkiKrYczqJOBOZUHGv27LeDpxHBxbatvptn9sVfu9487PskiOPZcKSyWSd0aFQy0rnIZNy4tyF0kVSQiIxEc3UaHLOnG4cbVMRJDHGkuhYZdhlT9JwOK240VjqpNGt8NqwKhOcqJjkwl8bdo6N94QYiSRSythK8V985DZvvLFiGAKbEPBBqHLF1GjCtmxUPpcuRa8jWhXP8k72Cx+lUzBRCtd5fAyM3tE5R47F/z2YspgGMkFFKm14NPT4MbKJkaQy07f8i69q8HHgzc+xzyO5LyNNQVBGqFEYKZZwCiGowOnQl6ArVeg/lVHMq4qcMw/OdjSNwpnMkBMplo7srgsYAzcXNcfTmhZDXRl+9fyidG0TLCnd065zrAaHSxGkjKgrI/zPft9zvPL6GcMYuHCB0QcmlWVeCWFTOnA+Cx3CYCJWNEpKAyZQHFGuiWWuLcPoGcZI5x3b4DE+c5ki0STwlDwMlWh0xfnQs+5KIGJQaX+5vqq/x4U3P8eBCG5PK1NlmmxTccmrKBadicTaeRoUfm8xbIxi3ihyhkcbR0sqrl9SknOtEjZDZKYTi4lhWhvqpKnmwsurHcRyuWiSEJOmGxLrwZWQJQFUplHCH/vI87z48IRuSFz2I330zEzFQsPdrvxdlxPbXGpHYRFX6JhZF91BS2aKZhgcQxgZXM/QO3JMDD4SQrn0Rl0sHSsUq8ExpsxAoXfW+8nYVf09Prz5WToSjHvbVQRqYeKELpRJOAI9cN476loVo4AIRisOK1v24LOBWWUQXaYERKiN4mJwNKK4Nm9YtlPqqJgcWr5yeVHW0aw4UBWRxBgCm86TYt5PvBKVMfwvvucTvPD1B+y2Heejow+JG9ayNJp7Q5lABAVDhhADRgk57M0MKDSlZWVY6Jquc/QpsvMjGzeSY2YMmTSWxmFUkU4iNZaz5NiNgQ2BbGFemd/2uf1OeMcl7b7xxhs888wz3+mX8a7D66+/ztNPP/2dfhnvCbz00kt86EMf+k6/jHcdrmrw8eBqDfz2cFV/jwdX9fft4ar+Hh+u9uBvD79bDb7jDvwpJV544QU++clP8vrrr7/no6rX6zXPPPPMt/1ec85sNhtu376NuqL3PBZcXl5yeHjIa6+9xnK5/E6/nCeOqxp8Z+FqDfzWcFV/jxdX9fet4ar+Hj+u9uBvDd9sDb7jKD1KKe7cuQPAYrF4zy82b+L38l7fDz8Qbyfe/IFZLpfvm/qDqxp8p+BqDfzWcVV/jw9X9fet46r+Hi+u9uBvHd9MDV5dR69whStc4QpXuMIVrnCF9zCuDvxXuMIVrnCFK1zhCle4wnsY78gDf13XfOELX6Cu6+/0S3nieD+913cL3m/P5P32ft8NeD89k/fTe3234P30TN5P7/XdgvfbM3m73u87TrR7hStc4QpXuMIVrnCFK1zh8eEd2eG/whWucIUrXOEKV7jCFa7weHB14L/CFa5whStc4QpXuMIV3sO4OvBf4QpXuMIVrnCFK1zhCu9hXB34r3CFK1zhCle4whWucIX3MN5xB/6/9/f+Hs8//zxN0/C93/u9/MIv/MJ3+iU9FvyNv/E3EJHf9uvjH//4W38+DAM/8iM/wvHxMbPZjB/4gR/g4cOH38FX/P7Fe7EGr+rv3YOr+ruqv+8k3ov1B1c1+G7Ce7EG3wn198QO/N/OA/sn/+Sf8PnPf54vfOEL/PIv/zKf/vSn+f7v/34ePXr0pF7m24pPfepT3L9//61fP/uzP/vWn/2lv/SX+Of//J/zEz/xE/zUT/0U9+7d40/+yT/5HXy17258uwvGe7kGr+rv7cNV/X0jrurv7cXVHvyNuKrBtw9Xa+A34jtef/kJ4B//43+cq6rKP/7jP56/9KUv5R/+4R/OBwcH+eHDh//Z7/vsZz+bf+RHfuSt38cY8+3bt/Pf+lt/60m8zLcVX/jCF/KnP/3p/+SfXV5eZmtt/omf+Im3vvaVr3wlA/nf/tt/+za9wvcOvt36y/m9W4NX9ff24ar+vhFX9ff24moP/kZc1eDbh6s18BvxTqg/83ivDwV/+2//bX74h3+YP/tn/ywA/+Af/AP+xb/4F/z4j/84f/Wv/tX/5Pc45/ilX/ol/spf+Su88cYbzOdzRIQ/8kf+CD/90z/NX/gLf+FJvNS3DeM48hu/8RvcunWLpmn47Gc/yxe+8AWeeeYZfvqnfxrvPZ/97GdZr9cA3L59m6effpp//a//NZ/85Cd/x38358xms+H27dso9Y5jaH1H8O3UH7y3a/BJ1R9c1eB/jKv6+0Zc1d/bi6s9+BtxtQe/fbhaA78R74g18LFdHfYYxzFrrfM/+2f/7Ld9/U//6T+d/8Sf+BPf8PeHYcir1Sp/9atfzUD+R//oH2Xg6te3+Ov1119/3I/yXYlvtf5yvqrBqxp8fLiqv6v6+07jag++qr/vJK7WwHduDT72Dv/p6SkxRm7evPnbvn7z5k2++tWvfsPf/1t/62/xN//m33zr93/qT/0pAP6X/6s/hjWWEBNjDFBZjE/0ztE5R4qRxmjqdkJKmd1uhZIMAj4ERBlEItdqS2sNSoEPniE6XIBMZmE1RuDceaa2QWnFED0uJiZW85HrSyaVxaAZc2A1eFaDJ6VI9nDQWl473zCmCErocmTRWgZf3stRW3GtbRh85tXVmmcmU87HkW1w+BgIfeJ6W3FrXtMHcDmjlTCxQoiRsQuQYNkYbh82HC/nHC5rMrDrIjFmQgj8r/8P/x/m8/njfpTvSnyr9Qe/cw1+7/d9mqYxZIHBJ8YwICGwHSIhR7JkdM4owCioK8OsabDW4FJAJ2EIiaO2ZmI1WgkxQ1KaqqrBVkyVkEPgwW5Dg+DJ7AKEBMvG8snbU2ZYUoAxRC59YuUDMUUUmqVWvNw7Ru9RZLxWVFaxGyM5R45ry7XKshs9JyNcb1o2yeNyJpMZdiMHJnCjrQhostIYY5g2hsYKMQkGmBvFUW1ZtjXzawtMCgw+ExL0g+N/8zf/6VUN8njr77v+0B1sZUg503uHy4EWxbpzDMGTyRijsEYhCiamYt62aKNx2aOzpUsDx0qztJZGK2LKbInkEPECR7bCZuFu1zMzijHD1nlGn1i2ls88c8Skami0YnCRe+uOR9sBIZM83Ko0v36xZoiRSgmdwHxScdaN5JS51dbcmbSsfeRrlxuea1rOwojPGZUy623gqVnFM5OabYakFXVlOGw0wQoqayZWc2gt19uKxWLB9RuW5CIX68joMz56/rf/p5+7qr89Htce/Ae+9xm0NvgQWbuOznum2rLejbjgSDljlEKLIALzacNyPsFUmsGPGKXoouO2bVhUltoqssAmJwiRMQeu2QaL8Pp2y8RokggXo6PziYNJzeeeu86kbpgZzS54Hlx0PFr1JBIShRu14VfOLuh8xBphNGVffrh1aIRnFxNuLxvOdiNfP+t4rp1wHkZ8DOQI253n6VnNc/MpFzHhlDCpLEeN0BsAzdRUXGsqnppUzBdTrt2oyUPichtwIRFC4i/8H//NVf3t8TjXwN//2SNsbckCfUz0KVAH2HYjLkWSymilMAqUFhpVs5jUaKPogyNLRgRmPjPVispqshLGnIFEFyIHxmCycL8bOFSaAbiMgcEnlrXlD9w6QKvMTFf0PnK6HTnrBnxMqAA3GsMLmx1dShijCWQWE8vDnUMBdyYNT7UNJ2Hk/mbkdlVzGT1jSpAyuy5ws7bcmVZsYiaI0FjNvBYwIGhqa1lazTWrWTQNN59qiDFxsUl4n0kJ/vf/11/9XWvwiVB6vhX8tb/21/j85z+Pc46bN2/yD//hP+SHf/iHWU4t88mUmGDrHEELMzFsRofqOpwLWCmLjdbCYjrBGk3Kmc3YIxkGH0lK47VGaxCd8EPig0dLxhQxIowhkn3g6YM5XmfO+hETIsvacriYsXIjdw6WKFEc+ci2d5zvdlyuO9q2ZTLx2BjBgE8jqqoQEuRMXVfMpy3WRWxvSUqBFkLKDCmBZELObGLk0WZkM3iSZOZWSDlxdj6SI9w5aGkrYVZVLJ9ZkBFy3OHHgJcAgIh8h5/kuxe/Uw3eOTzgeDlBGc0mBE42WxrvONt6Lv2ATwGbEypnaq2ZLWqOplNSzty9XGNCJpIZciJmsFloRDNK4qMHE4JocoqsO0+IkWeWC7Yq8mhIhKCYTyratuFy43l6OkeJsIywcYGLcaCL0FaGmSiqYIDMKkMygkoRJZF2UjOvK0BY54gYCB76nAgpAkIk06eyyPXJo7SwCBZrDOerHpMST00r1NGUVgmHiwkqRWTTMbiRICNwVYPfLn6n+nv6aMHxwQKlFKt+4FG34UArHp53nPU9LgUqrai1QWs4WE45ms4IKXF3dQkh4HKk05A1tFpRi7CNnj94/YiN91il2LmI22Y+cLxgGwOvXe4QIvPKctA23NuO/L6b19FzYVI3LJqO82HgbDXQ1A2TuscEhdFCTyQZEC0g0DaW5bSB3tHUBtFCStDFSEiZJLlcQlLkbjeyjYnaGm7Pai6TZ7uONEbx3MGE77q5pDaG5ew6yTl2ux4/Ooxk4Kr+vl38TvX3oZtHHC0PiVl4uLnk9YszbjYT7l9uOd1uccFTa00tCqWEw+M5xwdzQkqsTnoMCp8i6zDiVKRRmolSrFPgD944YjU6ahT9EBhc4tM3jtjkwHCRSbnU33JacW8z8vSdmxwrYV5NWVZbzruek3VPXTdM6xplAtoKIwFvBbQgCHVlWDYNo0/YWpPIRGCT9o1EwElmkwOvbXouQ6SpNc/Oah4NI6suMtWWjxzPae8cUFvF4WJBrALD0IF3KF0oFFf19+3jd6rB24s5x7Mpog2XznF3t+FYaU5FczEOjClhtaKpBK0Vy9mUw9kUFyOX5wMmCVFHdinjVKIlMVOabUh8+mjOZgjoDLsxEELm+YOWMxNxm4xkYV5ZDicNr6zW3Lm+5FAJM1sxVZrzYWRFxBpLuz/3iRF2RJwtFxABqkoxbQzbIVAZIWUIkulI+JjIGYLAlsy9YWQXE7VR3AiWTQisu0irNM8uWuz1KROlOFrMiSHRbzZE7xFdPsffrQYf+4H/2rVraK2/wU7o4cOH3Lp16xv+fl3X1HUNwPd8z/fwi7/4iwDo7JlPLFoZJr1wuuupTSZY6JuaKJoUPCEEcs4YqxFlUCljMShJeJVJCCPldnfLTphq4YNHC3KG11Zr3lhv2Q2Ba/WUC9VhR40osErhUuTu6SXP37xDXdVMXKJRAzknZMzMJi03UyKGQCKRxoSgCYAnMcbMegwMznNgK2KKbPqRrXeEFFEeQhV4sImMYyTGRMwJhzC1GpcTISVOdwMvPdIkr/jQR4/QWqG1ImpdLhdXeAvfav3B71yDtTZcaye0jWWXIt4FppVBq4TbCWvXQ/QQM0kUTgu75MkukcZMREGbCUBIiUpbnmlnbKvMc4sWrSwvXqy433dcjpHjuiZlx8QkvAhWBDdmXr/oeHq2oNKaSikqMUjMWJuZNTW3Y8J7xZgzLkIik2JAScaPgYsEO5eZ60wOAZcCLgRCSJAUSQzbUDoLWWVCTng/oFPNdtdByEjKGGtJQfiAHxBlgIjKEZ3zk3yk7yo8zvprRXFrMmXWNuzakZQSc5NJM6FPkTBmFAqVNRohVppeEikmQFAxYxogCesQUMrwkemChfJ88toRKUW+fLbiK5s158PIU7MZj4YtrVYkndAidH3gqw/P+e47t5hYi4hCK8EoIUdhuZjyPIHgPClBiiMhJ6bGEELCpcSpG9kNgetVg0kZnzIuJFKEBAQFpz4SlUIDSoGxitYbHsWR3rO3sVOEIfMxv8SojBHQlAvEFX4Tj2sPrkXz9PKASdNyfTrBRcetqiEroc+e0CWUUmjRGAWhFjbJk3xCa4UkAZPxZLowcqRqvutgyZGN/L7bR3iX+bUHp3zt8pKT3cjzB0te7C6pjSKGiJHM1ge+8uCEzzx7h0llYS6QM1oUKQrL5YwPEvEhEFJCXMcoibk2iAg5wmYbON8FbtY11sHOBTofIEKI0OvMQx8IWjAolBaqRtMGzYl3BJd47UKwwNAFPv6JY5QGowWjNJKuePu/FY9zDbQJDm1FU9e02rDajhw2gtDSrSJDP6ISqKxRIlAZ+gwuJjQKFcGZRNaKjozN8LRqWc7hU4cLvIv8+umKVzcdF73j8IZmnSPl+K4wWRjGwMtnOz596zoTY6BJRFeRUgLRNHXFM1oIOeNI3HcDLsPMlCZcSnA5OrZ95EZVkT0MLjHGRE6JkDNBC6uUSUphAK0V1mpsSozB43Li7ga0QJwnPiWgDGhRWNQ3fQp87JVaVRWf+cxn+Mmf/Mm3vpZS4id/8if53Oc+95/93s9//vP8d//dfwfA2cWWe/fvc3FyggyBcbPj4mJNGkam9QHT2XWirlBakZJnvduw7laMvkNrjWhLa2qOFwtuLA44mixYVFO++/bzHE9m3Fw2KKPoYka0IWoFvWZiDLO2pq1rsitjpNfOHjIgYCxWaY7qCqU008oyqyy11oSYuOgd29Fxez7h5rxlWhtizgwhcoRBpUTvPLve0fee4CNTrZAUMVaYtob5pEJZYRsDqIxVMITIq+uOX3l4wW+8fMHp5UCMGS0alb7jQ5p3FH4v9Qe/vQYvxp5Xzi64f7ImbiNE2PUOZS2VrdCiSaJpJ6UD0e8Cm+3IznmyVfvOj+F4OuN6M+PATllOF/yhW7e5NllybVqTBLZjxIrCG42Lmlop5laYKlAOdinx4uqMi92W3g9ECTTWEmPpPi21pRFNzJlddIyMHDfCUWVoVKGHDdEx05YchRgSISZSBjGJmdZEEYyCiVZMlCLGxNqN+BDIOdKHyL0u8quXI7/2ygkPzi5xw0j2gejDE3qa7z48zvo7HXq+9sYDXn7tAbtdj46JzVlPNgrdaFStkMpgFg22tvTbkdV2x9b3CILWFq0Ut+Yzbk+mHNqGtmr4bz7wLMfNhBsHU7yBU+9QBgKGvstMteVo2rBoK0LIbJ3nVx/c58FmRe8dVjTX7YScM4vFhNnEUBnBxcTpdmQzep6dt9yeT5hVFSlDT+K6rhEgjJGxL00O0XAwMSiBaaU4bC3zSpeGyb6RUxnF6AIvn6752TdO+MUv3+WNh1uiK1PanK4unL8Vj2sPfrhb8ZWXXuTll1/Cdx0tikebS6oa6plFtwaMop7VSF3RrUe2l1vGoUOp0mHXonhqueROu+S6mXLczvn+D3+Ya5MpT19bEpTiYe/QVoiVxXfCVGuOZzUHbUXuM+fjyH9443UenZ/j+56KzGJaoZQwX0w4nljmWsgxc7J17LaBTxwd8IHFjIk1dDHicuamnmK0wo+Jro90PqIquFbXpJyZVZprrWVpNLsQ8CisNUwawxgjL5ys+DevPOAXfu0NHpyuSQEq0eh8deP8rXisa2AIvHhyxmv3Txi2PSoJl7sduVKoRqNqDVpT2QlZVazXA6vLDWM/YK2h1gYBrtdTbpgJR6rlqJ3yXz/zFEtTc20+I2jNRQioShiBcZeotWbZGma1xvnMlswL5xecbzp678gqcVBXxBixVlhYodHgU+ZsCIxj5IOzKc/PphzUFUkUYyUsbQ1K8DEzuMgYMtoqprVmyJHaKhaNpTWa3kfGXJofTaVxMfHK+Y6ff3DJz/zKfe6e9OQUMToj32TT7YmcFj//+c/zZ/7Mn+F7vud7+OxnP8vf/bt/l91u95Zi+3fCD/7gD/Laa6/xYz/2Y9xZHCNW2O46LrcbjqYNr15eEoBdesSQE0oJ1XTCQSWo5SGiqkJ3ITEhEoJl0cywVcXMKm6WCySOSIwa1JR5kxEgijCZtMyx7IJHtOLadMLHxwNOznZMq9c4vPVx8vLD3H1wl184/R9Ybiyu89QalBH6LuK0Y111aCVcrD3nO4eTyGeWh9xdbfncc0/x3LUZY/D8yy++xmTesl714DzkTIiJs61HA0YZgk4kJSQjrFTgf/iNU2av7vjU7QM+cH1GM6ufxCN8V+PbrT/47TX4wZtHaDSuc+w2Wz40rfn62DEMPb3f4ujRRqgrxRRD09SA4FygigOHkxqtFa0yVE3FQWs5mmQ6t6XrerRWbDaBPCpqMSiluV7PAM9l8OQMc4RPVBPubUZOhnW5omdBonDiPHe7CzZdwGRBKWHwDq01nQYl0HXCZoBkArcnE3Yp8Nlnr3N7UeNGz0+9+IDja0vOu4TzAzEFYsxcrByeQDNtEbFgLE4pQs78qxdOqSTwyRsLPnDY0lydt34bHlf9fdedDxLFs9ltuNxs+EA946vVwLbrGIMjSALtmbYtC9cwmTSIKPoxsE47lrXl2XqCaKgmLTdnDR8/mpLJnI0DOij8TqgHS600zgXm04br05bzsSdK4tZ0wh88vM6r99a8crYiv1l/QfG1yzUvdyu6tafKgtLQeQdjZlVXaKU4Ww+cbh0+J559asrDS8f3f+I5PvjUEV1I/D9/6WscLhq68w5RpZOfMjw89yidqXShhQw54ZViJPCPfv4uWt/jv/zIDX7fMwfMJ9WTf6jvMjyOPfjTH/gEkhzb3ZZ11/GR5TVeOnvAg7Mt27HDJUfSiulEMXWayXRKVIYheMZhx9G84uOTY3IK1NOKW4sJz1+fEJPjsos02hB7oXIVBsU4eg6WE27Ssg4etOK5+YI/dnSTrzy85KXzFSFECJlaLL+2WfFr7hR/GWgRjFX4nBjHxANX9uDVNnCycQw58pFbM7582fM//wMf5sO3j9m4wD/7+S9ztJzRne9IOQGZlOHsMpKqRFUphjEyALZS9Cby4z/3MkoJ3/fRp/jMc0dMpvZteabvJjyuNfBj158CE+j7HW4Y+eCs4twl7q/LGph0xNuEnniWo+ZwMSeIofeeYdgxqw0fmCxx0VNbxY1pzY1FTecCbvRgDXFUNKFGVMKJcG024bbS7JJHKcWddsr3Thyvn3a8YTuGFAkhUSfNa+PAa3rAbz1N0mityTmzGwMP7IASoRsDq94xRHj6es39neNzt6/x9LKh94Gfe+Wc5aRmWA9kymYac2Y1ZpTO1JXGuTIJ0EbhdOL//qWH6K884nufOeLTtxcctN9cDT6RA/8P/uAPcnJywl//63+dBw8e8N3f/d38y3/5L79BxPGfwp//83+eH/uxH+Mnv/QVaqm5MZ/wkacWtHXLNIysesd217MZRrQWGiBqzbGtqawCZYjK4mIkSmLte2x0uEHw2zLQqOuMiyMXXYcLnsoYWmuLCISEoLBKURvN8XyKhAGrK5pmgVlex6xHbh3OeeZ4zunDcy63AzsXaCq40ViO29J92HnHloFaKXZp5HQY+NrFKZvUYUVzNLN84vZNlvUGGyNaC5sU+eUXH+L2c2oRQSvFpKpoG0s1tQSBN3Y7HIG5vtrs/mP8XuoPfrMGf/qrrzKpK55ezviuW9eY1BXLzQZHAp+JXQQRUupZK4tBiAl8SkUALgGTLMEHdE4454m78oOplWYUzxvbDSs/MFM1c6M5AfIIEsFqoTGaa7MKcXA/OaIoMopN8txZTrk5q7h/suZ8N7LzgVljuG5qGkCAR8mzio5mL3raKeFe3zPg0AkOZy1PHy+oqhFLjZFMNwa+PCbGOKK1QolGK40ShcmJoCJjiLyy2THEwEKupky/FY+r/v77X/8y89py52DOp27fYFFNuZ57NkMkDhB9QkQIOC5UIKdAToJPeS/gjmzJJJexIZB9JPVlGtMohXMjL68uOA075toyaw1jnwl+hJSprKatNXeWLdpkXunWhCxIFi47xyeevsbTx0ecvP6Ih5dbLmPkYF5x3Vbcmk9RIri0xQ2RibXsvOfMO17crBlNxGbh2szwB27fYmrPy6FNW7Yp8yt3H1JpTXKeJAJZMF5orDC0mZgTv3Gxpg9F+HmF347HsQf/s5//JRZNzfPXjvj9zz/NvK4482te224IfSSNkaQzoQ6s/JtroRRqjYVBMjl5Uj+g+pFxcKSu6H0qHeld5GuPzjjrdyyrmlnVsnOJGB0ueIwY2qbi2tGcj3Sar3aXb1G7HnaO77p9nQ89dcSj1065v9pyGT3HE8O1puHapEUJOL9jUIHGGs6i4zQ5Xlid0+sRlYVbBzV/8Lk7LJsTGjRGadbe8x9ePwFR+OyLKDmDDcLUKNZtRGV44WLNmALH9VXT7T/G41oDv/TghINpy0HTcLxU1KIJSnjDd4RdIgzFMCVLYhMTarMDCr0GBV4nVtGRQ2Tw4H1kHCIAVRjoSbx8seGi75hVlqWtOSGQUqFYK4SmFm4uGsjCq32PGQUTFavk+cDxjFtty3nacb4b2UTHtNEcm4rFpEKAByRcgLbSrJxnFQIvux3bzmGTsFxoPrSY0SA0FD3WLgdePN2iDEgszTyDYkKhVG7qokV5ed0xxsg1+82dA5/YTv2jP/qj/OiP/ui3/f0bPzDEiFFwstXU40iVNT45onJgPFkEP/YgljjzYPYHEyv4rPAuIRlcDPQkugwxZeox0fmeyzHgc6YCIpkueCQlKqWZVgYlwqTW2MmcUDVAJvkdzndYlRl2PavRcR4cQ0xUAseLioO2QURwIeJ9YBcifYwEFXk4dGyTo8ZQR3h4uaFzI7enEw5nLUcC9y+3DKPndDcQvGC0oaoqZpOadlqjlMaFzMnGc4F/bM/svYTfa/0BbLqOMQYmteLM9fTZYZVmCDuSBIyVtzYDSRlyQkSBViSV8Vkx5oBRgBeGmHAZxgAVkS47Llyk9JVycaAKmRQ8VhQzbTFGMbE1tjaEUXHpM1tXxD6SAsMuswmBVfSMKdIGOJhoZN8pOMSgEoQkJKXJJnDhPb0vB35RmpMu4kJmWWkWlWGsMifLgdEbthFSNogoFEJrLV3ykIXeeU5yZvVk4jze1Xgc9XfZ7RijZdJaNtGTho5a2cKvb6C2Gg3okEgakkkIApKIUnQgYwpEA5IUg4dBCSFH1ODZ9AP3tz0+JpLKpDGycx4VIpXWzOsKhbBoK+rWMFwWPdG6D+y855bP9KdbTseRsxToYqRxhlvHEw5nFSJwm5aQM72P9CkQdeb+rmMXPDYLxMQr52t2o+d4PuXaYoZTinvrNT5nds7jc0YDtVEsq4ooHpUz29Hzuu84FfdYntl7Db/XGjzfbujdQNsaTvs122CoawsWbKtpbWlyaF+64vlNWoFkomR6PP2YSXhyhG5M+ErhxgBjx2rneH213TfaMsE7VuNAlSITY5jXDUoJy3lNPbVszhznO8faB7romStFuBw4HUZOvGcXI3MRbt+aMaksAjyVi2ak84FN8ESdubvZsXUOkwov/zdOz9k6z81Fy/FiSge8sd6Cgu0YCDljEVqtOGwsLmfIwsZ5Xr3oOJWrPfg/hcexBvY4qmios2LQgkse0yjYgamEWjRGBBszMUMR9BTXKFFCItEFDzoRI3Qx46MmkvDrHbsQeNQPhJzIZEKEjkQTI40IU2tRSrOY1rTWFL1RGLhMjp1PPJUVZkhsYuSCMomceMVTRy3G6MIeyeVl9THTx0g2mXPnGFKkSqWp+/LlluAT16aWRWvYobm/HYoRwlgcsVCCtYpGKTqdMEAfIg/WI6tvsgbfsTt1VgkfA6uu55UHCaMzN+eHOOeQGNGSESmWbGNIHMZEI4I2Cm1Ao+l3gZQyQRIhenYxIWQahJ0L+JgxWmOt4bwfGGOgkiLEsSiQIp7YjpEHF2vOh9eoZpdcnF0gIROi2ws3SjdVJWFWVyzqIugYjOWwqmlM5OakZeM9u+wgFdFbyom76y2NEpQWEMGniK40h1YTstD5hDGWyaQma4VSBqUUMUd2IRLCFX/6SSHGhPOe813HS6dnNFbTBmEcR1TK1EoVYZhSBB8Ro6mrCiMQJGCSYtOPjDERoVhwSSJGxQxLHxVgaStFoy33d45dyliVqYyhUgZlDGI0w5AYnWN0Hh8DMSVwgYFITB4hFi5pTDSmuAG5GElaI40hoLg+neF9TxcHcsqoLPgUONn2zJRgstqLiBKqEpa2QXlwWZEBJZkgkBQgCkdiHSP5SjX5RJBSZIxw3nW8dHJOI0VjRKbUngIR3rJslVlDbSusApM9Vms2u46gihOTi55ujCidoPese4cLmYmytFXNq+tdEfdK4sjUNKYqEx6lWG071mvHbvCMMeBThD4QVLmsaqOwKUOAha04amtCTHQ2clhXNDrw1HTCVgJDjsQIlVK4EHjlcs3EKLQWkIxPnqzYH/psWYcRaqNxOZNyoWGOKeGDZxWvDlxPAjF7+hB5tL7kq/cVVmkOpzUKYWoMtVJkKSL/0WcWdkptbWl2KI9SwnbrCbp0I8cY6PsOyQnpPJfbkRAz06qibSq+fn7JhfdUwDXdMNUVoqCylpPLHZenjm1wjJLIKaJcwkdHzKBUqb8chKO6YdZWuBDpbeS4CUyN5pnZojio5ED0mUZpxhR46fySo6rGqCII7lMk6sxBVXE8abjEoXKmqTRjzuRUrB77FAkus4pXe/CTQjCJUTy7qDAOFIlF3VArw7Kq8DriUzE38T6TZ5qqslgFURKWzHrniCIEYCDiosNYYQyJbR+ICVpraOuKu8PIVmVcjCz3GgClhLo27Hae3aWnHwOeDJly2TUZMYK1muQEAszqmqnRuBBxJjFUiSYlbtmGYDIdAQlgUG8JfQ9Fo0iknBhjJApMRTPThm7vKqm1MORUTPelrIEhZ7bpm3OIesce+GMK5JxwfWB1PpBzZrhpqaqITlBlISnBVcJlN3A9FiceNOgcsFaxdo5kA1FyUfG7wKQy5Nqgo8WmhNaauql47XLDrLLERkHIVKPieC4ksbz24IRfffEUO32Jg+s1zgtLZWkmDYdNxCB0uYzTVVbMjWW764k+Ikq4M5nyP7p9nWum4TdWlzRGc9w0vHq5ZpPgcFrEbKebLW9sdzzaDTx/MOPOwYQuBbISlNGc9yPVKJSMhVRGVlwRqJ8UUip80Yt1YN3tsJXl+qRFj5kmKGyGpBReC5f9yI1bFdPFFKUyIQzUSRi2A31O+wXHs42RiTVoU1Mpi1IGLZm2tnx966nJLCeGCsELmKoiasWDc8fLp4GkBuomYLNgPJgqM5eMUeCSIohCKbihG87CyCAZU1sO2pqPLg847CteWQe0SiyM4fXzNT4J7byFHLkcRh6MA2fjwJ3JjGu1ZUjCGANjdJz7gAJU0kQtKJVJMX6nH9V7EiknYoCz9ZbNbsDUmmeODlFOmHiDlUi0MDTC6nzkZn3M7HCOsYoQBpokhIuBFCFb8Dmw6hwHC0OFxmLKRc8YZrMpv3B+xqHUxdlHa5YRqtYSArx4/5L/8NUTTAuHx5ZagwmwWNY8YzMz0VxmzxgTJgrHuuWs7/FjEYffnjd87tmb3Dlt+dL5JXVlOW4bvnzvEV1K3GpqRDIn6w2vbXbc3e34yMGc29OWjbX4nIg588auo6IIQk2t0Cb9Zmf5Co8VUTwxCo9WgYvdFq0Mz946ovKZZbDEnBlNZKcDq37ken2d6eEcU2W872iSJVycMURNUuyzbDquHdZMtKU1GZ0V2gjtrOVn759yvWkQlUmiWUwT2ihShF9/6ZSf/9Ij6qVw7amaVgnSJ+ojy535lFaXfIqQoEZxs5lyut6SQ6G9Pbuc8V8//zS3HjR89eyCaWW4MW354sNTxgiLtoYMd8/XfHW14vX1huXxER9YLjg3A130eIm8su6oRVCiyFXG64Rwtf49KXiJjOKRAKkTrBGadspM1Sw0+Bw5DY51dHRdZPnUIdVhi9YQ/UjjNbuLHh8NyQhBEoPfcXhQ0xpD0GCyRhtFO2v49W7DoW5IyROyMGvA7PMYvvbGml996Rw9F5bXK2ZolAcmiqfshJnyrLOnDwFBuGYrTsZisKK0cKeu+d5b13jmsuNLlys0cGgtL3c7os60tpi/PNoMvDY6Lp1n1ipu1DVbFQk5kSTzyHkMQhIIpria5W9SOP6OPfAHFyElYsiMQ0KS4H1kUivqqgGBJJnV4FFJ8N4zDAO7bsflesX1ozmb7bZ49duaCQqlDdFofEyEDD4GRu8JOSLAyWpEdSAqcWsx5WOTY3LOfOKZm+w2I5s4YBPMKo3eQVdHRheILiIRqCNnfc+RqXntco1YxYeuHWAjMMLNxZyvbi859w7E4rWhiQEhM46BMUZ8ylhdsR0DtVg0BhcSm+jwFVRagUkEX8ZEV73VJ4u87+ikEAk+sE6R61VLU9kiMBR4OOxK2zsCCYYQOFltWMwanAtoZTFa0ShDUgI+0JlEVIkYEzkKY4SMovPFwtAmx1gLH5s0ZOAjh+B6w85blNGoOjF2I8HBrkuEqFBG0VSKJIFI5jIndGN4djbBmDlQul8vKc3aOYYx4ACDwzlYY3B74XgdFevR0xhFTkIfPOe+BN4sU03IEMdITJHgrza8J4EUUzn8pEjIAUmKTVextJZWWZpcEbNwsl2RuwxBQxY6N/Do4ozr05ZhHAii0U5Rqf3kZ3SMKJItXdecAqMv4+Gu66gCPPA9Wxv5dHsdgM9+6g7DmNi6gaYtnFLVK1ZxpBs94xhJCapac5I8x/3I184uUZXiU08d0PjI2HmuTVrc+SUXXcfgHWOOiM+kmNh1A11MdC4xi8LZtmeiFTlD5yOn3uFy5lA0GSE5yHt7zys8fqSQCz2HhE8RJZ4+jDS6xtYKyWByZrVakcaMziAI3eh5cHHBcbNgHAdCEEQpJgam1jDsRgIBbzNdjPgQsX3Ahcx266hnivuhY10Hfv9Hb9MC/9V3PU0YEj0D05kgWaNGYeccY+dJQ6Hvqko4cwOzvuFrZxeYSvj0nSXGZdzoeGYx46tnFzzaDvhQJq/ZFb72qhvYhEKNbBDO+i0NBpMUKUTu+56o4Ll6yi4nhpAIrpxRrvCEkBKBhFcRjyNh6eOIVqCtBdFMAqx7j0TQSZAkDNFxdr5iWjX4MeCSR5SitoKuYNj2mFqDUbhtIDjHOCZ8iCWfpNacSmBMmt8/vwFkPvPhQ2JI7FJpKMdKCKvARZWxoskByDCpFYN3rIDX1juqxvLJgyVmDHSj57idYLYbLvqBzge8ZFSfGSRzGROOcj6tUWyI5ARWFUrwI+cIIjxX1wwh0sdECJDid9Cl53EghohEVbhLJoPLeBKZlklraCcWWxmO3IhSljEHJEZao8nzBWfdCosiDg58xmjDXFvmuuU+Dl95JCnERVIcqUzDZD5B6cSirbi9mAJlZL6caz79oUO+dnbJq5uiFl+vAmqrsGYf/NBari+nfPDwGk8dHiHG0o8DNguHE4vD89D1LG1F9COnXUdba4iGe5cbQtsQs2I3wqwyJBRrAhpDzOAT6KhgouljoGqqYthyRad4ssiZnMqYLSdY42iV5bBtWUwa2sYyj1NaNKMP5G6krhRHswmXDDTaMGYhh4wWWNqK682UR8AqlstEjpG889RNTdvWVFXioG2400whluc7aSMfvd7y2jZyd+jYBs/Dsx1UAW0rplXFYWV56tDy/GLBYbUkbxy9gNGWKRHQnI09UzK9z5y6UBymUubepuNaW6O1IWVNVQmRxFm/JWfofWA3FK50U1MuujqQJRGuRtpPCMXDWRBQmZwiZ12PqjLLScuimTA1NQdRo29UbMee/tJTNZbj6QGnYVs4/ypDzlQRlrriDgu+YgdOZCAHyGMiXA4spg2zQ4uyieNFwwePDoj76c1Bq/nDnzzmyycrvna5ZRxHHpyskK1QG0NrNMup5enllI/eusadgwOMNqxdj1HCtckUF0u40Uw0Wz/y0nbDFIXExIsnW56aNGgFKXtmE0OXYD2WjWw7BrZdCTlKU6EPkVzYTcRvcrO7wreGnDKiykQ550LLeXSyQs9n3FguOZxMaYzl6HgOMTEGx7jeoKzlsDng0m+pxdJnh3KJSTLcqFqeaid8hY7LemTIAdUJtVcsmymTCdg2c+1gwoduHO8zJeDg0PJHv/smXz675IXthi4P3H94Tr0xNMYws4bDacVTB1M+dv2YW4eHkDMb31MpzY1JQ4yBlzaXNEZY9ZGvn605amr6ceDFhxfcntclF8Ilrk0aMInzXUAybEbPZhfRRvDzxNYFcp2J/3/2/qxXzyy788R+e3qmdzojySAZQ0ZmZEoqSTW62yVUoRt2AzYKaN8Z6At/M38DG7CvfGG4AZdhd1dJqlJXKQflHAMjOJ3xHZ5pT8sX+43IlFRARTdEZSjFf4DkOSd4XpLn2Wfvtdf6DzkT3p7Bbw6meM+jhNlkap0Z/ERUCqcVVeN43LVcnC9IkpnnSNgNaKtZVwu2cWRpNHOIEBJNNFxIzal2fL7MDCYTQyL7jPGwbpcsl4asM2eblvdP16SiM2fVVvyXH53yk23PT/tCf7ztZ6qkWdaWhbGsW8uDTce32iXL2iJJmLVgtXDatqQsPBt3OCk08BvvWWrDHIXr0aPrUpLnKKysIQlsKfrA3ifGKWOcJtSZPRlxkAWy+noO+9/Ygr/oYgQMx9GtRjuouxZjIaSED8KjszPqesHd/h5JnjjPxDnitKVyfBXMpRW4qgIC07TjwtRMVnFAiMHQtjWrqqKq4HLV8XDRESNYAybBsm3QjeNwyIxEklYkG0E0RhRaQacMJ7XBxxnvIyFkJGXu5syiqxnGmbaynFhDHzNGCVagcRbjCgdraRROgcfikxAFEM0Sy3ldc+8jURf/fQXIW8Hkm0NKYI5d/pTJZHxOpLohxsR+mOhj4INHl6xMxav9FsiE6JmmmUYrTGWJISGpaEdWBjKR3eB54Bomo9krjSRh3VqcEZyxnLU1Z50j4ctUJ8Gi1uRJuCcykfEOjLHUysAxgq1JmlVyjNNMH4WgLZI0e+DSJmJMGKtpmiJAqomoBNZZjFYopXBGU+nMXCQBeMlITDgSp67iVb8rupWsUNqQ81tbujeGDKLKZRNg9J7oGrJkhjAxxcT75+dUm5rX1ze4BMlntmGm0hlTW1yMkIQKRWc1gcgUZ/5gseHGTLyUAZmFs82KpVVUTvHe2Yb3NuuS93F0Llt0DdnuuYkenyOjyihRIBmLQURRG8VD4wizZz95Jp+og+JV6jntag5hpnKKRWcZbaJJBpeLxLxuDEkrtChWKPAlfn6SwqlurOFRUyLqkxZULKFbObwt+N8cClf5S+bo4D0pZ2IM7MeBA5bvvfeI5CCHgAnCbpi43+2oNDjnqEIJAWy1ZmUVkcgYPL+/POOKns/ZI1Hx6GyFI9F2mg8fXvDB+SkpgjOCURXr9YJ42PH6biaERLQc08I1Vopo89QY1tbhh8R+DEwxoSI8TwcuFw3b3lNpTddZRpdKOqsUSq1yBmUUnTWsnaWfJ2bjmY+F1aqyPOoavugnkgIRRUrFBest3gzEQFLFdUyTCErok6J1huwThzAjBL735AneBPyuRyIMPtKPgUY0WI3RCaOgsYrOQCSyG2a+1XbcuYpXTSYFxaJrWVaASjxoKy4qi08zTmuMcbStIhwGbkMotZkrwa4uU3JsFCzRnFYVY0ockpCioCXzKk6cOsPoZ7SGqrLUGlpR1OqoGa00UYFzigbNnBNJZ6LOKAsLY7isKl75QDJAOE7ivmbP7RtbLVpXjMQlFVGaEnWk8PRY21IZhY8z2mqm7FGSIETi7BlHT1VrVqrmVgW8JFTKVFGjYuLF4cC9HnjQVTxetizcgmQcRinu5p4vgmcYRt5bLTlZtlity2VBDMGXdLPfeXLJth/QOaKUIAqe34+M4YpV2zJ5z+ADoPhgtWSxaHhi4bbvybMnaGEKMMyla9rWNRfLlspWXPUjN6Pn6WrFPmbGJFgUJ7bi3u9pbMtmsaY2iv7tXvPGIMdCh+MNW0mxA7w59Bit6KggBWLK7ONIZxTO1PReczP0VM6y0jDqREQI2jDpIoC98RNzTpx3LU+7lkXVQqUJYeZ2nnl2ODCryLd1y0ldU+mSIohSzD4jSfiDyw0HH4/hIoqchc+2PbsxUdcNYxKSNtSh4fFiyapreGoXVH1A5QAxM6VCJwM4qR3nixpnK14eBnL0vNstufETJiaW2rBMmWtxGC1UtqKyjreunG8Q6lhrFRsUUozcDj3OQkcGAsls2I09G1PTVJaD98T7PZVVrLThZZoJKYHRTFZRmYrXh5GYhNOq4nsXJ2y6Bd5oZPI873t2fub2cOD3TzdcbjqcMVQipKzop4RWwh998IDdGMFkFIAoPrk5MI3PWXQNu3niEIut4XeWK042Cz60htfDnrmfGb0i6MxhKreZ06bi0aJFVY4X2wNGJz7YtLyeJhxwqR3n1vFyP6EoY+7KaGyluPpNPZ/fdhyL/S+PmRgzr3c9jbUgmYhizJH9MPD+4oTaOaIXmALOwlndMoSJoHMRL+qM1vBiGAhJeFDV/MGjM5qqIYpFguf5/sAuvOBqX9bfo7MN1lpyJWTRjFPEKPivP3zC6/2MNRl9bED89PWW133gcrXiduzZh2It/N3lhtV6xXet5fX2jtDPTAl8DBymsv9tFjUPV0vqpuL1bk9Smu+cbHgxjFQSqIzi1Dg+vyvBYo01VEZjauHlb+wB/XbDKIUyJT0+Uppu1lhmFNWxuTEdaViHMLHRFqUg5ITMGUdmpQ2zVWUCYDN7G2mU5WqaSClzVlV8+2xFaxwRR8qeV+PEwXu248R3Fx2Xy462rciiEDQhCNpo/ui9B9ztJ6w6Jtxn4eO7nvshsu4q7kJgSpEqat5dLFl2NR/UmquhR6ZUprepUBYFWBrLeVdhneH1NDH5zHtNw83scSZx2hg2SvN6zmCgVkVMb5z6WmvwG3tU28qirSYnIQUpbihKOMwjy8ZhjCHlRD97RAFSPPRzzijJdMrSac2LOTDmiNElPW8TK+6mkeucWFcbLto1jzcrDlnjfeD53rObJ/qm5qKuOaEttkqiqLTlpKoxBp6sO6zPKJnJKnOImU/6gS/6kZN2QmthCgmnDU83K+rKcumW6ByoTWIR4VXKbEWYU2RVr3m83lDZirspoJh4slxyHzI388zoI0kyGljbmtN2Se00xs+/6Uf1Wwv5sthCyn8i5Jw5TBNdXaEVGA3bfkApWBpA6dIVFVgozUJBIDKQmSUxB2gTDCkySuZEVVx2jofLJaOCwwAv+pH7OJJ05knryFXx2BVRVMocY+OFp13LtXiqqvRgt5Pns/3M58PMqvEoMkpb1k3i3bbFOc2Fa9BS0TCx1JoXAySV8DmzbioerzqcddyMHofwuFnhNCgf2BFIAm3VsbCKtq5pnEPeUnreLL60PJTC69+nkUVt0YBCuB0Hogpc6pagIIpgU2ZlKjqlmFNgyIkJVVJGRdj5wG4OLE5PeLpZ8MGDC24mz+Gu5yd3N9xsJw7jyAddwwVLUAoRRWMs502N0/DR6ZqXagYdCZK5mwI/uxv45H7gbFEfnUwitTV8Z72hrSseW4e1gdZGTp3iiyHwesyMMbFqap6u15jK8XrXY43hg5M19UHzMsOYIomMycUPvbOW1lqK+d1b/I1D/hPvCmynmf04lyJHw+v9nlkmzkzLqBJDDNTAUhs21vAJmV4iPmfiJCzJbP3Mvfecnp/xwekZD042XB0S477nR3c33G637MeRD9qm6NQUCIrOWh60LZXVfHSyps4j1kQimdvR8+ObPdztebzpESX0KVAZy3fXZ9R1xdO6omKmqQKbCV7cJwZVHFtO6o73N2dUjeXldo/Smg9Pz3BmzwvpmWZfHMyyYmMsG1uzqMvF5/t/6w/n7wfM0cFQECKgRRCVCarsfSlDCIGbw4FA0T2ShZATTspUaakUL3RmzJkpZ6aQ6bLQx0SfRla15fGy4eFiyf2YuR8zv5wDuz4wes9TY5BFQ85S1qBxXDQN1io+WHV0UaNJTJK4mQOf7AY+2Y88WrVEhCknGmt4f7Wmco5HlcXpyLLO7IPm5SGxOyRSElbW8aTtsJXhavYYpXhvscBhuEoTcy5r3Qh0aJbG0hjztcWc39iC3ziDdYYsgrYJrR3qONf2MXJkwPD67sBJVw6XaDW0hlNbc9F25ONYeed9ERmi6YyGTiAJKiesKpz51lWMY6ERRYo3qv7Sx3Uugo5V5fj25RoExsPAIcysjaI2hsnA4cjl64cByYLJwmldM2chT8Vx4HLZ8FBpfAp0BF4nw8144J31hvPlit4HyMLaaU66hiYJY4y8mPb4SuGM4bRuWKgimlKY39AT+u2HaPVVh7V45fPVITjNAacUbWV4eb9juWzZeY/kESuwrC3nbUWePUOM7FIkZUWOEWPA2qPTiNZU1rCuDGtdUWfBuQM+QiUaQyny+pSZfWahDd9aL0BgPgRmD86WTVFpzeH4d9+PIwCtAasykw/4EHBGc1YZTl3FuBAaK9yZhns/83i94nzRMaWMM4bOGNZ1RaUXDLPnk91Aay3LquFx29E4h9bCMI9/68/m7wW+pFKIlA4/X4qzFONcnBoqrfni+pbVpuW57pFZUCGxri2XTcM0T4yS2OVI8sKL/YxzI7ZWR3vLjNOZtVGs1mvus8JeGfRxXRqjSTEyJmEYZs5qxz965wwFHEbPLkY2TtMa2Bu4C+Xyt9tFUhYMisu2ZpgS8xQwleG9zZIPTxyjn/jhy4k1kef7gadnax6drtnPGaMUa2c5X6xoraWfIz++2dE1ms5Z3ls0dMZitWaKbznUbwRlqf3q7V/DYQ5UylA7wxdXt5yedPzFzasiwM2Zs4XjYdOQZ+EQA3feF/7ydqBqNFWjCceXrzScdjUni4Ybp7BXCpMVTWVpa0vOkXES5tHzoKn5Z08uMVpxez8w+cxFZxErbGPi5th82N3sADDARVOznwJh9ljneHq+5j1j6f3ADz+dWZrE1WHi2w8ueffsjO08kTOcVDUP1msaV3HwkR/d3tPVhlVj+bBZcNo2WKc5hLe2sG8SpeCHmIXiPF2s0CWVBpykzMvbe05PlrzIPSlmdE4sa8WJrZE5cciZfYqlgXzIGDvhOk0qunScVmyqmrXTLJzm+/f3mJSotcG5YhJw6CdChE1V8Q8ebDBauN9NDAlWTlFrjcma3bFO3W97oFgKn9cVwxTwtdDoxMNlxXuVJqTI919Estfsx8CjVcv5smXMgkJxUjnOuyWVcQwp8Uk/sGgMtdM8bRqWxqK0ov+a9uzf2IIfU6gPShXnB22Kq45CMeaAiQqj4fXdPbe9pW5gUTlOXMXFckFtNLdxYtVVHCQyzwmScJDIWbSI0qykosmGIB495mNxFVg7xXlr8WHm05cDnam4v9+xz4HJKpTRdAL3e0+7rFnUFUuVaSjCCT8JgUTOgpfIfj/CeUdOiv00cxgDKcHDzTmtHGhIWO+ZDj0BWH852taJtbNcLCqu+gpjDeuqYpEj6nDDnDNjP/0mn9JvNQy/CrACjp775QTMOZFTJmXLZ7f3NP2Bbq04sR1L3XFqK7QWtkRqEjplxiCkUIqe867FKMdKNXSqAg0Gz6qGxlR01vGwcYxB83q850KtOIw9BwkkXQKWlpXjsJ9ZRstKK5TNOFP49POQi+BOW6LANnuqGBnnzKEP7KMQTM3FakNnRlbzAZ1hGAORzBroqoqsAouq4UG74Z02YYzhvOtYdW2xxs2JaN8GH70pfGk5+dUqzOW9kIr3tFWKT17f0/R7NieWpa451S0niyVGa9JcwqqGnBlzJMbyeReLhpQzK+1oxBBjZO4njAalhMu24emiw4fEj5694tFqydX1jjsiY1WIbgutuelnulXNxjlwisaVBoQfM5KLMi054TYMGHNG8pm9aO5HxXY2PDp/iJEDFQaThGmaQITzquKsW+C05mLZ8c645OxmjzPwaLnkUVVhKggK8G9tet4INJSS/K/zRucUmaTYA3/64prN1ICLnNuGTbPipFuhgVsOdK1lJ5F+jMQoxClzuWpIMbPSloW2VCLM0462BWPhoW15f7HAh8hPPnnB5WrJ1dWWOzxjA1YUa6N5NYx0dct5XXHuKmpTzuAwCBHBaoVPmdu+pzEPmEJApOLuLnK98zy6OGNtDnxs9qicGaaZHBMXtuOd0yVaJ042NQ/HJedX9zTO8G634J22QRthFGF4O+B8Y4gx4WJhe1QmE4zQ44sbjrGF+u0Nn13fc59GrIsss+WEhs61kITeZupKM8xlkhMTaCNcGkNIwkJZWlUyR6Y5sqrAWbiwNU9WS5LSfHq/Z6E0r+8HDjoTao3TinOn+HyMtKJYKM2JNthjHRh9JpFBKbzJ3Eyef/yO4jBD7DXPboXrKDxeXdClgVemx2lLOIZxXbY1l65kUZy0DY/DguthojaG1cLxSFtEQwDk77pot64tdeUQEaJEtAbQ5Kw59J4wBpaVwVrQVSbGEl88G0tfa2YCP7rfsvUTQTKVMzS1ZSDw/vmaP7i85LypqY0hDomqtlTA/+bRO2QRfEzc70aMNXBqeKkDv7y/526cWVjHRydr3nuy4PVu5maYwSi6pYWkmd2E8pZT43ivazmzNcaWv/+zwwFrat4/O6VKMyfrisenl3x2teenr6/ZJs/KOX4yes43CzbdgmXd8E/fOaUxDd9/+TnXHvoAxlQs7Df2Ef4WoDjbKGWxTkMuHEKACcqEKGd0DVSZGCxTzhxsiV6vPPxgOLCdfXklq+kaRzSOd5drfndzylm3pK5qUjYYHal0xT+/OCMLhJjY7gYgky4Sr8bEZ8PENgQWyvKkcpxvLJ/PI6EvSYGuMtRREZcjKmtWJvJIBy7jDGmkAq7DhHWGd1ctVfCc1vCkW/PpzZYfv9hzHwJLV3PrI+fLFRtrWVUV//LDRwiOn+1GDlkYgsdpxco2v7En9FuPQt3/a+inCYkJaWrMArQT/BDxaGZj2XrLlsQP+hv6KRCyUGnNcmkZcuSDbsE/e3TBSd1iMOx2EWvLZfZfPXpKPobZHPbFdapZ1by6D/zw6p6rybOqLL9zsuHDywW/vNnx+aSoGsNq6dBT5vUigIeTyvHBpuNhu6ZuwCb442fXaGv58GzNMgbOTiu+e37BT1/u+B9eXLGXzGW74k9vX/D4pKVzjtY6/tvf+QAnhn/74gVfMLHvM41xPKjrv+WH8vcFx0RJ1F9bhAfvUUqwRuE6RTIRE4RpiuzGGTtZdA78wG/ZDjMhZ2qj2SwtfQp8t1vzXzx9yHnb4LThri8Bk7XR/HcffIcUCgXy9X1P11SYVcNnd1f84NUN18PEaVvxj043fPRgwY9v7vnlbKm7ivVph94HXixmSHDmHN9adzxadtR1xiT49599galqvvXoguV+j17VfOvhgh+/2PInN6/xTtFWln/98cd8cLpibRpOqor/4z/+CBHhf/zF5/x88uzmSGMr3mkXv5Gn8/cBffJM43GCohU6QTaC1ppJaWqtqRpolCVrIXoYopQspmni3iR+Hnr6KZEEnNIsOo0n8UG34A/PLzmta5zWDENEG4Wm4r+5eExKmSiJ3WEqAtuLhu048JPbAzc3nnVl+V7Xcbao+Yu7HVlB5SztyqLHxM4qTNasrOXxouHdzYJFZ2gqx598/pqI8O6y4WQ4cEbg0YOWj+8GPr3fMmpoNPxsuOedZUNXGTpb8y/fe4J2lj999gUfS2Q/JGrluHRfbw/8xlaLTjlQGpGMwYI6/nqMRS7Fv8XYkWgMeCH5BEpoRNNYg5ajk4MApoxtnrYtH21OWNYVxjmUMZgjH0ybhHK6dNFyJqfETRi57+953U/cj54hFl/U0QdS0mxzoQs14uhMxZgTtRiMlMPu0arldLMiJ8d+yvReEZlAb7nUjqVJkA1JQ1Kw95GPDwe0UtjRlC5t0XXwPAx8enKeoRIAAQAASURBVBwTNcpxWlswb8fZbwqiFEoXhwDJkBVHES9ASfwMklEugclkrxlTwDrNcllSkRutGbQ7jiE1jXVcNB0fLjcsXYMzDmtLmp9S5VlaVYr3TAktug+JFy/u2XrPLk4Mqdhh7gBnDIcYiaRSfCtDqAQb7FcioAdtzaJpOCTN5CM9QoqZ1AfWElgDyRhKfp9mjMLzaY/J0DYdzlq0Eubk2YYDX/SlpdWqwqN+GzzzZvArW0T4q53WL0fbUTLGCWISYdbsphllYL1x2GOq+CAU7rFSLK3lUb3iu6cbFqbCKlMSbknEaGiPFMWkNSolbBCu7md+0j/jRd9zFzxjijAIvksMRrgOM9ELq2hZKMNUC/VkyFY4b2s+WC95ctoRvOF259mPmYERL/C4spwhoB1Ka5y1hHHmz+/umHOi7g2hEYLNDCpw6z2fHkYEWJmGs7rGqrcuUW8EijJilzKpUcfl9yW1MaaSSOoahZgMXjGNkdlG6oVGK0OVy+cFKbbEjTM8Xbb8/oNzNlVLZQxWK3QWVJwx1FinUaZYc1dT5vXtyI/3n/C8P3DnPYdYbIwPSyEQuPaelDwbSZwoy76ONHOZND1Ytnx0fsrjk1Om5Li/G7mdApMv7jtPRHOhFJMuYVomafrR82N/z2HyrCpHslL82ZPn+TDy8/tyBq+rirPGlYTet3gjSCmjtEYdt7+gQSdBtGCswdiiZ3MkjAHlDcwlo4lO47zQYBgl4yWBVjTO8qSq+fbqhE4ZtAKtFVaEkBKthtZpklHMSVBBsd17fnk48Hqe2abInDP9nBhrIU+RQyzJuGutObWOXZ2xvvADLuuKjzYrHq9X7CbNrh/YhUSfiq7lsTIsABMVWhm0Sswh8lmYmGNiPVm0QM6efUjcbz0v+hkB1rZiae3XVjF9Ywt+pTQlQF1RJBuqvKdLnrzWZUOpK01GkaOgs5B1ZEwTXdXSVBrnNT4lUs70MVJ7xYlrscqAKvQcZQ3OOZCE0gmlim7AOUUY4Grbc5c8c06l+NPCIWSijEwktDLFUkkpYsolFVJljFO0lSPGzF0fUcpQOcd2Gri5ueMKw7eWDa2tGGJkpqRJGhRRl5ASB4QQmcLE9TQyphmypnaGmDz76S2l501Bob9afZBA6WOn61c0iwx0tUUU6PmoqJBECAHXOmpjsEcXk4xilpInsXIOpzVKCUoJxmiMNkjORy9yMFowwBwTt8FzIOFzQnImkJi10JuM10VUjgg6w6QTIRUrR6Oh1orD7BljuSBoFNsYuZsjKyKPtaWpUgndMpqsNRWCt5raKIw2hAzj7LmZZnwuQXWdMfiUGOe3wvE3gl+zQ/xP0Soy5WBral2qqh60UgiZcZo5bWsaazBWwSzEox5o0prTusKoQptEa5wx1LWCrKhU4febpPBJMw2Bl3c9t9Hjcy4FjhQe953LeJORBD5naqWZciIlSAiV03TO0Y+RECkWsFZzGCdeX0+80pbvdQ2rJjOQGbUwIyCJmTKZVaqE2YWYeTHNTCpjUDinSCRupreUsjcB9VfeFvVrHxfIIiQRmkaDBongtEYbYZpnThYVbWUxIaB8IokwSGQIZf3ZL894rYrttq4AwWQLmaKRcg6/PfDsfs+tzMyp5N5oFLs5MKiZWeVCo0gZneCQEnIM5qysYVk5Bj9zuz0aKljHdup5/eqGV8ryu8sFjQgDiYNK7IIn+MgsgjUGpTNT8vgeXuwHJlXMM5xVZBJXQ/+3/Wj+/iDLX9oDJZc1p7I6mmZojINWGZQRZC84o7FKMU+BhbXU2qBthAApC6MkhqA4cVU5g1EoBdoYamORnKgqjSDooGj9zE2eedlPbCkGBVaX1t8hJm51Cc9SmmKskkpIVkLIWnDW0FrLfprYTwayoK1mjJn7w8gOw/t1xVJFJpUYyQy55D8krVC6OPANPjKkUAIItaBFYYwqIZtf8wz+5hb8Ry8w4dhdOG4/plzH0FljjaZrKuacmTVYK1hd4paFhDKKbEoibcqZIQhGhJSKm0+WXJoXymCrinGaCCmRJRNzYsyJg0/sJs8oRWJk0agMBx/ZSkCyolIwowBNykKUTFQZ0SU9dT/N3M3CxbLY2+Us3A0Ts0Cj4MRldrF0zpSGs7pipzNNZVk4xxSF63HgdhpQOWGUQVRkiIkwvyUQvimo4zPlyMOTr8ba8uVvQGnFpqqYJSNG0RiDUxofMqkV0vHggbJ3zSmzi4GUElFHXDYgCa0UzlmG2Zf1e3QaGGNgHwJjTMwacipjTdGKKUNPInz5l6H4/YZU0h/LlKBYifZjZMyBB4sOtBBi5n6ORBUxZDZZMyghGIV2hjPtuFea2mpqbQoPdvZsffnTKqXJJPahZA68xZuC/LXuza9fOZWGk7pizpFsFLU11NoQJSNKyAaSLrbBOQqjj9zm0jlLOpXwwWyorKHtHLvDzJzKhS5J5pATt2FiNwVmyaULqkrjdx8DdzkQkFKUS0YlIUi5XCQlJRRGhKvDTMgDl12LPR5gN/1EQNNmxQMye2BAiEo4aSxzTDhbpmKDD1yNE/dzQBvFwjiUgUOamae3osk3B/lLwt1fNy4AQClOmxqfM8FkFrWjNZaQUjn/DCX4jSI4H3zkVgkpJpJJKM1RIK6wjWM/9PhY2ntJhD4l7vzMdvSl0FZglUYrxX3wvMaXyaTAGCMugk+ZlISYhUxZx1eHge3gOVs2OKuJSbjaj8xa0yrDBZmDgV4lRolsKsscKQnplWUKiZf9yP04o61ioS0Y2CePn96ewW8KkkuRz5e9tlzab5KlGBgcm2WtMiQtJa/DGWyGMERybUmqNGlLZIgwhsidKonySZcCXalSPDeVYzcEUi7ZTYnMmBN3ydOHzHQ8y91x1r+NkZ0uyfZGFGNO5KAIqdSZSQlZCTFnXh9GfIKLpkIrTRbYzWU632iN1zCq0kCJWlhXhpBKzVsZwxATd5NnnxPaKDptEQOHHPBf0ynvG1vwiyS06NJf1YLFkI8dT2UchpIG+njdcDuO7FuPToITg8URshQbJpWIuvijkqGXyFW/54FdoI3CqkxEmDvYzzP3+x6RyJg8P98eeL4duY0ekxVWaZRSRJ84MLMNCacsQWdmFVmII6eEyYqMIWbNEDIxC6/GA4lIAqxoFsbSas1LPzFKZoiRkEoQyGXjqEVhjo4oc5y42u8ZUmZlLE1tmaJnSBn1dq95Y1C/ftL9Gr4UkysDVaV53C65nydCDRUGmw0pwDbMbGNkjseLJUKOMMTE9aHnZOFRDmwymCjkuuIQAvvRIzExhsCzaeCVD2QFKRtIpvAYlaWP5YDSostUAIWgMGLQOZN1xktmn4tY7vN5ROkMVqES1ElhtHCTZmbtyJUCC21lOLMdbbZY4+i0ZQzFm3hWiQWOhXHs/Yz3AZXeUnreCL5afnKcEB0/9mt8aqc1H3QrXo4DsRMaZaiVxUnRk+xyYJL01aUzhbJmXu9HHiyF9vhSWgmVNGznkZv7AxYIkvnpdscnu4E+Z5TSWFEoAU9mayP3U8CVHhmJTFa27NuS0KIIIbOdPD5rnu12+LhGmbIHrpRj4wwv5plQKbIp4XHGah6uKtRUDvOTumKOiefTRExCW1Wc2JqdeEJKVG+zSN4MvupryJda8b/yv4tr3Lc3Z7zY7fHLxMpWdLpCRc2YM7scmUnkY3hcmoS+SrzY9TxeGtrkIBlMVqjKcnsYOewnrIZREj+8veeXQ8+BiBaFy4VyO5O5c4l9DBhReJ0ZU6RNBieKEErdMKVYqLgebsY7PpQ1s8q4rFhg6SrNs3FisoJuHFkJ1iqeLFqsLx3+Td0yhpHP9j0hC61xnNqGPgV68bi3rNo3BklCjhmMQhkFGnQuhbsPCUuidZaHuuI+RaSFBo2KMFSZiciQEx4h6yMVcoapyrzcDzxY1DTZUUlGSJjKcj+O7IaIUcIskZ/uD7wcJ0aVIYPJCi0lkDLqyE7iVxcAHxMxGSyGEDLYcgHdh0ifFa93PTG3eArdvMZQW8XL2RM0UGmU1dTZcFoZzJyptWFT1wQ897EnInTWcmIadni8RJz6epvgN7bgT8egmS8PvUiiwpFdZrNuqU1LpS3/5Dvf5pOrz/j085f4ObA0FQ/bJbs4sU4NKNjbwFilYxiZ4adTz+lmCUoz5MhVP5HmA486x+vZ89ntlpf9geswMh9rGWUErY8BM8kAGRU0T9dLls7iU+K2HyALna5IlWJWwqsUOOs2XF1d8fJ2ZLGwZVykFC8PM5UWzi/WrFrBHsc4312dse4alk3Nbpx4vu0ZpsDFesmqcuymHmKmVgbn/mr/7y3+ZpGObPqinEep49uCsoZuseC/+d4/4s9++hOu8kSaocqa2mVu5xE3ZVo0XimCgeAK7/Snu2v+sLmky5ntHPBjJnvPqYHn88wXu567aWY0GakblNak7MvkSAnkSKwUcYL31jULZwlZ2E4J52OZS9jELMLrEDntVuxm+MUu0bUKayDlxPMh0mrFamWpdHFWqY3iu+sTatNirGGcM/fDBCHxoHK0ornp75nmUmy1X9Mh4C3+50EdW/m/mmj/6h0xIMawWK753/3Df8q//uMfcKtGkpfilb/oGPGs7g0pWwadmRsh6OJ08ePtjtWqpVWKyXtejzuG2xueni54Ps18dn/gapq4Yz7aa2qkBDpDVsgEAUUcM985X7OqKnxOvBxH1KhYmgqp4KCETyfPu4s1z/qZZ7dXnJ44usairOaLg8c6xSNbox1kE+gqzUerM/7Lh0vWnWG/H7jZjaioeX+xpHWGl2NP0kJnHQv9dv29CQhlDX55v/yrJYXSmkW35n//j/4F//0f/9tiZxkKjeZi0XITJ1ZBE6Jl0IqpzngjBA0/utly2i2ptXBIE8+3nv1V5NunG34wjfxyu+PVOHITfKGXKY0Y+YpHmWaIZEIUfudixWntGFPii8NEHBQLbYjWsAuZT4aZd5cbfvT8Jd9/vediXbNoLBjDF7czVa14dLrAaEVrNHXX8A9PL1mvT+lq2O96rnYDKiu+020wleHlfo/RsLSO2rw9g98USpfeYJzGVKXh+qWuSUwmW0VtO767XPCDZy+Z51wmPVlxbip8nTkZDDEkRgW+EQJCMMLH446L9SUa4TB5nvlA3u94v13yvN/yWd9zEwNbIiJgVNH1YcqFI81CNylSzHy0WbNyFp8yL4eRMAsr7cgWhiR8MUbeaVc866/45H7gfFmzrC3OWF71JdPi4boiq1QsiauKPzw/ZV211Lbw/rdTwGTN00WHFs2VHwhkGq1ozdezZ//GFvxlSCIoNProNZ+N4KxGaYXThkXTweVHLFhwfjXTs0c7mOsSO7zIjpfDQDCgrcWggcSzw8T7qwFnDaeLloerDQDTcZQ9h0QImdO2Yk5FIBzycSR07G5FoI0GFzNaZxrgUdvxvB9YVg5jNKdNxzurNefNiuHilAfGsXAOYxUzkc+anl+8vuXZzQ5c4Vuf1xUP147DnOnjzG4emVPAWs1J5TiMM8/HAWc0tTLk+W174U2h2FB/WeX8qov9pbqk0o7Odnx+e48R4Z3FCr2xzN5zfXdHQrN0lkPOiNEYC6IzKipejIF3h0TrEidLuFhWGMDnRA1ISkhKnNUV+VjQ7AGtDGIsUQnaOBaVxlGjs6YGLmp4HXtq59Bac+ZqHnYLTlxNWiVOTVvWp9WMEnm53/PL7Y4X9z0UKQqn1nBaw5hKd+IQZyZC6XZpy+txx14rjIOUYft2yvQG8ZeI/F9BZai0pnKKT19s0cnz3mqDa1umFLm9v2M0kUVteTFMzKokM2oNWuCnuwNP7zuaE7hYdLzbbZgkEHKmqTRBMj4lThcVyWcwhjHEMmIHZp2JWVOjkKjJSmGwvOOWfBYOnDqH0YqTpubxasXjxYY/3Bx4sHA0VY01liiZz9WeH+92fHa9Rbmyx55UDY8e1xwOkR2Rm2miz5HKGU7bli92d7wOI6uqQigX5rf420djLZum4hcvPqWKI0/PTmnbhhgDV3d3HHRkXVc8P0xMWhAHVms08KPdjg/6JZVbc75s+eB8Q4qJMRU3Hz8LfoIH64YpJAyKIaZC6VbFFSgATdCYSRddm2ieasMv9J7zpojAL+sF7y82PFpt+Kdn5zxYOE7altqVqdFP9C0/uLvnZ6+2mMqglXDeVDxad+xnzwDczkfxpHacLWo+vdtyEye6xpKB/fj2DH5TkAhZl6+vHO/1ximMLqGsOpashc9vDrgpUOkK17UE4D4MHGKi0hov4HWhBtljuM4vDyOPu553Vy2ni4b3lhvmORJSxrhCp0leuFy6Qq1BMab0VSbPQCIh2KxJUQhKQBQXruXzMLB0Dm3gomp5d7Hkcr3kD++WPGg7urZCW8OQM7+0ez6/2/Px/QHtjr79tuZRVbH3mb2fuPITPcLSONbO8fn+wB2Brir1Sf8168BvbMFPoHDsVUbrr9rsOAx2sWS9uODRZsH5+RnjNJLWa9ZDZsKzF89diNwMA9HkI+cLQKi0JQJ/dnPLXQ58z57RdW3xVE+ZlTW8t15w0Va4GkJULJzj1k/4nBhC5JPcEyNQJ/qcSEfNWEaYSIR5ZFPXrJzjybLDmkhnFUtX0TUNSoGJgfc7w/Jccz2PXMe5HOBVRfTgfaCfEy/2B0LKPF4tyNlzNfUYU1TkDsM4v51nvylkMvoo3NVHd55MRlF4zJu24v3TBbvDPbODs2PIlRhIdcWUE/2U0VUFuggMJU04pdF1w8+9JwaPyQ0nqiKLRyXYWMN7y5YHTbkggsKZmpfzwCyZWRTPQ8Zg0O7oFBTLJhQQphwZc/G43riaJ4sajeI6GrqqJOQapXFRo1cr6hy5ihP3UjoNRlum0TDKwIjjlQ8krXlnuSCkTKg7nGSceLQSkrztcP1tQY5uFUrBsql5enLK6+sraBMnjcEYSEQG67nzkZtxJujyeUkEiWUClZPwp9d33Erk9y1sVi0pCDkoTk3Nd5ZrHjcty1ozpsy5c3w+TnglDCnzs9sd2QvKKcYYj/vrcQ/0iauQOWkqTquGDzdLmkpwjWJdWVZNg6AYvefxekFrDdd+4jrNOKtprSHPcIgjeRf5eH9giImni47DNHAXIrUx1GhIwvg2eOsNobQ8/hqK4RibZcsHjy548eoV3kYetkLtIvfi2VrPcz9z6GeiPXL4M4hkKiwpCv+/F1e8jjN/aM85WXUkpcjZcF7VfO9sxburBeuqIiXPoql5Ngz4lDjEyI/vtqXgqxW7FAhzoU2GLBx8JOXMWVtz3tZ8eLrEWIVrhItlw6rpQBQmCx+drlk1hufjxCs/UVeG1lUED6MfGcbIL3Zbekm8e7riME/cZ481mhaNzbBPb9ffm0ShY2dUKmsxkcmm0BdXdcWTpuNw+woWsM4GqxT7HOl14joG0pxIpuiM0rFh4dCEKPzZzf2xDoR17goxJ2fOrOPbmwU+tSydISZonePlPJY9LiV+nPfkKCgHYyrujVkEnzNjiERJnOqK06big5MO64ClZlFbFnVVGtoh8+2249JYXoaJG/HUGiqn6QOM3tPHmS/6EZ8yD5ctQ5wZyDitaTE4pTiYr0er/cYW/PLrm82v85O0YdlUPNh0vLNpyf1zZL4rdAQFOx956cvNbrSZtWvJAlPI9EMoGkyT2U/C8+0I+Z7dEHhQV+QsjHOgT4G7WNL2qqx50rac2AVBMn1MrJzjqg8sO8OZa5Es7INnNwfOa8vD1RpjDEkyz+7uWFWarIollNUaYzRaF1cWi2JWmavdzM3gGcOecRDEZEKK7IOncRWXbUeSRO1GYkxMITGpzPzWEvHN42jHWbb1jFKKdVvzeL3hyekJL69eEAiQDCGnkixpE2MCFjVrU5euaAjIEDEolNP0UbgaPFYNjEk4N4Wz2PtykdxLYh/LN+mH1vFuXRGVZkZzkoT72dPVlpXVhJjZz54+BTZOuNw0qKyIOfDp/Z7GGvLRU9uYEhpilQYq7LJjHCKvtwN3wXMwgckrnIFBG6YoNNZwVjm8AmYhxUDKCaU12b2lVLwZyK+5cR7fVgIJFnXN45MTvn3xgGeff0JWmRwjaY5sp4Hn08g+JoIIq8qRFcwpMR7KeBqj2A6BZ3pAsuJ+DLxjLDnCIXn2EriPnm0WjFZ8u2tp7IqZzCFG6iRc9zMnq4oHTUMSuJ8Ddz5yXjveP1uVhEwlfHq7Y1kVq0XRpTtntEarCpOKYG3YB9IIBx8I857oIanMJIGtD3Sm4p22ZjaR1mvGLEwxle8r3o6Y3ggyRewIf23QtO4anl6c8v7lBT//8TWBRPCBNEdupoHPhp67EBAN68qSBcaYGYZQznatuOs9n5ieLIqbMfCha4gJ9rNnFz33IbBLAUfm/dWK5bpizolDmFkpw4v9zPmy4mFbE3IJNjpMkXeWNe+fnGCUImXhFzf3dFZjlCIrhT66uGhlsKahcpqDLxqRaz8T/RY/CVoLhxy4mz0LW/Gk67BoFtVACsIUMxPF9eUt3gxEpAReSjkb1TFRXmvNytZcVh1ndcVtjBgrhcMRIofkuc6eQ4ooBavjVHzKiWks7BEEdinwhRrJAndz5BE1KWV2IbCNkUOKbJPCZsXv1Q1ttyBSaEM2w83oOe9qTuuaOWdu55nRJx4sKh6vFzijyJL5+HZL7XQR8FK8aq2GBoUWS2sNhz7wus/cpISfM8MsWAN9DGxDoLUVDzuHjeC8JySYQsJrReDveIdflKCPHvQoVawLlcZg6JzmbGE4bS3715+QhkDtFKq2EGHr5yNPCzbaIqJRMeBjRETQVXnNvo98EXp2h4l+UYIL+pR57UeuffGJ7pLikat5uuywruKkhgeLll/qgc2i0IR2wZdbqBbeaVu+dbJmyMLzQ8+zuztOXIVyQi01jbN0tkIbhRFN21TUkyGJcDd5Xg4zr7cTTasxuUwnLjrFZSvFIUNrUgYviVwczd7iTeFL0Zr60pqzCHmVFs6WC56cnXG5XvP86vnRzcYWd5JcvO5Fa7RzdLpCMqgkRHGIUJx2gH5OvFITvURGVb4d78LEbZzZ50jSCpuFTYIHXcPKOtCOS+CZiqzbmqgS99kT8CgiDxrNe4uaISZe7kc+3XpWVcWyq2mp6FzCuWIJWmlBOUeFwk+J28GTlOc2aFaVJWuFQXNWOdamyJizj/joj0mWhupt+NsbgVAOu+M7X/6EAs6WLe9enPHk9IJPn/2S2lRYo0k5EVLkbg7lENCKtXJlD02KlEoAjdKQE+z7wKfxwG0/0duyB965zCs/czd7kmRaY3jXtryzWrKxipMcubCWn+ueRycNxsHdHMhRwGSe1A2/e3lCnyOf3R34+HrHyhl0XWgXjW1YVlWhZyJUpqIeDJKE7Ri5Tp4Xh5lVbY+ZK/CgMeQG7NG3PSdhTrnsgW/vm28eX148j3vi5WbFtx4+4J2zc36eM87WWO2QlJhS4nqaCVLsB0+zhazQJFJOSFbgFDkIu0Pg47TnahiZXQmwek3guR+582V0XovmW+2Sx+s1xih8drxTt/yALU9PFuAyV/NEjIKqhG/VC37vwRmHEPj0bs/Pbu7ZGEPdWBo70lYNy8phnUFrQZumOJ6kcgZf9xNfbEdOWkuk0DQetCXfxOjiwiZwpHeot+vvTUKV87fEQRT3Jn1sGGyqmoumYVVZUMW1sUITRUhJOMRIOpLv66xxxUuWHDMpl31DEuyHSMwD19PMTh33QBLX0bNLsdB3RfHINbyz7LBWEVwJVv3Y9jxddESreD1PpFT+jk+rlo/O1oyS+Hw78MubPZ3T6ErRpYnaODpn0FrhrMJqqHpFjJn7OXAjnpeHmWVjS4YPiovGkMlYU7IDRIQxZZRWX7uQ/waf1L9SCkkSlAWLxWZFTaYx4Izm1as7jGlZrxaopWWuEs24pRG48p4xeUQg5kzlShJbGQ0JSkCb4l396XYPwHX0jFK4WTkL45T4j+kapy54fLJm1TblspCgs4Zf7O/5Yhg4hMh5VXO+WBJi2fTuxpGPd1sIhmWluVtEmkqhbHmAiCGr0p0dc8aTyQgDgTkJl9SEKAxj4NrsEeB+nBgoWoNaGZZvi603B/Wl+eHx3VzoOgrN+WbD48szNosFS1dztqw4aReQIOx7Pj5atfW5dFYlJXJM1M4hKZcXjRk58paVzjwbRwBu5hEvsdhqitD7wA/jRDxd885Ks24tGM1pY6gr+Olu4FU/4ufAibWc1RVDH+glch89L8LMVUicpMRhhtZodK5QZLSaiAn62TOmQJSMUpaUhH2CNRoRYQqJ3ZzKJuOLFSMaNJr6m7yN/J2H/JXIrYJHZxvef3TBerViVbc83Cy46CqQzP4OXL/FobkPgX3wmGNaat1qYjy6VYigkqCTYJXip/0AwK3E0lA42rpOY+JPpzv+mdG8v1nwoGtJrTBI4Tv/x8M9z/YD05w4c46ni5YQYc6Zu9nzi90BBOrG8MqOdLbCHi8yWoFxFkmaOQvxqDXwObGNmQ2u+LcTudIjgrALgZCLza1W0L3dA984BP5S9tuTiwu+/eQp5+szzpYNq8WKJ6drhMT+BprdPQ1wn2aGWaOlNE26zpIixCjF+jAJJpUGyA8O5Qy+yiVrAXV01psDf5qv+CNrePdkxaZbkLKwTYmzZcO/u7vil/s9o088rGqedh0pB6IO3OaJn+x3KA9ta3jRj6yqlkqXfAdjhJzLP2yWdNzXFLMk7oJwQkWSzKA9r80BEbib05dmoFgFS/d2/b0xfJU7WMS6yuivPrSqKk7rmspolrVjuag4UQ6yoh/A3fU4BQcSuxzQuXD3m8YQQ9kDYy5GFTqDS4pf+JKpsM3HtVA+hTFm/sPVHU5rnqxblnVFqBSDyXTO8We7UgeGlDmrKi4XLbMXBh25DTOfHIayB1aaOzeX0ENalFJYo5i0MIfEnI+W7ih8ytx7z5rSJJx0ZDuWwK0h/sp5TQON/Xq3zm/sSpVf/0kVP/Saiso4LpZrHm3WrFrL+rQFD2nwpBxIGWocooSuihyGmZyOgttWwAgmmSM3W2iN4aPLE7rjNf1Pnr/kkCIR4eYwAMKL/cAP9Za6ajhddIwpcdmUm+DGVfQuoJOAL0EQP7q6524c2UVfArlM8Yy9n2a01nSVY/KJT67u6LqWz7YzhxQRU0KYdNJIyoxJaLVm7SpOqg6A+yrj0kxC0NqC+sY+wr/zMEeVoxzdUUpAR/kG/daDB3z0zjs0Bp4+2lDjSHMkxBLy5kxZvs5AP42kUByebCtF6Xp0thElVErzpFtiuuJn/8NXI1PUJIQ7P+Fj5vl+wqRMpRRLp0nJcVbVEOFMLDOWPQIRqtnxg9sbtjIxaY2tHBbIOXPrB1AttTEMMfLT23vWleWzQxEFURk0BoWQgJw1C6VZG8PSlA1m1Woqb0lGoU0JC3uLN4CvHFLkL9OpNXz76VP+wYffYuEc7z04LWF9s5QOakw0pnQhF1iGPiBZsBaqxqCtInlwuVjJLZzhdx5uuDjuMf/6ixfsUwARbnYTCLzoJ77/+o62spwvW3JKXLYtxihOVM3eZLYmEEPGaMWfPn/FrZ/Zh4h2qvC+o2KbI85aVm1N7yM/fHXDo03Hzw979iogFSXjboIYMsEJnbacWsfFkTq2CxWjFaJI8eH+W38wf48gv/r115fgR+9+i9//6Hs0Vvjw6QNMbog+EpInp0hzfFYrU3PbT0iAyira1pQptYYqG7TSrGzFP3n4kNOqvPr/87Pn7HJAlHB9X9bfz+8HrL3GWcfvtUsGSTxaLkDBGTUHFbkTTxo1+qTi3352xXWY2IVQguIcGFFczTO1M1x0Dfs58O8+v+Zy2fLnw56tilCVcDg9wWwyE4kzW3FZ11wsHAJsvaXKimAyouWv38bf4m8MZaJeOvzqGHYlgMqKc9dxUTWY5Lloa+hBGiHkSMrxK/ekLJZDmIt+SSu62qAdJA82l0yHhbP83oMN1ZGd9e+v7+kpRfVNP4MoXk4z37+7o64MHzVrYoo8cR0KxUMqgknsJKJGqJbwH25uuU8zfUq/2gOzYhuKlehFW7EPgT97dc35WcvPp5GDSogFlQXtFdFA1IqlMZw4x9qV3W5tHIOUHIGSB/r1qB7f2GpR5xJwVVy4BEgsG0dWCsmeGAdCtKzIoMEtS2DC2lr+8PwU7wN/fhMxMVMpAwhb73GVRZsKcZosmaAT4zBTdzU/ubsBMqfOopRCt8L9OPOoa1g0lj+/ueJPrl6zqRr+q3ffw1jD717UfCufcTtNfL7d8rObG64Gj/eJRsNZU9NYh0man/c9/7eff0xVlajowxSpjOZRt0CiICmjsqIyGihc/7atmRX8bLsn6ogymgmIImQCcX6btPumoI1GdPG2V6ao+59enNE0hoebNXXlyDpx0Z2gmElKcbcPdCL8ftfiY+ZHx+6mQyNZ6PuArSw0uvh8pYiPA/t9YgX8bDjgfaA+JuzFRnN7CJy7CqWEH9xt+f5+5LxZ8F88PCsWmt2Cp3XN9TzxRT/x/f2WgxUkVnRoamVZO4v3kc93e/7v4xZnixR59AlrhcuqoaUpnljaYXPkOIagcjWzZD45BLyeUcYwVwptHWI1U3jrkvJG8Fd40yor3n3njM2i4vGDhzTdCVp5Lk471ByojOb2kFnPDX90+pBZIv/u+W1JHNcljXc8hrakhSJpwaiiJ/E+kvD82c0tOkUutQUUuRPuhpmHdUnt/eMX1/zrz19xUVf8bx+/Q20c/+T8Ab+zSVyNE5/u7/n+3Z6r5IlRaJXltNUsG4eJip/dH/i/fvYJtdXoDDsfqG8NTzYNZlAwFxchqxWSQQdhvXZECz8eBsYUoLbEmAhksgg5vK243hSEoxvs8U7/7UeXbFYN7z64pG0WoDyPzi5Ivgddc7OLnMwN//XZQwbJ/JuXV9imoWk1SoQ+R6wz0JQXNFqR68wwDXTU/PvrGwyZR9aWP3sp3BzKGVxrzf/n2XP+Hx8/42HX8q/ef5dl5fijd57wBzHzchj45e01/+76iis/E32iVZrzRcWqccQAP7vb83/+8V9Q18X7f9t76trw3mqFi5o5JEwsWjtySfDtmopBw59vd0wxoo0i5JJxkpPA2+3vjUHZ4r+v9ZFOivDB8oKzasGj1Ya6q1Hi+LZTxClireVumLjUln+uaiYT+PPrPdY5dFXMN5JkagOhMMjQSpEcHMbAEsMPtluiCEulQSBWjv0UuaxrGm34k6tr/t8vX3PqHP/VxQO6xvGH5+d8GBOvp5FP9wf+9OqekURIRVx80lS01hJC5Plh4v/y/Fk5g7OinyL1wXC5abC9IswKHSnN4gjGZpZdg9eKH+175hQwzjCHwkQRKaGKXwff2IL/r4+ySwpaNJ5VW7NwCyRMhBAxAkobFnWFNYaT1YI8CX9xc8sup9KxFyGQaC2I8rS6otaWyliCFW7nyCf7gSRCpw0ua3wQaqVwRnOYI5MVjNOsKo1JZaZ8FSKvp5GbvseHY0dfl5M6iSIksCRuxoSyQiIyRY1WpehvomacJyQXC9IsmTALSSdcqxAthCwMIVLVBmcUZtaMRJLKKHl72L0pZJ1Rxxh3jj+fLCrWy4aqdviUSH5k9oEGhVGZVeOoreFBFuY58ZPDQPbCQaS4C2iF0iUJ1wFaNCKKIc7EbHjZTyhraLLBZI2XTGctwWX2qnCYu8qyrA1WG7LAjQ/cjAP348gYExqwyiBao5RG0IzANs3kupxPSQRDBgX1rJlTIinASPH5Vw0Bj9FCEI5uKInaVuVrk6VoYzCYrxn68Rb/81BsidWvdfrh/LTlwXpFW2uC7/HzRAwRlzWiNIuqwW0cD5YrYk78x9d3TDEz+kQSIelM4yxeSqBLZSzGGLzA6ynw2d1IsplOGaxogsDCWWIQtrMnaMEazYlzIBBCccJ4OYy8OvSMsdhFGYqQLGUhRcUYEvs5kS0kEillTC7fW7XSDHMmZ8AU/i2zIiJUbS57t8/03tO5wgffeSkdVvONPsT+TiN/OVw/QgHnZx2Pz89Yto7kR0LoGeKIzokWy2nXsqgs6XxD8sKfvbhi9oltLkbbSUGjMj5lOmepMVQYgkq8miY+vusRR1l/GULOrKwlpcz17AlKcFpzWlmMNvgkvJx7vtj3vNz3jKE4hxnAI6QMKQrjnLiePGIEn4U4SzFPsNBmw+A9ksrniRb8nIhBCMuMV4LEzBwyK21QxnA7znidESO4tzkkbwzqWAQKfOW/f1a1PFgusCoxjT2kTE4RHTONtZy2FV1lCEshSOIv7veMvtBgEgm0UNvimV9ZgzUGo4sTz230vBo8uKIdMUkREJbOEkLiNkDU4IzirCoJ5TkLz8aR1+PE7TDRe18SpI9u3llK6u5sIvchkBuKeFcELYAWmqSYx4gk0FohVohDIhmIpmg8c8jMIdE4g9KGOZZQWTSYr3kEf2P3ypJ79qvdxqBJUbFqGyqrEDw5BvrJFxcKrVBZUxvBWUNA0KJIqbg5eMmghewjxgkyKbCK6DR9yNgUiF5hrCInmGNinBJOK+51IClQSbPUGkH44c0tAIMVxhgIIVBpqIzj3YXmRnvmmFEKAiWSWavyMDNlERit8CExT1IOPjSzCDFmbKOxxqCUIUhilIDJit7D4IsndWUq1Nd90m/xvwClYC4QBI0o4aLtqI0iJU+aPUMIVM6hbUl5NLrcurVK1NawT5GQhHA08E0pIaKOFmEKazKjcgQRQhLquhTpPirmo0NAEEFpTW00YixJaX7Zl9bSNk6MMRBzEXl2xrB0iinBnCEpyBqiOvpgq3KYZwFtMvNcBJDKmML1pjheaXW8VKCJJGYoh7AkQoalhbZcL34zj+e3HfJrvxxDCI0oLtYrWgvJD/hppB8jJ65GKYOm7Fm1rUgpYZUqDj2kYt+aAJWIpSJCi8YroZ8TQ874JBiriEmOWqRMU8EgxXVKo1geHZ/+/OYegMnBECNzDBgFnS7ppHfKM4Qiuw1kZskYozDaFn2KEow5pvHGgNGKhpIBELOAhcoaUKWjOuVEjSGEwOwTda1prMFa+Pw38oB+u/GfOlmMUjw8W9NYIUw9fh7Y9zMr58AYjEpUVmOqQqs16OKSl3NxJ9EKiZFoBR0VShSTzuznTM6ZOWWqquTezL5oh9rK0KfEGMt6qawmq8yfvLoC4CCJPnh8CGgFC21YLBfcjlNxcpKSnROO688ahehyBmul8SETeo9SJfk0SOneY6CqDEopQsrMMbFoHHOIzD6zbB2ttSglPP/bfTR/b6CUQqujecuR0qME1o3DKUUOCVJiN44sjEW0KonMoqkaRUzFujdlIUhxyFGiyOnIgY/lpb3SDJJIMZFyuVTmBCGWy6lrLKMkVC4TAYclAT+43wKwU0W3mWJCaVhrwwNXc68jQ0gkMklJabRphdHqqz1QW83sM3Of0bo0QGLOzFL+/daZryxFvWRqscw+EkJm0ThaaxDJvGT8z349v7En9V+ZZqNEM42Zi9WCGDyHYQcx4VNC6RrRhQ9dSqjimFMbQ1bqmJVa2mQxJJbWkubMHANDgiorOnQJL1IKcmaMiSkmsoE+Z3RW1GKpJLO1gS+m4iAgVSnwWqNY1A1LXXNSOZbVyN000/tAMOBiLB0Tjt06EdrKsJ8icU6srKNSiiDFS32hHZVySFbHDSgxpYCPEFPiYbvkrGmZw1tLujcH9WvG58WV/+ADlTJI9MxzcayJGTAGbQQl6iv+uwZWdcVtzoiko1CyhInUlSaFxHwsuqusaXShcjmtkQw+Z3wUEkKk0C+MMnjRHBLsjgX/kD2oSGMUG21YqYplqxgT3IXENiWUUaV4jxmtNEUSDE4ZDhLJMdGJKtZ1JKJNuOPGlkUTJJEoQVxeJcCw1oZT44hvOfxvCL/iB4sqB92+9xhlSGFiHMHPZU/QrUPpQoDkq9UntM4i3pdLH6BEmGOmrl3pGPkS+b5PR9qPCJU2kMvvCzGjNUxHkwOXNXPM3IXA9lAOmNyAMYpOK07qiktbc1LX3Fael+PErfeIlsJgQ2FRFEmwUFnNMAZSgk1d4bQuF+Fjg6TSFqF0+yMwJiFIsRa9NA1nVU0S4Qdc/Uae0G81jofwryft7voJgybMA4dDmfCEIOi6Ro7uSXJ8fqKEzlmu9UzOUgKLVOl2FuGkMOaIEcU9lkoZlEClSlNtSok5lCJ9JGOilEJOJ26857Yv6y8ZwRlYOsNpXfPANmy6hut25GU/cDd5sGV9JynFXNKl0++MZhwjKRyLSK1JOSO6rOlaG0SEkDIx52IHG8ru+bhZ8mDRMfrAD3j1m3pKv904Uls5OhJqpdn7mZQyUUDnBCkzTTNNXRpyIhmknHMKoVYGVPiVxSzlbG0aQ/bgQ6JPip3VOAAU1XEfCjkTY9kLZyXoI83Lk9mGyBdjqQNTBdYoGqXZVI5LXXHeNtzGyMt55NbPJTAWTc4JLcfGbxa0UYwpQxQWtcOWEhSMQqPK5QMIkknHtTilsgYf1h3nbcM8e37M9j/75fzGFvx/FTlrxiHiJ+H6dkecJyrlaGqLspYsAVGJrFMRqGE4Wzd8MuyLAvvYUVUZNlUDGeYU6ecZEzNN16CNxuhcCi3JYIQJAa0xCbxkDimgUGxcEbgNzIwklLZs2ob32gXWtpwuFnyx3/Ns34MTCJoXPpBTcf8xKE5dxU4C5KPYjmP+gAOdNCQY4syUA0mEfQhYa1hUmieLjkeLFTfHi8db/M1DZ0HlIgwsvkrC9WHgZuppd5pxcsUm0LYobdASEa0RWyZTTmkebBa8jKUjriUxZYFsOLU1KQeGEBlSxkhg0XXUtkZLCdMKkiFHJiKiBa0MOWt8hJ1kzkwptAcVCTpRG8NFU3GpO5pagbLU40wYJ8QKnbLMEogpF9G3aFbKcaDY1cZjrJiIQiQdrUMtXqS494jgg8JYQ10rzquKy6pmJ2/X4JuACPBlwrcq9J4vbu754uaGykZOFw01FXVlca5G0gFjAaXIOSBk3ll3vJwnXCz+90EEyYqzpiGayDBHDqPHeuHhsqUyJbgmHJskSsOYM1QKnRQpFh72KxQXrgEF93h8jlTW8c6y5YN2ibM1D7PgtluG7T1WG5LM3EpxeDp+W9HVlkGKQDgeieJRlT1QSaHSTalMHrTSTD6hrWLRaB4vlzzpVuz9WxL1m4A6Fvzq13Spz17d8/zzG2pJbNctlauo2gZra0QG0BlEyhTTwPsnC15OI3Muk8WgMhLhsu0IJjGMgcPoqSM8WS2prKYWxZQyWTLaKA5EqBUqKIIXdimSRPHQtYDiVhXnukppnq4XfKdb0jYL3s+Bv7i+5Ufhnq5yhEHwqVDG4lH30a4MPhcaWpTSgY0aVFU6xaSS8Dul4qPcTwGthNXC8sHJhvdWJ9wMw2/qEf3WQ+njD6XQYlBa8eLQc3q9ZVpoWlfoLCKFdiXel8R4lZGQSCgebxquU8B6MEhx38nCWdPgVWKcIqOP7IziwbLCaYWRQnvNCrRVjERUpSAeKWI5cQM8cA0KuFOekYQxikdtw9OmY1HVnChBDor9LlJrjSiYJZNioTCqBLbTR7egYqwhWhGKDSMqFrODXqcyhU8wpYQ2mrZWPF51PFmsuOtn+Bpzpm9swV8Cg38VwGVM5mRj0C5ys9uxG4RFY3hoG+zsi4gmlGJ80dRA4h+/8w7j6BlDZkrwxe7AbCOSAx9eXHAfJq7GgWjgoyeX/B/+6QN++NlnjMPEEBK/2A2ICK/ziNIKozQrY/nOouMfPf2AmcA4TTRas6iKgv/zw5ZTmxBjuPeBF4eeysF3lmvUIXM9zsSccaLZXwdEjtZ3FG5so0vk9yHP1EmhVelKzLFMGVyr2M7Cv339Eh1fkOff6GP6rUY2CqOKAj5nUCqyZsXdbmDqRxqrWNaGC7WETpNUYAwCyrBqagyab52s2U2BgzUMIfBqBpQDhKcXS/YxcDdHjNF858lD/tXa8T+9uGb2EyEmPt2CT46tP2CS4Cx0leJxVfHhugUgTJbWwqK2CJbXw0iiJejITZ64Gg44o/n2subZIXI1Ruac0DlxPyesNojOaFfRNC3WWuYwk3wkN4I6Ciij0oiFtjFMWfGD7T3IHWl+O2V6IxBBlEJyabOKgwerBf4w8pNhpLaai0XNRb2iyTMHHxm9xyjFpq4haf7F++8QYv7qYvnp7kCKIDHxOw/PuZlGXvY9WSu+c7Hi//TPv8f/+PNn7KeZOWc+u5+Zc2JLcZpQInRG8+F6xf/6vYdY23Cz7WmMsGkMWRS/uNpz2UA0cDd7rvqJylp+b73g437kapyIWbBKs52mMhXThc7htKF1tgjB469MG4KUsBsdFPVCc99H/s2LVxh5xdvswTcD0X/JiROAy0XNftjy57+4p3aKh+uGh92a5nRkN3qGyWOV4mzVYoB/+dF7zAKzDwwx8dP7A0kXAfofPHnE6/HA57sd3ii+82jNf/cvvse/+dEztvPMROaL/chBItsQMVahlbCwlu9uNvyvPniKxbDbj3QWNm1pTvzi1S2PkpCs5WZOvOhHmhz4h6drfrYdeD2WoCWLYTd8qbuDlDJWGVptS4EPxCRoDVEyQ4yoCM1pCUn6f338KVY++9qCybf4XwZlFMZqtFG45Kgx7A89u/uIU5mz1rIJNdUD+GI/M8bizHTWNEgO/MNH5wwRfMz4nHh2GMsUJwrffnjG3Thx3feIUXznwYr/9vff5Y+fvWbvA1GE2yEwi7CVhC63Czql+bBb8nuPL2iMYddPVFqxqCw5Rn52OHCRBGlg5z3bPuBqxUerDjOWwK54bGL4+7K3ij5q60RRWwOhrMFkynSjZI8kSFCfWO6myP/3s+eYrJC/66LdQhr4ErmIHtLI66lHJGKVcBZqvvXkW6zWK3b9HqVtCecymhgTH7+65Wd3O+aUMMcYdp3hOk3c+Rel2M6Zyhj6kx339xXP7vcM04xGYZVwPYxIBZKFhYGVtkQsQ5q4u9tzsmxpK8echZ9c3/Ns3LKpLJfNkkprPjxZU1dwWS84X3X86atrboaJLHCdZtpsmHRCkWiNZeUqdtXM6CGKQgvkqFChbLz/ZHXJWAc+3x/YK481b+kUbxKi1Fcc6hTgPg00XvBGMwSYk+bJ6ZKuM0yTwthSIBsAybwcRp6NPXsfUBlsdmhT0+eBn273iDKgDAnN3O/Zs2S7Dxx8KMFYleLgBZImi6eKhi5Ykkn0w8hI5txV1FYzpsgvdztepMClCOva0mjLe6uOxmgeWMNFVfOnt9dc+xHJwhAytTGgHJWraVwJcIo5kg2k2qCVQqJBecEay3sLx+Aj2yDl4lC/Fa29UajyQ2V4vt0S1Zf8dU1KkQ/ff8Dp6ZK064sLGV/unZmfvbjjJzdbxpxKum0WJMLtduBPx7mIGrNQaw3ryHi75/Vh5H7yhavq4GZMRFLh72vD2jhENLsxcuivWbWO2jn6KfGjz+/4me85XVacdg3KwXdOVyyM4Um75p3Nhv/h1UteTyMomMdijJBEozRYXSZjU5FPEshoFCllZC5F6B8sNtyZwOt+YsoJU71NH3wTUH/1HQXXYaSdKtzRWKAaEx893HB6toTbLZ0rtpvOWeIMP3n2gh+9vmXI+av1lyJc3R64HntihpSExhg4jezvBm4mz+00gRIqo5j7wv8XYK0dZ7bGiWHYHdj3I5ebJYumYj97/sMvr/gLOfBw2HO+6jA28w8uTli3Fe+2G949O+e/f/Y5L4cBoyGPhfo7x6IYtFpjrWFKCUkw64TWqkyfplJ8/tHmnBd25uU4MaWIfesL+8ZQ3HkU5GKJjRHm2TNUFu00WcEEPHBwen4Kw4E6K6wy1MoRPXy83fHZvmdMqYRoZoEo3OxGbufpSK2BSmt2e8/OjPRDog8lpddoxTAGos7FxlhrVtahlWEYR24mz7qtqazj4CM/enXHpzJy2oxc5I7Kar57uqA1hkvb8mi54I+vbrgOcxHoTpTgy+PV2qAwKGaATJluaghRkFACw363WfFSTew5hr5Wf8d9+DkmLMqRlprJBBImZU6blkYrTM6sNwvskVeljiEJPpXImJxLMTPlRJKMM4a5FlbeEeaj+p4yRUgpYbOwtBblEjFnYkgkB+fO4bShVpoKxTB5fvT6Nf0wceoHTrsG0ZrP9nv2EqhQBJtYOsfKNQhCJIKGd1YN55XF+8QP9J4LXdPnIpxbuoaVq9lNE2tjGefCVRWdqVpDyJmf3d+yUI7oBZO+dKV9izcB9SUXVQovFUA7TWU069rhlKAks+gqshT//ZwE/ZVsPqJ9whxtZQWF06q4oOSGEBNRJdKX/rOAlsDCGZRUREkcvKd2mkXToJWiNhaLMPvIJ7noB8ZWWGNJWXg+BXoVWYWR1lR0RnPS1OhsCKmMg97tOh5WltkHfpBHHpgFvSSsa1i5htYpPJlWBVLWZBRKg2sKtenl4GmMQ7Bl7J/etljfBITCuS+VSOF8KqdxdfERb47ir9PTDokRncr+iFIErUgkVM5UTtOHCJKo0Wxd5GG9pE+RPkViKvtgShl1PMzEFp7rXQoYDZempjKGGk0limEO/MfX1+zmiQddy0XXIAl+1vfc5ZnKaVYusnE1D7sW9WuUnW9tFjxZ1Mwh8T+x5YFtGWMiiNDZIoTcx0hdW6YjZTErwXaKpISf3fY4owgxk7Og3hZcbxZfXjgNuNpSVbrQyYzBWM3pWYeEdNRVlnX6pUhXJFM7zSEU2mCrDXMVWNaOKQop5kKbFPA6UuvE2mpEO+acuJknRMFD21A5TYulEcPtMPPvw8T9PPN+mHnQtfiQ+fH9gTtb7BU3JnNRNyw3DtGaOZZJ5LdOFzxeVPg58Wdseeo6dsHjRVg4S2ctBz/jKsMwlik8CmyniCrzw6sdy8pBECSVS+hbvCFkXah9R5/5TKYzjoV2tAqMzlQms7SO6EcIEZ0zWcNoDQlQPlMZ6I/nuNWasSqTSp8ESUcHC5PROuNsZuE0KluCZG6SRym4dBXWFEGwzYr7aWZ3M9GnyKWvOWsaUoZP+pHeRBqliTpy6irapkZEmE05K99dt7wTKnzMfJ+ec13T50hOQmcstbX0MVI5zXzUCYgu9J+sMp/se2pnULnoZop+6z+Pb2zBX/hMhT+ojpzi3TSxqA2qFpbOcFJZWqvwhx7ijEURkrAdPSDczSNaQGdVOFIkdBaMKgKw4z5GBj7fDzxpRy7qijNni1uKa2DoWZoSELKpHBWK57uRu3kipMRh9twOE0ordkOgWxqmkJhiptVCbTStq7G1JYRAqz1ZJ/zRtmlPwGlYKYvLMHuPU5qFcfg842NCFDir6ZThUdPQYgg+H3lfb7tbbwzHWgsFRhU+X4oJoxW2MmUNGkVdCSFkjBasUUQRDpMHnbmfAmFKhV+IJppiOFspSFqXtNuj9eIX+5FTDSfWsDGGKJnaWl6HiKvs0XaxpjKO2xCZckmJzBEOFO5sUJpFbZhTICSN6AprLa0yWK0JQbhPgRAjmWIPO+lMZSwLZ2mURiRTGaHKmp4SZveldLhWloumwylNSomUIb+t998YRBc7OqVV8VtWwrKtaGvHyhrOOseqdoy7HToHjCkOJ9vek1Lk2s+EmJAoJClFPBSajORiQ+h0EYd92o+8209cNDWnVUXIQjNXfDGMLJRBac1ZVVGh+GR74MZHxhiYY+Z29CjgkAPrtsJLcUcxKJwxtNZSVxVzDNSp0BozGSOKQadid4wugniBtjZsdMXOB3xICOV7q7GaR66m0YrPU2bnj9Z2b/E3Dils2mIxaIuriBihbWq6umJVGS7ais4Z/H4HOWBNaUxtDwMqKe69JyRBBYoQ/Mi/MkeetJWSB4LAL7cj7y8mLuuKM+uYRXB1w2dDz0ZblNWcVzW1KH5yt2UYA30o7mSv+4mchZ7IaVMz5VzsXaV46jdNg7aGMM7UoeQ4oIp4cq8DtjassFiliSK4SnNmGu7nCR9LW9BZTec0T+qWhTHMviSjvr1vvjl8yd83SmGkiLqdK+FZlUCjNae1ojWWNHlUijgUISXu5wGVYes9IRQKj8gxXZeMtrbUh1L0USrD837mnabhzFnOtCUg2Fzxsp/oVOHgb5zDieLZYWSIgTklQszcz6WqnMmsa1f4/1qXyQTQWoduDGEKWF2EvyELSoRRlwlsq1VZg2RMpdmYmr0vmSZKgbUaYzWPTUNtNM+9sJNQnIy+Br6xBf9XNj3HHymXgl/hOFjFRdPydL3G5sghTEiOaDTTFHh+vcUYzdaPyNHKLmQYibikiTYTVTnwlBR7rs/2I4/cjg82K1pnCBnaKBxCJqbyIDvjWBnDFRP7481/mBI77UtQh9asXcMhenyIDELxVHc1S9syR00IO+5mzyFGJGSumXjkGpxATIFJElVjqLShrTS1KS49CeHC1fz+2TnzNHM3zeyD8Kug6bf4m4ZwFAtx9ANWEKbIOEd8V9G1FR8sG5zORDEYK2itmebIVT+hrObeB+a53NzR4FVGx0zUxRNdskCGpIRn+4GNhve7Ba11JITKWPZhIBtBKcei7uiqisM0MsyerDVD0szHi2xVWU4axTgEUsx4lcvHXWbdVHgRxph57T2jT5AUWxO4MBarIeWIjwmnIyYrnIo0SuFTZIqehYbvXCzoQ+Qwe8YsqPS24nojUIBRKK1LOmnKpJyJUiwuL5ua71yucUo45IQxZQR+8IEvbopjw7WfmWJGEiAw5YRC0ceIz6lYs6IQBb88jDy42fHhyZKFswSgmzv2sQjgJFNoh9bi6Bl8mQ7cxbkUTUZjLFwsGnbzXDpaKaEIVJVl2TTYoJj2mdeTp58jeLjVngvX4JQhZ5hSZFFblsrhq1zWXy4i9lPj+MOLE6Y5sPWBISX026bHm8Gx4NfHdPGYBZ/j0VBAWNSWDy+W2JwZc/hq/e1nz2fXd3TiuA/FnppcbKLGnIBic5mlOOrpY4P1F/c9j6uGjzZLlpUjoKlDZhciKmdIsLSOlbVU293/n70/Cdo8Tc96sd8z/Yd3+MbMrKy5qrvVg1q0wBK0muEcjBlMGCJOoJXsCG9YOYAFCjasQCst2bEjYOHAEWBH+JywCMcBdAzngIRAILXUkrq7urvGHL/xHf7DM9y3F89bpYMxdvVBWWqp8o7I6K4hv8zK9/me4b6v63fxdC6kqDyVmWsX8c7SdpZ7q47baaaIMMwHLn/XcHe1ZhZluhWeTHOdoGd4kmbuNwta68lF2UmmbzzHtqmTeV89JNEId9uGH3/hnNv9zJMpspGMf77+nl05hQP9zpWaeq9WSaZgraVrHC+tAjZV424I9hBmlXh4O9Bay23KdQ0e9sCYKyCl+PpzPjSnqzG8t4uc2YnPrRYsW0exhk5hHwsl1vO6bxwr53hoJuYilKhsSmIf66W9aSxnXctQCpi658bD9PSOXzCh7JPwNM6MsSBJubGJM9vgsWRRBlNoG8fKNmQjGF9JfRHlxAd+5PiI7Zy4Dom9FMLv+aRdOFzGgSyUyg/hel+wKC+vW84WLXGaERew1hPHzJPtxG8+veZo2RJah3qDbS0uCjorkyolQJbDOE4UFWFjDN+42XDv9Ii+aZBSmNLEkDNP91sWNtCJoWk7Xl4s+WAc6yIpBtQSvGexdCyaUEME56rD3gfDdZ55swYCczlFHuxn9ikzz9X571eBbUlMkjHG0EvAGOXIBF48XrAtmXd2W45tyyvHJ3x7foKoYFRoeD5PfFYl6EdToPrXFdH17uWWRRdY3vHcPerZboXQ9PVQiIXLMfP2kAhWCAftdOWhG1JMFBK6CIjUiYEcMHCpRN66gZcXRzjfMufCkEfGCLcSOfaOBFjveWmx4na+wh46E423tB6CdyycsnCh0gTyTJwjtx5i7gjZcTGPPJxGYhaKGFz00MA2xTpVE2FxACgeO8v9tmGD4e05c+oC90LLO1ErYoCMe97hfzbl6mXLmjqJKQglCd96fMGb98/43P01r95ZMgwzoWtw2jKNiUebLb/y+Jp1G2g7h/eWYk0NS5vq42w2NaVRDuQyA+yS8PWLW149WeJCDTWKZKZceDoMLKylU7BdxyvrJY9uRrxUQ3frHcsmYBtYOkcfWnQWdvPE3hku44Ri6ICn08wHw8Q01cel3VuapeVWEkkFa+DUthSnLI3ltfWSXcl8Z9hzxza8vj7mm/MNxlqsBf98/T2bOhBSgHphV5jnzLcvLvjsC+d8brHipTsLxv1M6BY4tUz7iYdXe375vSvu+pbFUcA3hhIsWsDsBfmQwiOKlA9TfGtz7Zef3PDq6RFHbUspsI8D+5i5mPasXaC3Ftcv+NzpCY/SWL1FUvGzdb1busayokenwnYeGWLkusxYNVgpXMwj7w8j45yZc8YlhzsyPJWR+fAgPvUNuQinzvHK8YLbnHlru+dFv+Azp3f45fERWENjDM3HvGw9r/8F9eFl/BCgJqYwqPJ23vDi0YpXFy0vHAcePRlp1yu64NkNM0+v9/zW5YbztsU0BuMN1hso1G65wqRVSityuPhbg5bCtzcDrx2vWXc1YX47RoZcuJoneuPojcU1Da8ueq72dV/zUhGubQi0a1sbtgJpmInGIsZyneJH/y1XKfJ0jqRUAxHtALY1bCUTtaKQ167eEY6N4/5xx74U3t2P3LctL63X/Ga+Qp3iLISP+ej8gb3wg8WoBxEKkSpzrrKKP/a5N/hjn7nHqpnYbC3kwjgKU8zsUmKIhaYpLBctnSreGppgKFExHmIDUkxNOi2QfL3YzR20vcUFw5PtzM9/9wN2EmkseLG4xrI4aRFVXopLGmtIuXYs1m3D5+6sKdbSLuByNzBmYUJ5OgxcDO+zK5mbkpiR6sALoDNc5RHxhuAMnVoSyok1vHmy5tXjNbkY3uiPWCwcbQMvnpzync2ONAyM+pyQ8qzKYTCUqr0yHif1z7oU4QtnK75yd0lL4sY1FaGaoKSE5EjJivNgbfWczCIMJTLnhBdq8IfUCY219TGhQArgF1Bc4eEw8K8vasCbD5a9Ee61nvW6R1V5paxRVRqqLC04eKWDIg5dK7e7yCSF2RZupsjlfmJXRi6mqfLVFdQ6MFXL7RtLHxy9wjzBcYDPL3ru9A1j6rhrO9ZNoPVw3jg+GA9J0O45FvGZlPltOU9Nea/ToJyEP/bGa/zZL73Cyo3ME0BhO07EKTPPmXEWGptZL1tOXcNkMhOCeKlmtxbECN7Y2iG31I5oK7THDh8cD5/u+SffeZ+YhcZDyNCsPSdHC0SVl6e+ppV7KMbQhMDnDuSope+42AxsYmSviadjZDM+4YrEZqpUNZzWxk5SrvIE3tB5z8o2WBNYtYY3VwteXq+ZC7wyjByHhuWi5fW7p3x32pN3A/l5FsmzKwO4w9pTKFEZSPyxN1/jz/7IqzRmX9dfKVzvBtI4M86RaS5sbWHtK7o3qjAlIbt67sWFIhl8MrhiKEYQY9j3hcVJNUB+59Et/9033yJlpWtrGrjzlvWqoajy+m5J6D2dc2QrtK3jK6fnRDILWh5tduxjYtTEB9sdj7cDFyVyHTNzObD2G4eZqhnZOEPnHSsbAMe6tXzx+Iw3T46ZFX5oN3GvWeIXDZ+7c8Y748CTYWJ4nkPyzMqIBTG1KXaYOAkCOH70zjFffXHNwo1cXFogcDVMzENkjoUpKTuXOVu23A0dSZXJlI/WoDaVgOOdwYpBbL2MT72wOnYE5/je1cTPv/s+5dBU8yq0ref8uO6Br5QJ3xq6xpGonqrPLnsK0LSWi31k0vprXs+J/zBdckNmyKWqTJz5qGF2lWecr2GCC+fxrmHl4QvdMXfWLaMqr/RrjvtQ1QXmhIfzzPUUK73nY9QP8IW/orvudCt+6P5d/jc/+hUefPCAcRxhHvmNbz6mbT3Lrqupps7iTO2098sGZy1fOXmB+Uj41u0N72w3tEvPrmRedEvUZLKDaGD2wlICx77hX799wRQTuzmyk4gg7AVSmLmxI693C3747Jz9MPPusGWk6vQnk/j1p7eUIhw3HrFCUUhqMM7ydDewIxPnerHDgjcQFzUFcG0drXU441iFhuQzGMMsyjI0vHHcfHSwvXTniB+e79A5y4Pb/e/qZ/T7uZy3uBB4+fSYP/yZV/jKG6/wzvceM4x7yjDzb3/tmuCVo6MVTetoKKSPGCnVbf7l07vMUfnusOP9UVk5xw44lUJjfU0gNVXic4THucIvvn9FLHqIArcUW4hpoqiyixaT4Y3TM6YcuNzuuUkziOIx3OyE63HgXuNw3tTQolL1tw/LQCpCkSoEEwsI2N6jRiBGIlAsLEIgemVulNk7Wme57xypZPDw2smSmcLSBS7s//+Ev+f1/ZcNBtda3nzhHv/Vj/wB/sSXv8TX//1vMo9bynbiF/7tuxx1lrZtAU/jq/7YoCw6i7OGHz0+Z17M/MbVLd/Z7XGdYSiFV0oPrjLHE0rySl8CS+f5p7/xmKFktjGTYqFYYRLIXtiGie54xRfv3GGKM+/s9zxOheAcCzK/+uSGVOB8Eap3CmU20AXLg3n8aLIpWrvHHktuq6StszUoJ5JYtQ07MjMN+yIsfeDN1ZI51wC4l86O+PL+BF8KjzYjH7D73f64ft+VC/Vcfe3uXf6rH/4R/uxXv8pvff0bjOMl9jbyi7/wDl3nWS7qNaKxts4FneP8uMUbxx8+e4HNeubrF1d8e9xiehgRXpNFTbD1QgxK9MKaQO8cP/dr7zLmzDZVLGK2yoRQTGLwM8tj+NydF9jMEw83e57mSDCekg2/+Ogxcxbuth14Rb0iqqxM4J1pYJsyMVbmuTUGYyAf1w7vIria3mrqGT5IYi7KZYwcty2fP1oz5trceOn+OV+YBqQIj7bPOfzPqlQqSfHuYs0fOH+FH3/9VR4/uWa32zA/3fOvL0aWfcPaO+btSAiOqA5nPSd9Q+OUL/UrZl/49nbPOyniF4YpKy9qhzeGGITJVJn3ifN4Z/in33nCXIQpZyTXszIiFA87G3FN4rPHx2xL5PF2z6MpYqyhcY6vX27YpsJp2xzWmCBZKdayIRKTILFOF6ylBtb1YNXRuMrCjQhrb9i5xI3PdMWzdIFXFp6YMwXh/tGK1/cDsQhPh4/HZ/+BvfC3eO6uV7x255QvvHQX0kBnCq51bLfKOCVEhb7pELEM80RNw/asQlv/oD2smoZzWbApiTTs6cXy4tEKY6oiIRbh1kRe6hZMKfMkzgylkPiQzgIckEnDVBhHRVhwp18y58y3dpsaklAcoxjGnOhY44NBTTWHtDj2FAL1xeqMBWe4YUacIlYYCoyl0HjHWgIlWU76NavQkqRwMe555/qWL/s7vNY0nC0WbBaJy+1zEP+zqmXTcud0yRvna+51ge31Fb0RNARuh4khZhqFtVbqUkYwAs56lqEBjRjjWS3h3HTsVUnTRJczd1aLj/BbRWEowgvWca2R21SI+mEChcHjiSWTKcwxM6dKX1lrxXk+vN1TUqazjkmUjc6c+R7Eg3MYZ+mLoTBSc5kMxnqwcOsyQsaKkitIiuAsa+/RBKftknVoSKlwVWYexoibhGYJx23HKFoJMM/rd7za1nPvZMFnzte8tghsHj+mszOuMdxOiSHO2OJwzpEQbmfBZPDWs2oaPOC90jcL7ufCVgsPpgEVw8vHC6ypksS5CFsyrzU9N1PiSZyYc13LguAOJIhUlGEsDINAabnTrRg0c3G5JeWCC67y/lVYzZbgLWIVayq3ekg1VbVRSzAG5w3XxMMeqExzXdet9yDgcLy8PuaoaZhT5uEw8t3Nhj8ULG+GwN3Fgu06sp2eT5ieRXWt597pkh9++ZzP3zlid/mQ1k10fWAXZ8ZhphRH0yyZiyGVCbLiTWDpWkQLxnnuNJ6XY+RWMmnYY4rjtZNVPaPVMBXlJife7Huup8jDMjBLqWNLrVleEpXoYBgz+6FgpOXFfkmJiafXVUuNKpspMUpmYQ1eLcbXhltvPbtNNXQ6cQRrMQ080Yh4pWAYYqkyWe849gCOl0+OOWkDMRfe3W/51tUNfzhY3rh7zL1lz83R8gAJeV7PovrgOF/1vL4+4rVFx7C5YqEzvoHrUYgxYkVZHfWMIuwO1KfGedZNAxS887S+4QVVRis8ShOm1NAqd6BKzVLY5czrbc/jeeJCEklqOJYeyC5SDFqEcc4Mk6Krhju2QZvC1bhDi+KN4aYUhlxY2wBWcL6eqb2xzIPgxWC1ynytN1yQUF+9pHOsMu/GV4OxLZ5XFmvW3jOUzKNp4N3Nnh/3jpfOPHe6jut+5nr+eHvgD+yF/5WjI+6fr7l/vGBhDTc3G5wtxFxIOVFypleHqqCqbMeZkgUEXluvuUmRMdV0M6PQe8dZ3zBoYN02WAOuHMxDIuxTZjtmhsMLPtjaFTV12k1RyFnYj5GLqx1LHzgJPafNzFQSqhCM4TYXvPX4A87RaTUlxVy1gaKHiGgxcOgwqKkykWBcdWgfRoR90xKc43YeeXd7ywfDjjenNdfbHdY4ll1D2z5nBDyrevlkxYvHK+61DUyJy5s9vXOkmMkpoSI429QYbCkMJZO1XuDvdQ23MbFPucazG0sTLEfiCWJYti3GGBpc1VbHmW0u7ESIVJOmRdiXXH0EphqWcs4M48TFzY4+CVNO9KLsi5ByZV2rCNbWyz6mrn+LJUsdH2b90AtlsO6AOxOFUnWM1piP1mBwDc46Nhp5mmcuRXitKNsI1gWWrdA1ze/eh/T7uD5zfsxLZ0e8tFyiU+TRzRMcM2PMpDkiOUNTqTYGYbsfSbkaez9zsuJyigypNhGwhkXjOadhEmXdhboPFUtMihTlKsb6kKDUw8hYtvx2HL2qkqKw3UWeXG1ZNp6z3HPezAwlIaq01nObJ6xziK3JpUgNF5yz0GKpbZBKaYEapqRaaU+O2vnPWkfUfdfSWMv1OPHOfsv708DnxpmL3R5vLMddy6ILv0uf0O/v+qH7p7xydsyrJ8f4Ilw+fEQwM7kIOWVKyVhr6/ozymY/knL1hbyxXvFoGLlNiYXWfWgZPHf7lnkyHC3qGezFEbOSo3AZZ26myCAFj6GzjluNHzU+VCAmYbuPPL3YsPSBs3bJWZMYSkKL0DnDRgT1VaJhBD6MqpmLHLww4FSr7tlUOa9ozQdwgAn1XgCw6Fp6b7meJt7a3PD2sOOL48TFxhEMnPQd/fP198zq1fWa+8sld0KHyZHrMXLeVz8Tcrhjmbq/WAPX00QpilXDq8ueJ/PEkCuSXaylDZ5T0zIVYdF6LKZCXUoNOL2KidspM1MIpp7D28MOWGU/Na15OyWubkc6YzlyLadNYlcyIhCsRU1BKsfl4PVUMPWMNmIRrbYYo1SvDHUN1qZ1BSl8eAYvQkNwhiHNvDcOPEwzN2mm2w84A+u2oW8+3j3wB/bC/8bpMadHC5aNp8TIMGROVpBzIpeMQQnWkg4X9CEm9nNk4QMvLZaMQ2GzS8hYuIwTs2QWrcdlRyRXvBOOgpCl8HC3JyVDsYmV9TTW0Vj7ETvaHEgRF/uBLj3lM2enHDUdL6+WXE4DYyn0PnA5zER7iIgvwhxLPeCKkjFEI2QFXxTvXMXjFUXVEIxhYdyBhwZRhbkUbqaBh7sdYy7klHl4s2HdLQi+4uue17Op147XnPYtPZa4n9ltR9wqMI6JkjLBWDpf8YVQGGJiJ3Vd3gmOTVZuhhlNlmuJjFLogsNmQ3auhnqoQ1GiFZ6kueK4TPhI3uW1UlkwdVOYc+ZyP2BneG3R4HLivAkgdfzYeYOfYbYOZx1ShHLAGopSw2REcQpBDcFZFItK1S9aWzF2csgdmLLgUW5y5GmJzMZRDFwloQ+GEDzL5gd2G/k9XV+6e5ez5YKlb5nHyGa753wJ8zSTY6kHg7Xkg35zN01cTZGld7yxXnJdEpfbSHGZp/PEUArLNtBkw6SCARqt5vRYhPd2e0pS8HDsAsFZgqn4OEM9vKYiPNkO9OUpb9w54ci3vLLseTzBPgvL4LksM5OpHdecCpLKR+E25UCaKFooxWCx+AAkalffGYK3H134x1JwolzPEw+ngVEKc0m8e3PLedcTnGXRPr9wPYv6kfsvcL5asWp60pwYNxvOjw37OZNzxlpogiNLZfDvppmrKbJynjcWS57GmSebAbWGx9PAUAqrrqETyygFY6CTmi6ayLy93VESYJTT0BC8JWAryvPQHBuz8Ggz0MQnvHZ+zHG74LV15skwMOTIIgSucmIwQjCmrqtY6oX+8GMySlalybaGDCJoOly2giU4Q5bfXn9Bhctx5L3djkEKY0q8e3XLSdfTOcf6+fp7ZvXG6oiT0NFiyHFmP87cX3QMpWY8OGsIwRKlNsb2aWYzZ9Yu8OZiweM8crmbKT5zlScGLfTe470ciFHQqaWIMEvhnWEiJ8F46JwlHIAb2RyIUtYwS5XQtPGGV05WLHzD/b4+LnY501vHxmYGW2iNpRRlzhVTLKJkEZJR0sHs67GI09qJ+1Cebg3l8PvbS0bUcDNHnk4zswo7yby/3bAKLa21HDUfbw3+wJ7Ux4s1ZENSpe+VVCbGyTDOGUulQgRjGGPlP2cDOynEKBy5wGYcKFH4IM08KQMlFO4e9/TO8s191dytiscUeJz3zKL4YDFSxzIr6yH0XOaRWJQuODYxMwwb5mbm9ZMjjvqGIj1ZlBynioWyhm8OV9wNDXEqXO1rh8J2pv4+UWbNBBy9BrRkSqkbUDYFg9DZ+uG9f3PFkbNc7Ae2c6Ykw5gK19PInZRYhobTpv3d+oh+39fKBUpSZjLOwpwjV9uZeRYMrpJRfGA6+GX2Atc506AsxLKNQhxGHjByQ0KD5XzR0avwKE+oMXSSMaJclchsawfUSb3MNcZyagM3Zawsa2u4mjO7ac/oE/fac5omcFZAsnKjoM7gneeDNLMwDTElttMEKCEIxVV5RjGKWkNDQEwN8CpoDSoxhsZWH8LD4ZaldVzlyKZkAp7ZGiYdSeLpnKEPz0lRz6LudSeUlIma6JeOVCLjXpinhDPQBod1hs1UZX27knkyzyyS5QXvuZwmtreRJznxVCakUe4edSyt55s3GxRlicMKPM2RyRRMU6dAFuid5a5reVpmogreWa5iYjclxjHy6tkxq4XnBelrUKFMNRxRLN/ebVh6T5oLu6E2ZdyydmqFut8VNTRYilhyPlzIbA2/CGpR4L3LGxbW8ngY2MXaqNlJ4no3MafMURs4+ZiH3fP6/uped4YkIWvBLYVYZrZ7ZbPPGCxtCFgMm3ECA2MqPB4mNsZw31ouysD+0cTDPPMkz0ij3D/p6TXwa9cjoKzxWIHHeWIWqesvVX39ynnuNx2P08SM4hw8mWZuh8i2m3j9zgmrVeAVXUApPJBCVDAZ3tpsOfKhmozHjAJNf/A0OSGqkoAmO2hqinp2ind1qh+oRuXvXlyzdoYH+z3bmLFquU0Tt9vESwvhuG15oel+dz+o38e1LFXSbL3hqPVc7QvzkBhjTUB2tjY8t1Os2vcsXMXEZDIveMtFmrl9OnLhCjcmowHOly1dcXxz8z/bA9VwLbFisxuDV4M1Velxoo4bMpnapL3Nhf20Z/SZF4+OWHVgTHO4zCtR6uX+YZxYWIdGJY71kuC72rkrrmI2RQxNtkSnSKpegeIqetQd6EHfu92wxHAxTYwx49SynTOPU+JeI6yawHn4eFP2H9gL/8lxy9s317z7+JLNfmSSxIv9kmXfcqKBXmE/jRytF7RtIO5nUlS2mrlJt1irfGO8wViHGCWK8mgzctQ1+GhwyXKbImPJRKO8slwySGIzzcRWmKyynRObORO8IavFe4ta5e2ccIue86M1oyrnWjeoX7+85iolcirc+hmsQTuLlNpBKAdeuRrINhMpvNp0XFOZ/CkVnshE6SzjOCJBOW4tV3HiKs6owsund/i8dywXdUTJ0+em3WdVi+D5YL/nvdtbrqcZBU5tz1HfctY0GFo0eRaLHtdYTN5ipbCTyHdyRLF8Y3dL8JBtIsbCB/s9i0VDM86E5NngyaZ22O9ZSCLcpIgNHjGe26GwSZFgBRoHBmYKb8eRrzrL6emKfDty7gPLLLxPAZsoBq5zQVQo3hBTgbGQomCoE4NoDM4Fzm1LaixSqp8kARHPIDOLKEQvXM8T1/sBy8jLL75M1wYa54hJ0PgcS/csql03fOvplrfev+Rm2JMQ7vmeo0XHi67htDhKirR9C41njXDmlJs0868ublFVfnPe0naBgCNK5snNxKINFWc5Gy7zTDygCF88WTBJ5nqemWzBe8uuFPZjxgVqiJGzNe12mvkLfcvp0ZIilvvF0WjgG/trbudIRtmGWIPDFpVGxgxZ8kfkl2whGuWebZlsqajkDNNUmDvYzAP9Tll1gYs4c7WPWGP5oe6U7iywXnpSEvzT56bxZ1H9UeA3Hj3m24+fcj1MRCe8YRacnS245xuOs2eaHX3fQx94fe0RLA+Ggf/x+hYV5RvTllUTOOoDE4XHm4lll6GAn+1h/VWx/isnVYd9Pc5MLuGtcpkimyHig6NxHusgG+XbcWKxXnB6dsx337/krFiM8fzK5oLbORJnYRcS6gx0ikTBRMipJgZjIVvL7AwvlIadz5AtJtbgpNRYdnng/f2GdRd4kmYup4xzhh9en9HdCSwWnpgUTc8bHs+qDIW3txve227ZTJEZ4RXfc3LUcscEVmqYx0zbeOyq43PHC1Z+4OEw8m9v9vgC37ORI99w4uq06HobaYODUimNtzmRS51ivrzuiChX+5nRF4yDUZQxCS5UNK23BnHwvkQWK8/Z6Zp4ueEk18bbb+QNw1jIpnDbFNQZdKXIoYMvhzVoLBRbgQl3bGBqlRQLpJqLIo3hep5p9nvWwXGdEpuxYF3hC/2S7tizXLSkLPjLjwct+IG98D+6vmE/juQsfEhCXxFoQ+DyekCGyLprWCxaHl8OXO13TKWQrSFSDV+NcyzapqK/YkJTfaE5q0y+4NRwTMAHwxfWK2Yy43LBJmb2sb6cbucZH1zVYanB4lAp/PLj9/hKeYlxFgyehWu46xpup4hQDRrFKrNXcJZ46IqYQ8qDOYTY/PD5HTQm3t4MXM2xIqgKXMfC8RjZTnrgo1ct7T97+y1+/JX73Kejs46z5XP99LOqh/sdW8moNbTWEEXp+xV979hnmKaZdSm0TeAmJ2wSFgiFzCZnGjxd37K0BlsMkiZMKjRkOgwjhYCwUo8HPtsuGCi81HmGrIxROXKWIVWtvUgdKYJFVPj1mwve5JSkDhM8wStnxnGbwfma4Bs1H8adNV3aAvaw2zgcHcJn10eA4emY2ZWapokT5tGykcxuVvazoNmQKfz3b3+LH3vhhBe6FZ0NnLXPD7xnUQ+uNuzGEc0ZWyxFCivvOfKG7TCynYRFCLx633NxtWHVLzlrW0SEB3GiAdrGcRwa5pwZC3WC2YJ1hhSgNY6lOLw1fH65ZI6FfdMxlMKclJO2YRMjxlfJlx5SKRH4tx884A+WcyapI/BV1/CKLLkYZiQLXizZCMUqtjfkSSDXtEhTgAKhsfzI8hQW8M5mx3WaEYVSlM2QuHSBy5TYzwlQ1Aj/z0cf8F+9cg/nGoL1nK6f74HPoh4+vWYcJ4woQR05KW3v6Z3l8nbP031m3TS8+ZJlH/cs/ZK1CayxvJ+Fzlp86+i7QEqCRAhYFjiyg9xCby3rbPHO8ZXVGYNExrZwnSLbmDnzLRs34wIkKXi1WDWYAr/0/jv8gfgiGgvBGJZNwxvHx1xsZ1JWPJCp03/TGNIkWCoZyogBMXTO8rXTu5QsvLXZcXlo1IgI17tMb2cu5linS9Tsnv/23Xf5k6/e5554Out58ej5+ntW9cF+y0ZnsqsTRi2KQ3HWcjNMbKYq0Tk/doybPdJ1kOpFfsyFBoNrarNWVPFFWWJojCU7JR9kZU483js+1y0YUe6FwLYUpqycNC0bSTgLkgrG2LoHFuWXnz7ly9RmRfCGRVOnojuTyGowUoEEait1rYzVM+IOZHaDoW0Mf3C1Jlp4dzeyyQXUUoplGIQrk7jNhSnX5DDF8M8un/JH753CWOiN5cXV7/EO/+PthihC4wyh97houJWEGQrGFEJjyAgx12CEFIVsINmaiueScr7qmTNYBGsKkwgzStfWDSMIHLnA+arn3uoYj/B0nJAyYlyicY59yez5kL9eEV/OW765uSVn5dQ1eHVIUU7bhvPUcCMZTEELBAyL4LmyVSOYTU2NsxjEKC80PYu246jpuUqJbalhIJtiGXPGW4uKIR5iwt/dDBxf37C+e4e+DUh+njrzrOpqHFAXaF0gtMos1YNxo7DwlsbUYDdVPaTpFaaiTGKIODJwtuiY5kpxMAJTFIwTVDPFWDoRVgbOm5bTxnNC4DJHphQxqqyD5SZbpo+sk3XM6BvL29NIug2chw5vA9lagoGVq1iySTNZE414WgpblOwNag32YM411nPqm6oD9C17hRGYNBHZVqOl1tyAOUckC49S4ZvBsLxTg25EnyftPov64PqKKWcaYzhrPW6G25QYh8yyGDpnSKYwFqmJznkg5sIu1fCWonCn68gCiEEV9qnQZ+gaB64GthxZz9mi4+VugWsMj+eRJ9OMc0LXem5MYpeqNFFUcdSL+m/c3DBI5tS2BKmHcVPgxDr2rWMiYwo4URat51YSYgR1AOZgJje82LV03nPUeK5TYn+gpN1mzySZgAU1dZ0V5cFuz69dXvMT9+9xp/VoeU5JeRb1zu0Nc8l0ztEtLFkCtyky3GbaLHQWghZ2JXI115yHOSemJIdgLbizaGu4liq5KPuUoDU0nccYZaGWEx846zpePVph1fDBbkcURbxhtQpc25l9rg8+OeiovbX8h4srNrFw1zT1cVmURVHudQ3XyTLbqsv2GFat52qYqY/GGqdotXqWXus6vHectE2VgGhmLparPDLmTLCectD9U+C97Z5ffXrNT7xwl74LxPicUvas6iKOCMrKOGgdWjy7LEzDwEqgt0AubHNiMIoZJ1IupFIYjZCy4bgJSIEiVWUxpEzvPKF1mKL03nLkPau+4bzrcNbywbAnFTBWWa08N65hKPkA264XZ+stb+13ZJRT43DZkLKyLIZjHwgI0dSUXVVYBs+NHPYqU5N9P8xaOe86vHUc+YbbXBhUiAo32VU5pR4ktwYoysU481s3O37keE3TtEwfM+3+B/bCf7EdwVaCgz9QbSYj+FRZ5p0PBFeRW9lD9BUqbgzkcqA+ULsCzlkaAmOJRCkQLSUJOSnZKCUa2s2O+6ueKQtjKeypG1jbBkqpbvCYlSJS0y+lIpra1lGKkkpi2QUWsaLpyiEBtzeOl9oFjAOts+w0MlEjl4+bwFHT0llIRHaSmVMmi9J7X3WHwdFaxRTQrCQRHu733BwfsXYtOT+/bD2ruh0LtnUYBaPVWV8QjAmEpqULnuAMEixxVDYaKVIoUv03aL3cx5KqSdw5xlAoxlIpWspeCmIiYkH2mdO+Y4qFIWa2pVSaVGNppJora2OhBhahFhHwxgCKaKHD0bqqJUyiNAKtMZy3DUyZxhsmqmzHOMuiaTlqGlprQIUpSzUtqcF7Q8oJayzOG0ywWKna14spcpsyqyD1IHxev+P15GZPdmAPRJEaEihQLEtrcc6BdTWfAeE6DvhsmEthkoJXA97WzpBWNJz6mjKeplKTTDMUI5TWsLh1vLjqKFmYSmEjmVELobU0Us3lJStFtLKlcaSsNK1BKIxa6EIFHkxSaLBVD+0Mr7Q939tDh2EyymwENcq69Ry3Lb1zZKPstD4sUUPbejQVwkFGZNUiWYgqvD8OXM6JpW2qXO15/Y7Xo5sd2SlBoVf7kfeHpCydo21r00CM5SrNXOaRhbUowlQyBUcbbEW8qjl0WWHOgg5CKQXNhmSE2UN3vePlowVFhFgKu5JITgitoztQ70qpP4wVUqmd+NAaJAtzKrTO0xh7OPMriaxxltcXC74zGHose1dqyqpRzprASd/hsUSUGxLTWFCBLji0CMFC4w2mkpaZRHh32PGFeMJx0x3CN5/Xs6jrfQSnOAyNVHKi+HrHc87RhBocqAZuS2Iv+aCugDkJBYunBqRaDMYYioUoipkKpSj7YqoaQyBsLXePWpR619pLIXkhBEcLiKnSnFKq4qJQ74RNCIgVsiksbA2Di6LUaM06VXrZd2SEVut0NRpBFJaNZxWq7DIbZaOFcc4YHG1jKVlovEUdWDVoqr+3R/PEG3nJkYP5Y+6BP7AX/pvdiA2O4C2NtRhV1FgQpfWOVdNggwFnyMGQxNKowYsiqQCW7ZzIIrS+oXOWoWSgEPdywHsKmchjGdnozMgxuzFylWduJJJQTt2ChXHEUsjmw8uN4a7vudf1nHYLtnFiyjNd07PsGjYkUt1P6GzgTujZNZlz03KZLVc6E52wtp6xJBTHpiSuppHL/UDwDQ0BH4R1F/DFstXEPFcH+Fgi+5SYG0Hl+WXrWdU2AibjqSmj2egBmeVpQkvTeJwtzJLYpInbMtDiwBhESu2Kl4pPbKyjD57sBU8gZ0W0Pi5vTOHCJC6z4yVrmKfIbUzcSKYYYd0v6LMjmkxSoUhFHb7geo5Cw9J7ZhGSKL1vWTphTBFbCq4UglWOm8C+GM6N5yYnNloo1tLZQDbgjbKXzE1OXMdMV6Nd8UZonMU4zxEtURPeGop1zAViJeE+r2dQV9tEbpXWGfpS8YfWH8xkzhKcwxhHEWVvhFuNnJpKf4pSKGrrVCYqCx/ogyf5umekUcil0nmurfLER27mmcGuSXPmJkUuJJGzcNI09eeWgphS90CBs7blTtNz3nds4sygmUXX1NCsYawPUWPpneWF0HIZEndKy7WJ3JpEssrCekYVnMA2Zy7izONp4ti1NM6Dh1XjaIxh8oFpygRxTKWwjYnBF0p5vgKfRV3dzsyNsHAWUU8WpVl6HJaFDyydhQNq+komhlR4ue3AVcKcqBKTQRIsfWDReqIvWIG4zWQpbA6Jo46Ji+vIjiNKzNymyNM4ka1w1HQsQiBJYS6lav6N4W7T8uJiwZ2+43aY2adC13cs954bLYfMm/o4ebnt2HSZO9rwmJkrjWSjrK1nh9IV5TolHk0TD4eRE9/RGFfNot7TGstsCqMpeGuZDhjmdKDFPK9nU5ttJLdKYy29WowzhL6S7tpDWGmlohhuUiIZ5YVQQSZJaiZvzIrJQmcdrXd0QTGipLGQC+xFKBacTVyNM681S0wp7CVzlRMZ5cQ29M4RtRAPjwFnDCe+5Sw0nHYtuxgZtLBwDcuS2MVDDKcaWmM4s55L7znKlp1XdqaQs9Dh2EmhV8N1iTyeR56OkZPQ442lcbAKjtZYstE6tbJU47lonV58zD3wB/bCH1MhUwjiOfEtJ33LTuu4en3gOivKpsxcpYhR8M6hTrFaKBRyUhp1GAshGM6dA3XcTolo6msNrXqvXcp88/qKBseMkEWYcyG3mRAsuzSRqXIeb+DIBlo8Kopmg5VA0wRePTll3hauppkxZeYsPJkGYpvJ6bflDyUrj8fEv+A93jxe8XhfdYKd9wRvGBIc28C5bcBa2tbzTt5wvAz0OI5cR+8bsn8evPWsKuVyMLEqRi2r1jNRkDQwJ+iMJ8pMurrh3bjF0dIsFgTvsSpMFHQQvIB30ATP6kAVeBLri9wYPhotDx7enge8QKTSWVUMCnjvGCQjKMYp3kFP7fwfljGYSrJ4qXFsZ2GviVkzkyqXk2C9pUgNm8sIUmA7DPw7nbnft1wXYZLKNfYIJFirY+0c3jiONPAwDaz6wNJ3HLUdvQvI8wPvmdSUM6KKcZbOW47ahskWdjlyYi3WOoTCbpq5zRFVIfiAcxZPqkjVaGiLoXWG1tVGCQoPpCY3Vx0puGzYlcI3rm9Zec8segjbErIRmiawLZFkqnmttZZT5+mpTRhTDI16+i7w+bNjZhUu88ycC/NUeNeO0FYkXYkfcveVy5vIv5CHvLLqeTjPbHOmcZamgZINS9dwp/M4Yzk2Le/GHaumobOGI+dpvSW556bxZ1FTKhVX6JQYHEetZ6AwSOZYLQssxcBuP3CZI14M8TC9xmv1dmTDMjuaA8Jz0VaizcPNVCdFAlYsLls2KfIrF5csbWCS8hHW2njFO89NjmRTcI2h9Y47bcPCWDRVMk9nLauF50fOT8m3Gx7PA7uUGWPhe8OANDULIqlSFFKBD24T/0Tf5bPdineHkZuU6KwnNB6bCnd9w3nbYqzh2Dd8J+04WzUsiuMkNPSNp6Tn+9+zqrkUSNXgX6zlyDkSMJIZAH/ICSkFdhRchkyuGSO+4jBtNjQZbIDOGVaH3IQnEilaE28NYDMMpfCdzY7OOlKWOtUqgjRK0zh2Yyah2NYQnOEUz0IcmgoSBVcsq3XgTbNg2OeDPFeISXh3mmEBZTRMpbL+JStXQ+Tn9TGvhp6LGNkXwRuDdwarjhPrWB+yeU6awHvzyOki0CisrCc4i7Ufz0f3A3vhz1rJOkJm8pbBGkqqo+kNsaKaZsOpdgQgWehCw8p72iawy4kHu4GdJGyKvNj2/OGzOwD83O37h+6lqeMib7ELwyxaWfcilKw02TG3CVdavHqKZooKE/DWbuDVk1N2JXIRBzYxYaLllfUJ7a7hTlOj5ndz4mI3cu0SE5FtqbIJUNoO3t0VbnRDayt7FZQkFmMND/LIg2HilWbJG/2K7Rz5My+8hnNC03gGndnk6XfxU/r9XZNMlOxwxmCtR1TQMYMbeZK2bFy9rB9FxUbB2UjItePufMMuw0M/s5WMF+El5/nK8QkAP//kFlCcyXiTcWJpu8CcMjEL8WDUblxf055tTZ+eFbJmZhUelpEXViv2uXCTI3vNFCt8ZnGMH685tUpvLPuYuUmZUSwjwm2ZmHPCJotbWZ5EyBScC2BqMNK+ZALwWCIX88g913Hf9+wbx4/dvUtLT2NhysrmuazsmZSo1Dh3FdyBDpFmmBEuXGHUjFXDma0mMsUiwdE7z4sWLmTm4npiA1yXwht2wZ88r3vg//nyPZICxlTWtBj8suIxb6Zc90BRvBgkVAlZUxwiQtHCBLxzO/CZl47YxsLDsT46ygSfOT7Dbm84doHWWPZT5v3NWB8rPjPmwpzrJWnZed7dDVzliG/qvidG2Ek99N7LIw938HK/5NXFmttx5k/dewWPYDvDoJnb/FxD/SyqqDBrbX5VWYIy5to1vZTIKILDYO2S1lpKgGgtC+94Zb3kKkaeXk/sJHEVI693K/74nbr+/i8X75BVMdYSvMGZuv6iKvMcSUUopa650lajeSOH3BxT0Ydv3+z58vEZcyw8HGYuYkSawGdOzpD9DUcm0FrLbsp893rPaIVzG7hN6WCANNg+8N3NwFXM+GCwLWQj7CVhreGtOPB+GXm1X/Fyu2LDzH/z4hv1ghg8+yRcT8/X37MqVSVJlR1acwgRzBBLYXvIhLEYToAGj1ohGcPCWl5plty4xJPNzOiFvRFe9Qv+yOkJAP/Xy4e16WEN3tY12C4sMSvbUvdAkRrQKlYQZ/GlZjMVqqTs/Xni9aM1NzHxcJq4zRkZ4Y1+jR3g2Hk6LPtYeLIdmb2y9IYxCinXgDDfGq52idxplc762sAYc6ax8I5MhGi413S84DuObeRPnb0AojhnmLWwKR9vDf7AXvjPjgKN7Rhz4SZN3F7NfOb4FOcTJMMcwVvwa1ddhlJ4qgPer/gj5/fJpfBz09vsc2LOheth5v0w8gdeuM9Lq2vIhZl6cVKxrF3DNTPJFIxR+sbSdwfnsyTOfMstcJsnisLNOPM/vPcBM1XqIwq/dbPhfn/NX/hDX6Dxngc3Gz643tB7x+Pdhtspsy0DxdbDbKWBn/jci5zahrNlS+MN19PMP333Ecdtw8U+czXPfDDvWfSWn7hzj7lMdYMZatDSdngeK/+s6iQEnHHMKoxamCZ4admQrAURYhSsgdKUugaNY1sKC2P5g8cnSJn4fzzZIUAumZtx4kHo+JGzc15cFawa9nFimEcoQp8yc4lkVVxwLH3Hqlmiprr5j52yySOblKAIe4Svb29RD8XWiPB3Lmfeudryv37tPsFZHm4H3ttssSgDlrFYbsxQN0pjcTnz1Tt3OPKOo0UgGMd2Ev717RXHTSDuDZsCV7mw8oUfWZ0zjsJjtgBkkY9Myc/rd7buHDV4tQy5cJMT25uRN85WtFpNskSpmQne4meYVHjKRLtY8Efv3EVS4h9ND5gnIRXhyTDzjduJr73yEq8sr8i2rutYBB9hYQMXPpJswYihM5bWe1SVMUfW3mNRtjlSSuEyzfzTR4+YcqkTI1W+fbPhm/0tP/mHvkjnHd+5vOabTy7orGOXErtceDCOHyWTd8byE6/d4b4PnC5XtNZxM078/JMnHPuGKUeu48zDtGfRGP7wyRnbtOMyRcxgiaKM6fke+Czq9fMOJ47NnHkyT+yHwhfunlAQfAFyNRwuOk8zePYSudSRdVjzv737CjIn/t74PVIuzFJ4Ok18dzvwR197gzePrtlJYtBMEaXDctx5HqfEeOjQtt7Rdx4p9RFw4jzeKpucSFl5WCb+2/feZ19SlZsJ/Nb1LS+vLvg/fO0P0gXPtx8/5bcePqb1htspsU2Z232imBqQ2DvDn3zpZV7qe07XCzrvuJ0m/sm7H3DStGTJXMfIg7xnVRz/9SsvsRtn3psmcErSwvj8wv/M6sWzBTYbdjFzkxLDNPL6yQKDx4uBpGDBtx7ySC7CLZll0/NHFsdIzPzf0iNKrunJT8eZb90MfPXFe7y07Jlt9SvlLLRiaNee2zkTreCLIWBpGlc9nHNh5RxWlZ0IBeU6Rf6nx08ZtZC0+kzefzDx7bDjv/nKm7Te8b2rDW9d3NAdwy5nbqMwy4z6+tjonOPH753you9Y9S3BwGaO/IvNNUcusJstu5i4jBPLYPiDqxMu9yNPylRBMCK/9zX8SRWjldkcrDlg4hJiBbWGIkCGXU4MEjlrOow3LBrHovXso3LUt+xTpiRlmgtPNzPf9dfsSLy6WhCLsEsZinCbZ7IRLIqx4K1l4RwNsKkN+cpQPdi0jVe2acZZizUGVJmLcDNFfvXth7xyuqKznjfWx6gqi1J4K23xmDpGt+B6w2vHK3RXw7Ya52iskkpEpdJX5lTQIswUTrqWSQv7OLNJE7kUTHmORHxWJa1D1KBiMFbJRcBW7bQYZTZKUWGRldkXztYL+qZl1ba0PlBE6NvANOdq9lLh8X6kdbds8sCL7RKnDicBVWVXZrRIpVB4R9cETkKLATY5UbP+PgxiNmANg2R61xKMrWSCPLOxht+4uObeoprRXu1X5JzZ5shDzXgBJ7aaMCnV0BsLTTa0vpoqc8qUAAvniLki7CJC4zxjrFH2oyiCgDw/8J5FJVcN2kLtwg/UCSOuavTHUrVcnXcMWjhvW6wzrH3gyAemrCw6T0wRLcocC482A19/8oRriby8XrAQYT9n1CmDZjA1/dZaaJxj7QNBlaucKhzZ1nAYFcAZNnPG2XpwAcy5cDnP/PLbH/Dq0ZrGGD53fEIQZS4zv3W7rwd1PhjgGvjM6hgzJzrjaLwneM+YMyvb0GIJpYZ1paAcNQ3bObPJda0X0RpP/7x+x2tvBVuUbKucYUhVd68eJuoU3MywmPfcSORe2xEcHPnAqmlICbreM28KkmpuzMObkd/sHnEpE68v10xS2KdEkGq6xNTJ+4cXoVPbgNWPZLtopdupUbyz3E4JdYrY6iXIuXA1z/ybt97h9bMTWhxfOD8nlMLOjfzGZocXg40GrKANfO74GI2FpbH0zjPZwJAzJ66hweGKIR8oKedtx3aauIw1VVW1hsQ9r2dTk6ni7WwFZ2A2MFtBAowijLlKfqwzDLlwJ7S01nBsHSvvGAQWra9o86JMpfBwO/Hr4ZZbSbzcd8TiGU3GKRWJacBhMA6cNSydqx4jqcF/mA/3QMW7+hgpruYroVBE2GvmVz644N5Rh8Xw5voIr8J+GPkWE7YYTAa11YT8xnKFRqG1ltY7Jqm5TGoCTgxG6h5YUNaNZ8yF21jY5YSKEvTjyRp/YC/8RgwJwWJZ2MDoElNOWGfIVslaHctD+pBA4ViFwIkPcIhBPutaNlM8yHcs1hr2uRJT+ibgspClyhnGgzRGTU0a/fDrBUCLZc7VrNO5QERorSdJZt0EvHXEIqCJ7ISH2w1Y4dWjY+71K3IR8jzj7K4yhMXUQBoPvTqSrXxsVUUMlZLSGTKVee2sxXtP23uuttVcl1VxpvoTntezKWctRRzWCp0tByyWwUKNxjaKiDClyrxvQsNR23IUwkd5C+dNTwwFK0IwFmtgSBMxZWxbCEZrlLsKc5FKoPBVkxecZd04LEpWw5wFjyFYQzSGoPXCvbAeZw2TFmarRIQnw4Qa5V634KhpycYw54zVhMNija3CRWMq8kurr6QgFBEmyRyrZzbVL+NMRZQ1AS6GyDZGiq3fUyrPNazPooyaw/d5NQ7OUuWG1hqSCkkEq7CPCSPQOsc6eE5dwGAowN22RSZlT41wN9ZUyIAUvLM4DMVpJaXEeoH5EBUXnOXYBzxKomr6vbE03jOXQrCWnJSlD1hviFqDs6IV3tlsyKq8vFpyt+sxqlzP9fduDk0TqTh/FsaRrPDhkaXWMOeCaQ2T1umptQbnLH3b8HA7cRtTNdo58/zC/4xKsiGWSqVbN4FZDoZZIGohFcEK7FPCoPTOcdZ47oa20kQsvND3yKA4zQRrMJaP1l8TbM0nEQErjLFOiZR6gQvechxCbbaoUDI4YwjWESl06kkqHPkG42CSikWOVnn/doMx8OrRmpeXK8iFKSWgUl04wAYKsPSOMR/yJTAUY5hSwXSGWUp9VFpwvk79373dcD0nZq1/Nun5+ntmVQq10QZ0zpFsJh6yQESr3NEoxFxzlYIxHDvPsQuVrody6huyE4wUnKkX+U2KRBHCIRspWwsoMVecsVL3QO8MS2+xAsZ4YqnEoGAsyQgtjiz1DOZwjhc1FAePdgNihBf6njtdi1UYp1hxnFqbJmLqeu+dY7YGQ83IUWuJuaBBPzLAGwPeGfrO8eRmYpszg1YyZeHjXfi/r+vi3/7bfxtjzH/044tf/OJH/3yaJv7KX/krnJ+fs1qt+Mmf/EkeP378/fwSH5VXVw2LSu3yWEfKmZgzY05MJZFVKm5JKxll5QJrG1BRjBSW1nHSNJz2DaeLwMkq0DaWXtyhW183kgnFYjFF64XfVpTXURPom8DLiwVnXctJ07LyDc4bOutZNJ77qyUvrhbcXXWc9R2Lvh5+Q8lkFRbBs2wDk3GIcxwiG6rJUqHMQnAWQ+0WZxVUDNZZrnIkUvFTwXlMsDyZRq7mCYyhC/77/AR/b9cnuf4AQrE4PN4EWhNonCejxFJH1FELKnUkGNRhsPTWs3QODu/xI9Nx1Cw46juO+5bTvqG14EUpJROlfq1JM3UXOEhtMDQoaw9LZ7gbHMfWsDSGzlqMVVoRFtZw5hyn3nLkLSchEGx9tEb0EAduaYIjHTYTYx3GOqyzOOuRJDhrEanUllSErBmD4aZEBk2oEayxWKtc5pnrg4HO1sDCT019kmswZAvZ4NSwwNNgSSKkAzZzViFTD7twaC+tnePIeYpWhOKJ8Zw1lSJxumw5X7csgsNTscKlVNJDQmsuAxwu/NA4y0moyLiX+447bcORb+hd3eM6Z+mD5YWu436/4LxrOe1bmuAQZ9ge9uhl8HRNwxYHzmE+7FKYalrXXGicw5i634tUZra3lo0m4ofsdWcIwfB4HLieI8WAaxyfpiHnJ3oGZ4OUGhTUG0djLLMKUYQpClMuxEPLs7eVDnXsG858A6IUB2em5U7XctY3nC4bzo8agq/UpXKAYyQRRlPTnotWF7lx0HjLaRc4aRpeXyy523cch4beeay1LJ2nC5aXFwteWa64t+w5XbU0wWO8rQQ8FY6ahmXXssEiztfFbahNN1MbFm1wOGMRDEm0Ts+t5VYqpcVZi3cWguG93cBNjCSjh2nHp2fC+UmfwS6BluqVa40lmPr5SFJirg9QsYdJp7GoKr11LK2rl2SBpTrWIbBuA8d94GwVaIPBY8gFYlFmFSZTL8+qeoi3UoIxrJ1jGRwvLTpO28DKeXrjsM6wsI4+OO61LS90HWd9y3HX4r3FekuWqtNfhsCyDWwtYO2B1gHYyuJXMXQ+YE1VFZQDghYMA7XZWCf/BhfgYZzY5ipNE28YzDOi9Hz5y1/mn/2zf/bbX8D/9pf463/9r/NzP/dz/ON//I85Pj7mr/7Vv8pf+kt/iX/1r/7V9/vLoGpQo2Sp+qoVjmJq9zIVQdA6ViETS8EYgyAkahdsUuXhzZaubfAOvIejRcAc5J67OXEZR55ME2JqOtrGzXhn8GoODuh6iH7x9C7JwG9trtjfPMUUoQmOe13LF0/P8NawmSemDvZa9cx3lh2nTUsRoahyGWfEWoyt43I11f2dS6ZtegRDTkqKShscxhou5xljDb2FKRd2w8g7N1tuNUKu5s38KWNQf1LrD+pGQENlnYthiSCSKKWQKETNqGZ6DMkqzinWVNlXERiz43If6YMjOIM3sGgMcSx0VkiSuImZyxhRK9yhY+cM3jqCGtoC/WFU92JYkF3i7bEwDDMuKV1ouNs1vNkHrLHsrSOawMXcUJzlrgusjUMwiA3s2GNswLmEs6Yizg7u/tZZClWSsU8znUAhs5tmnLEU75kLXMfE5VzH/SpCyXLYmD499UmtQck1oXEuQs7CmkChSgejCBmlVHoqk1MUhxw0nckqxlgeb2a6xnHsLW3ruLcKjFvlyAdsVi7nmYfzjFh4yfdsXMJ/+ODUeqApymeOz0CV39ps2N7eYLNh2XhOlp4vHh9jneU2ZUafuEgzwcJL/fIjwolBGa2y7DoaP+K8QV19jNoCXeMRMYxZGKZC6y3FmjqJqPRHplK4Hfe8P+zZmkJJymwy+ilrsX6S6w9j6lqbIivviZqR6bAmjSAOcIZqozCIVPlL9hUT/OhmS986vPd0jePuUce4Uc6cx2bhapx4MI5IA+ehhwLNYWrT4TgJlerz+bsnRFF+9eqK3dUFe00sG88rbceP3jvHG8fNFNl2kSfzxKr3vLpYc9b0H53Bo1XaPhCauuZwht5bTIblwuGsIebMHGdab8jOMIrQ1LgL9jlzO+x4Z7tl5wpBhVkrMvzTVJ/kGSyH6YqgzKUy7vXQmMpa5WZiKzI7UU3kUqQ2rlrD6AxPNyNd8Hjr6RrDeR+Y98LSODKFmxS5TBFtDOddgKkcpuDQquVEK+bzzcWKeVH49rDjN/cZFBa2KkG+cHyEsY5NKow2cy0jbfDc7xcctz3Wepwq0Vr6tqWZExNVnumbKlvsgiOpElMhxUzrLFCzK7y1qDPcSuFynHkwTgxa0aAOrev5Y9T3feH33nP//v3/5O/f3t7y9/7e3+Mf/sN/yJ/6U38KgL//9/8+X/rSl/jFX/xFfuInfuL7+4UaZdk2WAUTCy+1HZ99+S5vXV3xZD+wmedqBBpnfHAcNYEswnevb/n1fEXjLE/nzMIoag1xKrz9dM+qrf/JH1xv2UmuGDGUx25AivDKakHnAxH4N9srthK5f7RgadsaQELDfev5yTfexPmKWLTW8sJqyUxisx8YnHDslmymxHevrsm5cCORm2FETKFvXQ2KiIXNFMm5MOZMG0J9LXaOp7sRqxV5V6SwLZFfurjggzwgA1wxICrYTxkh5RNbf0DTKm1/kLMUx5ExfPb0Dt+5vebJMLDLQlbHJYmlBFqqnu9qyowlIXHmKgpNLpXhnDNvxczaVZzb06EwIBRj0GK59gZcw3FY0AbLROJfbh4wSeEvHb+ARfFG6XzLfdfwv7t3ivcVU4a1nC96csks9iOxKAsb2MTC9bipgSWuBof51rMSi4pwE0duh8jeOWZNNdnaQqtwvRvriN0okxauc+Qbg3DbCxIbNgW2YrD66YqW/6TWoF1ZjoMjKGgSToLnK6+9zG88fcrjcWCbM0mExznRYrnrPCUV3po2jLc3tFiuNLEuShRhmDK/+eiao9DigO9d7Rm0oIcO5sM0U6Tw0rqn9zXh8V9snzAi/B/7Ba134CrQoHE9f+GVV4Dqc/LW8EpvmI+Eq3kgCpy1Hds58Z3Lp6ScuSVxITOzyXRN7ejvUuFqGPElMWShC54+WO4uOq6HGbIhOWVH4XGa+IWrzCMbMQPs51RTL8unC8v5ie2Bx5ZT3xIKSCycW88f+cIb/MqDBzwY95VkkpXvbna03nJuGoYp8x92lwyPE511XJTMcYbJCrvtxK8/2XASWhpj+N7TPVtNiFVCtFzME1qE19Y9xhsuS+T//vg9pFH+T6ue1jqsUzrvuG8W/O8/9zkAnLMEb3n9ZMVQCg83txQsd5c9V9PArzx5RJ6VWyKXUyRrYdEGrIXLeeZ6mNjMVY6xaBrWznGv7bjcbCELI8ptjHQ4fv7hEx4Q0R2kISGi2E9Pgx/4ZM9gtwosWoPNUMbCHev50dfv82vXF1zMM2MpJFEuYiR4WFnHVIRv73ak3RYHbClkNWSjPBkK377a01tP4+HRVWa0BXWKG+ByipCVs4NS40YS/8PuAoJy1jU0VsAUvDeczw1/7t5dwEOoMrR7vSEjPBkt0cG5C1yPe37t6im2KNtcuCKTTaHzFqxhkxJPhx3eWWZVOt/Q+MBZ37DLGXL1MlAyzWz4D7cbrsnoDDlWyaN7Vhf+b3/727z00kt0XcfXvvY1fvZnf5bXXnuNX/7lXyalxJ/+03/6o3/3i1/8Iq+99hq/8Au/8J/9sOd5Zp5/myW/2WwA0KLEOdFay7J1uN5x2jS8turpDOybQFblKs30ruGtyyvKQetpG4MrcFMic7GVc24Mi5XnTrPgexdXtM7jxECpH9CHUpuH+5llEIKvuCMifOtmz9LNPIgDt0SOmpZRJvrScTPuSVJQaxkdXM8j7487FnrNHGtuQNe2nFnHUfDsciYlMAKdgV+/vjpIqYXgPW1oOPGragjuqo7rNiV2seCc0jnLps04NXi15E9Z7NHv9PqD//waTCLIXOi94Th4VqVlSeEVF2ibhtGZ+k0sDQnLe5sdztZxczaClsIuZ1w4gH6doekbTvoll9N0QIwJIkqNiqsa1VtJtMlQZ1ZVM/Pt/TWOhkstTLZwpA1jqS/863EmiWCMJaM8zjMPy0AnnpwNUQ1d03Bv0bNWyyyJcZ5hnllaw2/tr6vMzHpa5+m95U6/4GLMdM1MEhhLzZRoabDWk23G2QZnLfopCz76xPZAFYZU0aon3tO7hlPneXPR01A7jh7D7VwwBr6x30BWnDXYztTMkTlWyYGtmmXTW/rW8+R6T/AOky1SpHbHrKH1lif7idY7vKsJpirKNzbXBGd4kmsi+BENUSKNbfhgmMhSsNYwW8tVHHh73rPGM6UKRliFhvM2cIRn5zNJFSuV1PP12xswhmwgeEvvHWeuYyLhWkMWZUyFeSxct7Ym+S5T3QPFfuo845/Y+kvKLs8sreesbTi2gbvO88NHa468Y5MzCmznjGL59d0telh/NOBT4naODDbDh/lIvWXRBh5f7QjeVklZFmZTCM6zbDyPhpkQalouCXJUvn5xSdc43psHtiRObMNYEr0LfHB1TdGCbRxbozwcB96Z9pxftwxz5nKOHIXAvb5lGQzXGSQplJon8e+ungD1+6PzjoUP3HULphxxrUVyYS+Fd6YBXwaCcQx9wgvYUsOQPk31SZ7BuSTKBEvjOGnq+XTkLJ9vlpxgGaSAGm5TRsTw9jCCHuSJTR2370thdB8K8xXXG9Zt4On1WBNsBSQq2SkOS9s4budMyPbgEVLirHx7d4vxhiclMuTC0nkGlMYlrnaVrme8YbTKVZx4kCNrHHMUdrl6Vs6tYyWGwRtyVpwoSxzf2G0wQKb6UXsfOHcdj3LCtY5SKqb+aUpcacZbx7zMuFKRypKfgaTnq1/9Kv/gH/wDvvCFL/Dw4UN+5md+hj/xJ/4Ev/7rv86jR49omoaTk5P/6Oe88MILPHr06D/7NX/2Z3+Wn/mZn/lP/v5kMgsTOA2B147XnB51oMppu6DBsw+RzRyxxuGc4SbPOFsd/jkpg9SNJ0o19arCWArBBL5wfsJehYf7kWESemswYkmmUFQYNRHVVAMlhqfDyJVzXOWZKQudE75+dcnCdFxNExMZdYBCFOGyzDhN5FTlDkfGoSZxvmg49g1SIs4YvnJyzreub4A6Ai0J+jnwpeUpxio9jjQVTDF1vFOUszbUhLWo9cAzn57u1rNYf/CfX4NFLC2WYxd4ddlz4hwqmVXjsaZjSI5dEtTUb8at1GS9+hgvJM2oLWRTzWCq1Sw2F+EzxydMOfFkFCatBsoAVTloDNlWFKek+qh4OiScM+yNIRnLbODXdls6Y7iZ6nhQncHaihHdqjCq1GhvY+mDY4/juAscJ1e7Uh5eCw2/uamITbWK0cLCeF5frDAy4qJhjhlbLJ13UIQ7jeVSEiKpjhI/RVTET3QPPJjKjtuGz50ec7ZokZxrh3Tp2KfMNiac1IC4y2mmC57GWIaYmEusqbtaHYpauQKMrvDG2ZqkhashkqLgfL08qyhFqlGsqCEXxQs8Hiast2xyYipCFwq/dntDawJPxpmplKpHdZYomasc2ZLJqSb6hiZwPUdOFw3HqaApE6zlh0+P+OaHe6CrYVx98XypP8W4jE+GlBSvls45NCmnbcOTUgO8vDEcsuw+FfVJrr8ohRbLeej40vkZ58sa2nZnsSL4wM08czvN+CbUrmYa6YKlMZZ9Lmxyxlglmtp+1AImwRSEL9w7ZsiZx8PEPCveV58AQBZFyyH8T8BjeH83YFvDdYzMsTCHwr+9eMLCBR5sdoxSMN5QnGU6IGO3thBTxc42redyjtztW6asXOZIMI4fv3vKv7u8ACqFRy0sQuDLy3M0znixpCh4LIvGI0k5bxoepipn9NbSOMP179Dn+4Nen/QZnIvSafWmfWa9ZtU1lCysmwbnDLuU2MZMDFVGKyiNWryaGnglBWvrZFuhEhajMjvhsydLJhWuxkiiMvA7DvQ6rZdG0bpuvRoexwhi2JZc15QRfnV3y0Itl3NkVgFrEAtJC7dS2JtCSUIucNw5bopwJwSiwK1mgoUvn57wjZubGiB2SNHsNfP59gS1GZsVkwxWq7eUBGdN4EKVkhVnqrfk49T3deH/83/+z3/0/7/yla/w1a9+lddff51/9I/+EX3ffz9f6qP6m3/zb/LTP/3TH/31ZrPh1VdfJRtIoqixNa696erF1we208xmjlxMM3sVXIZwMGwgiscwJKF3NVm0PfzvxThxZUZeOllTUv3mtsHgnMHPhuIMna1ymyRC1tpxvSwRV+omlqWiDL837Dm2mSkXBs1MWiPDAZyt0e9ZFKeWUjJ4x3HTchx65sOBOmtNLYxajaAFZekEPYLXjhY8vdyRc6HB0liDFlMRiwb2JWNMRYt9WupZrD/4z69BNYZycPovnGHZOMYxVfNWNkxquC3UzUaVcDiwimo1g1nPIjSoMQQMuQibFBlFcUBJBZGCtYJzFpeE7KGzAWMqiUWond6rnLBJKC6A9yQrvDfNrC2MWRlUiFkJrqYIBhtIGNRYGu9QV7X6q8Zy5B3JW6bJMo1bokJCKqFFFMTjfODFlfLoqZJjwQMaasjJS21PiYckTSl8moJ2P9E9sBwu6g10jWXdBCQJrQ+MubBPmafjzCgFHPTWV7KPKCZDTgXvLahW7asqF/PMzide7jpSlmpcdFRiT7Ekm1k6j9q6/xZrcMCNJGy0TLkgqiQvfHc/sLaBfS4MpRBVMAdPSGPcR3xrZwxJCj01nfRo3RAXSpYqNZpFiZRDAqqSC7i15bN9z+NHGzRVz5M2oBlebRakJIwHza6RT0+H9RNdf6JYrabddRM46XuMKF0IXM8z2ynxZDezNyBINe5qNVw7qdxz7w2iht5VE+XNNrJtIq/1HftcsdvOG7y3mFJnmn3jUGr4ZrF1+n5RZsxomVImi5Kc8K3NhuMQuC25Ts6jYA4Ui9Y7hrlK3tzBh7A0ljt9x2noGFfCrMogwiA1Tb2SgJQoEI4NP3Sy4NHjbV1/7oBDFnhztSLvlY2kSnL5mISU3w/1iZ/BUtO51Rv61nPcBrRInQ4lZRszT6fIztbE3IA9oDFrQ1QP6g49QAAUZYzCEDJuEZADqMV6U31tGYqDpqlnuQDiwBbDjWZIpt7VBMQr704ja+MZJB9QmvrRami9q+Q9qcGFuVSqz5EPrF1D6iosYdTCqEo+UP9EFCkGvzK80bY8udyhWcEe6I5JeSF0xCLsXcWI2o+5Bv+LsJwnJyd8/vOf56233uLP/Jk/Q4yRm5ub/+iF9/jx4/+veq8Pq21b2rb9T/6+AoMqe6p7Otc7MxbD1TTxzmbLkzmSXI0zvrdomVJFWy5bh2pmZT0pwaltySgXeWQXZx5Ont1UiIeYboM9OM6Fs75DFTYpkzSiRtnYREiOVOqrr4gwSMHZhHNQkjAd8KAGuOdbxlRQA85BlkJrWo6alhcXa4K1PJoG/unDd8mmMKkQc6mosOAYyfzQesn/+CCRciF4gzHVN36vXXKdZoKvHePDu/VTWb8T6w/+f6xBD5NRRs1EiYg4hPoNvRXhaS5cZiE5wRRh7Rui1G/c0DmS8ayaFhVYYEgpsTM1mvvxsGc/TEyawAlGFZM96pW1N1gcQ4HJKonCKAmbCjZUGURRYdBqvhVrKPmA9dT6rX/WNNV07E1FJhplXQq9UV7oPbaxPCLx/7reAlUKJAcMrmLIwP3eUxLVlBuE6JXGWk5cz7WZqVFfgnyKDrz/z3qme6AIYxZ2OTLkRIwZ7xzW1E7nO9sdD4aZ7ARrHC8eLlExFxbWood0XgROCWDgaZmZUuJ2SjVxVATjDJbKMVcLp30DUkNioikUqww2Y2dbEYWmdt62OYM3GGNRA7EIeqC6nIa+7oFUdOaUE3dC4Mg1vLDuCc7yZJ7479//AKwhASnXzq5oxYR+fr3gf3pQu/7ZwUTBotwLPZdlxrc1eEzn53vgMzuDJbOVxCCJdJAQWmO4mma+d7vlg91E9BVP+dKyZ58yqQhL77FqsNZAofL0nXKbI0OMPBknNlMkquBdTTlNSVAvvNAtQGFXEjeuUIqyNRkXLTlXik8uylZy7aj6erGLc70sWQx3fMeQMqjiG0vMmSY0HDcNLx+vsNbx3jjw3739NtZaihTSAZWopSKxf+i4519+oHXqZYWR2tR7sV9yGSdyqf6r8Hz/e2ZnsABjEXaS2ZvMkXgsdb3czJH3d3sex0TxdSJ+6hvGUul5K++ZxOAwkIWFq5f4SQpzLjyJkXHKRFsJOI7aLCkOTrqAFcNUChtbSUB7q9hY9yNjamNvEsE6g7raK0uHC7sBTl3DFAtqFBssMRVOnWdhPff7juAdT1Lknz95XOU8pk5XTanT9uyUN5aBX3qiiCg4AQsW5cQ1XDETnSCGj/3o/C8Cmu12O77zne/w4osv8mM/9mOEEPjn//yff/TPv/nNb/Luu+/yta997fv+2qrUQA1XOaWiyiaNZBW8d7SNp3OeU9uycJ5shGwFExx932FdVeUPNnOdJoY5snKeECzXrrDNmaxKg2UplRAhRTkODZ89PubLpyec+5ZCNYXNRShGMF6ZyfTBM4hwMUe2c6ZkIWnV1G7mwpwqMnSSxE4Lj4eRmAyI8P7tNf/h4QOaQ4DNh6QU6ww0hvf3e37p0SOiqS5uVSUnKEV4f9rzcBjYzRHJ4Aj/JR/h7+l6lusPQIOjBMvsYNBCIrPXUrv+1mK8wwTLmoZgG1zbEDpP13mWbYt1jlIqcnNIkRwzSyzBChtq5HwqBZeVkJTsBbJnZTwvd4HXFp4lVPQsFqGQJRLLxDYNdM6yL4WbObKPmVKEWAoYw00R5pSJKTPlzBQLjzY3xG3CzoVHt7f86uNHNTQJQ3Ae1GANEAwP4syvXN2QqKQiGyzeOiyWx9PIo2ngdorEWHCf3vvWM12DxVSeczYwHzDCm5wP+RyWYByts5wYT69VvlgohADrhatoOOoBdzVN7A6kleAcT12dkpYieFM7PwZFSvUL/NBqxZeOjjn1TV3vxXyE+ixWmWJiGTyjCldxYjclcqyPU5U6SZhiISVhKlW29nCoZnIF3t/u+PePntI0FkEJ1OwJ31p8WyUc//LhI5KrPH4XbO3eAe/Pex4PE9sxUaKhtZ8u0/j/vJ7p+rOVApWNMqNEraFWgwgYR/CeprHc8YGF8WQVxChNqKm5LtQzeJbCfhvJ28JJaOgax1OZuZ0SKdcpjRNwYigRXvAdP3pyyv/q7Iwz15KE6rVTqfcBqwwp07WevRSu9jO7IVOyHsIzDY/HkXEW5qJMUqdPHwwj81wvZu/cbvil9x/R+Cq39NSMgNDUNfjt/cDPP3xIdAXjDx1gXx/G721HPtiPbMeIibDgP72oflrqWZ/B4pQSlGSlEuSKcJ1SzSexluAdnffc8x2tdYgvWC+0wbBoKmNfteKp81Cwg7Dyjs47NqYwlnKgzOlhCmCqZIaGz/crvrRcc2JCRbMWc7iX1q7/kGsWyVgKmzkzzvVrZQtguBinugcWIaqQFJ5OkTnVLKYPtnt++cllnSxQ178xda9zreXdYeRfXl4RvWI6g/VV0GGxPJ4nrobIPFbZ4+pjrsHvq8P/N/7G3+Av/sW/yOuvv86DBw/4W3/rb+Gc46d+6qc4Pj7mL//lv8xP//RPc3Z2xtHREX/tr/01vva1r/0vcmeXA+rqdp556+qKD9yei91Q9Ztx5jrOQOFIAsY6JpSdyTgKfYRWlQdxwM0VeXrkGj7bHjGRiBEe24yUGrKwp9AHS6ABYxkOoTI/dv8uv/rkEqEgxlCMkEzFjamFMWZSqq8yRQnisAFuS6wJwYfXvxqDb2CbRv714xtuY2Yq4HH8gdWSd6c9xgr4OrofbeZbuy29BoyDaGt3qxHLk+3AkWmZVWjUcdd/ejabT3L9AVjrwMJQEt/ZjDxgy9U4c9wuuLWWPTU8zc1CC0TNRGtxxtPjaEtiV/YAmGhYiOOlUKc/Q4DRlgN2tpBSpl92WArGKKlAg+PH+hW/Ms7MjaJNNfcmQIxFgmGcIKb6cDSuGt3UGhIZoRDEYqIh24EgkcvxigeDsE11BLlwDWe952kStlZqwiqVrf9OnGpHwTtwHoPDF7ieZ05Nz5hGWhXO2k9Ph+sT3wMNbFLiratbHoaRq2HkrGt4GCeuUk2/PZoMoXFMFLZUM+FxsnRquM4JUpXO9Nbx+XbBgLCPEKmhQhUEIfStrwpWteyy0FjDV0/O+aWbK4pTTKjTzah1DxQL85yJsT6C1YCPFhzsTMI6aGyVI1oB28BVHHj3yZZdyvX35CyfPe54Zz9zmRLGQhscG194NOzxWmWXH43JrefxPLF2nhKFtRruL3v+/e/op/yDW5/o+pMqd7jKM796/YTvbRouNzP3+oZ3p4EnccYp3MktC+MYjXBrMwtjWTjLuXd8cDBiGgNHbeD1xYpbSVyXQjKVwz/nOiPsV542O6w1jKngreOPn7/Av7p48tH6y1qZ6bHUTv+cCjEKH2b/eTWoh40mrDe01tFSiVCuhafDyHf3N2xTJqqwtI4vLTq+Ne+5zjVZtQuGnU18e9jj1GBbwB5AG87ycNhzalsSjlPb8upyzb/7nfuIf6Drkz6DS9G6n1B4a9jzzmZkM0ReXLY8iBOXKVU0ZTa0WGaEvVMWBjpvOU6OB5JAFOtg2XjuGcdOC5MoN6ZU6Vg2FJTOG8IBiDKnKgP6Q4tTvr67IVpFvVKUKj+0VRKZRcmprkE14A/+uAHBBENja7PCAdbDnol/s9mxS1U2fuodL3Yd3xkjtynjHHStJQXhwTBV6IyrgYSKwRfDTU6sTQOmcGwb7rRLvv4x/jy/rwv/+++/z0/91E9xeXnJ3bt3+eN//I/zi7/4i9y9exeAv/N3/g7WWn7yJ3+SeZ75c3/uz/F3/+7f/f4/ZaDJNVEvZ+W7w0BnR6yx7GKiaNVE1e/xehScho5gPbuUeDxNeHGs5ppG6jEghS0TMYF3FRngtGqxR0mIc3TW8ebxCWd9TYZUEdJZ4Zuba+52Ldcx8XAYyVnpG0eJUKRKdz6kTMwe7jUHisac2aREY5V9zFzEEYMhU1CEHzo6YkwTeaibV7COJZ61a3gvQt8ZKJZchEkzPniapg4QGwNLZ1m2nx4B9Se5/qBe5J2HmBLvjWM1aKllyhPaddhQB2lRM6UUuuJxRshG2VBZ0nbMtCjNIextK/qRxzWXqjO06pizYCeh7RyvLFrOm4AKlDnzmW7Ju3nivGu5VeFJTKj+v9n7t1jbs+u8E/vN6/+ybvt27nWKVSyKokmJlEx1WXJ37O6GA6cBoxPHD36z4QcHhhUjgAAb8IvpfmjYCQLEQGAEaaCdt8CAH/yWdicRBKkbVluWLKslUiRFFqvq1Lnu67r8b/Oah7mKliwrosQ6xari+oiNYu1Tu2rt9R9rzDHH+Mb3ZXQy5Liv9imXzoREKMlKaUSEIXiGMGKMxE2eXaUQqNINlpE36pYrH5lICG0wUlMnyQzAgTWK7CQ5FRORBtB7DTBrEy2Smf3hKfg/zBhsUEhTxAMerTsaPaCT4t3YlYXsVJRuMsWF+ZYwIDTbEHgcR7RQ1BNodOGzxsw6RXoitTakBCoLVBT0KSJ0QFnJp46XnNZ18YWJkS/mwDe3G46bhmvneNYPpADSgA+lYyr2/8uydMBOraWKksFFdpNHa0lMga2fSEIR9uY2n2uO6NKES0Ue1KJYJMNCVTz3O7SWeyO4Et1Waipt9iPwQKUERvzweJF8mPHXJlUWYX3mnRc9rXXoJFgnRx8LBVUAjozPgWNpiCkz+MA3ww7lBdKBURK1d4e+DBPrELB1oYcpIVGpdEtTCFRW8urZEbfatpALY+LLOfH19Q2355YLN/Hurie5jKzBu+IOjipUoyhBqMQtW2H38dc5j5WSbRJcVyORzBAjSWR+anHEtXfEMSMy2CxZZk1rDU/XGatU2WWJCUeglRWV1cX1NENtysT2hwUf9hlsc1lWDWPicddjlUBlxdvDUKg7eU9/2VeDLYoUE1NKvBPGst8zli5/FhkfI9eqmMZpVNG4F8V9eQiR0Sd0I3hl1XBmSzM1p8So5nxr6DnRhpvgeTFN+10VGKa0d+YtugV5b2J/VBtUFjifmVykMqUxPcRETAKfEsjMZ+yMy1BEXhBgsqDxklqVPQWDJMVM3NPZtNQ0Vn3XPM4qgf4ec6DI+aPlGrHZbFitVvz5v/BjBFEWuyqpUAK0h3UonUmXIilHzvac+6YqI2GfMoP3kCWrJBhCcQxNAoacOG0brpgYZKLOkgaNUpIpBGZK8KWzO5y1LUOM/PblFVfjyDZ53lgtGHPgydDzYph4ULVUleLppmOMoViBS8WRrWkQDK4sM1pVZJ5eX7REl/nOtGPIkVYoGqG5GUauU9kSz5QCsFKax9uOVV3hYqSWivttw2ePTtBJ8KTvWBrLWd1QK8F/9d/+Auv1muVy+YN+fJ8IvB+Df+4vfBmnMy4GpC+LuK1U7GLAS01UiiQy85ggB2xVYYwGKXEp413AjsWITUpFFJJeJo6t5dx1DNFjUTRKU6mSqCqj+OLqiOPK0HvH1y43XPqeUWZemy9xQnDuPTd+4o42SCO4HCZcLsviRipmSiJ8YJoCImasgKaWPGhafIg8DSMuZ2wWNElwHiJRaqj39/9YxuznQ08lYEqRVmvuNzM+Xc+RAp6PAy2ZU2OpheIf/j//h0MMfkB4P/7e/Kk79LIss9ZCYbNAp9K172JgSglS5lgZ0IJ5o9GySLh1zpPIzEKRiJVSEnLhZN+e11zlSJcCNgkaJFZLJp+orebLpyec1mUf4OvX11y4kS4EXlstmHLk2TBwMTke2hZpFM93A1OKKCUwSFqjabOg8wFSkT6sKslnFkuCj7wdeiYyc6mZZc1F6Fm796lKAo2kNpYnXUdrJC4nKim5U1V8drbAIHlvHJgrzZmtqYXi//4vvnqIvw8I78ffT795l16V+JsLjREKneDSO7beM4XiYXNiLUIJ5o3ZX+wywxiIPtFGwSgS0kiyEIwhcmde8yI5djFghWQmFTOp2blAYyX/8d173G1buhD49fMLXowDXQ786HJBlwJv9z0Xw8Rr9QxtFE+2HeM+/qxUHGmLFoLOBWSCRilmjeYz8yVTCHxr2DHmxEIZVkLxdBzY5tLpzbk4o1qpeNp1zGyFz5FWK15tW/7E4giRBW93HSfacK9pmBnNf/3Pfu0Qfx8g3o/BL335uDjN5kwrJTIXY9R18gyh0GUAjpSB/bKtVkWowMVECqB9LrlSiv3lIHNSWa5zYMiJSklaqbBZ0o+eqpb85PKYE1vRp8K2uA6BnsjDtmHIiWduZOsDt02FFYqLacTFVKS1paDWmjrCGBMiC2qhaGrNq3VNCIlHccSRmUlFmyTP48QQ967BCFQqefC5G2iVxpOopeSuqfh0PUMJyaNpYKE1t21FIyX/zX//7T80Br+vpd2XCaMUMUey2C8qSIkIaa9cUkbdCUESglqwHw8Xy+4+ldtWXRnGnIiUjX9PYjIRkzRaQ5UFNQotFYqyIb1xI62R9CHxznaLixGvMtd+IuVM2svUueS5VVVcGonPpZsrcukE9DkzhEijNLVRZAWvz5dcbEfmeUJlSS00KcDWJZIVWCFwe+WNyRdpJh+KmFSlJCd1xcPZnBwiO+ewSlAZSf3DpEn3YSMVRZK41/WVe9WbgCClWDj1EpKERu7HeaIszY7Jk1PESMEQEzknogKvEkEnzFQW2gyKShXDNa8SmczGByop6ELgvXHAEYhyrxKQBTnHojxB4szWbFPcLxJphJAkJN6NuBiLHfleneBhM+O8n7gholLERElIkT4kKivR++XdMUVijKRUqEV5r4++0oa7TUOIic45tEhYLbHf3yrQAX8AlJBAicFMJgtBUuBdUaSQQBSQNMyswgGVFBgh6UOhhjXKsA2OIEsndhQJZzI6SBZao2MZhddGofazx62baKWk95G3Nx0TkaAz6zSRI3vJRJhS4nZVc+McIST2Dvelg+oSQ4w0WlNZhVDw6cWcF7uemdAoMrXQxAA3kyftYyykTBciznkEglgMLTFKsjKWB/UMcmbtPZVW1FZRc8iBLwOVVAwkskhlip0zSRbFG4poCIGS/+ZG48k0UmIF9Lks1LZaE0LAA5OI9DLgVMKiWOnCnW+EYq4NeZ9rN9PIyig67/n2zYYxRVKVufIOnzLEjKEsVN5fNlxO416hRxS+dk4EX9zpG62oKoWQ8NnVivc2W2ZJoZJkJgwxZNY+gCn0s/fP4D6V7rH36bv6/Lfrhk8vF4wucuUmKqOoa4UVH9ky6mMPBZCL3GamUMMiRUEMiu9S3Hfva1kmhzXlbHWhFPkzq0g+4ETGibKTEjRUUSKkwMhCu6mkIqZU1KS8K7VkTLzbDaSUCTWskyfu1ZoMpUt/0lrWQZaO/fs5MGdcKFTKSim0lWQJr81anncjrVQoykQppEzni9KaloKQM31MiFAMRsJ+78lKyZGx3KtrfExceoVREq3/3X7TH4aPbKRupwm/7y6unadVBp1gnT1WyP2DLze3hVFIo6iMLnzomLD7w9FRNqmTyCDLSPF1e0wkElMkpFTUH2TkykXqYUeWiZBgGzwaQYfnydgRQsJNCZskV3LkeKzKJaA8YZKIvAgDxH2ginI4dtGTI1iteKBbrvzEzkcaaxGAzFBRbqVDjntiRvn9tCqyiloWHmJlNEfWcu57lINj9ceXwjrg/z82MRK1wOXEzpWYMkkyAEqVgzBkcFKyVAZZGWqtirxbLPw/YTJD9IT9Mi1GsQ6BU6ELdzDLEiMykpWki57K9WQsISaGXGy+JzIXfiyKESGhpGYtPfNJkdJ+8ShlUJoN4F0slu+qxGWIHpFhZg13csONc3QxYLRG7ClCKgnyXoUoiaJH5FO5XGgUWiiE1JjsWRjDhduBjxz9EC+tvUxc+4lJlvHzOpQCwxjNJhX9ZlF8ZXAqsVJl2UtrWYzc9P7yKSVThDEGgshklTkPE58ScyKpbHok2PmIFHAVHI+GnkyRx9yFcmntCTwbB6LP+CljsuRCOFa+IotCh0iRoh6VAvQJKQVCCcgC5yMSmFea+7bh0jlGn5gbg4xlNG1EWVpzFD8UIQUu5CLvj9znwEKbW2jDdZpQAY7FIf5eBm68oxORIQVugqcVCllJ1sGVZ6WLSpxTCWskyVI6/CETZFH0wgrGvpzBgdLBPHcjr9kVXkRCLHskN3ggcz5NfKffgCz+DRtfzuBtCjwae6LLTGPEAC8YOXU1WRSRjxQykUwXBsS+oZKVICVPmCKIzNwq7quGqyngHeXSSynWKlUU+4ZcOspCCtz7S+1CFoUsJams5KSuufADz5zgTP/wUBo/bNxMHqfK3lAXPbVSJFWYG0YJUJBEqfPmSqJNUUZMqYgeSCmQUjLGXPaORFHhuUmeB6KmF+Ws9jHTG4+SsHGBx24oTZYEQyh+FIOInIeJ5IrDrUWy1p5jb0pTJhUFn6hgCh4cSAlZCSKeEDJSSGa15k6qufaewZUlYp0EQSSU2vv15EzMpdnt9xN3ZWQRo1ESleFYW66T4zpMZL434YKPbMH/dBixVhW5LR/pCaxMDWLPFU1FqiipxPUY+V985iGzynC1GRAJiJFZjLybJoY9T6uWkkUynLaK9Zh43juuxgmvEm0jmSR8ZwxchVCSAIFdSmhKQS5UZrLFGTB4OL+ZcKIsHBmjWBrD1eRwPmOkpMueqzBiNVz3I2fzGT5G3ut2vH29w6CpZTGIEFphhMbsgxvAasOR1ZzWNTNjC1WEosDxnSvPpgt488PDX/2wsaV0SxMZF1JJKiKBlIhYBClDjoxEXkzwZz91l1Zrdr1jfi1wOUKceEZiygmVBXXOzKJiVUluJkWXCt8wI7GqdDzf8R2XcUAngaNwCBs7Y6EtPjqGNJVOwhjYjA6vAoiMFcWh9CYGXBKFPyiKzrQVksl5ztqWKSSejBOPhgmNoEbjfCSq4pZqksRLUS6eEhqtmBtJXUx/QRmsyWy7HevJMx0OvJeC5/2IrkrX0k2ZcUqs5hTteYpqT4zQm8S5m/hfffYV5spytXXUlx0qZiyJd3NgSBEtBVoqWhQn1rBxRb/8JjomFWm1wefM21PP1b7Z4WXCpYwKglppgkwEG4u7bYD1esTvL4fGCBaV5npX5BYtRbd/kx210vSj4/asZYqZJ13PW1c7rNbUWbGbPCKr8hqROJmKTKyGWmlmRlHL0pFLZNpK886uYz1E3Ef2FPt441HXo+si7+qGzEDiSBo0ssi4pkSKidEmno8Df+FHP0WrDNc3EwthiDGhYuQ7sWdKxb2+NpoZitttzdUw8CxMXEbHqCILafEkvr7bcT5N2CyZcmSgcKJbofA64fbxJwJcXg0EEVGAtpJVZbjoJ0IuF8gpBLbJUStF13fcnS8ZdonH48i3Nh2NkCzQXIwjySiUUFQauuTJAXQFM21YNpZWa5IQCAPHTc1bw5abGAg/RKIFHzauJoeq92ZYLuFINK0uTrpZQMjFVLXKXIaJP//qPQCuO8dNF0ixzBxdjrj9PmclFbOgWLSa4AIXYWKTAynDQiiSzDz2Ezc5lhxIUR8jQZs1QWUGvZfKTHC9dUSRkAK0VSyM4WZw+JjRohTsg49YLdnEwJGtmGLm2TDyaNdjVdmbm0IkZBCyGGwNoiieSV2MVxsrqaRASAFK0FaK9/pYFtD1S3Da/VAhRCkucsbI8vcTnhAiKUaEFAhTWlxRCr7w2ivcWi75+nvn/Jt3XtC5iRrDlCRaJEwZCCGl4DdeXKOVYJcDzmTaqLm+dmUTXwq63ANFO1VYwTIqZlrxhcWSWmt+7eqKF9PE5djz03dvc1ZXWKU5ahf8ysVjvjrd4EjEWL48il+7OefZ24/IFtLemdVFh06aRKIbJxqtWdiKyzhgK40eE68u52Ayv3bznP/hxVM8CROhkYpTXXE1/vAsDH3YUFKRRDGtMnWJn6BlkUgFkhJkKUgu4eLEpxeWs/mMt853/PqjF2wHVyY1xmBrhRKZlCJZZr41DqAVTmuyNNRac3m5wcdAIrBOGUnGGECCGSdqI3i9qVFNzf88XNPvIpeu48dvn3BUWQyCFZrf2G7oTABtENKghMQqy285z8XVM/yeFx4obq5OKlKCKSRqrTDSAo4aQY3h1dmSZAT/tt/xq7trpilgUNRIlkpzkw6XzpcBoYrCVwa0KSPsfq8MJoUAI8hVUXOKwJc/82nuzed89d1zfv3x17iZRgQwxWJMqGShpQkJv7leI2TpXrkU0Vlys3EkCUkltjkgEehKgsnUSVKjeH2xpLWKX91cc90FLpznp+6eclpXVFJyqiz/o3zBt8KWTKGDCSQ5Cn55c82zR0/JOuMok9Wd9xinCCmxdYmZtcwag0sTBkGD5kfaOUEl/m13xb9aXxBlQnlBrRQrbWAMP8Cn9MmF0kWmN5FR+yFK5zzRUyi1NkPLngoIX/7Rz3F3MeM33nrCv3r311kHh5aKMWWUKn4gqDJ9+uXz5yghGFLEpYQKgsvdSFZF9nWTHRqJqRRUGZMkTVL82OIYYzX/8vo5vvecTxP/2cN73GkbrJIcVRX/nyeP+UbaIIXYT9+LY8gvnF/z9NtPiBp8TowpspOZ60kRSWzHwMwYZpVhSJ5aKBZovnB0QlCJX7x+yv/7+ROcKs67tdCcaIN0h/z3siB13nsQQRnkCSaXiD4T9hLSuSqLrgn4kfunHNuarz2/4dcv32YKESNhysUVWaviGRKrzG9PHQLwREQG7SXrLpAMIDM9ZeppjIIK5FT2kT5Tt5i55DeGG1wf2ITAF4+POba20G604lfUJY/SUGJQlEtJ9plfu7jmcpjwGqIoU68uRnQSpAR972iNobWWXgaqpGiQfLqd41Xm1/ob/qfdFVkVec4awUwppvC95cCPbMGfUyLnYnCQ9yMakQRkmO9tlbc4hqnwj8+f3zBsBp6cX9OHxMZlKpMRMbOsLJVRdDHiAYtAS4mMpUsghCAKqCqNVMXZLSVQEqLLeJkRErYxsY6OnshMK6RSvHW+5bKZWDQVqhu42E4EF1EiI5TAKEnKcLFzGARDKiYy78sMLYxmlEVDXUmBUoUTLRDMtORyOzDIyE10SAkGhZDFmGkdA1dx+gE/qU8ukijqI0gB1pBTQmBQJrBSBiEk16G4tQgpeHq1Y9tFnmxHpiIOwDwJpJEsUZicuXGRnQ1oB1JIhDIEdLkckmhMkWGNCWSUKEpsEiVYSZ8i0QdiBKsUFZqnFzs2taGtNE9S5tIHslcgBGqf5IJMXLpElqLoUqdAipCSoLUVQUasMlhlkAr0CAGB1op1KJ+biUzOitoW1QCJpBeRXfZ/2Ft5wPeBLMrlUhSKKELCrbZBa8kLPxJDwhjB42cXbO2Ot16sWXvHdvScKI2MmaU1VEqyjuXCoFJRYHIhFV6+EEQDVkPSsvBi9yos7A8jMqyDZ52LYZc1RVr4O1c7rirHorY8oudydMRQLijKCJQoZm4Xfena7gh4kRCi5N5ZZfZKV6CNQGmJCGCTpEFyPTp6WXjVEsEsG4JOKFk+D/2h4HopEEiKBH6hgon9PkWWcKdpUFrw3A+ElGis5PzJC3pjeOfpBdfes+sDt2uBjpk7pqFRiqdhxJOwUWJmimlKRJdRUpBNpqk0TheaBbEYCvn9nyuh2AWPjyNTjlgjqILmay9ueNb2HLUWJeHCjQRXJrEoMLJcmi+GiUooOkKR+dSClDKLWuNzac7VWlEbhURgKZKez3cDnQxsU0RHSaOLa3WOieswsTukv5eI8uzeb8YyQVkgyRzVFUoVicqUMpWVPD7fcK17nt7sGH1kmCJHlULFYkZpleLcT8WBOYMwAheLB5MikW3xkQia/WWx+F2FUHTyyYVeFn2ZzFst0UnwaLvjujK0xvA4J65dKHtNonTjtSz/vqtpQkdRYlxBNmVKMacs5sYkMVoXD5UgsFqgkiz6/TIxUXKgieV9CRm2ITB8jynwI1vwCzIxl/GF2tdcOZYNaCn2m/RZU9XlQ/vV955TG82LYSqW66qMYmZSUwlV5OeSIITEzBpmtixoRF/GPVoX3pRVZekypIxMxXcUpbiZIn3sSSLTu8BSKKxUuBDZOs+UE+vg2QZPFLmYyYjiCBdzoXQ0SuHk3jQilQfZaMWdRcvWFY61EZJuFCy1ZpCR61TG43nfrXAxoZAYUxaisjgsrL0spJwQe8lLIcriOEiEVGQpEVlgpEc1ihAEb133WO258ZFJQDSJMQraJFHFiBmZM2nKVEpRSehFIKZEiBGtMwhBpRQhppJwcqGwRa24iYF+gigifUzUMn930XEKRZ5uHRx9jmSliJL9QVk4qpMAK3LR/o+pdDX2Moe3mppMWfrNybN1koaIV9CL4kMhhEIIcKND5oxWheaR00dK6OuTg73ZVhZ7Uz4JhL0msygylUYIWqsYY+DfvP2MRmvOO0efAknDqDNNVIXhuRcdyGSOtGGuNTlEvBekkNFGIARUQhJSIu4PkZyL78h68kwxFtOZGGmkohGSECO998ScuAoT3b7bFAVoWV57SJkpZyojCCoTE4gskEAtJHeWi6KqIiRWKXaTZKENo4jc5IDPEanKZ2H0exqlkFRCkn6Ynd9eItJeOQ5BUT4hkwMImYuYBgKLoK4UIWX+p7feo5KKZ93AQCDVmU5EZkqDKGIAhRmRWRnDyhhEKIZeyZdOas5QS1V0zmMu1DEgW7gcR3beEWSmD5GF1DRalj2/qVxCb4JjnV2hgOTiDKxUEfXoc2SBKiad+9uzzDATkqNFwzp4JJJKKConODaWXQ5cpQn3vlCIyYw+oLJgpqoimqEOF86XhYwoXQdRZNSTLjEodaFzCyEL5bqShJD5refXGCnLjpBMpBpGkWmlRhiBV8UtFwkrpamV4jp4bpInp1LsS8okNFI68ykCe4fxzeQYUyCpvXodCilgiBEmcCGxDYFexe86l0tZJrIhZyYStZBEkYrPyj6+aym509Z0MSCEQguJ8YJZa+jHwC4Xo1j2l1fvCwOgkYZK7B1cvwd8ZAt+lUsHtIy0MzIVTdy431gupu1Q7eXkvnOz/u5yhpQCY3RZtKFscZcCar9YkffuolpirCTGokfNXirOk+lzkfQ6NTUAQwjlEBW56KdLSavLprXe2zJboSA7sij8LpNKd0HsVYRsJVGC4miaBVEK7h/Nub9acDN51sPEdhoxWWCi5Fp43H6cJVPZwp7l0t2XuRSk33WkOeCDh48YqcoIUOyXq63AQ7kspuI2ZJQCJXk6BqTOuJxRQtAYjZYSk2VRiqKoXcgo8RoqQFAuFQaIulze5krjiYwU5ZPaaIRUTDEwhFhGgTkXSTtjSLmoWgklqVRmCAlSOVhJGS2Kp8SUI1pkpMyoXNxalVLcnzfcmdcMQbHznvXkkbkkh14XZSGBROZy6NdCoyRopUEp9uS7Az5gyAw6lxF0EKkY/xjFlNK+GyQgQWUkPgi+fblBCcGUyqJrZRSV1CiVCJSFWvY5sDjiqr1bpSzKE/tcMpOl4znKWCaNQpNFOczc3mAmioTFMNcKrzJGCuS+CxfEXl4ug8hlYqlEMU2qTFG3EEjIpXt8f9by8HjJevRsXGmaGKGwWnKTioUcAtRejWduig662VcCB6GylwOdy3ueBYS9/Ii1Eu9/V/xlQaNUkXB9cb2Pv4RWEqXf75JLPLl4LeRMiuBUJCVdlEq0KjG5L8KXwuBUoo8l/uZSI42kc4Eu7R2AydRIjhrDGFNxARdi/98pF9ScMzoLqiyRew32pAu1zQpJzkXq6vXlnFeOFlxMnstpYjNOaFEWzodUlKvYmzEBtFIS+XeNyCQPh/DLgkagpShncCriAMZIYirKiymXTppWEu8D7257EBS+vpRoUZRwjBLF6A1AgMiURe0sC21n/zCjLHVljSqxJIvnUy2LyP7oE6Mv7JMkMlYIGqOIsuzQSSFIqihCZgmIIrVuk0BJURR3dGnEQWkCBgn364Z7y5YbV0RqNt6j9gnZyUi5XpemNZS6kr1YApQJ7ff2fn5EobKk3XNT+xTBw2Kp6ccy0k6iuD6SFVJKrpwj5IyWiqU2AFRZ4lNkzImQy2KZRbCbHEoIspHMtEVHUFPApcCRsmUBQmRSSDxoGq7GiUmWAIv7w/Rk1rJAEFwsHGtjeEVavr7OvBe2EMvDUJQkeUMmq0QtFJlizexi5nP3TrndLNgMkW9xw/nQoxQMMTGoiJcZlSU2lJvnbWmJSLrgDlSKl43JY4UmK8moSqE0N9D5BKmMgEMUpFTk5XY5k3JCZ1goCVSgDDElJhHLIZkzTbZs4/TdjftWSWok26TxKbJSikkEkIEsBLcqS+eK0VwgEXNRPLllG+aibOcLKZBacmpr3uoE16MnhQw5oFJCkOnCSGMkVrHnMkqEMXzuaMVxU7P1gnd2O56NO9DgnSTsnXtlFqhYkt9tW5MVdFnSldXlH+BD+uRCIoqRjIBdzhAyq6VhPRaN/eIQmUkyo5HcjJ4gQEvJwpYcOI+aQXsGEQmiFDg6w9XoigCCliwaiyQzhsSUIktlcarktZQzt6qK3kc22RMoEwclJXebhoVUpFSaElmVBcfhxrOLAeFBRrCx/HfWKSCNoAmKLDNRwiQTP3p2zMPZnE2V+NZ2y/nmGqkVTuUiCSoTKv27HPjKvMXLxPXo6GJEykOH/2XAJkmbNT5nNilAhNXCsNsFEgKfMymB9BKTBTeTLztmSnFkS16qsyCoxEDci1FkZIBLPxH2tNdVa7BCsJsCY4wcS8NERNiMz3Bqa5xM+FS+ci4XzAezOWdW41IuC+xkhFDsrgKTKjWDCIJaKhoDV9GRLTRJlQmAglEm/uTdU+7Nl7zoAr95dcWT3Y4sBFvK5yaSMVFSh7IsendWsRWR0RUFo0O9//Kgs6BFE8jsciAHmC80/eBLw4BCf82+9CvWeylzKyUr87vqQF1ym0+Fnq32fhKjKM25eWWweylslxKL9xu/+2L7qDLsQsDnwtjIuZjG3d1r4Of95TdKEFrS7Tq8LEu9MoGVAlFJNsIjTBGByez3OSX8ieNV8YgaMt8KW566cnEZRs+kEkmCThLrSw48qhSDTHhXGnlSfUwL/vd9wJzIKL/vHMpMtAJDQuSIQUEWhJC5CBONLCOSlECpzGKvbPH0umelK5ClSCIV1ZVNN6FT5mzVcNxUtEmh5hW/s74gpYDKkkWy7JJnOw70fq+DHROBiFWC//KLP8Lb33lKN0xcO8cYPZWtOdKaR650YAMJnyS7mIoxV9D0KeApMktnumKRLePgGMZIP03spgk5CYbgyVVCeoi5mD400nATJqaY2YkApuge/+737YDvH++/l2OYYAIlNVFLpJWkLpB9obMIIKfAzeSpUaTkQBYaV200OcPFWLTIs0zEFEkhInPG+0wgclpZTuqaeVJEK3nr5oYYS7GukiCqTN9FhpSIREgBcsQqyZ/59D3efbqlT5HORybnObKWRdacR0dOhXdPjEwyIHOG/cUhUvZFjhpLlRXDEOiAPnjG0RF8KuN7r0hR4ol4IobAdQKfBGOGTMCG6fe8bwd8f3j/fSwO2xEodJ5kQPiM8IXOgoQoExf9gLGKlAU5CYwQLJSGnHl603NkNFKVwyWnTJsUu9HjZeJuZTlpKqokaY3hq9sboFApqihxJNwU6WOAWKaViEyL4i99+Uf45rfP6TrH1VRoRIumojGaXedJuVjQTznhUulqiVS6XO83To614VgYumFiQjLGyM4FdIQ+Q05izyXPTHgqNOehZwiZbookkZipQw78IPH++zgQkb7QKoSEXEEzSrosaIVESNgEeDH0VFoW2ddciptja8k5886LDUurSapQDnMWLGLp1juTeKVtud80LFBIafk31xcIIdBJUqOBSBwCmxSKKRaZBDRS87/+yR/lvUcv6IbIeT9yGRxtqxBGkMb9Z0hkhpwYY8YYjYmSIQYCpTt/y1hWqmEYA4Mf6f3IdvRYYOc9QhSZYi8SUToqDBfTyOgyXQoImVlI/XvetwO+f3w3BmMkDeV7iQwG9FioMFbt5dlz4GZ0aAHJlKmnpuTAnDPPNxMzXaaUKe8bsVkhRogqcdbU3DIVbZLIRvKN7YacQQuokWWiOkWcK0aHQpbdoypL/ovPPOCbj9eMLpS9FR8xSqGSwMUSO0HAKMplVUm5ny4UOXcp4EhpZkj6XWCIkSE4BhfQOdPlsjj8fq4fRaLKmi4UvyZHAlVc2X/3+/YH4SPntPvee+/x8OHDH/TL+Njh0aNHvPLKKz/ol/GJwFtvvcUbb7zxg34ZHzscYvCDwSEH/vFwiL8PBof4++PhEH8fHA5n8B8Pf1gMfuQK/pQS3/jGN/j85z/Po0ePPvFW1ZvNhocPH/6xf9ecM9vtlvv37++XSg/4fnFzc8Px8THvvvsuq9XqB/1yXjoOMfjRwiEH/tFwiL8PFof4+6PhEH8fPA5n8B8N32sMfuQoPVJKHjx4AMByufzEJ5v38f38rj8MH4gPE+9/YFar1Q9N/MEhBj8qOOTAPzoO8ffB4RB/f3Qc4u+DxeEM/qPje4nBw3X0gAMOOOCAAw444IADPsE4FPwHHHDAAQcccMABBxzwCcZHsuCvqoqvfOUrVFX1g34pLx0/TL/rxwU/bM/kh+33/Tjgh+mZ/DD9rh8X/DA9kx+m3/Xjgh+2Z/Jh/b4fuaXdAw444IADDjjggAMOOOCDw0eyw3/AAQcccMABBxxwwAEHfDA4FPwHHHDAAQcccMABBxzwCcah4D/ggAMOOOCAAw444IBPMA4F/wEHHHDAAQcccMABB3yCcSj4DzjggAMOOOCAAw444BOMl1bw/+N//I957bXXqOuaP/Wn/hS/8iu/8lJ/7qOOv//3/z5CiN/z9bnPfe67fz6OIz/7sz/L6ekp8/mcv/SX/hLPnz//Ab7ijze+nzj6JMbgIf4+XBzi7/fiEH8fPg5n8O/FIQY/XBxy4O/FRyL+8kvAP/2n/zRba/M/+Sf/JH/1q1/Nf/2v//V8dHSUnz9//lJ+7uOAr3zlK/kLX/hCfvr06Xe/zs/Pv/vnf+Nv/I388OHD/PM///P5V3/1V/NP//RP5z/9p//0D/AVf3zx/cTRJzUGD/H34eEQf78fh/j7cHE4g38/DjH44eGQA38/Pgrx91IK/jfffDP/7M/+7Hf/PsaY79+/n//BP/gHL+XnPg74yle+kr/0pS/9B//s5uYmG2PyP/tn/+y73/vt3/7tDORf/uVf/pBe4ScH308cfVJj8BB/Hx4O8ff7cYi/DxeHM/j34xCDHx4OOfD346MQf/qDnReAc45f+7Vf4+/+3b/73e9JKflzf+7P8cu//Mu/75+fpolpmnDO8au/+qv8rb/1t3jrrbc4PT1FCMGf+TN/hl/6pV/ib/7Nv/lBv9QPFdM08c1vfpO7d+9S1zVvvvkmX/nKV3j48CG/9Eu/hPeeN998k81mA8D9+/d55ZVX+IVf+AU+//nP/4H/3pwz2+2W+/fvI+VhJeOPGn/wwxGDLyv+4BCDvxuH+PsP4xB/Hx4OZ/B/GIcz+MPBIQf+h/GRyIEf2NVhj8ePH2cg/8t/+S9/z/f/9t/+2/nNN9/8ff/8V77ylQwcvr7Pr0ePHn3Qj/JjiT9q/OV8iMFDDH5wOMTfIf5+0DicwYf4+0HikAM/ujH4gXf4/6j4u3/37/JzP/dzPH36lM997nP883/+z/mLf/Ev8jN//nPMmpqQYD1ODHGiSbDtEy4GEhktBIKMkoLZzLJsWozWjNEjcmIksBKKmVHUWqKEZEiZRCSmzEIpRIbHw8SJlnhgGzwuwVFd8aU7S+pKM0MxuMhl77gcPE4EVFScGsnX1zumELFKMKnMXBmeTQ6A+63lXmO5mhLPup77smGdHGOOpAyTh7szy6tNzSZBlLCoJGetYogwRWiMYqk1R5XhaFZzelaTYmbbZdyUmHzgZ/9P/x2LxeIH+yA/xviDYvDLf/pVrNW4FFmPPW4KtNrS9xMuRnIChUAqUELQzDSzeYMxGu8iCOiYuGcqltZQaUVWgj4nSIkpRU6MQSN40ffUUhMzbHMg5MxRU/Olu6dU1lAjGUPgxW7kqh8IOSI83Laa39lsGXNGSUWfIseV5sUwgRDcbRruthVd8DzajNw1FbsYCCRSznR94FPzhrvLmovRkwQsG8vtec02BHwSNFaxNJrjynK0aDk6sqSQ2HUe5zMuBP73/+dfPMTgHxN/UPz99J/7DK21DM5xvt4RcuKordn2kSgiQoJEoKRAa0ljLMumQimJ8wHIXKeJ21KztIZaK5TK9CETs8elzEqX+Hu2G2lURivJpY/4kDhqLD/+8BZ1rZklyeQDz3cj57uRlBLJJVZW8va2w6WElgoPLGrF092EyJm7TcXdtmITAo+6kTuyok8OTySlzLZzfHrVcndWcTkkArCcae4uK9Y+EKNiXhmOKsmRlcxmS85uNSTnuNk4XEi4mPk//F/+x0P8/THxB8XfT/6Z11BKMkyey92OlOC0bdn0Ez5HMhkByCRQwKw1LBYNRiu8z0gyN3HklbrmqDXUtUZoxeAj3jt8Shxbg8mCZ7sBKwR1pbkMDhczq7biS586Y2ENTbCM3vN42/F8uyP5SE6CM6v4nfWWKSaMkvQIjmrNs90ACB7MGh7Matbe8fZVz6dsw1Z6PIkYM9su8NnTlldmFU97j8+CVWu5f2w4HyZyqlk2mpNacdJY5u2CkzstfvJsNyN+yrgY+d/9w184xN/3gT8oBv/z//LzVG2Fi56bbUfIgZnQdEPE50BOGZJAiQRIaqtYzCuUVoQpIkVmGwPH+zqqMgptFKOPZJEJMdEqjcyCq3GkNQqpZDkjIywry2furzBKMsuaKUSuhpHrwRFCRiGZKcXTbkeIES0FkxS0RnHZOSRwOqs4nVX0U+SiGziyFp8jkUjMmX7M3Gsr7tSGtQtEIWlqy9lC07kIWdJUhtZIWqVY2pbjuw1xCnS78llxMfI3/uv/7x8agx94wX92doZS6vdtFz9//py7d+/+vn++qiqqqqKua5RS9H0PwIOjBbeWCzKK827gRb/hxGgut57LccSliJECK8FIwXI552Q2I8TMzfUNFnAy0SdJSBGfMgsl6HPg80dzhhCRGToXEQheW824yRHfCVTMLGrDvLFcjI57RzOOZ4J5HZj3jqtpohsjVaWZNRU2RqSAiYAHlNZkMtpo6trS5oCZFBHwGbqccTkjpcQJQU/mfPIMOTFLCmlqbqbAk/XETEnuz2vkqqVSinnTQsr4YSITSTIBIIT4oB/lxxJ/1PiDPzgGXz1Zcbya40k83264XG+5tVhwfrNjPUyEmDBCoFUputpFxWLeQhZc+x4pyoWgC5EgM41SzLJi4ye+cHrK4B0WhfORkDKfOmrpRCL1Iz5ljirL8bzm+W7gzvExJ1IwszULW3E1DGzciLUV1k6IlFBK0oVIT0QoiSeDFtTWkpVAKU8QmahKEuxCQgO7nOhS5Hk/sQuBpXMIDRfDwNNrx8woHq5azNmC2ShZLWZEF3BjT3L+u1pfhxj8oOPvmLunR4zO8/bzF1z0A6+cLHl23bMLnpgTNiuMLCPzZmZoZ/uGQO+xgnK4ZSCXS948SzbJ84XjJZ0LGCmZfCICrx0vCGTcbmCSiWVdcdQ2nI8DD1arcqmtKhpjue4nNn5kXlta7zEhIaXA5whGlMZLCiQtMdYw0wo5OiKJKDMbH+lcQGXoSPQ58qwf2YXIMmiUyTzdjjy7nlhaw6eOGz5zNkOpgeViSR4z3a7HRYemxN0h/go+qDP403dOOVou6CfH2xcXbLuRT50c8fhiw9pNhBzRCFQSKAHN3NDOK8iCvp+oNWit2MVIdDBXibnSXDnHF0+W9FOgkorRBaaQ+NztI6hg2iZ6l1jWltvLlvNtz4PVKVII6qahsYarTc9661hUFXU1oVPEKMkQPVmD1IoxJpKSVJVlLgVSjUwiEyRc+8BmDFRZsY6BeZC8s92xcZGT0WLsnLdvBp7d3HBSG944m6NvL7Fy5GhxhDOZaeeJefpuEXWIv4IPMgfeXsw5PVriQuCZVHTjyGnbcC5GdmEipIjKAq0ABLbS1LMaMgx9wCiJ0gIXExvpaXNmDow58JnjFeMUyBkGH8lIHi7nOAUMIyFklo3lqDWc70bu7XPgrKmZ7Qau+4BzgXltaIMhRoWQAkdEWoXxChcTaIm1mpwlanJEASELupzpY/kMjTIzkLh2niEl2hTQdc11P7LeRmaV4fai5t6ioZWexWxFUOCGgRg8+ns8gz9wwpm1li9/+cv8/M///He/l1Li53/+5/mZn/mZP/TnfvEXf3H/wiSt0pwayyv1jJVsOG4aTuYNdWVASpASZRVKK3KSbF1kOwUIghTe/8UFY0qEnLmtK+4vGn50NefHjpdIKXg09KzdxFldoSUowEhQZPrB89b5DikUlS4XgKOm4khbjmc1i1nFp45mPFzMuFU3LKQiA0ulWUmJjLAZApvBcSY1Ime6EBhCIiWIOROE4CpF4v7Qzlnis6DWGp8S6ynwZOv49tXIo8uBYfDkmJBkpBTIQ475Pfjjxt/v/tn3Y9BKzXHd8MpixRuLU241C+4et5wdtTQzi6oUutJoa1CVpM9w2U1seo/WGiMUKScimW30uBh5YBo+NZ/xubNjvnT7FkZK3t3seLGbuFvXtFZSSUktJEpktm7kWxdXaKlodcXJrOb2ouXYNpy0Lc1szoP5jAdNw5k2HBlDFjBXhkoqQoa199yMnlNTIRLsfGDnIt5HhpC4IPLYBbwEISU+ZTyJ1mrGELnpHU9uer5zvuXFZY9PHiUTWki01EjUS32mHyd8kPHXIjmuZjxcnvIjp7c4a2fcms84XtRYqxFCIaQsfxWSy2ni7esbnqw3pJQJMZNjIsrENnumlLijW+4sWn70+Jgv3j7FKM2j7cBl77gzW6CFohGCRkk0gq6f+NbTK0SWWGk4qivuzGqOrOGkqTiazXl1MeN+W3OsK2baIqXkyBgqpQhkNiGwngJnyiKAjQ/sXGDyiT4lXsTAk8HhJGQpmSIMMdFoxRg8V8PAuzcd3zjveHw94JNDKFBSobJGpgNv+nfjgzqDW1vxyuqEz925xxcf3OPB0ZK7x3NOVy2VMcisMGiUUAiluBwc71yueXa9IwtIWRBjIojMtfP0U+RV1fBg1vKFe0e8ee8MKxXfuel4uhl5uFyipMAisUIiM+y6ia+9d4mUkray3Jq1PFwtudXW3GobjpYzPnW04JXZjFNTcaQ0FsGxMdRSEXJm4z03vedWZUnA1ei5Hsrr2cXAe8PIt7YjA5kkoYsJF2FVG4YYuBwm3r7q+O2nG55e7kgxYBRoJVFSHQr9fw8fZA6spWSlDXfbGa8eHXFq56xmNfO2QkpFygKJoFRugq0PPNvsuNz2yCzJSRBDKer7GJlS4kRU3GobXlsu+OzJCi0Ez3Y968Fx1sxIAowQGCkRAvrB8fhiDUi00sxtxXHdsDKW49oyn1nur2bcmc1YmZpalZhYWk2tFSFlNmNgM0bmxpKyYOMjO5cIPjOFyNoFnk2BUUAWgpBhigKrFVOKbEbHi+3Ie+uB827Ah4iQRdpTZoEK39uzeSmUnp/7uZ/jr/7Vv8pP/dRP8eabb/KP/tE/ous6/tpf+2t/6M/9lb/yVwBYT4F0uWUuFY0qL3PXD3gtEUqhhEYnsLoiycSmn6h8RCjAgnCCTOJW0xKJNCpzUlu+fGdOpTQG+Pp2xzoGhJRMQTK6SCUkWglmShGjZOs9Xz2/4t5ijs6SHBOrWnPddyybI5wLpBzZhMj55KgQfPZkRcoZgSDlTCSztJreBSKCkETpVhjNwgqGGKmMZiYUQmR2rhSHCoGRAh8DT3cd22Fi9W3BK2ctal/wk9LLeIQfa/xx4+/9n30/Bm/cSL68YKkralmhkex2I9JIVKXIuXQFlDRAwk8BYRJCRXIAowSRzHHTknOmFZK2avji/XvMbIXS8K3LDTe9RwpBDwwDVNLQGEGtDcMu0U2Jr56f83CxQAtBzpGTRtPnkbNVS5oGNiFykzI3nYdG8MWTBS5kssxEAVsy923FRMJ1kcEFshAYJTGNwE2BptLMmjKtcFGwnUoHWAkYQuI71z27MVB9Q/HKrRaRE0plZI4v94F+zPBBxd+FH/GPH7PQFUZbGtWw2fQkAdJqNAIdJZU1xOghlOdZKVVyIAJBueilJGjQNMbyM3dPWVlLrRVvXXXlgooiIBliRCrJXAlmSjAME93k+frTF9w/WqAQpBBZGcWgBKtVSx9GgvN00XMzjGhn+fzpkiPnQSSEBB8zx9bSR8fUZ0aXIIOSksYKehdpKsW8LvkXwMVELRVKCaaYeLTuGafIyVcFr9ya4UOhjST/PZ52P0T4IM7g8+0E/glHtWVhNDMzY7PpiVKAVeRUaDWmMiSZEcN+4mkkSQpSkqSUOK2W5AxLpZjbiv/l3buctAq9VPzW5ZaLbkJLiVOaTSdQQrOqYKYU2xvPzcbxW++8x+unxyAgRM+qsbgQODs5IufMtdjxoh+43E5oo/mJe0ec946UKBdLImfWEGJi3ES6oVDepIaq1vQxsGwMRiqMEgSZGFxmbjVWSaaUeGe9wznH6rcND87m5JDQQuDyh/BAP2b4oHLgbnQ8urikMYraGLS2dN2OICVoiQil2LfWEGMmxxErFZVUYECJDAEWVU0iMROKpa357NmchVVYrfnOekfnA0IJOgRxKLnTGoGWksHBmCTvnq85XVhSTowhYazGx4nZfIEhs0ueMTi60WOl4bXjGX1IJEqAeJVZasUUJHF0e9pvRmpNpTKDD7TWYJRESgghMUVBoxVKSQKJi2EgRM/iLcXtVU0KESkE6Xs8g19Kwf+X//Jf5vz8nL/39/4ez5494yd+4if4F//iX3Dnzp0/9Ofeffdd/s7f+Tu8fucYqwR+8OQx85nFgne3W6b1gIsjXgWSFJxIg02S2VFLRjC5iPWK47nEVktSdFS24ay1nMwVm8lT4VFKMvWgeouW5QZ62zbcaxRD9ihV+PX/0XzFo5uOx92OMSZ8KLfOR27iO1OHvwnYDMoIpBTsUuZFH1BC0I2e9TixE4n/5GTGcxf5s6/e4sHpHJcl/+o7l9w/rnh2MxH3hXuImZveYwjMtKB3ibHQwelV4r/7+nOSkvzJe0t+9Pac1hy6q/8+/rjx9/7Pvh+Db9y5jdCZfpzo3cBrp8c8H3aMmw0uTARRiualUcyU5V69AhSTCwyx46TRfGl1m/XQo4Xk9rzh4Z0ZLifiZoOyGjdEtFdYpYgxs7CWO1bTE8lScKdp+eIw8fRyw2W3o3ee0QUqZXlrt+Prmy2xC1RCILUgmIx0cD4NJR53gasu0OXIa3fnPOkyf/bHXuf126dEL/l//Zvf5t684okf0CmjgRQSj7sdALNas3WRkYSWma3vufrNiQD81Ku3+RP3VjT1IQZ/Nz6o+PuxB6/jRWS32xKmiR85nXMx9ay3HaRAlIFJCRZWc6xqjlNLTJkYIykHljPN6eyUXbeFDHcXLT9ybwXAph/olKQbIzJKWpVxznPcLLjdwJg9gsxt3fIFE3i267kMPeMUGMaIUpLHw8hbbse4mzAZhBREmYkp8HTYlUvsEFj3gU4k7ixXPB0cf/az93n99gpi5r//tXe4Pa94fD0gE0gBMcK744Qi0bYVW+/L6DsmdjFw9ZsDUQh+8pVTPn/niMWyetmP9GOHD+IM/rHPPMD7wO5my7jr+fRRy8UE19NEDh4XHUlIznTNcWvpbYm/kAq/+s684nPzE3bDiBTwYNXy+v0jIHO1cRhjmPqM8hIrJdMUOLVlWjkkhwAeVDU/OV/ytNtxEXt23UTXeYw1vLUb+Npmw7h1WCEQGjqZkN7x9noff2NgPQa6nHh4epu3hy1//guv8Zm7RyQy//xXfod7Ry3vPt+QESRVmhvf2vUooJKC9ejxMWOE4Pk08vRfj0Tgzdfv8OMPTjheNS//gX7M8EHlwFcf3CWlQNcPDD7ySlNzFeGmX5O9I+RAFpGV0FSN4jQt8CmWHbssWNU1t+YtYfRIrbi1qLlz2pBz4nwzYa1mN3pyyBgpYAosl4ZbsWGKgSwSJ1jekDPW/ZZ1EAw+MLmIloqbGHivH/C9Q2VBlgIHuOR57kakEIxTohsDPgeOT5Z0zvMnXzvl7nFLSJl/8/UX3Dq2PL0ZiBFyhExmM460OiGlYTdFQgooWaYF19M5xMQbZ8d86mxOMzPf03MROeeP1P10s9mwWq340Z/5DMtFzavHC75w5wyra7757DFv32y5GEeGUIrq221FjpIja0hZ4HMGCZUFrRSkiEDRaM1RXTpHbcoMRL5xveO9zcjCKP7iZx9wMU1IlRlDxErF546XXO0Cl9PIo6En5ERKgs0UubOqeXi64MmzK863E7uQwcBZZVm1NVIInnUj73UD0ig+X8/5xqbn/qnhzryilobrIfDjd85452ZNlQS1VIwp8RsvzrHkwsmeIjFmrFBYI+hihCS43VruziqOrOYf/rf/ivV6zXK5/AE/vU8G3o/BH/nyPY6WDQ+Pj/nc7Tu0jebbT5/wjfNLzrueIXjUfjFWSMPCKEASciYSMbXirGno+gmAeV14eABN8AzJ81vP1rx92bGwlr/0E5/mcggo4xljwErDG0dHXO0GLkPH437AByBCHyIP751xZ7ng4vyCi+uO9eTxVnJaWU4WNVLA403Puzc7rJF8vjnmfz6/4cH9OQ9OlsyU5cXlNV9+9SFvPX9BBRhj6HLmq4+eYwzUSnMzBkJMVFpiK8Fu8ADcX864t2hYVop/8N/820MMfkB4P/5+/D/9NKt5w2snx3zh/j3ayvDuiyf8xnsXnHc9YwgoKbjV1KAUc6kQucRfkIlaK+qqIrmyPDarNLfn5WCQMRN85GsXa96+3jFTkv/tj7/GjUuo5NjFgFCSN9o5F93AOnne6ztSApkFuxj49L1Tjo/n3Lx7ybPrjksfSBWcVg23WoMUgkfbnu9sOpRWfNbO+PrlDQ9vz7h/PKNRivPLjjdfu8s3X1xTIahkmTL85vNLKikwRnG9c/iYqYyi1rANCQXcWdbcXTYcW8P/8f/xm4f4+4Dw3TP4P36No1nLp8/O+MlXX6FtG959/ja/8tZjHl1s6QaPkpL7q4bKambKEBP4mIgi0raW2hqSD0hg0WjuLkv+m+fIlDK/9t4V33ixZlEp/sqbn2M7BHIa2ESPMobPHZ1wuRt4MQ68M+5ILqI8dDnw8JUzXjk+4+bJOY+vNjybJkaTeFi1nMzKGfz2puPb6y21NvzEbMWvPrvijQdLPnV7zkwL3jvf8p+88Tq//eQ5FQKtBbvg+c13L2iNpDKa825i9IXCWFWZgYwCHh7NeGU149ha/qv/268f4u8DxPsx+J/+bz5D2zTcni154+Q2Rmqe7Z7zjcfnXGx6BhdRUnDUtGgtmUtFyhmfEkEkjLVolbA5IxFURrFsS5+7DhBJvHXV8WQ9MDOG/+JPfIrrsUPpzJgSAsMr7ZLdONKniWfTSMwZkQVjzNw7m3PcLNhcXnO1G1j7gJOZk7piPrMIITjvR551AzWSu7bl0brjzmnDrUWFVZKrdc+P3znj3ZstDRIlJWNKvHO9plICKTU75wkxo4XEGHApI2XiVttw2lisEvz9/+u//kNj8Aeu0vMHYdOPeBIza9h4Ry0yWkuSycgIVkiUEGghCDmjFQgkImecTESRmZxDG0VKiSkEnJOEBKIf6EPgYhjxIRKlwo+ZLmSqnKmFYq4tWUDbKExTM6jA9eDZjIFd8LxKQ9x6rkLgIgXGnKmT4mxumVWFq5rIZDK7FBlzIpnMtQ/4TaYmgJC8c72lc46juuasrYgSnnQWieTFpmcIZanDaKiVZCQhtGBMkfN+Yjf6H/Sj+sRi3Y9EkZhXFbvoSClRGQ1KoI2gEqrEIIXqJavy92TwFP7qed+RcyZnweRgGsr3RTfQOcfzzcgUIzWJ4GEIAZMTldYsjEEJwbKpaIWiz7AdA2OM9JNjqSVh13MxjDwPE32K2Ki5Nauom5JsbqVMSpneBYYY8DKVuL9IJbmQeHR1XWJw1nK6muO14vH1FiXhahgZYsQIwcwo2srQh4AVAucDF9uBTXfgUL8M3Ox6fE4s66aMhlUiZEiAlpJa6bIYLiB4kLVAy0LkiRK8ELjJoUyEJJlCZOgzMWWU83SD40U34nLEIvA+s3aOKiWM1rRaIyWsGstMWMYc2TlPPyX6MTI3inDT83waeBEdu5iwUXM0q5jXhcd6i4pAYuciU4xEmbgcRlws9Ekj4J2rDf3kOVu0nC1anMo83nUoIbjcjQwxoYSkNZpVrejdwAxJiJGr7cioDjnwZeC62+FT4KhtimqJd9S1RSGpjCShikKUghAjwmislogoGWNijBE3ZYRJkAWjg912IIWAmQKbaeK9dc8UApUWpBjZuAElPZUuXGkpBcu2oq4V/ZVnlz1TjvRd4qyxjN2Ox0PHYzeyCQEtJSfLhlVtkUJwj7JDtXORIUWCSFz2I+F5pJYCReadi2sG57mznHHrqGUS8Phmi86Ki93A1sWShyvFUat5x480QuJC5Hwz0ItD/L0sbIYRT6Y1FX10KCJWaiQCYzRZyb1SWSbHCEqgpCJLiDmRctlTC1YiUmYIkX7MBBJ2SEzeczlMeBIhJ5yPbL2nkQKjNJXUCJFpKkUlGoac2HnP6AotdqYUsR+4nBxXwTPmiMqS01mNtBIEHGcLGcYpMqZEIrIbJvJe9EMQeW+9Y/KB46Zm1TYEKbkcypR+PTj6UGJwZgQzq7lwDq0ULgY2E+j8vZ3BH9mCP+XM5AKX255vnV9TWYmI5Za20Jogy8EVKbJsQYI1Ei0gpISSinH0ZC2LBGaM9Lko82if2U6RFKFWCmM0T7uJLZEpJI6NpbIKhEBr2AyJzS6wc54xRVKOyJiYJg8IlFboXJLarDJFdilmvE74ylBHye22xhnBmDwylSAdc+DZdsdMCURKhBgYUyZLQaM0ldK4EsOFx5oSOcvCiQW6lBjigT/9spBTZpo8l9sd3zk/p241VRZURrJKFq+Luk7MGe8CVaswRpIBGcvi+TCMqFoTgTEGhiFhEOAi2yESEzTGUFnLe7uOISVUjhzVFmVL4jJasusi2xtHHwNhf5EMoyP4RIiJJMo4UWSYG8O8qggpEbRmqgyVkJy1DQ9TZFQRkVKJwRR5vF5TK4XWZYfERU9SmZmxWBcw6n01IsUQIjFDRuBSKvzpwxrJS0GOiWF0vLjZ8s0nL7BGkeKAAhZaE2UiUOJvcpGpliQjyAIQIDK4zpMUpAxjyuym/bN0kZuxdI0qURbennQDNzGgYuLIViytQilFqxSX/Ui/C/TBM+VMiompd4QxFqpjuedChJmWLCqL30veHVtDg+SWbejxBFKRs0XQ76UWG6EwSoIsnTUvoLEKJRVaJYwqalhDKgVcluX3HmLE+Y/UkPoTgxAi/TTxfL3m64+fYrRmZiNCZJaVptKl2RZzYpwSttJYI8gG8EVQwvtAVmWXbZcSV8GhQqQNcN07vE9USiKF4N1tz804oUTkuFIcV4W73EjJbj2xuXF0ORBVOfvdFHBDoA8Bv495lQSLynLSNoQYGX3krA7MdeJu07KJgSBSyc9J0oWJ92421FpS6fI6XIp4KZgZjewkWiqsKguUQ9wvw0sI+wLSh0P8vSyEmBhd4Hq34x1RLphzbVCU52NyIqZMygnvM5XVaCNIWZJ8RpNwLoIWpCTIOdG5RBaJNkI3hdI536ufPO8HtiHiEiyMoq0FSmWUUmzGib73DKHIuuaYCC7sC/lIEOUoVFnQmLIf4HIiqkw2MBKZW0tOkSQSMhdZ5SFErsaRmdRoJUGCyxEvyh4LUiBkoYxLBWNMhJSwoiyljzEhvscY/OgW/CkTQ+Jy03HT9ygtubuYMzOalapIJNYhsM2OnYvUuWVRKZRKKJexaPqQCFMiC4GPia73LK1gUdX4mFFCIJTAtBVf63bMtAY80cJcW+4IAULw1sXAV9/aIprA8lixkBKRElRwT9TMhGFNYIoRhWKlKy6nkRCK8s6DuuLH76y4swu8s96ggZnWfGe7ARILVZFC5Ol6x1PneDpOvNaU37cdR6YQ8WTOp0ArbNE/NoKsIB2SzUtDpuj0Xqw7Nt2ArhUPTo5YasNRVeTkLifHJjv6LpLmmqouy7omZ7SUKJfAlG16HyLD6Dhra5qmIux1/IWQVLOW37y54sQ0OD8Vnr7WnB23JDLfeH7D1755iW4lx7crZlaw2000reVu01ALxc3kSQkUilNds+kGrn0iZ8G9RcNP3L/F/brl290GaxVLa/nt8ysisGortFRcbHve6bY8GzrmVvFgNqNVBpcSLife3WyxQhJiJtSgJeTD4vhLQYyBPMLz8YaryzJxuXu6YFUbllbjY+ImBDpXOKIswZiMUmAC6KQIzoMwoDJBJEJIzOsaqw2TScgoiDkSMnx1s2GuDeM40dmA1ZJXTmYAvP34gq+9fQNV5ujIMDOKq+uRprHcahpMVtxEh8hgEqxUzeU04HwiI7g3a/ji7TNOrgxPh4G6MjRa8xuPX5BVuYxKBc+2HW9tet7b9XzmqOVkUWONLrxwkXlv01FJQVKJWS2xEtKh6fFSEIZITpmn4Yarmw6A26sZq1ZyVlmCT1xNgd0U2G0dqTXYFowRWJVpkiT0iZwVUWbGFBiCY4lisajJsUYniYtlYfJfv7hioSzBBfoaGlXx8JYiRvjG4xv+7TcvUQu4daeiNZrz64FFVXNvPqMSkqvOAUXl55ZtuOx6YkgIJJ9e1fzk/Tvcn8359uZm7y1i+eV3n4IU3F5WKCl5cr3jG5s1724HlmeG+8sZcxdwOeNz4tvXW2ot2RLRSiK1YBCH+HtZyD7js+diCqyvtwDcPjmlErBQChdhEwN9jLgRVAPaQBaJ5AIVBuUiCEWWAk/GB49VgtpYfNCIJMgxk4TgW7sdM6nZDJ5Bg0Jz97gF4OmLLd96coO0sFpaWmXY7UaoNMdNhRGS7RjKRB84lpYrN5JCaVTfbS2vHx3zzNQ8n7ZUplDNv3Y+cFJpTm2L0YLrsedxN3I+jDSLOUd1of6EnHAp86IfaBUMEaTU+0X270244CNb8JP2XZyUiT4jomQynkYphJYYpagFXA8eOUlULuJMwSe2W4erIPlIdBGBxIqShHCJzo5QS/wA3kdM7wgqcrWbaOaCaxWZMnyhOQbgTz5YkJxjGzzWgqkF0wTRBmLMiJyppCBbwRATvfM87keslnxmtaACYoicGc17WXLlJ26Cx+WMDZlBJYR3TDnhcsAmuBpH5jKgs6RLgnPnCEJwa2ZxKROAmEpRcMBLQspkIUoHK0cUkcFNLE2DMQaSohkzXTegIhipsdKSfOR6s6NuIskH9E4gtaKWAhNht94xLS1JRZwsRVgYJgYRGfodppasY08Igi9Vt8kZfvKNVxm7xJQci8pgtCHEovAkczEAsUIRdeQmBVaD5zvrLVoKPnu8ogKYImczy3sTjD6wSZJERsaEz7AdPGPweBeZRcVlN7CQESNgSIFn48BE5tN1zRjLJC2PmUO99ZIQAFKZUIqAyIJp5hG1pTIaLSODj2xcgADSS2TIpJDp+8IlzdGjXelOVqIU/ePoStyZyOgSUy4eDiJkXgwTUic2qUdkwZvtfXLOfPHVU9zo2UZP3Shao5kmGJLDALWAVsMoYB0Dpz7yeNOjjOD10yXCZbaT53Zd83QYWA8TXge01ciYcCS2Q6DzkRgybYSL7cjKWipZVHqeDyM+wY/MarY+EUboicR4uHC+FOQy5fQ5EkgQEnFqqGaKtrZEleldYu0SMonSpPOJ6CLbnSPUFSkEbNRorbBSUqOQKbCNE4OCjsAUPBUGxsRFdlgVedt5klP8xOwVdM785Gdv03mHS4FVY6krQ+g1kw1YCa1WDFqyS4kXbuSkH/nm+Q3KSj5z64jKJ+I+/31rB+vJkUJGW13yb0hsQs/GRbyDNgqebAZu2YraSEbveTIMROCzi4atK83EjfPEQ9PtpSEDImdySvi9eInzgdpIjC70xSrD5Atzwo2eIANJRKJzJJXQEYRz5QwWAouAFOlwOBlxlCLdSMMUPYMHKyMdA1IqvtTcATKfvXeKd+BiwNYKjCJMEBTMlGCmJVHDmBLOBbba83zTYa3m/nELLjNNjmVteToJbibHEANGacKUcHg6B8Ne18ciWU+OudY0WrNxnhf9RE6ZO8ezQpMMicFFYvjecuBHt+CHf2cYTJHYvJ5GjBRUsmHeWE7bmjbUZDw+ReRUfsgaxYRDx0RR1Act4EQZThrLUxydTgibybnIujW25vYKbA0ns5pXlvPvHiRHjeVPvnrEt292fKcb2HrPxVWHHQRzo1lqw6LW3G0a3lguuNXOkVLSRQ8KWiWJMfG4H5AyklPkevDMpCSmzDM/cWQ1KWecT9RKkGTm0ntEEnQ+0oeINoUaMpQLK1lCUgeFlJeFnNnz7wEyeYpcdyOVVOTaYGvDiV2Qq4TaS72apInWwEnCe49EEEJCxUyrFMfGcjRb8I6a2NaZHAT4QIwjAkUrBbNac7yoeHW5BFThAS4V/9HnTnjresO7/UA3TdxcerQRrOaWuTUsZ5qj+ZxPL8+4u2xQCjZ+RCg4lhUpBh5NPVkUubMnY1dkx2LmXb/mXlOjpUADt+Y1jsDOe3KC9ejY9L4YeM0l3eiIpizIi8N593Kwz+E5FwoBZNbXE3WjoRK0leHUFq5yPJYon/GbSFACbatS7Mfi55BiRCI40Zp784Zvx4FJCITOaFUUKnISSCIrIzmaV7w6nwMgBJwtZrz56Vt862rDd3YdF13PsxcTsoXT1rAwhtWs5tXG8MatOzw4niOEYjMMaJ85VhoXE0+2O3RKbAbH+RiYacm6H7neOW5XFq0kIsPZvGGi6E8jilDCpgtIVe5BXYgkKDS2wwrJy4EAyORUhCJyylwOG6p+CXNBYw1nJwuUFsRbkjBFwqbsargYmVSijQJkAg+NENw1lntHR3wzjcTkSAqkEihdZAi1DMxby7wx3Js3mP3ruH9rzn/+hTt883rDW93A827g8dMOOZPcnluWxnAyr3mlMXzx3h3uH52glWQ9DSiZOWsrpph4t79By8B1N/F02LGoJOt1x6/vOj7VlGmSVZLbq5pAZu0jBth2nqu1K67qytCFnqAy8f236YCXgqRAyH0puM+H6+sNet7Q1AalNYuFIZsMSkMqTV4XMzEooi1FrkyAL3TahVDcXs54h5FJJHASEUEqiUwCQ6StFLWRnAqN2je0zpqGL9w75r1ux5NxYNuPbG4cuVLcbiyt1Swayz1ruHey4qydoyiXReVhpjSRxPOhw8jM4BKXvWNhJEPv+NbkOKlLDiSXvBqiYuMcQgp2PjC4hNKlphhcKMk5Fwr894KPdMEvKA86UYymvIvkuozWtj6QQ+K102MCgbznnu5Gx3qMWJXxqCKtBcwEtEoQ8HTBc79u6YTmEo/zkbY2rLREVXB3Mef+rIyylcoQFavGEno43xUJzazB5czoQZLQJnFHSWYodn5i54uxTApwIQLHtcY5jyRiNdgksUpikGQElSkcbJ0VFsnGO/rgcSIjlGCB5rQ2vAiBLDMgEUEiDiLALw0p5fKBEhmRMgnB4BwhWRIalyKD98xmFbN5zUzWqCjYjCM3Q1lsjVA6oFIyU5pGKxKZwU+83i5Zp4nL1BNCRlpDpSSni4pXz054sFzhEDRkiJGjpoWu53JbTJS8jjgpUS4AAislbZIcV4oYBGOM+JDAZy5yz3Fj6ceAzoLKKoyINEmhjAQk2QiClmhRcVxZbnY9k5vos8eJRKs1t6uad7al0y+9KDzEeIjBlwNJ2id09l3ELjmCs6RgcFITg0A3kroxnDU1Kku2vePJtqOuBAEwKaGlplKKVmvGGHA+8pl6xs1Mcy4mnAfdaoKHk0XLp06PuL+a48iFJ+sjtTVMOvM8jIw+gQWfMv0YUVFSNYaZNhxXCj8lxskTvUdJuAiRttasoy80SquQKRGzoK0NIFBGooxmbgyzVnF+1XM5bXi/eTWzinttzTtdcaKWCIQAfQi/lwOREXJfUEyly9pFR4qBnAwuJ4aYSFZiZprX752iveBi0/HW1RULrfEEjJDUSjGTiqUBQSAQ+fHFgkuheLrrcBnEzKJS5HQx5+HJggerGcPkaa2GKJm1c9K259I5tiEQbWKKcDMEUsyctXC/ajm1DTEEBh9wIaARXHSZk1nmonOQJI01TBlSzBzVttQZRjJaiTaGT50tubjY8GzqGWJZ+J1ZxcO55WuXG6Zc9M+FEIf4e4mQku/eqLIoTbhpCIQ6kTNlNy6XGokZvFodo7Ng3Q+8d7OmUopMUYmyQlJLRatgTB6XAg9tyzALbEzAR4FpLTp6FpXhpKk5bVu64Pa+TIKqNvhBcOU9Y4woI3Ey0flETglVKdrWsFCWyU/sosfHQo1z2TMzmj6EQn1UEqUlPhXlHS0KxVdJRWMK7fJm29P7iRTLzkBrBKeN5XE/EBLIXBpu3yur7KNb8AvIorT4RRb7gitx3Y1oI2lFIiFwOdIFx726ApeYsscGgc2CRaXZeIfPkVFKrCyb+S/6CZcSp3XN60cttdIMSESIvOh7hhDYjCOfXbTcmrVoLdAYBJIYS7H95ftH7KYJRTmPY4Z3b3Zses/p0YybaWJwASMFr8xbVrMGVMWLbkNKCUwiC0nnAIr++nFTYazmoh/QwKuy4tJ7upDQWbASiuvJg4BKg1VyX6wd8FIg+W77OqfCy3Mu8GLdYYSktRbvyxLt1AfunCxJY0B4j5oyjZZUdcUmBrzITDriKoXWkovtRMhbTrXhjdMl1mheTB4VYNd7vv3iim038dnlHLNo0VZRWYtA4l0mC/jpV+5wMYwIUZZ/coJ3r7dsp8Cd4yWXQ8dmdMgs+fSiZbma83pleL7dMCaPDZAV9HuZzXlVcTJrqWvNzTiSpeRBO+P50BdVIiU5VhXnw0iWGSskjZJFv/iADxxJZIQoSg+IjMgQU+LiekAbRZthCqUlIv3Ea6slImS6DPiElpK20vQ5EIQHlahMRknF+dgzec9pZfnM6ZzaWkYkXTcyTI63L67pJsfnTxacLVokZaeFJHFjGTn/1INTrnYOKRNKlF2Od687tlPizvGKi7FnN44o4MFsya3jJbLWrHdbcgqMJuNDZtxfZo4ay9mspWkrzvsOJRWvLuacDyOCzEpbbmnF067Ev1WSVinMwen05SBk0vtTzvJ/8Crz9GqHVYrFTOJ9wPvEOBWhgSwCNwR0TOiUWLaGbfRMJJROzGtDsIJnVx2j85xVmj9xd0WlLVFXxNFx5Sa+c7GmnxztLUFbLVFaY20mJMl28ISc+ZlP3eXFbkCIhBKCGDPffLHmeRd45XTFs27HehzRQvHGcsnJ8ZLPGcXzzTXTzgGRUZRuKcBMGm7NZzRNy3m/I0rJ6/MZz3YDwsCZUdw2lkfbkSQyjVLMlKJSim/8YJ/UJxb5/QlyBlImJYhJsN45tJbUAggZHxJpiCwWhtpYYs6oyxtsElTGsEuBIQcQiUorhIDryeFi4rSueHXVUimDqmqGcWDjRs7jQEqZo9rQzFukkmgMOQu8S0gh+NHbR9xMHilAkok58ni942b0rJYN62licuXSe7uZc7SaQWXYDDvUVKr0zkfCvmBf2opV1WIqy0VfVHpu13NuphH2hrBLrbkcJkSCWktqrRDy497hl5TrSyrFDFkUicvJMZsURpbD8GYc8TkyGE1OEUeiloJWFnv4y1ikkPpc+K4zIdnFQBcDq9pwZ2a5O1tw5SK7buDtnefZMNBHx/1ac4uyNBkz1FJzaiqkkLw6m3EpJIbIlDOXU+Sd3Y5HDNzPERcSLkRarXi4mFMbS6UVEk+rI10QnE+SMURCgmVdcW8+RxvF5eiwGl6ZNZhh4nycGH0g5dLNqkXRm6204uAq/xIh91/7Yl+QiTFz000sbYVGEEJgCIE8Ja7tjuQDvZuoEMyEYmYlV3t1p3GvKDLPmW0IbMOO5dGKe6uWW4sZq25i6h1fvb7m+dDRjyMPK0NatghR1FdqbTipK7KA11YLbJZFgiwlNqPj7e2Od7Y7XgkOFxy9C1TS8MZyQVVZ7hhLxqFlYGkFVx4u+oBPmaWtuD+boyvF+W4HAl6ZzxBCcNEPxaJcZHQu6gErY5lZjeDQ4nopKKcIvJ//9mPbbeeZda6odaWETxIZE9f1ACnTuwkLzLOisbD2E1NOjCngXKBFsXaOGxyLWnF3UXN3tWDrFBvZ8W+fPePZrmN0jjdmFWIxB5lJQCUVx7ZCKsFryzk2TUjpCSmyHgNvbwbeWfe8EgODmxgmRyMUry4ly1nFrNZcq8Csiqyc4NkmcLH1xJhZ1g33lguM1bx3vUYKeGW5QEgJosf5UujpTKHH2Yq51RzC7+Ugh1xMgAq3EfbqYNfbgaO2wWhNSuWsG3aR85stMTi200AtYSElK6O5HkaGFJmiJPpMKyLXk+NqcqyaJQ+PW+7MVkQq+t3ALz55zPPdwBAcn1st9g3eIsNjZck7Wgl+5HiJTYIsIyEm1oPnG9cbuNpyMU10bqKfAq2xvHFyRNNWfKoyGDlitGNWZS76zPUm4GNi1bY8PFphdcWjiysQmddXSySS511HCoEkSqd4oSRnjWVVGcSB1PPSkAWU/Afk0vTIArrJ0ziN0oVqFgLEELjZ9VRVYPCuTLy1oMmKG7ffkUyieMpkyS56dtFzVBluNxVn8xnIihupuBoGtuMEZHxYkGWpPxNgpeTIGIQS3G5rRFZIGYk50rnAk20Pu47TtCB4j/eRWhvuLCRtU9EYS2siS5fonODJxnMzJFLKtFXNaTtDKsGTm5IDb7czhJTcjAMpelLOGARGFv+pmdHfvbT+YfjoFvw5wb+nLfp+Xh9dxKpIZQQX257jecO7XUeKAZUSbaVYSUlMkT4ntqmM/JLPKAOqLt1QKTKVkixsRdNIdhK+upbIXN5MrTUJwTS6clnQih85WmCyottNdCFzojT7/Q12qbzC37neQcpUQiKrisnFvWJP5vay5h7FI+B3rjNaptIRW7acLCydj+SsWKjEatZgjGZMkff6nt4IrDbcrSwzrZFSsgsHDeCXCrEPw7TnEKbyvWHyxd1RZjo3YYTgtx4/QhlNow0nlWFuLDIk+hjZpUB0mWebEV0LlIWUCj/RGMVx3XBcL7lpd3yjX8MoMEqijSJKGCdHN3kWleZHbx8BsO4npgFWtUbKzCQDN6Esce9e3BBT8XC4Uwkml3CjRyrN3UXLg4Vi8o7fWQeYBDfO8eB0we3VnI13pJyZa83JvEIqRRciX9/tmJtIZSSvtg2nVYO2ik2cflBP5xMNqWWhlJHJSZSaZ3/5HIdQpCqNoJ8i1gt+y7/A7KkTx7XhzBhCjLgx0aWy3PrcRYyRoMv4GAotoVWaalZhUywycBTXZTI474kxse49baX57J0VBkHfB8aYOVKaSkk6mdhEB8A3XlzjY0RnuF1ZJueJ0aOV4sHJnFelYfDj/4+9/2qyNMvSM7FnbfGpI12Eh0hdWbIVpmcAokGAymzGSJsb8o78hzSjGa94R+MYMYDNAGwA1UC1qKqsSh06XB31iS15sU9EVveAwxxMByq74CstMj3cPD1O+LfP3muv9a7n5RdPB5Kf2A6Rh8s1F/MVe1cO2tYoTroGrRVDivz80HMwmcYa3mkb7nU1lTFlaPku/tajDEyCcES9QuG7AofRUVtNZRVTzEQX+dNPv0ZbYWENF13N/bYmxzLEuIuB6ODpzlFZECPHeopgtWbd1Sg9Y0cma8gqY3TxlUhRmIJj6B2ryvD7Fyc0WjgcJsYeTmcW0ZlRJW59WQv/7vkVISasUtyfKYYQmXxAa8376zkfnCh6P/HJU8ef+5Gb3vHO+oyHqzXbcSJFWGjhfDlHG8OQEn/x6opFG+mM5YNZw6NlQ1dpNoP7rTyf/xRCXif8CkQEpTPpWM0efERNGm0UOWViEP7qyXO0VTTWsGwtq5klDeAlM+ZI9JmrYUJpgRp0LPmeUYp5ZclWk0Lxf1AKjCqFlhATfvL0zjOzmg9PFwD0vWMIiaUWKmVwkumPyXd/syHHTIVGNQqXHMF5GmN5uOhQSjGFiSo6voie0QXOFzNWs4bBjWhJGKNZNRXGKiKRx7cDLhsarbloak6bGqMUt8O3ywO/uwl/Usfq1jHRz69n2EobOPiM1Ymr2w23w5a6FWYYVtQsTQVAUNBqxRjhkDIugUmw0oYsMMsVbbJHYZijqij4T1PzQT3DeeFXlxvmWnOzGdilwGhgUpkHleHpfsLPapbacBbLVDWA81K6AgI+wnVyKBVJyRGj4XasuJ3KIFynAzfsUQHGMYLKLLuGU92BUiybmgezGTejR5vMWlecVBWRMryWvsOP8HcmjrSKbyqJwugSrcp0tcKNmVQJYgLzqJgZzUnX0kZhR6LTmjHH4/R+cWxcNZZAos2aOhXBRIgjVWUwWjifNTxazPEiPL+8xYjm5mbHQSV8pUgIs6B5sulRpuGsrVjYiooyxO1cJMWM0QpfZa5cj+KElCI511yOmeshcT47oTrredFvSDGyH0dCTqzrhlPdkkSx6ioeuJbLfc2s0rR1xyNVoyuD1wmJd22mtxOFC55UKnthOJa3yDiX8NPRb8QHsrV0FVRZaLVlUTcEyh5htCoGNCkxTQmThFXbkFMxC9ROMY2ZGG4BEJM5sTX35w1jcHx1eYURzeXVwCgBKhiAuY683O9R847TtmJZC+ZY7QwukGNxCwe4dj2kNTEleqm4OUSutrCcnfHD1Z4XegLvOex3eDzrtuZUd9RG8bCeMcTI5WFgVlnmlWVdKeq6eKXUd/nWW43jtfB1kRWAyXmGSZGz4XLnaFuFsYmZrljbhpPZjMoaeh1orWYbHQcfcH2iqjXr04YQEk3W2KjJMdNPW4oqO3LRtLw3W+BS5otXG4xL3N7cslGBWAl9yDTR8+ubDT+UGfdmTdn/juvNjcWjpzLFcOm2HyBGUkw4Nee2F673kdPlkp9Me16oA9p7DvueEBPni5ZT3VJbw3una4aYebkdWNSGead5pCrapsJr4a7e8fZCKUFzJEBlIFJ8HgCfMy5ELIntEDC1IDZTAy2a2liYDNkmKq84ZJhSIkxgqsyqK4jzRmk0hilnYj/yOvFcNTWnXcveR/avbmnEst0O9BJwtrwnllrY3Y50s5qZrshKcXx5xFEIZKQCpTP9UDqvYwwMQbEZi8fTsjvjI0Zz+AeUAAEAAElEQVRu+hFcZuwnIpGTbk6nLcoozuqKlFqGccLois7AojIoY8hSPEq+TXx3s0V1LH8eW4mJb2ggh8kVPamt0B00tUJN4FxmJw5sRPnEr+gZp0DIoERYtxpP4kftkt87X3FaW2qtiTECFRUV/+X5/dKmTKm0h6qKqqu4qXs+uTnwoh+ZVZqftHMWS8MntxtEQVUb2pkmHRLBFkziwlrudzUP6hZjIEbNz683WF3x7mqJOQycVJF7bcuT3YEnu4ATIWXD5/ueR/OOmVG0WvMPH5yRc+YvrrYMaWI/JWplOdP2f+SHeBf/s0JzrCwUrfubTysYskP7jDINphWqRqOcQIB+crw6ACSeMbENRYqgRFguLY7ER+2M378447RpabTFTaAMVMB/df8hKWV8zOxuJ7pOsTzp+GrY8vOrDS/6kXlj+OF8xocPG57sei6Tp64tJycNcYi81B4dhblWXDQV9+oZdV3e7r94doXShndXC8xhx72l4d3lGV9fbfnFzRZnFG22/OnuOY8WLTNtWFaW/+rj98lYfvHiKdfZsR8GtK5Y2Pa38HD+U4j0ZlItq1x26wQSM8PgkFzWX90p6g5MBD9FdmlCDQFr4Vmc2PmIy6CVYbEyuBj5oG744WrNqq2pjcY5Dyg08E9OLo5mNpndLrxZf4fhwC+vtrx6ObLUhrCa89H9GZ9dbrkMlratWC8apsFxbTySoNKwaDXn9YKu06SY+POvXqJMxQcPzmn9wAfvrnAx8qvnO36535BqA0HzL7ZPeW/RsbaGua34Lz/+kIjw2auXjGReDAMKw0LVv+Xn9LsZikLQ4TgsWWSNJbHYuwA9nCmhrsFUgk2GNCR2wwhDYm+E59pxNThCzrRWszix9EQ+nLf88fkZ9+qO9rj/gUJr+K/f+/C4/yVub0e6zrM8W/PplPjLV7e87CeWjeWPVjP+3vfO+PzVhush0c0qzs/m7PcDBxWQVIov92rDqWlZd5oYE3/25Ana1nzw4AJ72PL+BysCK37x9Ja/2G6RWqOC8N+/eMpHw4xla5l3Ff/HP/oeOSt+/vw5WzJP+j0KzVzfrb+3FVVbLvWMx3kSBK2BBN47xpzQusZ00GjQySAhMzmPdpHcKp4Nnr0PRKDRBtNBryPvNnN+uJqzqBqM1kzTEQ+rE//Z6QkpHZHIe4/uNGqh2bnI19s9261jrg0PFx3vnC34erPlWfAYa9CNLcasTUaSUClhZgzLek5lNBITv355g7Kad9antDGS64Z3Thq+vDrwqt+irOCD8MXumot5TWcbalvx++88QoXIZ9sbbglMzmOVoTHfLg/87ib8okDU0cTgG33Sa3KPT8Vh11YapUtLh5jRClqtIQtt0DgSMUW0hroS7tuGj5YzWqNBK5Iuh5zg0UClLUlZiAHjI7eD56v9K67ixNY7XE7YKEwhEgX2qUyLz0KkFcWmKZeNjGLVGN5bt5zPOmK0bMeJMWZ2scwdLH1iZTI5FQxTztB7z9PdHhcTq6ZCK0VUiU0MbEbHi8MIZBpVURshyl07+63Fb1iWqte/Vd/oCpMU7bytFMYKJmrwpfXYNRadErcEDjEyxYK0rK3loan5/skJK1NTK4NRqowKhIjVikrr0raUhPaB243j1/tnXLqRjQ9MMcMYiI3QS+TSTxA9i1yhMkxVxniNQlg3De+fLHh0MsNH6A8D2+gJ2RP3iZmPnOXEhEVEoQUm5/j8sOOQPCtvy3tOC1OC23Hg891ABjpTc2YNd/X9/whxrOy/IVYAKSViTFStptYKcYrsUyFSWIPJmVoZdjkR49GaXVvemdV80M1ZGkOlitSQBMSE0cXjREsmpIj4yMtN4Iv9S14MAzdjYUdrMkMMpD5z4x0qBdaSqDUkq7EhohTcaxp+sFzw6KQlOMPNdmQbSjeLWzhDWFfClBVZaUJO7A6O54eB2+i4N285HJ19dQ5c+54vNz1Q5llOans3tPuWosxOHH+2kv+6Uj1DyoJHYeuEqkFGhY8ZK4pWW4wBK6H446RidNlZwyPT8pP5KaemodFHHbZKxJSoKH456Tipqcncbia+PDzhybDn2nkOPqKAYS5UKXDpHRzXnxXFrDIcUlnXD+YNPzxb8t75kilpbm8Hrg+BZBKiNEsXOK0KXjOoxJQDu53jye7AtfPcW7TIFMk5EpLnahj49eWODDTact7WGO7Q2G8r/JhQVo6dJYXSqQzyJsiRN94P1hYqJ740QkVA1RathFpHDh5iTogoZpXlflXzoOuotUYrMCpjj1AETdkDk5Li6Bxht/M872/Z+qHgMUNCUnHpPaSJbfIIkbnKdJVhigGdCgp5VVU8ms84n9f0EfaHkV0M+BxwW+EMxbzSOCCZ4qJ7GANX/UQfE8vcoXMoQ/MxsBl9oU0Bja5oKoPkv+sa/jep/euPv/kLvW4t5gRza1Ai+BSpjcYoxRQiC2tosmarPCSIOTPGyJQ1a6uppZi7I4JSCmOK/3xFWVwSoU2Ky37i5WHiVgrZx6pS4ziExCieSeLxzxdMFEICn8qrtCJ0otmPEZUDmYxWittp4uowMEvCu23FXBuGlDmkxN7FwuNXsQyJJvAuMuTM1egYxKOTYqYhEe/0q28xygF3XIMiiOQjFj+/GeDJWZg3BmVU2SyMwqrSNZpXNR0B7TwSy7pyKTIFYW0rrGiEYputNVhTo4jYrIkpk5Vgvea2n7jsR64pF06tBMnCZoz0xuNI6ASTC6gsTLmsoUjCGKGzmsPkCChUKAf5rRt42ffMovC9tqE2mYFEL5k+RnwMZAo6jCSMU2TnA5f9xEECJinmqpiSbca7OZK3ErkYv73+GEVRPPAaWpHJMbGyDUrDlIr7p0YRUmJRGyoKkYKUiWRGHfAO5lWFEY3CoOV4Ya01OcU3Bx8JTFJMo+P6MHITHS5HlCqa7o2LTMrjKW30kBIpwpgiMWbycbCs0Yb96FHbiWGKJIGbaeLVYWCtDB82FW1lGciMkulDxEVHpYRGWYgwxEgicTs5JgomtxMh5cTG362/txEi8hrzXSL/xpmsjgQVgXljyDXEocjHrGhShnldHOhlFHLIhJgZU8QHxVlVYaTIdpUWtNXURwf7mIvhpqhStLuaJl5sR65jcbxVR3LL5egZ1cigCqgjhUQORboWYyKTsUrRGsthnLg5WCYPKM2rYeDZoWeVhO/PGzpjGVJmyLDzgTF4jILGaiQVFOQ0JV6OB4YUkQRza4HIdup/K8/nP4k4Ip9zPBKyBZIpvy8pYrkYdrVGjOBdRCtBiyLlTKUqKgkFLxsK4n3MgcrBUldHcLtClEZpMNoiMWFFE7MgCUyKuMmxd45d9viUUMeUdB8io0wEMlXO5BhJERyJEBM6gzrus4cxoMTjHGQR9pNjMzh2RnNe11ijj47OufgI5ITRxTQRYPKREAIb54ivizQCMQcO7u+6hv9/BL0gHAc4RHFqLS5nJiO02mAEvC/V1KR4UylICUaf2EoorZqUixlDLt+rqmwxE8oJBJLKDDmyCRM77+mJxY0tlyG3XYrceofPxWWQnGljSdRCOhINUqlM3fiJgw8sm+ODC5HrYWIEKgFvoVeZMWcCmXmtiSkhGUwWhpS5mRwbH0BBJZosiUNyTN/yQd/Ff0i8ZvNQkv3Xn5OjolUA0Zy0Bp8Sg0401lCJIvgMRiEUE7UsmZxg9JGNKola0pGUhZwFUYqmqTgMAy4Vs6+Yix39bZjYjYFRJciFEiEZNsFznVwZsEy5SChEE1IixoKxzZTD83I3IFPgzDYoEVxIvNwPzEXRZM2qyfRGmLQQjs6VcrygNhR28Ku+53qYyGRqrUEl+jjh7hL+txL5WNnI+TWX7q/vicf5SU7riolIMhmrFTYLPkSUsSSO+yCZlDJ9yJhY5DopFZC1aEFrRdvW7Poen4/rhsyQIjvn2E6eMRV+dIVCUkmMrsUX6UfKHHwgh4yLZUA4ihAz+JB4uR3YTp5aG0iZyUWuDiOD1agQOWsiU6WJlZADdJUmqoLcrLKiD4ErN7FzDlGKWhWpSR8dk7uzen5bUZZgWWi/WYI7CvtRCs5nDaMEBl2q+5VoAhljVEFWS1lLOcLBBbQqZl4xKWJSJBRGhKYrlB4Xyx8UKReEGzdxPTiG41nbikaycOM8l4wA6CT0zpNCKh4lISKSSwHOZ175Az2JmVRlWNIHXux7DlphcuS0aZisJh7Jd501VEf0a5sU/RS5HAcu/YCoQqsSBWP0THdFt7cXRy8cKUcxosslFClo3iwFZrbqKhwZGYt821Cq80oUWYR8NO+KqRS0hIJ6z4kCRMhlMVetZeoHYihn8OsLwi54Dt4zEVGZ4hiNsHOejSryRSXFE4AgRJUJoRRpUi4fX/uRKUVs0uSs8CFxGCeoNSlkFrXFW1XMVHWksZosikqDRTP4xK2b2AePqIxVhiyp0P/Ctxtk+s4m/PKG0vPXD7lMUfsoI9SV5UHTcOMC1TxTZYXOZVh3VJFdCkXSc/wfY4C+Trw8jJxlYQ5oLE4CFTXbceLQj4gR+pz41fbA08PALgZSLJuKIHiV2TSOnS8OquSEJxKltNOl5GVMMbHz5fNP9z33aPGxbEomK6zJXI4Toxa0NhgjNFmxNIrOlc7FzBomVxBmk0Rm2bLUNYfgmHL81q2cu/gPi9fIydduu8JRzKoEtEIby7uLRfFO6BKV0tgsoEo1dZc9jlgOvAy4zKGKvDrsuS8tSldFUuEqqha2g+P24IDMlAKPtzse7wduUjlUTOlL4XNmrAL95DGicIDLibkGnaUkciK4mNlOgRiF68Me3y3xOiJeqKOlqYTn08ReJ9qqwyhFkxIL0QxS3AcXlWXYB57tBvocWFCxbCsOORBiRKf87/3Z3cX/vEipSMk4HkzFkyS/gRgggjGah8uWV/sJaQWdFBKLRGEUYUgRnyORokfNTti3kdt+wDYJpRISLApDBrbelQHHHHEp8vVuz9O9Y4dDIryGEIacGW1kP3kq0TgyypUChsRSGcsKphDYTY4pCk/2G+41MwKgvFCLokXxwk2Mklh0c5rK4HKgU21xAlaJRWXpD46vdzuSJJZSMa8b9nEixYi9wyK+tch/46M3PXcp57DRio9O17zY7tl1AZUU+ngOO+AQCyo75mNyNWZ2VeRVf+BCGrSSY1LmqXI5g6+2I4qEz4HPtju+uD1wFUNhqotGMAzJM9SBvXPYbIjZcUgUMh6lQ58lM/ni1jylxNf9gYezjkkyNitmYmi18HRy9BpW3YrWaFwMLEyRMOosLJqarTvw69tbgiRWyrKoK8YcGUJE321/by1yKsl6MYHLpKN6SosQdCZnQWvNxbzlZnDUjRylPuXrooqMPhLzsQBWbqA4K+ymEZEGc8z3E0LuhIP37PaeTGbKgcfjwOXgGFKRMlaiMaKZgOAjPalIIIm4JNRRQwSVjijPkPCTY4xwHXvWuj0Wiks3rBLhxjuSylTNDGMK7r1WFSlpNIm5rUqRZD/hpRDMWmtLweMoHfo28Z1N+HOSYjrDmzL8GzSYUkJja+6tT/jj9z7gp4+/YjMNpLFoVu+3HVPlOB8dWRK9jniT8SriqsgvDnv+wawmqcQuT2zHSDyMPKgsT6aBry8HXgwTN0zkY2sxaSm4sJjBJWbZ4nzix8uWpTFMMfFsX3BySxSxFgYFz2PirG15crnhq+uBk5mmrgSthBebgNLCfF4jkrGS6WzF9+dLtC6Ent0wcjtOmCi8M1sTVWJ7GAg5UitFZb+zj/B3IvLryuqxypU9HPt0aG1ZLU74k+//hD/95N+xmSJ+CLRacb5cMCmPvT6w8AYlMNlE1DDaxF8dNiyXLQ2ag0vcxlviNnFv0fFiOvBse+DVOPIyTuRE0RMeT5acgAnmWMIkfHgyY1FZphi57EfwwkJZgs3siTwLE+/Mz/j1l6/49cs9J/OKpi7t9Gdbj6kUF6sOo0pXaq5qPjiZsewsi1qzOUy82PaoKPxgtqaympvJITkx04pmdqfifyvhSxcp5fzNOvRHqZmAUopFN+dPvv8j/sVPf8GrmHEhMzOWd85X9JXn8dM9nS+yHldlgsoMwFfjgdNlRzKafYochol42HGvs7ycep5uD1yNEzcpEI5yyvhaXRQhe2EmmRzgo1XL0lrGEHmy7Qk+s7CaaIRtTHwxTrzXLvj582t+Rc9iZoruNAlPeoexmYt2QYpl1qDNwjvdgtNuznJZcXs48Hi7J8TM+7Ml1moOyaEQamNo8l3C/3bimw5n+d1rOU/Z/7IWqq7jf/Pj/4x//tM/IzHhKc61H64XHCpH/vKWVTDURjFVCUdiJPOrw471esbcwJgmbvaBtNly3tU8Hrc8vt3z6jDyMrrj+pOjEZ1AEvIAs6xIDr530rGqLEMMfLU7EENmZgxJJW6i59Nx4IPZin/x6ZfYBKfrlra25Kh4sh3p5pb35guImRg9bVZ8b3HGveUJi05zfTjw2c2Gg498vFizmjeMzqFSppICRriLtxdZAVqOxB4QezwDQ0aSom06/vjRR/zsiy+5khEPzCvD+awh6oS+6mmjQimLN5mkhZHEYzfye8uObBX7HJimAV5MnHQ1V3nPi/3AzRTYiiNIxGhNPP6Tk6C9oq0U2cG7yzlzezyDpwFiZl5ZghV2OfHcO84XSz5/dosNBxYzi600EeHJPmIrOK9bSBFipM3wbndCVVuWnWF3cDwNB4YYeDhbUOniJ5VykZlX5u94wg//vib2ax+ajDaKSlue9bfoMHLRtjSrCp8TL/c7NvsRo8uwUCSXaoRSEOGr/ch7s4FKa05nLe92C1wohw1aMRylNed1TYoJpRUHH49T4pmeRCRRI/ioGJQgaB60DV9PI3NdoUVxahoumo6zuiWuSlI2NxWihUMKPFE9jw8DT7d7rFVYLawrzbKGaUrsx4lLFzgAVWXoKnjZT7zKA42UWu8u3skp3lZkld7o+P/m20miYJJGIzx+9Qzde5ZVTb2cg2Suh57t6Jnbihe5x5EQLRgFJMVXu4H35nvUWjibtfy4O4WYmEJEG8UhJQ4xc9I1uFAEi1OI5Fw8JAYKdcCi0UGjRGgxvFPNeOIPLFuLEsXaNjzq5pzNGn5vteKsallVNUYr+hz4wtzy+c2eL1/tsY1ClLCoLOfnC/wEexJb7xlzxhrLqq14Pux5Ng20rWVmDG686zK9lUgZ9LGdneBviCqw1lC1lk8fP0OHgYuuoapaEplXw479FFhUmhf9yEgqnVEFKsKvtgdObMv7qzln85Z32wUxRnZxRLRmDDC5zMncMsXC5O9DJFKIVZMvMhqLRieNSkIjhkfdjFf9yNwass7Mq5qL2YKLecsfrBesmoaFsWitGAk8HwY+v9rxGVtMX4o5K1Nz70HNMAXGEbaTLxcZqZjZhuthz2O/p7Vl/Q13kp63Eq/tBl/Ld96sPwWiBGMqrK755eMv0WHi4byiaWtAeNkXx+9FY3mxHxml+DtASdr+4mbPO11Pc6I4W7Q8nK8LMjMGKqUZXOLgI2dzS398vkNMSCrUhMF6EIVNCluM6zFZ83G14EUaaJtCLTlpGt5ZLLk/X/C/OD9nXRezrMpqBiKfbrd8frXnU67Q+0IhWtmKBw9q3OSYqorBeVJKzK3ltLFshj2fHPbMmoqVNQx3XjhvP47ADIB8HM4FsFrTKMuXzy7J08R5VWFWDQnYHoqMq7GG68nhSUdrp9KlfDLsOds1PFrOOZm1vNOcMOEoVg6GKQg+JE5rS0qaqBR9UoiUfHI4vjQbBYkCGmo077ZznrmeuVZkUSyqhnvtnGVt+Xg1p9M1rdYoLUwkXg0D18PI05sBozVKYG4Uixb6KdFr2E2REDMLbVloxQt34NpN1LYw+Yf4d3xoN1HkMeRvcJyvoSkqK+Z1xcPTGZvNjiEmHtZQ68Q2eg44XkRPmhJJgWQhUXT7DYZA5s82O7aS+ZGFtjNEFAFYa8tH85Z3moql0owqsdQVz6cRlxIHH/hVKMO0ymSmEJBY5BqBzBSEawmsTMWytrw/rzAanlRCd2zDgKAyfDBvODeK5y5wkxxBKU6UxbnM1gWcZF4MDp/gvGkYfWDvJzTQKsEKuHzXT3xb8eaMA34z0RJRSFbM65Z3Ls642r8i1okTW1GbYiW/yY4XoSePpRKmkJIsJaFCkSL826sN25z4iRZOZx0jkJJmIQ3vziL36oaVtQwSWOqG58MBnxJ9iPw67JAEVIk+eNLxDZ+PLr5jTqxszXuV4d15S6M1qhIWbfEAkCxol/mgW3IqNVdx5CpOWDTnUpOcZnKB0TseHw5MKfHOYkEfPbfOIVLkZyZC7+80rG8lfkO7L6/ZiMdQwGrW8r0HF9ze3hIbuN8YjM7cOs82eZ75EZnkOGhe9qeUivQxkfmL7Q0H5flRFVl3hhCLDmMhhkeLjrOmZm0LyrCymmfjSKDAD75wh0IJNcLBF2PDYlAT2QbHLgfWteX9puJ7qw5dCaYRlm2RiJFA+cxFVdOeCTfRsQ2umIlVNd4dWe/bwJP+QMiJR8uWIfVcxwktQiWCipnB3yX8byPyawkj/PW5JQSF4bRb8OOHj7i9vWaymQdzS10ZNq5QRF6NA3mKiC1S2CgFrdglTQL+5eUVm+z5QyvMFzMm7/FTZq4M789nXDQN66aiD46ZrXnaD3gyY0p8erstJJUG+pAhRXKGMSSuQ8AMkdO64qxp+Xi1pK6FqslczCoWbQcIlfP8oF1yelZznSauw0RtNK01iNO4ODHsRr643eJj5nurJWPyPBkHFNBkQUXo/V3B422GpOMv8xsYjZRRUTGvG+5fLOjDntgIF01xYb715QzepABTuaCCFL1ITFgMEfhku2WSiNhM12iCC8SsWBjLO7OWi6ZifkyoZ5XhpZuKnDFFHoc9OgnRgk+R0ZXzN6XMIQVcyMzrmrk1XMwrtFYkk5lbTWMMJNARHlQtp8pymzyH7NEoUIYhxnLxzWV+zpE5mbUcYmB0AZUVFoVKvLkU//+L72zCD7xJ9uWbWgMoYV5XXHQtDzrLk+cTLkSyKXq6az/xcprYh4DKFMlBFqao6EMstVol7IbIUymtl5vJcWFaUirVzE0IHELgIAEl8HDW8n7bEnIhSNSiuR49606ztBUuJrbOM4XM+ZHNqrQQc+SL2x2tNeUCI8VV0IhQqYTVFZ1WHPLA5ZDZTo5hiIyHCAJOEn2A2hhOmwofQZSGEOljREnEp7vN5m3FN0Wt16iK18kXzG3Ng8WCR+s5z559xegDpxJJ3rH3Iy/Gka13SNasqwpypveBzRhIUkgT297zRA5Igu0UuDBNIZIEx5A82+joU0AB7y1mdN2CicQ+OCqE2zHQdpp7tiHmzNY79j6ybizvruZYUWQyX9/sWFWu0DCURquC3xQUSlUstGHsA8+O8rFhSPRjphbY4th4z8zUPOhaXBLsoFE5M4V4RNndrcG3F6+rHfmbX8C8a3h0suSD8xWffvaMIQUeVAnnHbfDyLNx4DY4TNIsjGGeYQiBzeQLmEAL2+B4Jj06wX4InClLjIkxeIYU2CXP5BQN8H5t+bDt8JShNxOFQ/DMGstFVZf15zyHIXFSWR6dzDBSBLdPdztmtUa0QmuNMbqsP53BF1Z6GDLXg2PjPHu3Y3CZWoR9juyDZ2YNF3XNlAQtIyRhCokgGc9dwv9WQooO/q+FKkOTy67m/bM13394zqe/eM42eN7phDg6bvqBx/2BXZwwXlgYyxLL4CM3oyvgFau47T1fqgMZeOUcD8WQArgYmSSyzY4pJCzC9+qWpa1xObEPnhbY+UQ3Ey7qlpQzG+eYBs+ZVLx/MqNSGqUyT7dbFo3BWE1dFXdgJYJRBqNhZiviIfFqKLnDboj0PSid6IlsvWOuLY+aOVMM2HzAx8ToAkEnfLpbf28zSrGD0lwyBcASY2ZWVTxYLXjnbMXjJzeFUpYzyUUOo+PWO/Y5oNF0xtJlcCGxn4o+PyrYBc8LPYAIG+dZYkgUF+ZD9AwhMOUC3ziXigdVSzjCDEwCFyJNo1nbipgzB+8Zp1LsOK9bjFZkEi92O7qqVF70UW2idEHHmqzolKKPkZsh00fH1nv6aUIwOBJT9FTGsGxavFKoQVAp42PEK8Hzd7zCD98k+/BN8iUaTmcd7ywXnDUVX8VELYpKG1xMuJjYuUBOiaAK4YGkEMrEfhaKW1vM7A+BJ3EoFB1TppyviVx6xy4ElMrUUbinau7PWqxRrKtCxfhic+DevMIZ4WpyxARaCY+s5cPVnCEHnu9Hvtr0zKuKuhbm2dPZSGVKO0dE4cVQiRBCYjM4LlPmhXYsbeHAGjSnjZDqhJYyXZIT9LlcRr7TD/DvemQpQ5J/U1uWMyddyzvrFRfLjsePU6ncKyGnhAue7eQIqQwKnWuLOZqlDjEd2daZFDP7g+dxPHA9THxUzwHYKscrP3LjHFGENige6oaH8zlzU/SJZ7bii23Pel4fKxruOJSUedS2/PBsyRQjTzc9X9/sWVUVtHBLoLWJ1iiUUTRSuOnVJIUkMDhehpFn+5HTxjDmSAbud4pExIigpLREhxhRufz+Lv72I/9mUf+I1nwdZ8sZ71+sub9a8MkRh2m0IadCKdlMjphi0VSrGotgKNSndKSKJeDQe57GnpvR887RvGWnIi/dxMZ5RGCGYima+12HNhqfM2tr+XJz4P6sxthSUfMxkXXmYdvy45MVQ0w82R34+mrL0lqS0swkUB/XnzGamowYRT2OxJi5GT1THHnVO05qyxAiooT7XUuuwYpGZTlWcwsi9E5C/XZCfmNu7ptPFlLKvdWMjx6c8u69NZ/8ZSHw1LoixYD3kdtxJOaES/CwbqlR1EExhlCkPUmIMbM5OL5IiRfTwGA6ADYEXkwDV2GCqJhjea/y3Jt1iBKmFDivDZ/dDtxbWrTVBVWYMtjMu23LH5yfMOXI15sDX7zcsqorsMKtc9jaFqJfJbRKU1mhGxTRJy57x+AHnumRRVN8IbSCh21HshGTi/MrqXSWVE53FP7/GHGsdYgRxGdI5Qx+dLriYr3g6y8zKoNVFp8S4dj5C2SCRGa6ps6CS5FALAO6qdDLdmMgM7B1jgvdALDPjtvgOYSI6OLcu1KGdd2gtGKOYa0NL6eRk86QlLAPnhgTaLjfNTyaz3E58eow8Hy7L/RFgR0eowyVVuijZDOLLheIWNDDLgdu0bS2Kh4qwKqFeZ3R6ht/oCmWAqR8yz3wO54vvh4TOib9WlBa8WC95v2zcxazMnyz1g33liuSJIZtptrvqJTmJnn6N9PS0FpFUhB8Ma0hFZSEQvhiX1i6tzni8hGjSOLg4c/9FqM1Dxcdi9owy5Y+eVpt+fVhy9NhJLjM/arhftsUlmpK7EPg+TjC6Okqw9aGIq1oKoQyaZ5yZvSRPoQ3ldIxB3KMzGNDkozz4WhjXhw2s06olNFA822f9F38Tw7J+ZhkfVNZRZVVebFa8t79M9brjrauWdctZ2dzMnBzmzD7W4wyRd7gNRYhKmHWWlQSejwSCkpTIuic+Wy7A+A6OzyFVx6BKXj+8nKDMYoHyxlnVQM24Qx0yvDJfsPTw0DvAmtd8XDdHK3IM1vv+eJwgMMB22t21lNpxVnXIoBRQpCiVZx8wKdUkLQpcO0zq2QJOTKK51oPZYbF+TcND5WFhf6ObyN/RyPl4tRYkHSv5RQlHp4t+ejRBav1Ca1uWNSR8/WaLImNydS3G2oUmxTosy/+IjozmxkICucjLkZSLC1oEfj6UFSpN6k4WKbja9gHhxozRivumxmnTY3SFZNPrKuaXw63PO17Rpc404b7s4aYFVEHNtHx6bYnZ+iOA+DGaM7acrDqnEnG4FJgjJFw3AMHH0gSWSaDz5mD8tzaoST6LpJUIW7orJipu/X3NuLfKxY9rsFHF6d8/P5DTldr2tqymM24d+8ELYmNStRXNyCKXXL4FFBKIyazmhczpL3LuJSQlJEIEoRfHcoZfBkHhlyMLZFEHwL/brrm7ynNg0XHedMCFT5nurbik/0tj3c9h6nsf4/mLeqoB772E395tSEnoe0028XEf6ENZ10pWliBYMD7wOADLhaDoz56UowssyW6xDY7nsm+kKyCw+kyT6BFaKu7M/g/VkQlEDMqwsVqwbsXZyzmC1pdM1OJ1XIFJLYqoTc7OhR77Qk5oFBgMovOAIreJQIBxfEczorL4bgHeocTSBpiSPQ+osOe7yvNma2YWw2twWloNXza91xPIzFGVtpy0lakXCiR2+B42o/QQ62FySb0iWZRVYgc80AlRF/eE4FEpiA+c/TUSREjTCoy2KkQIAMEK+SYMUGov6X95Xd8pyyV0KzK1qNMKfF/8GDND94/R0nmg/UCksJlT0iBlCI1iiww15abgyenTGOEVWXwCgKgk0KJYm4sP1mvqY5/4p9tborJS8y8PEQymedh4pPbHY3RrCtDTIn7VUcUeMfUiIaNjviYUEH4dLdn6x2HGFG6oEVz9FwR0HrNvLLsfeSnVxvuLQyfHib2IZKluEuYpJnINJJLK0pbquOtrjMGjyLpWFi08U7D/7YikY7zI7/xM5aydj58911+8P2PqCx8fH4PUOSY8NFDzHQYsmScNbzYjeVzRrNua3LOmFAun5riDPmjixUzbclk/vTFJYdcjK9ud44IfD0dqG6Fpq44b+dMRE5iRpNYYthjIGeCT+gIf/Hyiu0U2IWANgVCrILwMg4YJawrSx8CP7+95aKq+Px2ZJsiSWdUEnSEwUcaKSZ1M21YVWUNXu1sIfpUGaUU+U7C/1ZC5fKvv85KKfHxRx/ykx//iFoJP3z/omBYM7gQjhrVUp01CM/2I2RoK816XqEaCCNUQSFZqK3hh2dLTnTZb//5iytMjJDg1W4kZ3gcJ/TtHlMZ1l1FiJp7nQVKtWuJRRGISagw/OXLa27cxMY7tBZIkFPmxTSilLCoDIMPfHK94WQ149eHgQ0BrGCSkPrMlDJRCVaEWTasVE0GOl1c0ZMprXGJf7MMfRd/G5Fz5jcdnoUyiyQKfvzue/zRh9/DWOH3PjhFaYUSz+gD7mgYlHMZqvxqMyAIXa05ndeYLFiV0SGjsqKtKv7o/iknqoh3/5snL1HJIwquto4cM7/u92gNdXXGWbcmRMuytpA0tVfMUzHOTD5RAT99+orLwXPlHMqoYtyUhK92E3//oWFddYze88XVK7q25s+3B658IItgtICDaUz4KiNR0WK415T1d9VP9CqTVEZp+c3Rmrv4W47Ma0LZ61HbQuiJHh6eP+Sjd9+n1pmPHp0Tp0Qk4GMiJkEfNf8tmpf7CbLQVoZla7E5YwEVVZlHs4aPz9ZvEue/vLxmSkV+ezM4Qo48G0eUKJRZ8k5tiVGxrGt0hJUKBBXpI6SkAMPn1we2zrFPESqFipkUFbd4RCm6I1nvq+2GZVXz5DAwJI+WkhcQMhOBmgqFphb7prh2qxUpCUlKJy5+yzzwu53wSzFREKPRM+H95T1WTcW95Rx00Sefn7boGElRszk4zk3if3kmDFrxs5c3pCYVx7LjG7mpNFpHwhGt6KtMHyc0lr/cb/BTpjm2Muczw2Fw3FcFm/mnl1f8s5dXnFaWf3LvgkUNf7i+x0eLwIvxwBe7HT/b7Djg8T6jRXFiDZUpwyDPR8f//fHXWKtQGYaDQ18pLuoaJJKP9uNKleESg9BUMBH5dO/pcVibGH0oE+dZCibyLt5e/AadQkT4+NF7rJoZ909XWJVQIXKybNExILRsDgfuNQ3/+MF9buPIJ6+2VJ0wpbIGtVa01pAJRF0GySed2E+Bzhj+cn+LSpkzZQuSsU3cTp77dUujDD998Yp//uQ5J1XFP350QWdq/vjeQ350Enk1DHx1uOWT2z230ePHhNWKB11Fo8oh9vn+wP/ty8+xVmOAw+SxynD/pEV2gvgy5C5HMrsAs65mMsJf7vvyXmk1wUEOpRrr74bW3lq8vm/K8Uf84TsnnF+suH9/BWR8CCxnFTpEUors95m5rvmTe/fZ4fnLV9fYNjPFVGY3YqE5JauIdSZKxpuMmwKxrvl311dYhPtVxWvzrdt+4l7dMLOWv3q15afPrzmra/7hxTnGaP7w9JzvrSNXznE1jPx6v+eZG5hcpBLFo9ZSGY33gceHkf/H119gdemsjiFjt1c8mrXYUePcbxQxEqBg1dUEI/z5ZseBicoKo0/FbTNCvBvafTuRUtkBjkkFCr5/75STdcP5eoHPkAbP2XKOEEnRcnB7Frrmnzx4RB89f/78imau8TlidMFRN2gcE74GL5nBeqZpJNcNP72+ZGYU57YrhkVT5vowcr+uqY3wr15c8k+/fsmDquF//egB2ij+5OIefcxcDY5nhw1/td/ybHAMU6TVhu8vaowFcfDJtuf/+qtfUdcag3AYPKIzHy4X2CSM43FAlGNz1wvnXUM2wk+vN+zFo63GH5G5RPDDXcXjbUXSRcYtGpQuSf89vWB2ry5d6pALSWdVk8eIB0I/sbSWPz49x5H45HqLdEXOoyiPrdYVvvIYq0gCXmec8xht+XR3AyoxN5qEMMbI4OBeVTOrFZ/tNvzVzQ0ntuYnq1OMFj5ezHi46LgNgdth5PObLRs34X3GKMVZVWMrIcXESz/xT6+fYTbFU2f0kVor7lUtalIFwJFAOUhVKfV0nSVo+Gy3ZyCiK413kSSJSYrL+beJ727CfywuJAXaQFbC6cxysZzR2kzwPTEWu2utNJVOLDpDa+dcxA5H4tPbHftQDhGXEkHn4mwbS3u6Fk2DwUfFTQw83TmSQIMUA6+c6LRlSJE45aKpN4plpagyBCe8yiMvx5HrYeAwFo2zFcFLIqVE9ImoFJsYya8xoa5UjoPALCh6FSCXgUoBwlQGSqY24tBISkwp0KpSYemTIqSEqNKKv4u3F3LU25dhbzhfrri3bGhrjfMTMQx4X4zitPbM64pGW04XiSkOfLHZowYh+Vw6R7Zo9wcJzFpLrTULpdEZbpzn8bYnq0yNQiUhZJib4vlwPTqCZLQWlo2lxpBj5rHveTX03AwDh8lTa1CeYr9NJoZEMIpr50hWcCnhQirkoJyZCQxjQBLFkpxMChBUJtSpEK5CaXvXoqm0Zp8KCShJPjYg7+JvO47O6UChmyiBdx+sef+dC05mDdk53DSio8YYGEdoTcXFXHPWNbg48dn1LXsnxJAJOXCbMr4qOv+2MsyMZaktqMS1c3y9nUBnalWkRGOKnGjDFBKb0RHJ6KMTaUya5GHAc+kGLvsB5yNGZ/Sx+hTJxXUXuHSObHM5lFOZ//A5MQuWvQvEVDxXEkeXcjKTKaS1nDN9CsXlFI1PmSnHo/Tybv29jUgpv6l35OOBfH7a8e79NauuQVLA+54g0GgNSVg2LbW2PFwExjjyyfUNu8Ez+cSUIXiHbwy9z8wqw6o2nFQ1JhtuhsgXNwPJwmwsl9PJR5ai8THy6jARNKVwd3StTzFzJYlnw8DL3YHRRbS1oBxZFYO4KWSyCK/GiWxhyongcvFGkcA6VWxGXyhVqpzLyhWnc9em4/dJDCEgBmaVZe+K8+9R+PbbfEy/2/Ga1iIgqlyyzrqW1WxBVWl8GiF6UgRrNNl7ZkYws4ZF2xHiyGebDdElQgByok8BqozLmSopZsawNBUiwt5NvNxMxDpTZ4WKUnCYpnQkwxBJKqOVpjOlqx4jbCVx6ye204QPmUqXmSmf05HcAwHDIQW0EmJKvL4m+piYJ8MuBXzMxxWVMBQpT7R8swZ9IqtCJyMUf56s8/9wuP7/R3x3E/43OLDjryRIFk7blkqB9xPBB8YJuq5MUWuVEZOpjEZSGegqCOtMoGxgznkQIbpi/e1ITBKK5jllrCm6VR9h8pmZLa67E7lUaCk/+L/abADYSzkUfQggQmc0J8aw0Y7eJ2LK5BxJStAolHrdpgKMYhozo0too2lEiDHhjqxjI6Xl7lOxTzaimWIixszcVDRaEe70FG8tcj4afAhvhteMZM66jlaE5D3BBYbJYa1GRMrUvRasqbAho48nZsrl8MkxErPDmwyTkA3UVjHGTI6BEAtCzOdSQZ9CYt5o+hiZFGgNcym1919clzV4qwJjDGUNkqmxPJwbbibHGEo67iTjJBc6xZHe85qp7UIiHBxKFDUal0tXDChyIBFCSkwx0VnFYYpMPtJojTWK+C03m7v4nxb5qC19A+qRwt4/m8+pBYIf8WHEp0xlVeHsS8JqqK3FulJder1+Y4YxRpLLRIHsSsXMa12wbrHIEkWKK2qKxS18biz7FHApYZQwU5ooiV9vt0Ax9OqjZ/QeydBqxTtdw6VzhaCWwalMpFwy7XFPT8e/0xQTfvCIhkoUnlSoE6+9UxBCzvgUabWi9wHnIrUtl890l3C91SjSHiBnrNHcXyyZWUWOgRQT3kcabRFV9rtGa5TW1B6sLvtHQog5kUIgTqngpB1opQkm08dECIkpQQqZnFORNLjIiVZsQmT0YLNidZQ+/mJT1t/BFnLP4B2ShSWWD7oZl8rhfUm4RjJjTohArct7IpJJAqNP+N4jIlSi8TmVIoYIldUoVc7giUQjisPkGFygqXQZVL6jRL21KDMe6Vh4EwgJbYXTtqFWmRQcOUZ8FBojOFGIaKzOaKtIrsKqQmbMUubahhQJPpGkoLJ1znhJHFQg+liS7pjJJUvHx0SjFIcckVTcxuei8DnxtD8AcDAFiBBDIGehtZp7XcNGBVyKlKJNGSJWIiilSZLLOSvCkBN6KhKxCoVPEKX8vY1RyHH/jpLQWuFDxKfMzJbu6fgtpR7f8YT/9ciukENmP4RSFfKRgVQqR1lQokES+XXF53hgVapIc7KUieZExsdE21hSyIw5ss+eNhWLcCFTizouikSICadgkuIJYHOpOty6wMuxJNrRlKnpWiuWleXUWs67mq2feNFPXLmA1UKVFCll8lGuE1NC6/Kg8bAwghZ5U0lWqhx+KQsu5WNFKzPl8loumpZ1VXEY3W/rAf3uRz4edvDm4rkfelQ6I3jHOArBe0KKiG4RlcjRkcgYCoWpOc5wICW5joCPEVtpplBmRSQKTfJUUi6uVhQpFeKU9xmvMyMJlaFK8gYD++I4ZOmahOgywL2qLGtTs55bVqPj1TCx8aUyZZQixNKFepNHGmEcMhIS80qjlCrJlSoVMKtKJS2khMsJm4W9i0V21NSc1M0dh/8theQ3QCegJMfbw0gMiWkaOOQyWJi0QhuNVq4MK+biwitiaCuNjMLx5kkmM8aEtRoXI+IElQUboD72ExQQE/iQCCEzSGYkIlmosmCysAuOl8e9JxQpP5XA0hjWtmLRVszHisthZOs8YgU7KWJM6Nc8bEq3avQJQmJeG5RIwTaKICpjlSJl8KlcQnOWMtCb4dQ2rOuawd/pGt92vE7696PDiCZ4xzDsSTGDMihTk9NESe1BKY0Ww7yyqGHiNcomkAmu7H9jjCjnMaKwUWMVKFFAIqSM9wnnIq4RBin7X5cEFwoC9sVU1t9UJTh2RZfGcG4rlk3HST3xqh/ZTI5gylqKKWKPeUGK5eweYzzufxZ1BGkkVSQktTYkKAqB12Sr0ZFS5l4157xt6J3jZ7+l5/I7HzkVp79cupxMmUN0KMmk4xlMlpIwaQ06FqmpgKiEEkVrNTqUvIr8uuuYqY0mHPNAg0dlMMeOghzRnylmQizeDyOp7MVJ4clsfWAXyxo86FKgqEXotGZuLPPK0JrI7TQxRF8S/ShEElo0kI8UKGHyCeOhUQY5dtmD4ngGF7O5dAQpKCDETJLMaV2zrBu23zIP/G4n/PnI0UxC8okXNwNPznogMLcKawy1seRsSLknH9vBIUcMmvPW8uSgsEqhBEKOpKQ5aSq8T4w+sZsCOsDprMZImboPuZjIKJ3ZE8GURCvFglXMOfLQFoTYbR45ZI9gedg2PGgquq7mPDdkdWC7OzCrLMkXp7eQ1JEQJFS1FPnEsYUdAC8gtnDOc6YYOOQIGUYH2mZaY7hoWi66jls9/Vaf0u90vMYg6jKoJkp4+uqGe/M5WTmWrcUkTVM1qNqS4/TmihrxaA3n847H/YjRgojGU1pxJ3VNCpnJBfaTw0yZB4uaWsCqom2OR3rKJnhULaSU8T6zD4WSc++IEJvSxETCGOFB2/Cwm7FqKu63iVrvmXY7aq1JOeNyKtX9VCoG1pYuV0YIUi4mSWV0RRkETWUzcimRE+yn8prmreGdxYwH7YLb4e7S+bYiHwcmy3+Ez5/dcP/8FTEOrOoKayyLpkZri6gJY8qga0oZpRUXy4an/YiPmixFSpNS5qSpSSEWLvXgEYncm7fURiMq4UIkxTJDdZs8YgSVisyhz5FrhOVx/Q25IGi10dxva96rF9hOc9KAUTuGtKUxGi8Why8FnFQqr9aWCyY5H7tppdBTTHYEdTSgmXLpFAwuogTq2vBg1nLRzrhxd+vvrYT8Bof/2OL88uWGxw+2WKPYdlsqY1l0S3TTkNzVEaxBMUbSiofLjq8PPVUUkhQpagxwr2mPVcrEbT+RFLy7auiUIZiAi+V5a6W4igHdGUwul8FdCMQ+c6pqAKYQ8SohxnCva/h4MaetLQ9Dxydqyy9iYlmViqqLqZCpcjlzG6twADkjucxpiQjKlsRKJU0fE+NRVz25iEZoa8MHiwXvLhZcHsbfxtP5TyIi5bIpCJIg9ZGnacu99RwlxcnbGsu6q4miQSaULXNAOUHSifN5XQyzYqnqFzWH4sw2uFioOIfgISZO65pK6XKC50TKGaWEbY6IzujMUZKbSRI5Neb4OiM+Z5TWnLYN9+2MxhiWuihDng2Rma0Ik2OTHTkm0jHFtQZyLOdxipmsy+yCLkhAQDP5hD+ewSkWT6fOCidNw1k3x6hvtwa/swm/5Nc+yoAHkcx5Z9ncbDncZlqrWLeW87pCll1BarmAlsxiZshYfv/ijGGMTCHRp8SXw4HoQTvF++dLbtzEZT8QNfzewyX/p/MP+Ndfv2DXlzb5zRQZQ+IKVwoUGTql+GjW8OP7Z5ioGQdPbaGtVaFZ3O5ZA6GCXYwMUyZmx0e2YBCvRk8+Wga7bWn1VEYKOUiExmpcSOAVMRaTk5RgSgFSYNnVXI+ef/HqJTpC9ndyircWr0XUCTiO+yxqw2G/4ZPtLUbBSWe43y2w04J9Ckw+YMisG0MG/vjhfZyPjCEyhMRXmwNeEtbDB/dOuJwmXhx6Jq34/v01//V//n3+7dfPudr1jCGxd3CInuvjGjRZmCnDB7OOv/foHYzWXO4O1DqxqjU6Kz653BPRiMBhitzuHaYRfnDSYbaZ6ykQcqYGpk3GKo1uitZaZUWrDNOxTZ2TIongY5GukSLNwnI1Jf6755eYeEme7lrabyPyaxSnHJMolZnVmsuX19xe39BWwllnOa/n3Os6DjEw+YhI+brs4I8uLnBjxIfMEDKfbw54k9BR8b2LFZfT+Gb9/f67F/xf3j3j//Pp17zY7hhDYorCzsU3e6AGZlrzYTvnJw/PAcVtP1BrWNUGneGTqz33MGQ0B++5nRxd0Pzn6zW/2G55OThcKhLHaYCmFow1BA/kIqMgRnKAFAvEIKbIGCM5ZNqVwQ2Bf/XqFSq9It8Njb+VyDG/maUTLYgVTucNt9c7fna7odKZ085yv15ybzlnkIjzAUtm2VjiBP/4vYf4seAu+xD5xc0OLxmtFT+8f8bLoefZYY8zkd9/75T/8z/6Mf/yl1/wbLNnihBQ7KPja+fRWWFyYqGEj2cdP7i4wBjL4TAws7DuKlCaz15suBc1gcjtVDqhXRD+5GzNv7vZ82IYial0YadDxlRCPVNEXzC4nTaMOiAeQgooUUfDrwBjZrbSbIbIP338DMVz0t0Z/NYiRVA6Q8ykMRN9plaGVy8P7DZ72kpY1hV9M2fZWZwLuFiKUo1R6Jj48dkpfkpMTbm4PdlOb+bO3j9bsvWO63EkaMVPHp3wf7h3xp999YSrw6F4N6HYT6EUPqIgJGqteDTreH+9LK9zjNRG0dQGyZHHtwOLKhIoLriHMeLjwA+WKz477LkZHKRMnWFMpUFRd4rkC+mxMZpRxzK4G1OR+ZLYE9AR5mtDP2b+7fNLJFwSvuUa/M4m/K9bF8eCDxnh+WYg5oxVwsEVlv4HJwtOug49jkRr0FLkNX2IPNnt+LTv6X2pCkG5LV72Iy+fDUeNtlCrxKEZuTU9u8HTh1RMrTTsXSRSbMUXurSrczbc3u7ZTYEHswarKw4u8vPLLS/CxDp4ThpDrYXvn8xoBOZGs8qWP7veceMdSgkhRAxCTgU9qlCYrPGpmB1NuhjfhBTBgRj4uGu5zJrN6PCS3iBL7+JtxHHW4tgezBEur/dv1lgtgk2JH9zvWNzrCNsdplJoNApLDCO/urzkl5e3TDmDUgwxkqfEFQM3LxzhaBLitOJwmOhvevqDx4eyaSmdcH1ATNEg1qKYK0N56yYu9zsaJcy0YZoSP396xeeh5zxYzpsGUym+d76iMnCvnnG2WPGvX77iahxLdzIdh4NCQqGwckzEckniJ1WqCTFmxBeTrT9eL3i2ndiOgaQzYu8mx99GyBvnrfyGFrXZT3SNwYhiOICMke99vObktIXDQHNEVBbdPDy53PLL2wMuJ0QUAxE/RrzN3L5yhKN22uvIZtvTb2vCUSKTFYwuMKXIawhEozQzXZHRbJ3nVb/noq6ZG8s0BX7+7JYvw8hpqDjtaupG82OzZG4Np/WcP1nP+O+ev+RyHFHA1AdUKDb3KoIWjYjCEY/GT6X7lGOGqdA6/qBb8FRGtqMrmtY7csFbjGP3JUBCc7nZURuFTWAzxK7iBz854+xey9W2x+qy+4EhZ8dfPHnFz15dM+WIEmFygeCEKw7cuAEXinSn1prNpmdYDnifiBk8kTE6wjHpSSnSYOjEEqLgnOfn16/4eL1g1rb0LvHzr17xy7Bn3dY8nLfUjeL3zpesKsu9xZz/3dmC/9dXz3k+jGiBHAI6K8L0zXzJa98eEm9kFSkL4gpl6B+cnvH1YeB673Axou3dGfz24qixee2Jk2HyEy5awiC4AUwtdKeKk9M5201PddT8ixL85Hm8O/DlpmeMsZAZKUPbTnsur0dSKl4klVJsto7DbCgGWkDKZX7SJYixXBM6pZmZipzhNg683Pd81CypjGbyjs+vtzydHPO24nRW0cw079cLZtowNxV/0NX87NUNGzciWkguYVKZMUXzJg90R/rYdMxAfUolD9TCR/WC5/7AQSLZgrXf7qf5nU34ARBFfs1RikVn31WGhVGYnLFJOJt3THkiEomSy3BQTPgYSS5SkxmIxFx09FGnUlH3mZCKbKYQCKCWxMoYLKWifnXU6T8wNcYINYURvR2Lff0+BvbJc+5rUhKeHEb2OmCDMIuaU2OYVZqcEyMRFDxsLedG4VPk55XnAs1EIkuxf6614Uvn0Erh3Tf8E1srgmS+uDnQGYPKgsTf0Jjfxd96vAYEQGkPSoSqtdRtxcpqTCxDYCerDgmpSGBioZOMqgxsWwd1pTl4R0gRrQXXQGt1kTLEkugIZUNRAp3VJAxjTNyEQNRwog3GKDoUbdZMLvCLV1dsw8hMGVa2Ikb49X7PRhy1USxMYl1VnFmLSMIRQME784Z71jKFxC/Zc65qHIkYodWGyii2vccoYZyO+mjJ2Lq01H95uaczBomlLc7dpfOtxRsJf+b4DBTLeUenFPgAkliuOnKKpFicHuU4FJYJ6JypjeLgQllfgK4VRlRhN8fSOlbHjmpW0JiahQUdfGHjA2fWopWiRdGIZgyer2+33E4jk/MMdQMJnowjt3gap1nayFldM29bEE3vivzw/XnDO22Fj5E/S1vuqZpBIjFlWmWwWtEfCr//4MLxdWWqVuFj4tfXe7QtAzHqf2AFexd/a/Fm/g2QjEiitUWX32mFhNKhPlt15JzQKZXhDyVEnfA6oZOitpr95AnhOJTSQlSQpiKvIeUy1eECOcfid9NYqgCHvWcXE2dKY6yiQVNnxd5FPtnd8vhwIOfMYfTkkPnlZscrmdDAujKcdw3vzGboLPShJFAfrme8N68JIfCncctD3TLlUIZylaEWzXYo668fA1AunnVXJEk/e7VBmWLIpFO5hN7FW4wiYSfHMotZt5q2MdRKo1Ik68Ry3iE+kuJxn9NleDeQkJDRtsinYyqzINKWxJrwmgpDodapgM2RzliyFSYJOF8MtU5NjVagjxTHyQeebSO3/UgVhSEXn4YXw8QhRKxWTFaxbirmM4tJikMhJfBwVfEgWUJM/Hy3Yy31G8OtSmm0KHZAFQXviicPqnRDvWS+2OwR+Q1s87c8gr+zCb+oXJx1VWGVkssbaz6zdEpRS+a00TRWse0nUkzHocTM9eBQCTbHTSbHckH0OZNIVKLfDPO+Pi4eTxNnQ8PCWhbG4FNExMAwslCarISlMdgMX+8H+pgZcuZpX4YiFaXtt6gs7jh0FFLhWLfaUlc1k5+wKuDlG+TZIAkrmkobKhFijCgFS6UYckkCUYIyQifwwFa0WvHMFUfguwPvbUdBoZpc9HSiDOtZw1xDnYs2tK40ftcj0WGPlJHroUcm2PiCe9OxYEliyigErVTRGVKm9EmKr4eBh4eJhTF0SuNSxkqFqAOtaEQpTq2lyYqv9wc2fmJMkQrhykxloDFGFnOLI+MShAitCF3VMKuEafJUyhNUBil42EECRiusFHqFl4SysJKGKQamUFydjFG0onjQtLRa89KP7IIn3VF63k4c5TxKKAY/ZDCJ89MlTU6Im1hYmFeW6bBHxVj2kJzYHRzOJbZ+ggRVUoQELkf00Q8ip0Q+Epskw5N9z/v7jmVtmVnNGAJGWZ72A7VoshTDthp4sh+48a4YLcVE78pQ75Azi7rC5Yg7DryhM11jqK3Be4fxDh8TPmVUhp34klwqYZKEzxmsMFcVQ4r4kBAylVa0WnNRVbRG8ypMbEMgyp2k521EPk6NKy2YShe6nI2slxULZbEpsqihazTTMKKSQ+lC9NruByYfuPUTkoVWbGHuk4o0kULD04Achym/2B54b9ezspa5KUO9hpq03zMTA1o4qYoN0ee3O263E70LPEsD/eAhwT4FVrOKiUjvA5OLzFXFsrFMyuK9p9WKIQpTlpJYSRl2L+CgMpwrBma6YggJ7wOiM7ZSNAgP64ZGw2XwbH0gyp2k8a3FayQnZR+U4/lUV4rOGBoxrGpFZy1+OKCJaKMIKbPfD8RY1oFkwUqZjRxDRKoyIP76PptzKdY9P4w8OIwstGbeaKZoEaXJDFRiEIGZ0WiBV/3AEMpc3Y2aShcVwefMrDU4Ii4EfNBkZam0ImPLuleeKcWCV4/QVxFz7M6GnAiSUUbRaMuUPCmU761N8cc5MxVaYBM9Y0zEb1n4/e4m/FpQpgzRmlQqAlESQWW8TqxbzftnLSIRjpVRDRxc4OmmpxXF1nvGlItmPsGUi0QjRXlTvS17TeLLcWKxHflo3rIwmpgzqqrZhUDypZJeW8XMaGpx7HM54HZT0SZarait4qyp2IaJGCKHVCodojQnpkF8YEiJ61CSqBzgRkXumUIHcEedai3CXGm0AmXKoKcXODeaP1gt2TnH9TihfEZzl/C/1VBglKYRg8+paOVyWWzz2vDBSYeQ8MGjJaN0MbN6sdlQxYqb6JlCRiWF5IyPhT/+WqlBFlRpMPFVP3Dves9Hq4621kQUbQ374PEpI1nRKctcF+O27eQIIXPIma3yaK2wRnHWNfQx4WMujr0JTG04qzqMF8a458o7Rl82khsSa12hpaAPw9Epc6EqjM40Wgqqk8xJVfGHpyfsR8/OOfbHjfIu3kIoymVfK4wtEkAXAyEnxAjrpuLDZU1FIVfo40VyN3lebPaopLkNEy5kDAVcMKV45Hu+rmyVZD8BX+577l/u+f7ZgtYqXMxoVfbA4IussjWamVHIbmDvAiFmQvYMKqBFoY1w2tX0YcKnzM55yAlTGU5mKyaBfrPlxTgxuoIIvcqOTmsExZBLkURZRYdFNGStCtJREifG8genK9yUGKfIIUVyult/byMyJRnXVmFrTcyJEY+XgBjLSVPzwanFqswQPOpIlxuc5/n1FjLchpGQiu7aAIN3EAqdqcCYMjqXj3+963n4csMPzlZ01uJSRqtCOUkJclYsbMVcGx6rA7fjRAoFajDoQkGxVniwaLmaRlyIbHqPJMWsUszbjilnhhB5PkzsXST7zMs0MbcGSYqYQ6FHGcVMVWSZaEQVhCdwXlv+/vkp0+SI4UCfEyncXTjfVoj6jREmKbLWPniG5GmVYTmreX9VYyQzpIAxhdo4jZ7rXY9WwiEGUgKTCx8spgABpD6u8VR+5QxP9yNru+fj5YK21owpE7Vh5zw+lI5irQ2NEa76kRACEoXBJXz0b/bA1cyyGz0pJYYpoJJDt8XRN8XM4APX48TkSk4xKs8MW/LRmIpLtdLUUqS7SnQBvEhmoQzfny0YvCOEhEvxW4OJv7MJP1ojunDo5ainGmPgk8sb3l93vHey4N6qZug9qq2ps2UcJi77ni82A8tKIwbEHC2WY2aajt8nRyTzpvKPyRxC4NPbPR8sW3SlcTFz8IHBZ7ZDoDWKvRT287uzju3uQPIl6W/RzKyhboRaCxfREFxglIQzim0YGSRRO8+N97zyHu8jPoEkBVrYOn/kVwgzNFkUSwsP2pp9ijwZJ+5VFQ/nC242t2RdaC7Gq9/iQ/odDylkHqUKu96lRH+Y+OXXt3zwzoxHZwsennWM/QRtRSU14+i56Xse34ysqlCqs0oIqgxfZ1+G4XwqEoYcS6sym0zy8PObLe+uO1ZVxZiEcSqJ0Qvf02VLmzK6rnlvMeNmV6b9Q0xYbZhVFlNBZy0zBHGJAcdgPPs8kZXGxsRNmHg+jkxTxLmEShqMcAiFtS4izIwhp8xMa+6vZuyD5+tDz7mteHe54FfTdUnMMjTpbg2+jSgJlyBGEAvJJ3Z7x3//57/k9z+4z8MPL3h0viT0I9EYxBj8lLgZPV/uRk60RWtFUhCOqOIcixRWvcYah6LRTgZ2MfCzVze8v14wrzQhe/apVO8v+7H4LuQMdcXDecduE0gpFWdIFFWlWbSKrlYsdUMMicF7phjY5UROFoXnxnleDBOTi7iYkCxMNiFypLJlRa1LRXmuDfeXNYcYeHw4cKIN7y3WfBY2oASb5U1l7C7+dkOUIFrACFIJ0Wf2Y+DPvnrOjx6ec//8nHfur2AKKNsiFsLguDkMfL45cE/XWK0IqtCdMpBTWXOx1sSUCnMfwMBNCPyb57e8d75mbi1xivQ4epd5MfbMlKVFU3UtP1gvuX41FYSmjyCKtjHYSrNqKhoEXMJ5xyUBt3G8kzSKxPNp4svDwDgm3BRRphQDOZKgRKDVGpWEhSjeX3fsY+SLvuehafjRySm/eHVN1j0aYZ6+u2nU70pkio9NiImY4LPra/TFKR/MOi5OW8ZxIqqabBST82yc5/k0Ma/Kswmp/H+RTFbpCOLQhAS4IivLtWIXI7++6XlvsaZSFVMoPjuHGDhMnlYpKpXIYjmfNxz2juzKvqoQ6kqhW6HTFbNG4V3E+UiIjlECa6nQ0bLxnuvR4abMSEBPpuBlOc7uJaFLGtFliPz+rGbMkRd+4FzXhf63KyZgAlTfssn0nV2pioSkCKlUokRB9AGvEn/88IR/9OEJRjmmEUhwGEb8NBUnPxcYgHXVcL8SQgoMBAblQUO2xflMayjPvhgwuDYx6xRG4Pl24L999oqcCqtXskFbw2LRkoH3CJAbtC4HaKUUHy1aHImuVbyaPFMOxBx5OUZ+8eqaEdjHWKQ+CpQFPNz4CW0VrWg6MWijWCrDuzPL/bYiZsW79ZxVZamriu+tZlz2A7tUjBzu4u2FACRIQb7R5/eBP3r4gH/8wzNq2TOOQErsDw43OdzkcS6wR1i1llPbEFJklMi1iQSbiVUZhNNSHHW9Kt9jqjPtvEKM4en1nn/21WMOIdIaRZKEsppqXpNy5mFsUFWp6gYKr/ej1RxNQnc1m/3AGAOTZG5d4GcvX3IbB257j3fltqtqgSlzMzmsEbpK0ypDrS1LLXxvvuTBosWlzAftknVXU1eWh6dLHvuJ7RS/ta33XfwHRC7yv/x6GDdCfwj8/v1z/uTj+1TqwKsJzKS57R0xRQYfmVxibzydLt4gU4q4EHECwUDUGWymUiXBjiRSOvKk60RQ8LR3/NMnT5lCoBXBZqiNYt3WJOB+8scZotJSrpXl4+UcgHsnHZf7ge3k6JPndpr48+EFrxjY9JEQEpIzuhYIhXmtrLzxHznXRV75QVvzYNYyhsh93bBqKrra8HC14PHQc+le86Tu4m87xCiUBpGCpFapFCcOLvD33n/A//b33qVTE5eXkRiFQz8QnWeYPJMLXJriVH+majwwSmS0Aa8jyRapqj3iXgOZkIStAVUpks486Xf8Pz99zC4Xt10AjEBVCoEP2w7baJIOBBKttvz4bAnKcHE+43JzYDMNbMLI02HgcnjGizhx1XtcKHhi0wITBJ+Qqqw/K5qlblko4cerNe+u5ww58+5+5KJqobLcO51RT3vyCHf5/luMo9yLAIQjuhcICX708Jz/4sMLOhV4fuTQ7/eeFDzT6Bmnkh1VlWFd1UwhMoSAQUhoki6XO2ULH/81lG8ikSrwOvHCD/zr65ckx9FPKWNE0+mi139YhTK9DvhcvG7eb+ckrVjXDdt9T+8CA5HbydFPA1dhw857XIaoQWuNuGKAaTQYJRhV/oy5Eh51LWetwefMmavptKWuLGeLBS/cVLqo37Lm9p1dqiplJMK7Zyf8ox9+xB+/9w6ffv6YyfXkbeBP/+K6VJIqg1caoyOhlGSpW0WF8PuLjn6W+NX2wCZEbCOMMfGIFqPK8MOoirnWylga4P/9+SXeZ/qQiCERdbkM9iox6YmmtXywXHIII5eHkZupDPVUSri9HugjnFrFay/TMtYENyowuYQ/ejcoVZ5Q0qU6Zq0iSWbIgYWq2evAlGoOQTO3moeNok+JaBKP2lO+N0WiCC8O/W/pCf3uh8kgMXPv/IR/+JM/5J/80U/44hef4IYdeT/xr3/6mLZW1E2Z2Ne6TJinDEortIYfr1e81wV+vdnxVd9Td5rgAw/SDBEh2sQkiUllOi10GP7ZZy/wMbFznkOIeDKZSFDCPetZLBQfrpe4ryZebCc23mGUohHDL663RBKryuKJBalH6VK88j1DiEypWM0rIygyYZ4xlIH3kUSSyKxquMVxoy1dqFmZig9Xlj5lokm8f7o+ttQjz7hbg28jlAIlkUcnp/zD3/sB/6sf/wGf/urXTK5H9RP/8t88pm2Ezhhyhq5SDL6sv6hhIPH73ZyHdcdnux2Ph55qpZl85CJVaBGSBpczk0o0KLpK89/++iUux+JeOjkcGa+E0WQumsDi3PDhak3/S8/zsWc/RbQSlAr8enOLi3A6DKQUismNlOrX43Cg9wnvj8Y4tsg1QwsGTX7N4idjrGbPSK81vURmleF7eo7PEbTmvXsn3PriIPFkd/htP6rfydAiKKV4tDrhH/3oh/zv/8Hf57NffUp0BzhM/Nm/ecaiURhryLlGW0uORfrXkyEk/sH6nI9nkV/ebvnssC/7X4rcp0P0cbhXEoPK1EqY24b/5pNyydx6xyFEIpmtgR7P/Sby8EHNB6tT4l8mnh427KZEpRXJZH5xuyeReb45MGRfKGIGOrF8NfYcXCD5MkegLCQUYZmxqQyx5yMesLaKrZnYmpptTixNxY9WdcF5NvDh+pxrF8gx8/V2/9t+VL+74YAI9+ZL/vDdD/h7H3/M1189JrsDso389C8u6WpLXRUsem1L4v1arz0F+P58ycN14KvDgWdjLvOUKbJKVTEqNJmgM5PA3BoMin/11StCzowh4adE0BmPEFXitEmcnFkeLhf87KuRq93IzieUUjRkvuy3DA4WbVXGcI/gGUHx1O0ZYyH+lT1ToXIitNCgCrExFwl5VQk+OoI2BFE0SnFhy3ypMYb325aDd6SceLH/dmfwdzbhn9mai3XH906XXFQ1u80NtQRsfZQejAFJmtoaQoyMU0QiGLHMbEVOGTGKtTI8TIkpJ54MhVF9f96hj7owlzLbFHlUV+yc51VyuKNbr3DkwCbBpcTBRXoHkhvWYonGc9lPIGCt5hAjOwIdNZmE0YrKKFql8eOIIWOSLjc6C9chEBUYMqMvvXar5Ij+zNw7bZlZgw+Jy3Hk6dCja0O7bFjVlnVjednftbPfVlRKs5q3fHC25r3VjHHzCqtHbCvs94FpdJA12hhiFFz0pJhRGGa2KkYhIiyblvOY2OWIH0Z81lwsuuK8B/gU2cXI92czroeJl94V63mkDJaHTBbwOXGYIvsxQWpZq4ZQJ27HiRgzJiv66OlTQcwpVZCZSitqZZnGgAnQRIVRgrKZS380LVKFARwDKAO6ygiad7ola1ORQuLVMPDZbs8fqnNmpw3LpmHR1HcJ11uKygjLrub99ZIPFyv63RUWj63gcPAMzmGo8I3CY9jvjzKxVCRZEkvStmwq7ueGSQXCkMgpc2/ZlDVCMb46pMD3Z3Oux4mXQ/EhkSSlgh/LXhp8Zj94tr1HrRSn2hBqy2aYSKk4RO9CYBc9FYLojDKC0QojmuFQBtTs8WtFwyWOhGBUJvvXZjkFQ6qwvDufs9CW0UdeupFnfY/UlvfbhmXXsDjUcLf+3kqYWrGed3zv3hk/Oj9j3F5T5eKavBsndtGRsSxE8ASci0RfzC1XpioUMkksupqL1LBjwh0CSlvemy2LJpvImCLbmPm9dVl/z/qBYmGojvN3RbvsY2LXO3YHj15r1nXFFGqu93t8iAiJIZa1LNUMbJlxM6JorOGwjRDBxgIfwMJVcETJGA3JF+pYVKXLr5Plw9mKdWMJKXHVj3x+s+GP9H0+eFCxnrWsu46v7hL+txaNaNZtzTvLBRdtx/72iio5lFGM/YRzsXS0VUVEEaayByKGuW2Yci4Y7cZwj4oggVdTworifNagjlbmPmXGmPloueB6HLhyrlDM5I0nPSkev270TJNHoZhLS7DCzvcF76ngZvT0IWB06RhpU87bYi8iVEGTY0IpIRu4TaW3kFV+432BOqoLlOWs65gpzRQi12Hi5aFH1xXVesaysqyqiiv5O57wf3iy4sHJjPuzBvGOm9FRm4A/0k7IReuUiAhwGArTXDK80za8mBw7l6lNJiah0opVZai8pqvKtLXNQkyZFGA7xTLke6RYmNcmZxQOb8wZFxK7wfPqtqfRhoWuODGBIUVyglprdsExUagSkjIpFt2ijxGTywGqKA6mgiBSXH1TPF4ElRCPmNDWWioNOx94Oo68CI6PJs9VfygGY7Wltd/ZR/h3Pj48X3O+nvNwOcPGiesXO2odCBlIiZwioI+6z8yuH/CxrMH35nMux5HBZ6ItHZ25tbiYsCmyaipECt4rpATeE7MUs6Nc7OmNkuMcQeGTJ8DFxG5wXN7smWuLMw3LyjOGSMq5IDV9YCKjSNhUmNmSU2kZBnmNMy6o0ePg5lGZcZwTLe8LEDpTUWvN1TTx5WHP07Hnw9FzfTigBBa1panu1uDbiA/OVpwuOx6dzKklcnV5Sa09PiZijMX6/aiNFhI3hwkXSlfn3XnHzeAYItS6dJxaa1n7SGMUy7pBBHQW4pEUgSrryx89GF4DAUQK0SLmyOQi28PE5U3PoqkYx8yqcmX9pYRRQvCJIQUEqEVhVeHHhVgwjYlCaFHxG65cSqXqJRR+djzKxLq6psrCzTjxdOr/v+z9ScxuW3rXCf5Wt/d+m6893e3i3mgcEQ5sDMaZaUclJJIFAiphgqWSPMgRQ2CAxYQReORBloRUA6QaIBhRJahGqhSlQgWVDZiIJO0Am3DY4biOuO3pvvbtdrOaZ+Xg2ecEVCbyjSTOjXDc8yhCtznnfuecb6937bWe5////XmcRj4zRm4OPd4YjrqGrnnJRXwR9bl7J9w9PuKNsyM6W7l4/JiFg1gKKWdyziA6XTJkbnYDMWWqCG8eHfNkmphKpXrw3nHUNJxlpTeddS3GGECYpOBSpnWOlGWmnahE8Zk9yGKUiR4Lt/uJ66s9p21DmpacNhN9yZRSaQzc5ELfZCiV1jhdf0DMhVCMeqmsrr86p6mXeVO0Rln7Mq+/1aKldYZtH3nnsOO98cBnhsjmMNBaw+kisHi5/72weu1ozdl6wd3FkgDc3Nxy5CupqJ5fitCJ+pEE2BwGsr7YuLfsuJrm/dIbjLd0jedIIKXCqg3K669KE7O2YKxRyXVV1qW1UB0w75VSK2MStofEbTNw5ALZC0chMRVNMXdYSq1MkrEYmqIZN4JKkXzWRvKzZOeq7X9KFawYbDU4DDLvw63zOAxDjlxMIzc5cpgmbgePM5ZVaGj8R1uDP7Qr9dPnR5yuFP9X0kQ/jqxPHTlZqBZrHcFZSlFO8xgj25RYOstriyVPY+T6EMnGcJMmesl0wWGrYaxlzhOxVNEO66PDRCKD1YAtbzWESGrFOOWcjqVweRhx4w1vnB2z9C2vLiqXcWIvmc47fLbsaqY1Rm+EsSLUmbluyFbItRDEzgEl8vxWZ5zBOacHftDwo6JovasUGamMKfFwnzgKns45TtrmB/iUfrTr8w/ucrJesOwCkgYOu55P3Q3sn31YKzjrnr8cDnFiP0XWoeFTR0fclMh2yKQpsU2RWIRl47HFkZD5sK1rrFB5rz+wmSKTLSyMI1hLYx3RVIyxGKMjxov9QBsv+fTZCUvfcX9RuB5H1Vp7hyuGAwVXK10GkwtSC4rNriQr5Nns6FH9ds26xp03ePfswI+So6jcxIkPx56+FIaSeH+zZdUGuuA4XX7E1I+X9T3VZ++ec3zUcbZqsXViv9vzxpljm2WWvhiMtfPhWNhOA7spsW4aPnW8Ypsjt1OClNhIYiyVzjmctxTmw3Wt1CrkKnzQH7iNiSiFxli80U68OMEYBQqMuXCxG3in3PLW+THr4nily1yNA33JtN7gJstGMr4acq1IkrlHo82NZIQsBp+18xURTSsVRUAaA3He14c5Tn6bIpfjyCiFMWcebbYsQ8PKe8669gf3kH6E60t373C0WnDWNRhJ7DY77rx6TOq1E66oQ4uUgqGw6Xu2Y+QoNLx5fMwtwjZlchY2WTXLqxltneYwoWdXtUrhg/2Bp8PEKJnOWJyxNM6QrK5TA/Q583hz4CRaXrt7Smw6Xl8veToM9LmwDJarybCtCXJlKcphL7UipSJiiPP+F7KGDBYKUp7t5wZndN8DGCkEMVyPI+8e9mxrZpTEh7db1m3DUeO5s3i5/l5UvXF0zHLRsA4BV4VpnLh/1pKzPG92YAwpF6CwHQcOJbNqGl5drdjkTJ8SY4VDTYy1EpzDFqv4X8DPe2CRwtOxZzNFUlXEsTeG4JXZaot6PfskXOxH2rrh9dWaMTjuSMPNFOlTofUOlxx7ydpULoZkrEq8ZxNCpmIFXNZmoLiCZFWTuHnyn+c9MBah1so+RW6nSBJhSpmn+551aFgEz3H70dbgD+2BfxE8KWcMhdB5xlRIk6VMSVNwvaMxhv2QlR1eYZOEIQmnLrJLkTIkHqbCtUxUL9xdtDjjeLvfAbDEYSvcSGRycyhN1c7WylrEBy7LszQ9x20q9ENP7xNvnaxZLDznpiEboSQhi1Cr43IcWQaDyYYUdVG5YDG2km0lm1mjhSFmS0n6QKurSC00BCrw/uGWFsvtVBiTjqH2ktgdMnebwJF3PPAvD1svqs4WK4oIpWSsLSSTkeKoWZTM6R0N0A9RQzDEsM3CVCfu5MA2jfR95PE4zWuwcr7oCDi+ud8AcITHCjxNE4MkPI6AdvSXznNX4LpocJuzltsY6YeJMYx86uSIxcLxwHQgwoUIRQw1OR6mgSNvsdmQJ90Ym6W+pIe5gxGqhigVowZKMeqRN+jnoFJ53G/osDwdRg4x47JhSIkPhpF7acm6Ddzvuh/gU/rRrdO2o5RMyRFPh5iCzHjX4FWO0xrDflJZVqqZTYlMsXA3Og5x4LYfeDpkDiaBr6x8IBTD5e4WgDUOqqIJUxIqlkWFhXc01nJeA1dkchG8t9zGTD/uiFPmrTvHnHQNrnRUycSpMM1hgI+ngZX32GSQcQ6UWVukGrJVyWQFWhxZlJIhVcfnUg0l65743mbDAstlP3KYMqbqHvh0O3Kv7Vi1ntdXix/UI/qRrrVfImOhhsjCq6yLmrAidE4vm8FCP4wqjy2FmxyZqvAgdwzS86iHD7YTNzVRXeUEjymGb+yvMMBahfQ8nkam9GxSbljPlzlLx+M4MpaEd46rPtLvI7mLvH7vjJNVANbUCo/HgbEaajV80A903uKTwYw6SAprNfsmrwFMQZQGlaVgMhrMZEAQkuj6e3S7ZW8cF4eB7RihWvYy8eH1TuVmTcOby/UP9kH9CFdTHTlBaSo+CMEISIZaaL3B4HHWMsQJMAxUbnNhqpHT0LDPmalkntwO3BLnNdjQFMflRvfNpbXYWtnkSDJAtjShYl2gMw5v4aJMRISAYx8T76ZIzpHX10esOwc05CJEEW2g1cplzqzEqSF4Dn0La0G8JVlVAgQsi2Lo3ZzwbEDm/XESbZA8Oexo5nf/FJUkFaVwc5go3ZJl53mw+miN3x/aA/9q2fLOdsP7l1s2SXGBrz5tOD5ueCUETqwnDgbvWprG8+aJEILnUT/ytd1AUw2/E3uWPnDceZIRbmOiaxXP1GbHQZSLX2rlzeM1WRJXh0Q00Fu4GYVDEmwL3greWLKH9yRDE7hzvuTh9YFjlGTw9f6GTSpIgW0tGigSjIbPJO3mWg/GChOVCeEV29EHIUYggaGSgrAvhW7vWTeWTcrcxoR1ls8uj+haWDaBVMDKS8Pki6rj4yXfurninafX9HEiWuHO+0vOV4EHTceJC+z3GdpA0wQ+dyfQ9o739z1fubjBFng4HfAYsqkaSJMijfPkCMsCO5kYRUjAa0cnAFweeqIXnEvcpIldn6C1eGtpnIbGvVcibtnyyvERDy92nGd9qf3W7pbNlIDCdc46nWqgRKBXHaKxqHzDCtkUzmzDZGdEY56JZa3j8bjFXxvOWsftNHEzRIwzvHm04AvtCUeLhpSEDy5f+kheRL12d8nvXN/w9fcechjfoTo9IJ0uWu65BSfWMx4ytEqi+OzROUvf83B/4H98fI21lQ/7CYejr0KMlTFPLGkgwdIaDjUzVjWknQY9uG9z0ZaDqWxL4RCjGrydeb7+3hkGaOD+8YL4RLhrHN4H/s31JfucqEVDYbBgOnRt9Sr3MQ5wkG3BAfdsyyEwvxQNHscyWB5Nex5vPEed4zpFroeED/DGYsXpsmW5cExFMFc/4Af1I1qf+9QZX39yzb/44An/9O33iQjrtw3LVcPrTccdF+j7AdrActny46ctR43n/f2e/+7RI2zRQEtnYFcTE8LOBk6cp0ywNpZbmTgUDW87Xy4RyWwH5epjCo93EzeHiG3ALxxNCKQK35CJP79ccHrcMD684RXjWPolX718wu0cUrSVrHK0zpCmCn0lStHAJWsQKySEu7ZhDJWcVNpoq2NtAx9OB7612XG+CFyMI1fbCectn1uccXzH0i4axgI5v9z/XlTdPT/mO9sN3/zwQ+J3EhlYOs9x13JuA8dYxm2ktI6maXhr2bLyPZfjwG9db6m18nA/Ya1hMEJGKCQ6r93zznpiykxZiBXOVi3iKoeimHSqcNVP7FPGBUPT6XtYpPL+EMmN5WR1RLw6cC4W7zy/vd3Qx0K1sHEJ48F6S42QB5CSFXlrIJqKbSpnxpMDlFgxxcwSTMPlPvKoGThpHLspcXOIeGd4Zblm2Tb4xqq0afhopLwf2gP/h/stuxiRAq0YKkLAEwDJwlgz1ngWXWQ3TKxcwETBFyHlPHP8Zw10MnixuGpUJ9gI4iFkQ1Md3lu+0HbkvGB7kjXIIxVO28AejdguFWzV4AWphd+8esLnzBkuG1pjSN5xLwS2g77ELIZiNDDMorpBq2HOGvRQDa0LfOn0iBrhYe3ZpEwplmI9fZy4dYWDCGPRZQqWf3H1lD9y74S7UmiN5bx7yUB/UfXO9pobGUhOqNUQx0p75FiHhlKE22nAUTnxxxz2B1LX4rNlKYYrERZOP17eWDqgYAnZEhy4+cDd4FhWj8XwmfUJxMx9Z9mlyBCFI9OyJWlKX6kzd9cgYviNp4/5QxSyqYRgWBbHedOw3SUSFmdV453R9a7mA5UhWRSz11jHHzk5ohTLw+3AbUoIFilCSoV9jIzZaFqh8n74/15f8J8/uEeYtEN7f/2yw/8i6r3bWzbjQC4KJBhS5uyo5Sh4xjIxTCNNdTxoFtzuB0zb4FIliCGhxl2YADdv9IUgsPCG1CjBojWeM6uEizcXOlE4VKEvhTEVTkPLJiVCmPXOVUO8sli+9ugpP1U0Vdw5S+NbThcd11MC1DApoMhPp118g9KHDAYrlmUwfGF5TAUe9yPbXKjFUoolRdiaiX319FkxjkLl//P4Q37+jdd5YDytddx7uf5eSL13fcMm90xGZV77mDg+6rgTAofdyGHsWYXAK68eczOvv1AcnXhEEqvWwCS46mizx1ahcSh60EEvsHCBey6QqvDF5ZpShEOX2eTIfsoc24YbE+l8UOmrrQRnkWL59Yfv8VP5LuRKYxxtEO4sGm77iR413soc1smywgA2G0KwMzDB0FnHT6/PqWTe2Y4zeQfGYhlHYe8ju5TYxgROscz/l/fe5s9/9lXeMCtWtuG19eoH/ah+ZOu9/S37NCKine2UYLG2LBvDfjdymCqrxnPWrLja95x2LSaDzyqXds7inIa7tVkl3dYK3jcUK/QIXVASolT41HJBLsJIYMiZMReOmkBMGq5acwU7S8Gq8DuXT/mxfIdcNL+mcY7j4NkNCZvAWDtPjkRP20UNuhozqNKdhXF8fnVEEcelGbRhAlBAitAPeh6dcsE1YBz8i6eP+LkH9znHs7QOs/hoU84f2gP/40NPpbLwmjqbxLKPiamvuGaB84GmwiFpQFZ0hVSFVPUVl0U0PKiq/qpUoZcM6A0NKp01LK3jqGs5azpMa2HsmUpGrOF4Gbg28bmeT56FIljL24eeZCyvukBTLaUIR9Vx5gNbp8l8qQoVw8o6bq3+2iqUqJowaOHMO0IIrJvAPmcOtXColb2zjBRiNaQ55bSUxONBWN/2LE6PaBv37Az3sl5AvX+7QYzQAm1nCTYw5MTToXIaPCtnQSyHkunziBw0hn2aJVjVJVbOYUQ7SlGEIWaq94RWx8tBLMem4aRtuN8GmtDyZFC3vguF0Dhu7EiuMvPGKw6HDfC721tSrbzerQii4XLnJrBrG64kU52QZ4nEwitBpdg5bfrZH9IYHjRrlW/4lk1O7KUwFUsjllG06zpVjZwnFZ5uen7HbVjdPWPZBhX/v6zve33r9oYkihBcNw5bKmOsXNqRpfUsquJ/C8K2FMw4McXMGAt9FqTC0gWkqPnRVKhJSLYizj6DQbCyjlXTcKcN1Brw00QVwThLsw5c2Uiq2hErVMychPvN2w0xC692K9pqqVm46wJPrMdYNQ+XKjgcwRsOU6LYyvNw8KovxNeXCyzKrd5Jpq+FqVS65DjUgkmVWIRSdQp1mxJvb29ZnZ/SeY98xFj5l/W91TcuL5hqxVJZtYZSLcNMjAul0lbIFApwEzMuC/spspsSfU7Uajgy2pH3TulRlYpYSw0GssFVw5GzHLctb6xOqLXydDxQRWWw7thwY5/lPTDn3Rq8N/zrq2s2ceJTfkmDJ5fKg9DyOAxkBGMgAbZU2mDZSQI701BAQ96M4a3jNY7KadNxnRK7UpiKcJk0jE4mw5CL+gCScHUY+MblhtNXG9Zt+zJp/AXWB/utSkyt8vKNVdOsjBMNhtYbqoVEZV8zZtK9YiyFfS44Z+lCoCSwvuDnl9/zbFoDDlg6p1AD1yg9LA9EY2isZ710DCJEmxSzaeb8nMbw7uFAlMpd2xKq+vlOfeAyDBhjqVYBBbUIwVkORWZMhkrH7IzDPvMtBsPSWfpaGKpQiiEsZmKf6Pk2V5BcsSbz/n5Pe3aMt+G5N+D3qx/aA//1fsJ4Q2MqbTWUgmqNMxSvh2YxlYpjI5kqhc6q4XUoGvMOQFXaiTOWXGASoUY1JeZciQiTg8XWcX7UkauO/faSGYzgg8Fki1RBRLV/StLRJFLrIVchVWHhG1auMGTNaTZVTUevLBpKFjye0RUy6sZeBcuxD3jrEWvZ28IQM4KlCV47F9ZijGOsomnBpXAxjuzzgmMfkPLyZfeianMYdBJkDI15trEIQ84czRMksSrV2pTCJves0IPUKIUi825CxVlLMNAXiCLUSeU1UjLJVkYj+K3j3tFCaSgi7CXjvbBoHXEyiFWaU5aCtRDFkiXjaqUUJUEd+ZYuTLhcEGNoKrTW81rX8j4j2WvAR8mK7jxuPMdNQ2stxkA/6oWlVO2+UQXrDGUOCCNDzsLjvmcTjzhxlfwyWv6F1NV+olpoqqGtFg3FLQxzEJu1TuUJOA5EphgJFcRClEwVB0b3Lo/RfcQIA4KblExSayE7YTSCK4XzpeIUJxEOVZhMZtEEXNIpa5GqmmdjmArEKNSmEEVTc49Cw9J50kzNcCil527b8O1JscgY9ZL4allZz7ptNNTJW/pUGGOmVjNTrcq8B2pCek0aRPZo6Pl0WrN2PE9Qf1nf33qyGaje6MGqGgrChNDnwql1hM5hg8NYy04yU8yaxGz0wFWqAWupBTVKOstUNAfETrqP7KSQnGG0hVU/cGfVkqow1kqPYJ1ltWopQ0ZspVRIWXDW0EcYU8GGSpFMKqJ7WXB40eusE0PrDK+0Lb897rFGuehm9uqdeM9R06hx01R6Mhc5QzWchECUqvAOZxk9SIJS4P19z9WUOArCkF6+g19U7Q4R68Cjl8NcK1AoydI4T/AO4xzVwmSLps4/o+kURbeDNmutM1QcORWSCFYsmcJg1IQ+OWhGy1EbSEUUwVm1aeY7C9lR5p+bi54DU1GqDxYySpha+sDSuXl/VT9cYzxnTcN7uZA8383HMYbOWjrXaPq50/NrjBlTPZ23SNIzbDUoGbAoNfJiHHkQl3S2Ieb8kb6fP7QH/l2fKA201rCYO+PeO8wcfVrIVGPwRk23UQr3QkulMkrCG0+l0kogBIdzhi47DJU46sOMWZNqbU3sU+YNr1Sc3Ww+iiKs20DjHFOtasioFVvhNDTcaRpWjaePhWxg3XQcp8wmZ9KM+Wqt5Sx4NtaxEM+t1VASg6HFEOeux7ZmLnLiIiXWJhBsIJjC2nmS0QUSp4yzhiiZsRRyUfTny3ox1Q+ZKQiNtyyNZ0LHhzKzybFQrbJ2rlNmTJHX2w7mS6CIQaxuVt5YvHOEeS1PvSLF9lkP/LbAXiJ9SJSY2OSJq5wpWTgOAW8dk8lMVYkSVDj2HeehZekch5TIVTjplixjwNVEKSpD65zlfujYGqG0ipibKviq06dRChbYlcRlVA772nZ0BKwvLIMjVsEaiFHpGlEKQxKmUCn5Zdbpi6jhUMiNpuEWsQwIC1/I1VKrknPEGbIY9mSmHLkTAiZAmZRuU2cUcFs9zhlS0BdHGTOxVgap3JiELSPbFPi0XzPkzE6ETUmUGjkyDd42RBIiWV+WxnDkO859w8JaRsmkWjhpOk7bhr5PTDNZpTWWe77hYTNSrCLwqlT8fJE5SKEB9iVzPU1cjAPHtmPhAg1w1HomWynREGvGWsuYhT4Ko63E9PLA/yLq0GsqeGctpVomCsbpVNl5R+M9NjhyLdyWkSkmXm0C3hsSQqkWscpBb6zDOyhOZV51EKZS2BehWMFUQ7+rfMYdKY2kJG5KQiochQayZTRZ4RhFqCLcbxfcbTqWITDGTKnCsg2cLhr2QyGKEneOrOP1tuXddqRYpd+JoBdO49jlxKrCISWu4sjToefYLVi7wGgzJyEwVYcYYaDgraHPme1UODSKqn1ZL6bimMkBgrG0YplMpXrRqbk32GCpTmUzA3omOrUeawy5yhxipdhih1P9vdczU07q4YhV2LsMNTHkzH3TMSVhkMJeCqUIy9DQFc9IIUnRxi+WpQmc+Y7We4as8tqVbzjyHX3RybxBpT5nruGJGzGW5+h1h6GpllGEYCp9TdzGkdspsrYdDQ7jKovgiQjFCCkKwSgxbUxCdDJTin7/+qE98JeaFSMoim47aRwRONRML45QrJJuSuUyjbTFk03F2Ir3iqorWVg7h58RX8tG0UVP6hzfZlRLb8Wwr5lv7Tas8MQqlKJmcOsMAcM+QzaaztcYy5kPrNEDFVU3j3XjeZM1m5oZRtXA5lR5uIvUtkKEnJnNIJXbHfzzesmrXcdNEgYROhNonaUIrHxl5R3BOk6c58PpwHnX4HEcmYbGOKJ9udm8qBpLIdWqCYweFs5hWsOwzwy+sDAWX4WbvnA5HmhxjDUrXz9YcqmULDjvwBpaZ7nrA1C5qYVYoTo9FCGwmzJvX271IliVLTwWobWVrvGMY9IL6rwBvuI6lskrJ1jAW0+7cLzlTrjeR657YUiFWBLvjCN5HmSWKEip5AqX28Sv1id8erHiyTCxS5mF9TTBkIvl2DnueI+1llOf+bAeWHnPwlmOvaf1lhRectBfRA2SFUhhLA5Dt7QYqy+HMRU6VKKV+sTTvMclWDnN8jDeYkQ7oI2xiBEa63ilbYHKZZ2epzoCiBgOUfi93Z7OOOVSF0MsheKUCnSIRUOKgsNbwyu2ZYnFicrT7LzGP3dyzE2ZGFNizHpAe9wnVlanoruS9HNlhJtD5isXT3l93SmBJQudcTjvmKRw1njutC3GOtYm87AcWDjHiQscGU9jK9G/bHq8iDpkPXCL1SnScuGxHsaUmYojO2WLX243PBx2tMXSG4MxBustGUULLghUA8Eb7rVKlbvepRlkoSWlshkyv3O9YWlmZGKBXAtVCq6x7EdNbm4aS2Msr7Qdp1kxx7lWioO2Cfzk+Sm3VxNXY2aXCpNkFqNj1Tr1QeUyT8sqjw4T//zpI95aLHm079mlzMo6mhb2Q+VuaHh9uQALxyHwTulZLiyn1nHsPK21pJfv4BdWz7w71Qi2VprGQYAYM0MxBAtthW3OXKeEKcKirThvoXGYCikW/Nxoa53lPHRU4EoGUrVQ0HVRhHEqPNn3WGtJRvdHEQ2IK8YxpIxQ8UGDtE68p9GB0HNp4cI5Xl2t2NXMrkSmUkhF8MmysIZOLPuayUaoxrIfhd80T3ilWXKbEkMRGhPwwZAirL3n2AeMM6yt52kcWAdP6zTU1Wl4zkf6fv7QHvhzVnJJsRXnDGHuZAvCVgqpWGyB0wArHNVWRpNZOMen246rSXgkI4/yiE+WN1YLfvZUKSj/zYdXlKpkHW/BGwitIUllW7KGcYl28mUe1wQMUjW0KLnCo/3IZxZrNtPEk3FiW4SpNbxxtMAc0O4/hUNMPB5HioMVOk7Ps3ktBcNlnBitdsGsNRgqo2jY0rspEiRyv2154DqOW89/dnoXgKaBvk7s0vQDekI/+lWq5ieUUvUQ1VrsvlBS5dZlBqM39PtNy8oFoi0MRlhbzxtdy8WQuEqJcSjsXOSN9YIv370DwP/znUfkoihMYw3BONxC19tWdOQoBbzMZknHzMzXgK1ihEdDz2dPTuhz5kkc2eaMRMsbR8esD46maxi95zBmHt/2TE3hyAemVIizpMc3lg/6kUPNeK9dE6HQF4t1hvfLyGWy3G87zkPDhpH/4v5r6k1ooK+ZXUo/4Cf1o1m1qAcouoIJlRUeRCc8G5cZi2BHw3m34BjPzmd2RlhWxytuwS2ZTRm1M1sLr7ee/+SOrr//5p2HlDnB2VptXLgWcqzcmqzdsSK4BLkrOOcJs+K0oh22p2nkzdMTtjHytB/YlUzxldeXp3Rbwx3jmIzhMBXe3+/JFs6toxTV2RrAN4aHfWZXC621OKuwg14KrTW8z8hlLtz3C85dw56enzm5w9K3+MYx1MrhI46zX9b3VlJUMR+r4IOmyeckSDE8JXIbMz4ZPtUtOKdhQ2QjSXHCoeGWzDYJBzKkwuthwR+f31//6OYDUslUNA3ai8V4GJPQ10wWDZYzBcZloiPQFEOsFbFCMZanQ+Qnz8/pS+TJ0HMTCz4E3jhds7y+wjeGwRT2U+L3rvdMFh6EgKTKkDSwc7UMvH2r8pzGW2xQiWaNgg+ODxi4GSOvhRWv+xU3jPzZe6/Q+pambYkV+vpy/3uRVaWSXWVyFo+uS0T3CG1MZM5Cx5Gz7IF9rXS1cmYDUxF6VEZtKixdwxdPTgH4H4YRUqVafQe3SdOXp1IpMZGNrn+fITfgG2jFU+ZgOIPhlsSbyzX7mrkYNQuiNI43lgv8YFmbhgZhnDI348De6QQiSyVKxZqCX1ouk1DKiHfPzoGKdHe24YID2zhx5luOfcPoPF86OqVxDh80RyfzB7zD/8pxx8J5DinzdIz0NfHZsyNaoBGwk0YTE4BiqVT2sXBkPX/k5C6SM/+3yyeUakmlch0zbw+Rn7pzhwfdjqlWRnRj6cSzWAauY1R5hQiNMTQ+4JMlUlj7gK2Fg6i+9EYmvnp5QS+FhCDG8N7FyDs3DX/2C5+i9ZYPbw+8e73D2sokkdtUGacItWAxrKrhp1+9x6kxHLcLvHFsYuRfXl6xtJ4lld1QuJ3gfKk0lRgzTySSx0qSzDi+PPC/qHrluCM4zz5mrvqR3TBx9+4RKRhstUgEbGVoKq6ATTBk4Wzh+aOnZ6STwv/j4bsUXykZbofC29uJP/bGK3yq3bJvEiMaAreqnnbluI6JMmPlOmdog6MKTGNkaS3g6CVTBZ6kiX/56Cl7yUQyUivf2hy43234L//IF2i8493rG75zcUV3qvzo67HoAcmBtYaFN/zc/Ve4E1rOFh3BWW6niX/x5DHnzYJhHNgMI2UsNB38sbt3EYTvHHrqoImqu+HlC+9F1IPjDoxhSIU+Zm7GiTvHHWJhoDCWgjeWUypTEXxSj9Gy6/j8yQm5FP7f5UPinPi9i5l39j0/df8Or7VLhkaY1NZNaxytd2ymTLaCF4M3Htc4qghTiqyxHLAcyNQKT8bMV59cMtREFA3C+c6HPfebHX/+j/4YrXe8c7Hh9x7f0AXYy8TmIGzGolI3qzkQP3PvjAdNw/F6gbeW7Tjx1atLTtqOm51w0feMNmGaFT9xfA7Au/GAK6J+q5fr74XUK8ctxcIYC+NYuDqMnN1tKFQORTgUCNYo9hrBZsNo4G7X8uU756Sc+EfpQ6bZX3QdJ76z7/ljrz7g1dByMIZolG6yMoG2M1yOk+qjK7TO4juDqTAl4dS37GtiJxFb4P1pzz/54EMOtej6k8pvb7a8tljyf/hPfoLOO373yQW//egxnbNsc+JmzOScEKf+uM4YvvzKA15bBO6eLOl84LaP/JNHj7nXdew3A4/iQO8KdgX/xauvUrzlvcMOG3eMUtj2L9ffi6rTdQtOfRs5FjYpc3LsEQwjMBWVmjYkxiKYIhQsS9/x1vKIkif+h/01WXSq3U+ZR/3AF8/POGs6ki/kWpCqxDzX6Pu+BosvFS+GsDA6raKwbB2DaKPLV8d1H/k3smEkKaRFKtePEg9bz5/84mdonOPDmw0fXN3SWEtfJjYp02tsgDaTBX7y/D6n1rDuWpy17GPk67e3nLSWw2i5ipExVlxjePNEcx8u00AuQqqVNP4BN+1OpiJkkhGs09vQmBO5MRSBUUCKxYlntIUHocNbOG48S29JxnAcHJuYMbWSinB1SLzT9GzJvLpsScUwZIephoMkwOCMPMcuddXSecu+VKwx33VXa3IztzFRHVRj5tGPcKiZ37q45MFqRTCWzxwfqb5s7BnKhKsGRE0k4g33fYfkgq+GxhqCNYwUltLgCziBahStuHAtWYTblNnHhNSC/Yju7Jf1vddoKsmopMG3hilW+lqoRgNaqAVJlSYbBlu413UE5zhqW1aNJ6bK0aJlOyRKFWIWnh5G3rm8ZsvEncWCVIUpFzyOfUlIFVw1VKsR70vraJxjM0XcHLtdq34egvXc5kQx6vSXqlSUQ5r4xvuPeXC8oq3w2aNjLDAmSz8NODGQFfEpjeH11QqiXnJb51h4T5KsGEVxaiyeux132o6hFK7SRJ8Sde7CvazvfxWjQX3Fq/Sw5pmSYw1iKkUqKQv7XEjA3VVLsI5141k2lnGsrLoGc9ADeczC033kW37HQTJ3lwuiOMacCdZyUxIJ0edudALaWUfjLLuseyCi+1+mEKxhlybSPM6uoqnhG5v4+ntPeXW9JhTDm+s1BuFO9fz2eFA08RzQVRrD68dH2CnTVEMwhmAtvWRWMwa0lqq62aZw0gSGXNhHTWQVqaq1fFnf9xKnaxAPrjFq9geMn99fRb/3Yy4cKDxYdzTOcNwGVk3DKJWj1iNDomIoSXiyGfm9cM2hJh6sOqZSGUVonOUmTjr9roDR/W9lHa1x7HLRz0DVz0BECM5oWBJmnsoLpVRu48hvfuc9Xjs9oa2Gz52cYQ3k2POvpx2hzl3cKlRb+bGzE2pMiv02HmszQ05IaTAKSCE9o6ksOkbJ3KRCPyYFKLyk9LywqgrCA2txXoEVBbTRK7oHUjTjJgF3ugWNsxz5wJFzHIqSb4ZcKaLvx+tx5L39noHMnUVLKuon8dawL/reszJLI4NitVtr9OcY5edX9Gt5b9hlpfeIUQy2zYXewtuPLzlfL/AVXluuNOU+O/pywFAUlVf183SvaaCU2e9n8NaSStHpfoaaDcVBMXDsGlLObEqmjwVqxX1EeMsP7YFfBKZnxlfviKUyKhhz1t9pSJWIqCnIWY6C4zg0YAyC5bxpyRm8E4JV3v4kWUeUVpn4WRRPPomaLKsBO790jqwnWINzjiSFKJYGS6pChyUbYeUD1Sk6U4q+oC/6EWscD7oFZ11LqZUhTVTmlaITKYpRekY0GnWv8fOKFLXe6vhyxkAZC02w3PaR3ZQZJCva8yWS7oVVFYhVvR6LzpMkMUjBGebnjT7LrM+o9Z7jEDgOAWsNFbjXdkisDD4re9dUdnFiqmoGDqIdrGJgiCrXqDovxDvL2nsaa6k0xKQXw2AcGTXu6EUwUG1VoxyV6IRHhx1ihVcWS+4tFlQqD+OoSFiMvjylUoAFnmSSLj6FLjJlQVpN9JuBF7oGW8fFduR21MAwg8HXly+8F1FV9CBjDLSNm1G/Vcfa8wHHVKsJpej6O3KBIxcwSjfgPLQYW7FWk5qtgTEnJikEp+Qeqbrmximr1JGKtRbnDEurjQhMIGVR3vm81jyKt+tsQExFYU2VbCoPt3tE4F7XcadrKSJcjpFa5wNd1c+XVDWFZjNLSKzug1Mq0EGqmjZpZunbog1cDpHtGJnQ7rCRl+vvRZTlGTbcEFp9RrlCeNb5mv+SkjYDjhrPkQ+c+QZvAAz3mhaJwiDgjV5U95Ouv8ZbnEEPNA6GsegFrur00TvH2gcaa7HGMmXwOFrrKbXixZKpSuezEAWcrUQrvHO7IdbKg9WKB6sVUiuPp57M7FsRM7+KDSvnGKwmDlYBwTDFDAuYqv7ZlMcNi85xedtzO2pgWAVeWkheXNmqVCRjwAaLyUqQ8zxfghjmcFOpLPx3D/vPcNEnPsDsnfTW4KzipnPRMFWsocznqPjvEOeMNYr1NOojdejnwWNpjCOZqu950QmpYEi1KL2PyuX+QEE4a1qOm5YicJMSVQxGAFE5Ua0qKy9oQwWjzZBUMrXqeRP0e4DRqf9m0jCwaZZG2o8Ib/meUpv+1t/6W7rB/jv///Ef//HnPz6OI3/5L/9l7ty5w3q95hd+4Rd48uTJ9/JLPC+X5oNUNTTG01hHMgbJMBUY5whjW6HBUat+8JcuULEUsaysHr6Om8BJ13C+DrRB8U4ilVgUP/eMfKIvPoOxGu991gTW3vPaquVO23AcAp13GKOd13WwvNJ1vLpoubNoOFs0tN4SnNONC2iCJwTPDqNf28waQTNvOKKIsYpi8kqtGNENr6dSnhkyjAFbuZjUWJltRYLiHD8p9XGuP4CQFMPGHNgWjJ3lEZWYClPJc4y2bgJVNERjZZ12oozhhMCp9xy1gaNF4GzR4IN26kHXXJFKpJBnChRGn3/jHCddw6LxvL5ecWfRctwEFt5jnaG1Rgk8i4b7q47zZct5F/CNpTpFg1ZTWbWBRfDcFp1MGKMaQb1/Kuq2cxZnNJa+iJn9BUblQ882NlsRD5fjqGmYUhldZfcR9YM/CvVxrkGTFSTuipphG++ej6ZL0b+auUGgy8ayNI4VHhELFlZGO/5HTeC4DZyuPItgsGYOxJovieOM3JSqjHID2vRoHW1wPFh2nDYNR75h5QLO6kuvsZZ7TcP9ruV00XDSBlqnh6NBVGa2CJ5lE7hOWRF2zPugAaiQy5yNoheAgh7+g7GMVfT3Y3XPtM5yM0VuY6SXwohw+ARpqD/O9efFYYqG7YVgCU5hGFVQ9rwYsLpXmKqdyWPbcGyb51OiEwKnLnDSBI67huN1wDs/B1hqQ6vMCEV5ZiK3+pxb7zhpWxYh6P7XtZw0DSvffHf9OcuDruPBsuNs1XK+bPDBkQxsc6QgHHUt66bhaVRyVH22wJ+9g3OhCVbRtVWTcopUjHMMtShG1kK2FeMrT4aBm3HU3BzRoM5PSn3c72CXDXamzVlrMMZqo0Pq8wBTaw1JwNaKRVgYw8LoZdAYw9J4ls6zCI5lGzhZtASnyNY673lZqr4vi4I0cLp+G2tYB0/nHOdty8p5ljawMAE3w2AabzlrW847zdNZdwHndRKQilCrhsU1PrAtmTw3PQw6wahikKLo7mdTLJmzo4xxTEb092S/O+G9LZE+KTEtURnkBWn4f+InfoJ/+k//6Xe/gP/ul/hrf+2v8Y//8T/mH/2jf8TJyQl/5a/8Ff7iX/yL/Oqv/ur3+suQcyXNmT62VJbe63cnq1Y0z22ivdXQLReCspxnTn9yhqe7gbY1mGBpgmXVWlIUjqyjSuY2Jp7GpNgj65SVHgxeDEvxHFslCry2XFEXwrcPe3b7hJFK21rOm44vnJzgrBINInAzm39eaRtOvcPW+vzhLX1LcFllOKYSrMNlwTUBJ5Vcs1I1CGALVQzeWXCGXa5s+5EPx569m4O7KphPmKTn41p/ADVB9ZrXUJKhfRacViqS9WWVbGVfCyOFIplctHOQpJKd5WI30LYeF9Rgc7JsMLFwZB1Uw21Kqlt1agw3ttI5i69GD2+tkqW+sDxiksrvbjccNrf0qNH7brfgD52fYL1jmzJTl7kaRrqm4V7XsfZBA2NqJdZKGwLBJZw3z3XUFqH1AYwhlsSYRxZznkCWikVlRPtJ9aqPNgd2kkEsNmvg1yepPq41KFkTams12AkW3jLVDDPWUlAySfaQi3Z5ahGy0UN8DXB1ObJsPSE4QrCslx6JsG48xijd4nKctLNuDB7ojMOKoRGj+y7wmfaYshTeOex5e6fd0NZYTn3DF06Ocd6yS4nYJ25LZtHpQew0BGy1VFGtqXMW5zVhshqwTvfsrnEYU+f1N9FZp9IlAe8tGMM+FS6GiYdTr0ZQLKZWzCdsyvlxrb8Sle5kqJhkWc74Q6XiyNwgq0w2q7EyQXEKOhhrxTi42I8smkATAqG13D9uiPvMWeNpjeNJGnk0jGSj+wwGOu9pMKyN406rKcqfPzomGvidzYbfur1lV2AJ3OtW/OHzM6ozXKdIjJnbGOkay/1lx5H3lCIUo9KhVowe9hANo3MVk6FdthhjSSUTSyQ0juqUse41GpptTlz2E+9tem5Kprj54PbJWn4f6zu4lJlZL0CGFV7pNqIUPOXr6x5okjZNUxKiVFzrMM6y7yedJllL4yxd44kxswyKee9z4jpPZAX74KwiQHUPtKyDngMf+DW1Ez4cB94deqxUFjiOm4ZPr9aYYNmXRJ4Su1xovOO8Waj/0xmohej0wO4apZtVKsYJlEJoAmIKKWtDsbFh3gOFYCvGCIeSuImRp+PIoRaw8yX1RQVvee955ZVX/hf/frPZ8Hf/7t/lH/yDf8DP//zPA/D3/t7f40tf+hJf/epX+bmf+7nv6dcxR57TzhEEzFS5s2j4/P0zvnV7y3UfOUhhNIXLIbLC41vPRgpXeUueKqF6bsm0CaIRhkH43cvKqVvgrfDBqImOUDHFMjjNSDoKHm9hUzL//f4SEP588zqhKrapMYbztuG/fPUeEGgaDYy5YxaKMRwPTCSWznIZB55sb6jZshdhGyeKSbReNTr7ktlMEV+UytIET+sddxaebapgA1PN2Fw5kPlav+URCQ4qW61z8uknqT6u9QdQjh3LrqGrlibB6cLxpTv3+e3LK26nkb5kBoRdSqys5cS2TFn4dtqS97c62UmZ5DLRCGkUfu9mz4nr8MCj657BZKoVTDLEeSp0d9ngvGEnkf/+6SMAXn+lUVlahdY57rHgF954ixZwC68bAxocsz0smIDz4LiNA797e40thk1KHJhIVlP/rDXsS+R6GmmjYSpC13i6xnG86LjaD9QMIxlbK71JfO3qKd8pIwyQhkSZUwQ/SfVxrUF7ZFlbR1stXVXZ4k/ev8O3dxtup4mhFMYKU19ovf68Q8lc5MgwblkFx6EU9rGQLMRBKFeFte1YWMMHtwdGU0imUvJz/g7nbYM10Evi1zYjAK+frahWAwVb53hAx5975QEArtEX5/2uIx7BYdL/5jg0bFLi7dstecpEtBulhnQPzrCXwk3c0yZPRmiDp3OBo9bzdNODCKPoS3JyhW/sr3g/DTAJ5Zl34BMWN/6xrb8VnPqO1hjtmnrLH7n/Bt+6veCqH+lzZKiZfioEbzh2jikmvjmN7GzhODTsauW6JGIpTEPmNy+E465lXQzfujowuEJ2UHIliXrYzlqPcYbbXPhn19odfm3Z0VhHgyZDN67jv/rMp8je0jlllX/aLJmK5XrU9XfWNNwOE//m6glDyfMlWDvGnXNgLX2pbKcRXxJZEosQWDrPveD48HIPCXoKpsI4ev7N1RXfGvcwVL1YV/WtfJLq43wH+5Wl9Z6AUWCLMXz29A4PDxs2MTGUQqaQh4pvVA1yEOGq7Ejxhs41bBAQhRGkWHmn37KkpcXw+PbA4IVsgQgR8FFYLgMY4bZGPtyPBOBPrD3eWGotNLZypwb+d/fuA+CchgOeOU9tFlxPI945Vo1nl0feux2oqaJuqwwImq1r6YHDlJhiRoDOu1lKabnYHzQDo6jcbVHh2/2Oi5JgqCRbdN/+iEOm7/nA/61vfYvXXnuNruv48pe/zK/8yq/w5ptv8uu//uuklPhTf+pPPf+5P/7jP86bb77JV77ylf/gw56miWn6Lmlmu90CIFUYkuCt46xrWQfPsbd8tltwZDxD0c7DPmUMhvcPeygGZwzGV5xL9KnQe+GZdN42hjYYLvtE46zq+ER10M46goObmGicBnaYUokFvn24wRvHRU7spXBkPDsRjixcTok46Rg81spNHPhO7DnBk0plm4UWyx0fWATH1ggkpWB0jeV3xl5NIMYQspIyjpvAbiy4BkqGqRSeTAWbNRNg9AU3jx/zJ2yz+X6vP/gPr8GSBWIF51n6wCI7jl3LZ1cLLhwccqFguI6ZhbP87mGHVKU/LBuPyYVNieSscgQA78B0cL3JBKvJgSnpBMh6S2MtT0btSFhnMXOS3+8cNiyd41Ea2UvkmKBU/caziaM69QX2KXGTR95LB85tYIzCTUy01nMSAlUcO6fBcFagwfPbN9cYtFEfgmXRKFZvjBHbAhl6ER7Fkad5pLGOoSkEDKEacvxkHfg/rj2wZKGaSus8bWhZ+cCxd7wRFjTV0osatm5MoXOW3zvsEIHgLMuF42YQthIxYmbevsEGRxMM2zGpJrVAEdH0b+fw3vF0inirI2lN1q28O24JznIhE1uTOXKBgcq68RxiIkoho3vgbel5f+w58w3jVLjpI03w3Fs4TrOnT4kpCkYMXeN4e7ufx9uG1lsWznOHlsckrLeYIkxFeDwMXBRD5x2Hqnugr1aNxp+g+tjWn0CSTHCepQsc4Tj2jre6JaFWdtlCES4lERrLv91tKaL4zvUysEkT1zkic7ptNRUXFAW83SeCs1CtXjbFgNdE3idzuioWZCYxfWuzZREMH8aRTY0c24YJ9fftppFJClOFfanspgPfTj33fMNuyDztJzrvud85zhvPLifGKWOSEILjazc3sxFTJ/1L77hLo42OoBPQUYQPhoFHaaRrAwciDRbEEV/ufy/sHawX+kRrHeumxTnHsbekRptmsRhMbbii4J3lg/1IkUpwhmXj2JTMAWXnz//DWA3BHIYJ43UNSlZ5rnWWLng2KWKtwVqdLqQMH4Se4C23khhqYeU8BcF5zzDpHpjQKde2JG4PA0sfGHNhGyON9dzpHIugqoCcNIW3w/HuuJ9VZobGWxpvOHeOp1IIoWrjrQpP8oQbJlocfZcIWIwYpvoCJD0/+7M/y9//+3+fL37xizx69Ihf/uVf5k/8iT/B17/+dR4/fkzTNJyenv57/82DBw94/Pjxf/Br/sqv/Aq//Mu//L/491kqi2I5cQ1vHh1x3DUEqZw1AW88+1zY5UTGwOzOD17TQ8ckHETNlplKnV2yphiiF37s9JhRMldjJGUdPTbWUtCXW0UP/LVUHHA5JvDCvmRiFqKH39ruWbhBmelVnRbVGpIUbqbEYDV0KxU4XjTc5sx515ArbErBWMuPrZZ8a7MDoHqgZrrq+OxiibMZK8xyCQ1ychXuusBFVXSZs/oC/6TUi1h/8B9eg1KFTgKnTcObqzWnixYrmbO2pTGWfcrsU8G2qn9/mkfVGmIYJyFSKJZZly9QIGVDbuHNkyUR4XpQ82t1KIMcyEW7l86ovs8Xw5N+wnuVAE1RSKHy9d01K++57BNT1RF1ohCrcJ0jgxViLAypcLQAYuV8ETjPlU1OOG/58ZMTvnVzDUC2alpbFMcXFydYW7GiwXQilWyVWHGvacg+IlmRaN5/T1agP9D1ce6BqRSCdzTe8WC15M6io2RY+ZYH1tGXxCElCJoCGk3FWZVF9FMmZ536aEvAqK66VKqrvLpsibVyPU3KJDeaBi0i5CyINSq3kYovhospYpzlNiVizkTr+NZhx9HkuRwm1WAbMM6SKFxOkegrUyzsc2LVQhsrZ23DsQ+UrAayL61O+N3NDQDiDBRYOsdn2zWm6Nozs7m3WihJuNcuKE6e42v9Rwyd+VGoj3X91YypjtZ7Xjta88qiJeTEHR8IiyXbFDnEhMVjbOUmT+DUHzJNmQEotTyDkej6i+CC4fX1klgLeYwcUqWGysKq9CsWJZVZ+93197jvsa3lOk4MMdMFy9c3t3SD43o/ciiFbHWPylJ4Ggf6JjOOhc2YWa6ELgbO24YTH8ip4o3lJ09O+cb1FTBLR5xh5R1fWp5Qc8ZVIOoeLk4wEd5adhSfKEkBHy/3vxf3Do5S8N7ig+NsueCkabEZTmxL0xgOJdGXwhH6/Paz9h6jmQ6Z55wUQM90tYDxhleOVoylcBsTU9YXbuccWZTqaOtMxRNwBbYxYwQOpTAlwTuVebfOsZ8SY9WkXWsg18q+JA5UplwYc+YoqDR7FTzHBfY5YTG8tVzz7vZWf4NBdfydWN5oVpj5/FfrDHGwFRG444N6t1LFon6rj1Lf04H/z/25P/f873/qp36Kn/3Zn+Wtt97iH/7Df8hisfhevtTz+ht/42/wS7/0S8//ebvd8qlPfUp1+nPwRxccq+BwNeO8Y5cSh5i4miYOpmKr4OZvSpGKR8021qqZKMzmnDFX+qIGMZEZfejVIGSLIRslRjzTLhejAVm3RbAz61qqoZjKh9PAynrGqtrAXOU5GaOtRmOWc8VWQ5aMmMBR03AaGmJXGWU2DJtKlqLEF7FINdil5fVFw9PNoONqq5eQKvDKomGisJ/pMXyCulsvYv3B77MGs1ALdI3nuFGfSOcbDjHTp8LNFNkZJffYmdclteKNoVSdLllROkCdN6E+Jl5dLpiyqI7Za6KzSVBtpQ1ek/tmQ5Gzhpsc8WLo59CswRW+fThw5gO7VOiLRoTLbOIOznLImVTUuDR7gTkOgRPbEheq6Z9qYT8bNktVM2gqHre2fOZ4wePLAzUrCUEDQeD1bknJlR1JDUjfm/f/D3R9nHtgng/oCLRWO98167OlJPqYuB4jg9FAQmOM4g8reAy5FCx6SbNOfyznylgK90NDLBkMOF28mFSptiqVpzIHc+n6uy4Jlw19VqPYGDIfjAeOXGCXNJI+VcFabUB4HPupkIrqTKWqF2HtAt3S80pbFUlbC4cqCDqtlALJQTjyfKYNPL068GyrMwZsMTxoWrIpHKoa4Kgv19+LWH9FBJstZpbAHDdBDf7es02RPmaeDiO9MdhSsU49F0UqvkIUwaFeKO+hVsOUCmPMLNqWmBQq4BzgLSYqKrj1CuEoRc3ozhqu8oSpjkMsxCT0NvOt/Y6jxnOYCvucGWp5vhQ8hu2QybniZwMlAkfe82OrNW8sKrEKsRb2UhCj73wplUkC4STwhcURTx4dqElNu86rXv/NxYrqhQ3zpPT5cfJHvz7ud3CRGeFbDME6FtZR84zuLZEhZ26i4tuVaGi0xStgHKreAChq+hUgJSE1GRf882BV640mEIqiaBtnFcn6zFzrYVczJiv7P0kl2MKTaWTpLH0ShipzwJeuB2cNfcqaK8EzlK1huWjouoYcKrkKUYQJPW8WUVBNqeBWntec53o3QNF3rzNANZw1DTkVhqKSHvsRSXn/UVjO09NTvvCFL/D222/zp//0nybGyO3t7b93w3vy5Mn/qt7rWbVtSzsbE/+9qjDUwk4Kfc0ci6VYlexsUuJh33MxRGIAayqnTvnMicpJ0zDOiExfDIt5F5gQJoSLaeKQVVPqrFVc2PyQTho1B/elsDVKDjhQ8AkqdmZgC73J+GqRqh3ZfkZ0GeCV0GgMvahWOueM9w0L73it6QjG8DRG/tvLJ1SnTGuZHyhAqvD6IvC1S0GK6mZzEnI2nBzrop9cVcc2H+1B/yjW92P9wX94DYqBPuvLZKwFKUK1DouGuDwcDjwZEoPTTWXdBKaqOuV1YxmSmnBthrZRaspYK32MbHxgO0aiEZ3eGEOa9NB2umxBKkPK9Fa1pwcKIVliUd3oUAopVb3ounkNzrHfBjjpWq7iiBilpFgsrXWsXOC11VJH53Hinz16iDjVLuZSYL5kJwufWS/4yuOqnXxn1VRH5V7XsRsmktNNrn6CXnj///Ui98BqzGzgElIWYhIW1mGNYR8Tj/cDj8aJ3CjF4rj1TFLJwFETGJOiYGsG7/SFlsgcSmYXC7tYKEZ/zNhn60+zTGxRvvrOZIoRtiTaZEkiZCpDzeSsso9qhWyFMRZkTjC91y64niaqqXTBYedLyMJ47q1bvHNcpon/39NHVGvIVGKuc0aJoXjLZ1Yd/+pCp07WaiKrBb3kiiM7oYrwCV5+L3T9lQo1CsUKuRRSFoILOAObbeLd3Z73+x6CxWI5Xnv6ImQRTttAnzOWiovQYLXhIYZ9ThxyZjvqhS04fa+mlDCt5U4bNEk1Zfaigq1NLfjpmfxR9+VsJ/WEOIjz/qcNCMPrTcvlEDEO1p3HG4MTw8p7Xlstcd7yKE38kw8/pFpLskIsVfe/AtHCl07X/IsPdP05a/Bza+OV5ZLtMBFLRXJBPsFY4hf9Dq4VSlJIS0yKXA3WAYZtTlwMI5dThkbfTa0NFNEGQhs8YxGl8WTwwSDGkBDGkthE9TwlKt5ZxFRSrBC0MWbFEEXYW9X/78kEMaSizbFYtSmHsURj5vRcQeYe7Fnw7NP0HC1fAVstrQucNYFgLJuS+bWLS/CWYqsqTgTEGoozvLIIfONWp7PP9kAqrHzDPkeyE2JlDiv4/es/qjWy3+/5vd/7PV599VV+5md+hhAC/+yf/bPnP/7Nb36T9957jy9/+cvf89cuViiWGTmkhIcnMTEl7VQZZ/Hecs+3LMVpB9KhEeAe7AzrF1FTlxfLqfcsGs/OFKZS5tuUUlc8DrLlzLd8/mjJl05WnIaWLBZjNO5d5v+PSfDOsSdzkyKHnCkF0hxK83SMDCmTijBWUW1/n8mDAIWH44HfuL6mWt1g/Aw5t85QvfDBOPFr1xuiy1Svo2yZ32qPx4nrMTLGRMiGM/6336r/oNeLXH8wbzZWyE67B2OtbEsmVjAu4ILHesO9JtAZR2cNjYM2GNbBKVaxKiM6V+0+rJYBG+CKSJ+UxOSMhaqcXynCeQh8YX3MHzo+5bQJOhYXGIpeJqozykR3lm3JXA6R/ZQopRCrBpPcTJFxKkyx0OfMVDJP9yO5AMbwcH/gN59c0lhDg8e5eeLVOFxwfKfv+dXLCyYnEKA6RTgCPBwjT/qJYSyE5Dir3X/8w/wDWi9yDVYzU3icITuD2MIE2o23HuOU/nTaeJbW0llP5yyLYFgHReYlVZKRSqHUTGgM1QkXTDqhoWKx2PnQLAVOQ8tnjtd8/mTNqQ2kqgfxCd2TjTNIFpzxHHLhdkz0YyYnIRXdczc5MSXtxk5FkyyfjhMpK1Xj8djzm1e3eGtpnMdjcdYQgsE28M7hwK9ePSG5AqEiCrUC4GmcuBhGDmPCzuSOT2q90PVXK9kKOQjiITnDoSqe1xkNJArBcew9nVdeeecMi8Zy3OqBKVEpVhOdkxHahScHeFhGtpIQo4cYU1SykKNw3wX+0PqIP3x6ynnTMtVCKTCmQkEwTn0njXP0JXM5TGyHRIpCKgJiuIkaSnSIhU1U2cfTMSLVYT087g/8xtMrrNUzgzMGawxNowCQ7xwO/Msnj0mNYBrFzNb5s/T+OPDhYWDbR2wyHJn/lYblJ6Re9DsYCjiVU0UyU62kmqm24IwhGPW9NdYT8DTO4htL6BxHPhCyIZb5wlALYoTQWZKDWwrTJMis+7HP8jwSrF3Lp5ZrPr1as3Jhzj2ppKLnMetnXooxHEQ4lKxnyqKUKlDoQUyVKVeG+d/fzknSGOFq6nn79gbr9MLhjdNDfVCy5MUw8PXNNckLtamIr88B2DdD5LqovM0lw5EJH+m7+T3tlH/9r/91/sJf+Au89dZbPHz4kL/5N/8mzjl+8Rd/kZOTE/7SX/pL/NIv/RLn5+ccHx/zV//qX+XLX/7y/yZ3dq0V4yyDCO/uex5ue7ZT5kEXeBgnrlMiAF60c9k3hUPOLKqlM7AOjpsx6W3PO7rWc28R9AVE5YashrQKSSpdsDgLTQEZhMYZfvrkhK/nDdKqqahU7b4n0TTeWFS2I0V9At7p/WkQmcO75pASgXZhGHzh12537GMiCdxzDScLz8Nx5NYUrK+0AZJNPBonHVU75bi6mc5yGTMr4zkynhMXuNM23/P39g9qfZzrD3jeuT6kxLd3Gx5xYNMn7nYNH0wDFzFiLZA81sLeFw45sTaOlbOcB8vVFKlJiIBdGI5PLO3U0IrlxuoaZFLuuGmtJvxVZegHa/jpkzv864tLYlcxcxBTFiFJodo6byjleVfBzfz1LYqbbYwliCUDrYe+jPyryz37uRu2aDyfaj0PDyM3xoCD0FhGK7yzP2CqgWCpGn9Jh+dy6FmZQGMqq6bh3nrBr38/HvAfgPo416BBO+9Dzbx/2HM9tWymG06awONh4CZNGCpuchhj6REOFFbVshTPOlhuUqSUSjXKNT9aO4bJcOoCGxOJVbtKtVaMtxgEJ5aUwBnPTxyf8lubG3JwWKfSxTSPzAl6kZiiPM8deeYo2pUMrtIYcOge6a1hnxL/6rJnVzIJYektrzUN7w0TN7mCU9NadoZ39+qJwagczliV1t2kxNp1SJporePV1ZJ/+317wj/c9fGuP80/OOTIt25veLLrueoj97vAe8PA0xg1ryHrZPK2Cr0UTnCsxHAeAldTJAu4qmbIo1XDmBPnvmNjJ4Y5gbwWwbQG5wylWvpUCcbwn67P+B9LITowYZYdzuuvNtAPQhz1oAU6RcIKNxTw0GEJog5g08JtGXnncsc2ZaIUVsbx+W7Be8PENWluelQOTeGbmy1OwASdOoGlNYYn+wNHNVCksvCBN9dHfINH38/H/ENbH/c72KLvs75mHvU9V9NIHzNnIXCRBjaSMc6yFAEckxXl6aP/HKxBYiWRCWiAVmgsJDjGs2sU4Vnyd2VA1enAQET1+J9fLfn2VshBmw71mfzGCwRHTlEVGKICa6+/cXZzYlhTLU0B5yo0hr5MfHN3YMxCNpWjxnPiHA/HCYNKiUIRpgBP4jhLFtWYYNDU314mjmk4kOi85Xz50S6d39OB/4MPPuAXf/EXubq64t69e/zxP/7H+epXv8q9e/cA+Nt/+29jreUXfuEXmKaJP/Nn/gx/5+/8ne/ll/jub0wc3llyLny42WvAQbW8R6QvQpWqo7giCJbj2gCGQTLvpYj3BrIelkGINfNkKhrQFTSBt8FijeEgmVESbeu4f7zkTmgBjYr/4qnwbt9z2gRuSuZJilSpBPEcosp45gmT/lq2cqfzuGSYcmWsQmu9mjdE2cWJihjhU6HlVhKRhDHgxdNmx7LxPJwOdNaQyxwbTqUDlov5kYmltZ5PkGf3Y11/AE7AesuUhPcuDzTe0onjnRrpRV8BRmCyhQWOUxswRlNC3ymDSrxSpSS9EBZb6bNQB2HZNJSk42g7h9fYSXDe8unjY+62HRYwUkj2Dt/a3HDSddzmyJNhoGT0ApD1s4DRUBLQ0d+dLtBmwxALu5RpjaXHsE1CqpZJ1Ij2h9ojdjJS0ITVplqOxbKwgQ+mysJZpBh9ydqK9zoqNYC3hbUzrD9BWM6Pcw1aMXgHORU+HA+EMNAVxzaPjPMB2xjDWAtddRwF1VinVPhw7JlqJU+VZyGMmcqQMyYCrRq6scqdVrqv4LwiOO+0HUYEkwrCKW/HnpOmZZsiF9NELUIrAcmqWbV27oKiE4Az7/GpMqZCPwlNU6m2MLgEeTbhInyuOyJKIqHBYW21HItnjePdqdB5vQTLrK+2AdrgMEAynqV1HH2CPCQf9x7ojWGMhe8Me5aMeG/ZlGfTSVGZoopded0uuHWGKWfen0YGJ8gEFJ1gZip9yZgs4IsmO2vEgoZ3Uemc47N3jrnXdsoXT/DTtvKNfseZD9zEyJNxQIqwiJ40ZWT+fTDrm3FqDl/YGeCRCz5WihH2KSNzk68Y+MOna4axkCbBOkNnHecmsLQd30k3eOtVy10KuQpHoeFo5rInKkvnWPlPjqTn415/QiWIkpwux57WWVwNPC0D/ZwCb10h4nC2chfHgUoswpVMTEBOWb11HrJAHQUSlIUwamIX1hhGIBQNoXxlveQ0NJpfkzPTMTzpB9bBsZPMdYpUgdZVxjin5HqdfEnRvz+3mng+FWFEqDgaeWYhdiTUs/faomWXFO/qjcFbx8J5Fs6RotCgwBkxlWILDssi6J5XQ0PnLUvz0fZAU+sPV2rJdrvl5OSEP/Gnv8hoVa+8cBaDo8VwIxNTLKSst+7T4PFAs7A6ap41X8VUuqJaV9GJNNEa7nctGzKRqnxhVJM9TJGu9fz0yTFnbUdfhN+73XItkZHK66uOsQpPU2STMw9CwDnL1TARRXWrbp4utNY/N0sG51iGwFvLFSUVPkg9sQqdcSwLXJbI3ogeuCo4MTjjeTL1dNbo9MEaXmsbPt8eUa3hYZxY+4a7TcOiVv6P/9evsNlsOD4+/sE+vB+RerYG//Off4vR6CVxbT3OW4rAbZ5mT4VQKhwHjzOGZeepTo0+ZH33ZApjP7NyrUrt7nctQ67sJeOcBio1OMah0HaGnzm/x912wZgz37y55WkeOUjmM0crRlE84fUUubPoCM5z3Y9EEU3nxXAcPAHHmBO9CNUY7nUdX+iWxArvTAcmEVbWs8RyUUb6KnMCYMVXizeeh/s9C+/IVckpr3Ytnz86AiyPx4G1C9xtGxbG8l//w19/uQa/T/Vs/f3sn/wUyaiJa+kdzllSqdyUhEVpDlEqgYJ3cNw0VFspogQbqZWbMWtSpbPgtEv+StsxUDmUMqdJWhrrGMfEMlh+8pmUIhe+vdtxkSKDCK+tl6QqXMaJ63HkrOtYWrjqJ6Z5/QUMCxcICFMqDFKpBu63LW91HVXgg9gzVJVktMayT4nbkjTRGUODxWP5YH9g2TpyUdPyvbbls4sVAcvDGFkGx3nT0GL5P/+/vv5y/X2f6tn6+7mff3Nef7B0ntZZxly4yFGDkAokKZrCa+F82ZGNJj8jmgp6fUj4rKFH1VfECq8vOoak+594nVwf4diPkXXr+E/P73Kn6+hz4Xc3Wx5PAwfJfPboiFEyHw49F+PAncWCpXVc7EdGKVhr6IzltG1BVAI0iBp5X28XfHa1QErl29OBsRYWzrGocJ0yNyVS0QlBUPYT7x82rGxDqsLKWd7oFnzx5BQnhveHA4vgNdyQwH/9f//ay/X3faxna/Dn//efUxIjGs7XOceQhFsZcVWlYEkE11g8sPYNYus8haxIhsOY5q67mVOc4dy1DGi6rnHgnaXBEmNm5T2fXx9xHAJDKbzXH7iJiVSFB4uOWIWrFNmWxEnbsDCe2ymSqu6nHktnlaoYZ1+ps5bz0PDAN1TneJpHYhUaa2kx7CSzzxGDxRr19AlwNfQ01lOodMZyNzS8GjqMdRow5zX4y0vl//QPfu33XYM/tOLHBsv4LGZdJyFkpxIGjfFm/vFKay1ZhIX3WGM5UHDVcNJ6oghjUUZ0caqD6rAEa/BV0009FsmGUoRNjLRzIMeH/cBghdoYNpKUZV1V7zdJ4X4b2DhDnCOaK0rxiaUS0RCj0Gqa2httx1Ud6apRcpAo7WdIFWl1k8mi5l9mI1rKOphqneOsaXh1uSCVyq5o0EnjNQ3zZb2YarGKjmPW7WGYjGLjDNrVTHmm4mBJuRCcw1nl4tpqOV4EalLpQzSqJSyu4qphGTzOamJp5xw2Q67CJk4srWPIhff2B/qSKS3ssl5eTdWAmiiFs0XHLllS0tTHapTpn7NKy7JVtn418NZqzZNxYlkcthpa4yhFE3RrUwnWUgrP16BBO28VQxMs523Hm8sjohQOkmisctSbTxAl5eOsBkOuenCqRg8j/Rwe01mDM25GWKgpTKTinEGsIc50p6POE6cZG8zsjfIKM1gFT62CN4bOWZx3VCq7GOkwDEV4vx8YilA97IsaKMtMtphK5n63ZJsyKc+Jo1UnRyUXNbDZGVtoDW90S26nTOcnXVPWUQvsYkFcJVglkR1KBv1jkZLugd5ZTkLglbBAauW2FJbesg4O/xENay/re6uV8eyrSq+M0QyRVCpTFjrrsHNzwxjLem4MWGewxtKnjLeW485TIoDVtWe0s+6tYe0D4jS35Mh4zEzl2cXI0joOufDOfschC9VXdpJIIvOvaRhL5tXFgm1Kuv+hTZZSKzkWpee5Sgh62f30YsXFMLCYAQRL65EsbNOEWENj9T2+z5mSM3W+0EitNM5zt+v4zPqIFDObOLFoPKddoCufoDH7x1wBp4niM0TfYEhWSFmBFdYwi3egtY4i2mi1BiL69+smUKRQq1Efpq1IgFAc1lmqEZwx85rWafwuRWyFQZTEk1Ol+Mp+ZvoXKmJgEuFO5zmUrLk9M9WnFL34ploVue3U/3m3XbATobFOmxtGE4OHXKhGoTR1Jj+mos0ekVky7g1HLnC3XRBrZSxC661OQdNH69v/0B74b2Ni8jM2MGdW1hIblSgszbMHUxgxLK2ldY7WeQqGYoVuJuqMVCarxItqK9uaec0vSAbloxZBiFRT2CShHexz0OWhqql3qMJljNRiyKLM09uSOHeZmkGyarDFCpNUTBGMs+A1HS3OpJ1Va7nnGq6nxJALa+dx1aoB06g8ZKgVIc9YMr1c6JjHIs7SVDgNDVdMbCoY+aF9hH/gaz8mRlcUHThlOuPIoXKYEp13WKfBWaPRZ2mDVRlarWpQQw/myQjJVMToGrlNkdf8imiUaJGrsBXBO7gZIx+4PcB8+EkqGxLh8TgotrBAMJZdTNzt5tVa1fA7AUPJSDRYp/kNIoWLOIKBdeN41bZcxcSYYRU8bbGMJdNaQ6owVDAI1qJoWYN2HYLDusDCwUkTuE4TN3ni1HxyfCQfZ41Ro9gnhD5n1sazD1X3C18xXjGGperLbhE8xsFYCsYI3ltOrOGJREqu82EcLtPEm3bJhHKucykcbCUY1Bs19To+FsOuZLxAb4TLNJKyMGbBUdmVialbKDK4Qik6JdpJgUlwBl1/FZ7GUU3rbeBB6LhOkbFUjkPgqo7kamirfnZGMQgqN4pZ/VAmqPTIGI8zcNRkDiaylcRRfbn+XkSNaV57ktlPmWNn2TohpoJvdX/JopSuhXW4EDDBMOY8XyQd553nadUk+YJqli/SxGf9kskqXadkYWsTxhgu08T746AZOqVyGxMey2Hu7Mcs9LFgsexKInXP5IwGmSEZh9wjg15+ndWG28M0ApVV43jFttymTC6G47al7QdqhVa0cdhX1BxczTy916/vnMU5S2g8523LdY3clsTZJ5jS86JrLJrEHIswxswYMn2olAziNHsmm6oqD+tovMcaQ6qC1IT3jlVjuYyj6vSBZCobibzqjkimMGX1xfW24qqwqQWbVbJVZz9dg+FgC9dFTbdTVk9bnxMpqwpAWfmVKBqsRdFmijF6Jr3KEaxh6S3nLrBP6j1ZeIuLlYrFYbRhIijWG5UzYfXygtNLSsiFZQj0ZPYlPydR/n71Q3tavEgjwTrqPBaZKCyN1xtdrdRiqNUyBrjJiT/95musWs9uylzcRiqFUiaSVGXlzuFaxwSOupbtGLnOmZscEYTVHFzwQRzZSaE1RoOT5sCupQskW8lGiRMlVTamztpD1ZUetY2yf0slVEucKoeUaJ2ljz1Hy5ZV8jwaR94/9LTesbSWOiWSUTFjg6FHO6zOeRbBsGosnQsYa4mu0FDZT4ldzkz2o7mzX9b3Xk+GHr+wCJU4Vg5kVkuvk548a6hrZXTCVZn4k596nbVx7PrIk92kSr0SibkQRTnVHscaz4PQcJEST6akEiErnAbPSOHd8cCuZBrjmKh6+Cm6mYmbWfsFTLZcDc9Y++DnvIrtoHzoxhokQcqCcYZtHLizWLG3iYfDyIebkWAsS+8YYtJOBLO8aO5kuMbQWs8yeFrriNbQYTkODe/GPbc5E93LF96LqMsUCc4jAuNY6Ck0S6epoCKUBMUUjIWrFPmzn3mNpXHc9j2Pd1uVKBThiZkoogEtDliL42QZuBozhyxsSqRQOfeBWAsfxMKhVhrjyFQmCrnMAVfGkpyGv1hx3IwTORccmrDaeMtu1PXnrDZCci0EZ9mWxIPFgiF7Hg0D728HGu848pZ+yhDAGZWH9KXMXS1t5qyCo7OWEiq+ONbV8igm9qVw9xMUvPVx1sPhgO8suQrjobAD2rXDoE2tWiolCakTHqfIn/viAxbOcrufeBwGKNCQedpnZeobfQ8f47jbNlyUxM2keuiEcBoahlp4e9xxWzOt0UC5XS0ahJS8TuSdoYhgBC76kVg1b8J7x8JaNlGR2wGLZPXOGWfYlsj99RH9KDzqB9657TVZ1wb6Mc0BihaHY6JQXcVW7aCuW8cyOIo1FOtYLTxvb/fcSGJqP7mkvBddu5TxjaUipFERxXZtFeVrwIgGaeVQ2YwTf/Jzr9AGx26cuNr1QMIWRQBnEawY2upYtY62hZw0HHBXEtkLx1iyqzwWoc/qaUvoxTfP4AEzT6uMAFLZjIky55VYa2lx7EokFYuffSilqMn3kBNnywU9mWEYuNhHfHAscIwl4Y3H4wgVRpuBQrWONngWIdA5S7IW7yrBCcOQmMSS7EebMv3QHvgt5rn23syBPzELuYhGdTsQXznCUi38+Ot3udst+Z0nt3z1/W+zl0LrhMFAE2a3Nmoc+sZ+g8cw1gwIrsK2h2o0KGmMUZFPjVIyLJaA5TNdg3eG3+y3jBauh5E/fHrCaRMI1nDiHb/BLd9molYNTUIUKfcbmwNPHt8QjZp/coV9zOwFSgJQTWEXAn0ttECL4bOrI4oVfm1/xb/cXM4mYfUGdE1g8xzU9LK+3+U8KnquFevV1jomNfyMRvTTE1QWJgg/8+lPcW+55JsfXvGbD7/JjWhU+Di79Q2GFiWifHVzjfeOREFMxRTDVa9BSGKEA4OuwWCh1bllJ5ZPr48JwfO13RWQ2e0n/rP7d7jTNbTOcadp+edXF/xu3WpGw2x4LLbytds9l+9fEX0hoqFHIhWXLCXBjomlD3SNZ0+ks54Gy+fOTqhO+Nrugq9cP302YFWiAIZ38/4H95B+hMs+u0gZcK26EkUskiq9yeCgBpUkAvyxL77J/dWC33r3Mb/2lQt2k2qkx5i/e3i2Gmr0tZsbgvca1gZQ4WqfKAaqq/RTjwOcc+ANrkIohs8tV3TB8W/HDdshs+kTf/T+GWddg8ewro5/fXvDu2mnqNd5DzTO8PXNnv/20dOZHT2PrEvmViy5CLtUWHrPstHO1dIGkMpnj9dUV/m34w2/vr9G0OwUU/Wb8+28+4E8nx/1cr6C0fA108xShQQky5Dn/a+xz3mpP/ulH+OV42O+/s4TfuOff43bcUQcDFNGMLj58las4Vdvrmh9w0ghmUrNcDWOuhY99NMBh8VYh2k0g2SN47OrNU3j+Z92V9wME5e7gT/56n0edC3BOY6blq88fcLX8xZv9bJSi1DQ/e/DhxcIQiwaWnSdMz5HMpXbqbAKDau2ZSCxtA2kwk+dnUOAr2ye8t9dPFaJ05xKYjH8bt78wJ7Rj3rZRrMPSgV51tvMFTep1LQEkH9nwPeTn37A6arjdx5d8psPL+hjgUb9HFSl8NgGUi18c7+lwRFNUfQlcBUFrGC8IZpxbpJYxGljN4jhU4slITi+fdjTp8wwJH78zrGiaDE4HG8ftjwqPTM2HyPabHl7OLC5vqF4SBSSFWosBCABPYmVC3TO0WPwzuMifKpbIq7y28Mtv3G4AdQr8CyHqaaPBs74oT3w6x9DMKZiPdQyjyyshmM5a7ktqrNrsTy+2rEJPe9v9vRoCEznLF6EM6/x4Bcpc6gVV8C4Qs2CxGfmfsEHS5kxmFR90M+S9Gyt7IumTE5S8B6CWL693XMUPEch8NAKV5IoSTdKYw3Garz4xZQJFZLVy4qpaipZ0zG2iVorIRg9ZKZ5dIPl4jBqUAQFYy3G6UFLMowpkfMnh5DycZdxfk5P1u58nU9G1cNZ0+CdZVMStVSstzy+uGVsDjy83rArkf2YWLWeWirLxtF499yx36A61pQgj1UDNQwoaxbdJUTZ0DGjTn2v2Q8lRSZR3WGw8K2rDRddw+ki8ND1XI0TEgtidL0Ep1/uNk4E60jzxdYaSxHhmIax1cO/tRbsd19mNlguDgNTLWxLxlWr69Co5KjW+hwJ+rK+vxUcWFtJtT5PCgXAamKos4ZdLcy+Sh4+esqhCbz/9JZNyfQp0s4jYR8USUfWYK7WmHn9qd7ZPUNfOqher3OmWgKOoSbaYmmDZUQ4lEISRWh6ge9cHbjqIketwxfYDFGlHlVllY3Xtf0kjeD1j1HNfE4Uw9p7hpTJoFJIaxQ3OvsOrvqJbCq9VIJTN0J9/u2oP7wvsT/g1TVB8w+KXixz1uZStZWzNuC9voNN0aC+x0+uibc9Hz664rZPbKZM6x0pVlzQnBGbhGwzbQg4a2Eq1Kh0k2KVsGP8dzMXPIYxQSPq+RirmhsHZsM5lt96esvjZcf5smVhe54eFJNojBKjGmcxpvBw7DGz5Le4CkGn9+vQMKX8PMTLWA1S9BiKszzcDyRXuC2JBkdF92U0p/B5surL+v6XF/VbOF9xps7NUSXurILKWw4146Me/B9ebrnZDDy62dFXzaHxYkhF8FZVFEUEsmHhFLkak1CiKAIU0JWqe8yzJytFCM7jrWcQ1fgPFKwF21Q+3B24GQNt46GqAiMX9TVZp0m+Yg03JWKDSsYE9UJZhBUNqajnrjqDOIsv6j2RpnIZJ4qtjLXMMjUlGNk5d1D4A37g18RQDb3y1lAskFTHpDkJijBqnSMb+MbFLY01XE6RUTLFCb0xLIylmMqBpIfsDGvn6KzH2EQiIaUQWjdrldUkwqzHAsBUbmNW86Qtalry+rKbimBqIYmyYicjM51FE4CN0TCbicyC2VAk84XCwMpb7nYtQ1G9ljEGV1UvmKqwr0UNItZgqmrXAhr81cxO8Jf1Ymo+c2OsJTiDiFAmfa7ZVDCq0VsESwT+7cOnrLzjsh/pyVQP2RS8tVRnyBYkVbKBpXEch4Avc7hXroRGD0bVqI/EYKjFKB7RW7YxMklGEKaUaZ3HezikQp0Sk1R6MtucVIONXgqcVbPdaAsLZ8hGI8BrVXDByjvuLzp2OSNVR5Z2NFSvcqAd6Xl0eTWCKRVvVFpirPlEJ52+yEpVmw1YQ4smQT5DvGqcOrTVsAyBQ5n4N+/8z+z9SayuWX7WC/5W93Zfs5uzTx8nIjIj09m5oZzpNJS41EXcKkC6xQAGlhiAGPgiYQ+KVMnABMPIg5IQg6IEE4sRAnlASRQqBmUhDPca2dhgG2fviMgTzWl383Vvs7p/DdZ3wmnS5kZmnpMZmfk9oa19dhvv977PXuu//s3zPKJz5r02B3EKlEJLCeYTChXBW6HFsrQVOgnJp+IDsedfBuRZRJ6LSILWim1IeEaiEaYYS8+sUkwpspnKYPouerYplgG5/RqttcJLYbTb29vnTLGDV4rOWK53DZsUyFIqqioAuiixDRQzOSnnFSQXNR/Kj/MsPXTA88UUE6JV8UbQGq0gTYAusyNZlUHrhbGsifyX199lZg0PNgM9keSKlC+UQ0LSgo/F6fRIW5aV4zIJF6G4kzqX9wfB0g9dEgmlfdEZzTpERjJeJ8aQqJSh0kVkQE0Tk2R2ObBKJZubyJh9+BZSJpBxdj9TJYJkhUZYGMudecNlKLl7g4ahyJ9nI2xzqQAkpfAIEor08bN175DveHEI5LJ+aYV1RUZdphIoZw0owYmiqkq1/IsPn1Brw/lUVHBCBUYJOpRERlKCDeW5ttow0w6N7I21QBpQpXRYPifPMvRllnIIkSDFfTqkzFzbvSJUGeWdUGzF46UcOBNFdlurMu8nALrMNRUBDmAv2nHaNuxS3Pfya5QvajVihJG8lzIuflBkeU/JB8qg/PvBBzbg1yicNiitygBNFiqjIRfHspRLhty68kf45mZXhjVyplIKa4vkm01FWaUUtQWdSyBd7wckKlNOS/GZZbEyRMCrkul3ppSU+hQZ9jbyAjRY5s7gdTk5Kq0RTHFi2y9YRqDaD8oFSh+r1lDtN+Co4XbXcKOruPKZqxBZxVDK1UYxJQhqb/mxH8ronmWC90Ogz8h5wPOHiOz7lkt7mRYwlSnDiftFgixUxhAk8/rlGqcV014X2lldZC33KitByoBbzEJAoVLZMOvKYFUZaEOgUaa4o+piBuJsqfwMKTGmYriVc1FmmVeGQWUqZYrmbxamXFqIkghW1N5vQpgkU+kyTFnJ3spb4M6i49ZizuUUuBg9l+PEM1p5El4lisxwCay0KSpZuSSCSe9vrTngm0QKgCkBsyCoBNpIySzyzBauOJ4qFF89X2G1LhKtlCCpVQZxkPTvZ8VTTlitkCQ4pWmcIaZyEAVoKL4LJRNf1JuULooVYywqPSkLS1P6mgedcfsWm6Aowf3+gOGkvEFp21GWYkqo9P4QAjfbltvLjisfuJw8l9NUqmlakXRi1IJCYVDvKXVoVXSp2atuHPD8kXxGW1OqPiKYrMgWjCiiKsdO9tKCJsEXH11gtWJICQxUpgRUkhTZ7IMVhJwgqozOZa6u2Sv8xOKyht0HR0Whb78HG9ilxNYn0n79m1tD1xZFIGeeqZt8/fpX2nWrwhhiKgG/EYWTvZO6El5azLh7NON88jwdJi7Gwj/RmWQygwaUwkqpfJbqaDnQwu9XIw54/shZ0FmVxCmlNUYZVQL+/SYlAtYYYkrcX21KVTxnFApnFbXSZBdJxX+tzJ6wr85kcMpQm5LM8qqE0IYyu5f3eX6n9X5/LUZxWZfW3NoYjCtDwk6r94wH416uR9Qz1f3yPpUZ86IwhN6LLijOZg2nVcMmRDYhsPXFL4I9R0Wl/Rqon2Vkyu9/Jgv0Pjn4gQ34jSg6DEnBNmeIwqJ2EMpWlHNRkchSMq6XIZBFqLXhyJSmrkqVyeqwV0PZd9NwOQVCVQL1ZVUGgba5yMgdaYsHtkS8SrSNJkzpvYltAGM0t5uOmdJFnQeIqrQzjru+mCEJmKRoUWSVWWWQStGoYhqTAK/gh06WnFUNF174ar/j0XaFM4awzyKLLoGWy6Vr8LRy9CoxxGI1bQ6b3QuDykXCNSHFvCXAbGmZhqKrn7IgqcxoKOByKsOPVmvm1oGB+T77FUhFunUf1K9jwOiiorNsHaaB7RiZcuJYO4IqLWReQ1ObvTpPCdqUgNWGm23L0hjGZ+VrrVHZsN2GMiQnJTPRiEYMXMRAtFArQwNEEXYkPnbtmBvtgtWY+Wq+4knfo3RZDKPOJC1YNG02KBRV8aVjDEKUzPtMLhzwTUKiYFJpKfMxYYKmWmiSlAxXQsiiCJTncx4CKQsOTWdKw2tnNKkGz75V0RQ1nXWKaBTWwryxgKL3mZAzS2VJOjNQZo3qSpNTJj67rqzQGO62DQ5LHyJIqb4qDEMsFSGhSBBXWeMMXOZI3s9DKQ1JlcTKh5Zz7sxmbCvhq6x5PPSARjJEu6+koamz2StVlAPsM7k6OayBLwa5JKdSLgZq1mvcQpOn0moVJZOTEFTCJcXDfiLtD4hzW/i3MJbYqLL+7Q+COcJlDui9ydCyceVAGUrFfKEdQWd2KRKz0DgNkvdqdwqyolKGe7MZjYbtFEv4pDUuW7brUPbOVILFGkNl4WIK5FgCwJpS+Z80fOLGCXe6ju2U+YJc8WizKy8/C8kJQSds1jSpGA7iSuU+7Q3k9GH9e3HIe+MtVRQbrdfYmYFU3J1LJagkULVoLkPYq/aUmQ8oina+KcZuRcmgdEr0sSjgGaOZNRYrij5HYi6ys0ntBQso5qmBIkIAJfNvlOK0rjFaEWxCS0lUG1Xjh57p2UsANEKlFP1ePKHWJUmTRPCSuTefsTQ1Jy7z9m7L+TCU9se9tKwSwVJEP5QClNknlsvJNb/PxO8HLuB/5gM2pYQaPFAGZzEKfCnvVcaAEnoyVz7g3P60F4vBTFWXwbSnuxFrIUs5IOSo6PatQcEIp5XlelXRUR76V7e7UkYXoUbwKuNHIYQyCY4pp6nGGv7Mh+/y1UdPmCbhaooMIeJqg1JCTBmRhFeabTZ4hEqDzULIal82hDNj6ZJmGANjSkwxEELGeRhJpdREOS0m9mXN5PFBmHLcl7TVH7hvB3z7eHYvfUq43f7orAVxhnYqB0AcJXhCeDpONFYTVGk3aCycWoeI8HCc9oFSabbTuZTHJ+9Zu8Bd03GzbqizoWstn99dFdfILDRiCDkSptK7KLlo/4qCqrL8nz/6IR68e85GBdbesw2RrtIYK4xDWYASCh8VvSntR4hmSOXAYhRcrypOcIxjYEyBPo/soqeOsNtbnmiEqBMbk2hxmAhhKptzMoIz8gfu2wHfHp7dx0jG+vT7JqJG6EbNLmSiE7AaJZrLcaQBkiqtEVrDvLKICI/7oUgWqlKN0lFjs2IXA+ucueUarlcVdXZ0leKN3Y6owYuhEkUkkCeKkReljC5aqLTh//LxV/j8187ZycRmSuwk0zYabTRxjCidiQpGKZUiYzRjKj2ritJOds05lsqw3np2OtN7zzQF6ixF+i6Wa58oLRkzYxGbSV4RJSFlpvgP3LcDvj28twdLxox5P7iokFo49ZadD4T9odNEzdM4UFldWg2SorZ6v/7B/d22DN6qEpjorLEIuyFzQeDO3HKnqTnKFjezfH61Kh4PuWTsNzIRprSXvgaxCvZmXX/+kx/iq2+e08vEVZjY5ETjLMYohjGiKJK1Y86MCNZo+pRQe/5ZpbjpGs6MY+wn+pTpw8QQPE1W7OJeeEOVCn0k02FLltlDTImsi0z319+3A759PLuXY0oYbwoHNSQrzCZhCJlkS6VPJeFKRipdMu2kkqFvXIkDH01jaavZz2YioL0whUxuhdOu4rRqqKkwWvH2dgUoREqSuFxHLGtr2FerHDTa8pl7N7j/aMWUItsQGFLC1IakFGk/8+L1s120VAZ2MZeWnX0ceIql8UVOe3KKMQl+SugsDDpCsSUpSWISjbFkXVqTEmVNNpL/wH37o/CBc9p9++23uXfv3nf7Mr7n8NZbb/HSSy99ty/j+wKvv/46r7322nf7Mr7ncODg88FhDfzWcODf88GBf98aDvx7fjjswd8a/vc4+IEL+HPOfOlLX+KTn/wkb7311ve9VfV6vebevXvf8msVETabDXfu3CkKKwd827i6uuLk5IT79+9zdHT03b6cF44DBz9YOKyB3xwO/Hu+OPDvm8OBf88fhz34m8P75eAHrqVHa83du3cBWC6X3/eLzTN8O6/1B+EP4juJZ38wR0dHPzD8gwMHPyg4rIHfPA78e3448O+bx4F/zxeHPfibx/vh4OE4esABBxxwwAEHHHDAAd/HOAT8BxxwwAEHHHDAAQcc8H2MD2TAX9c1P//zP09d19/tS3nh+EF6rd8r+EF7Jj9or/d7AT9Iz+QH6bV+r+AH6Zn8IL3W7xX8oD2T79Tr/cAN7R5wwAEHHHDAAQcccMABzw8fyAz/AQcccMABBxxwwAEHHPB8cAj4DzjggAMOOOCAAw444PsYh4D/gAMOOOCAAw444IADvo9xCPgPOOCAAw444IADDjjg+xgfuID/H/2jf8Srr75K0zT85E/+JL/2a7/23b6k54K/9/f+HkqpP/D28Y9//L2vj+PIz/zMz3Dt2jXm8zl/6S/9JR49evRdvOIfXHw/cvDAv+8dHPh34N93E9+P/IMDB7+X8P3IwQ8C/15YwP+tPLB/8S/+BZ/73Of4+Z//eX7zN3+TH/uxH+PP/tk/y+PHj1/UZX5H8alPfYoHDx689/Yf/sN/eO9rf/Nv/k3+1b/6V/zSL/0S/+7f/Tveffdd/uJf/Ivfxav93sa3umB8P3PwwL/vHA78+0Yc+PedxWEP/kYcOPidw2EN/EZ81/knLwD//J//c6mqSn7xF39Rfvd3f1d++qd/Wo6Pj+XRo0f/3Z/77Gc/Kz/zMz/z3scpJblz5478wi/8wou4zO8ofv7nf15+7Md+7A/92tXVlTjn5Jd+6Zfe+9wXvvAFAeRXf/VXv0NX+P2Db5V/It+/HDzw7zuHA/++EQf+fWdx2IO/EQcOfudwWAO/ER8E/tnne3wo+Af/4B/w0z/90/y1v/bXAPjH//gf86//9b/mF3/xF/nbf/tv/6E/473nN37jN/hbf+tv8fbbb7NYLFBK8af+1J/iV37lV/gbf+NvvIhL/Y5hmia+/OUvc+vWLZqm4bOf/Sw///M/z7179/iVX/kVQgh89rOfZb1eA3Dnzh1eeukl/u2//bd88pOf/CN/r4iw2Wy4c+cOWn/gOrS+K/hW+Aff3xx8UfyDAwf/Wxz494048O87i8Me/I047MHfORzWwG/EB2INfG5Hhz2maRJjjPzLf/kv/8Dn/8pf+SvyF/7CX/iG7x/HUVarlXzxi18UQP7ZP/tnAhzevsm3t95663k/yu9JfLP8Ezlw8MDB54cD/w78+27jsAcf+PfdxGEN/OBy8Lln+J8+fUpKiZs3b/6Bz9+8eZMvfvGL3/D9v/ALv8Df//t//72P//Jf/ssA/I//8w9hrSGGxG4KpJyYVZZhyoQYySJoDSiFsxqnNW1rMcaQpoQ2mT5mjivDvHI0zuCsYpczIpkoibm1OBSrMaIUVE4z5EhIMKsrPnpzgUXTicGnxMXguRw9IWdc1jSN5cm2RySjlKZPQlcbrvyERnPW1Fxra9YhstqOHLcNYw5EyZAz05S4M6s5amrWISFKMa8sx51lSImUDbPKMHOGmbW0TcvxSUMOgW2fCCnjY+J/+fv/PxaLxfN+lN+T+Gb5B380Bz/149epGkvIwnoI+BBZtI5tPxFIoEBrhTagraLRhkXrsEozbTMZYUfgpbpm2Tra2mIrQ08i+ExQcL2paJXiwaYvv7+zPPURnzInTc2P3zulVpqZNex85OG659FmIiYwojhyhjd2O0QEpzWXUVjMLFdDQgN3Fw0vLWpWU+JL5xvuVTU7iUQykjOrbeS1kxn3uppHYyQqxXHnuLWoOJeIlpplXXHaOk7riq6dc3LdID6w2kR8AB8S/8sv/NsDB3m+/Pv4Hzti1jVkMldDzxgjy65ltRkJuazxGjBWo7Wgs2Le1VROk7yQVGYTAzeUY1ZbZq1l3liuciTFQC+Z66aiFc272wkjmXZmeDAFchaudw0//NI1nLVcr1qGmPja5Zq3VxskZ0zQnFSON3ZbYsxoFFcpsmgN6ymhNNxsa243DUPMfGW14+W24fE4MkrCakWMmTtVzcttxXnMRK1YNI4bs4peZbSrOGlqllbTKVh0c+7eWZCT58nlxDRmUsr83/6fv3Hg3x7Paw/+0f/jXebzGgFWvWcKgbapWe9GfCoc0aJwAsaBc5b5rKEyFpIgIjz1O67bmnnlmLWGrnFc5kCKHp8zZ7aiQvHubkKlzLI1PEyBnOG0rfnY3RNabTnBMMTEO5ueB9uBkBMuOk46w9fWO0JMaCn8m9WWbQ4o4GZdc6urCVn44uWGe03Hk3FgkoQzIB7udBV3uobLmEhaMWscp84xEsiu5riuOLaahVbM2hm373TkmLlcBfyUiCnxN/4f/9uBf3s81z3409doZy1ZwzqM9JNn7mq2kychiABeMIBxhkXXMZs1GA1h8OQoPJ12XFeGRW2pW4uuNVNIjDngBa4ZRyOaR8NIhaK2lkdpAuCsrfnozWO0MZypijFE3t7ueLDtSTlRZcPMWN7td2UNFMWazGxm6H3Zg8/aitO6pk+JdzYjt+uG83FkSgmjFSjFy03NzbphlTNJK7rKcNwYtiSaqubIWebaMNOWWVNx42aLSp7zVWLykET4v/+//uP/LgdfSEvPN4O/83f+Dp/73Ofw3nPz5k3+yT/5J/z0T/80t+Zz5l1NTJnVbmQXJk7mDeerkc3kSTnjtEY7RWUVKE3TOJTAboxoNMYIPgvbFMg2M9eaMSVeW84ZYkSj8EHwKfDq0QzVwMU4ESIctRUns5anm56b8zkaRVMHmn7icpxIIXHUOXaxIueMMeCj4GpNhSUm0M5Q1Y5OK7ZTJANZK4aYGWPEoZgUjCpz5T1TzPTJYGzLJgTOV555bbixaDHLjioGFvMZeQI/TUgOYMp9VEp9V5/j9zL+KA7ePe44XXQkFOc7z1U/cOO44e3zDespkLLglMLUoHR5FFZpdNbklHFGo41hnRIhwMIKS+AiBH7s9Jg+JTptmMbIbkh8dNni5ophI1hRnDQVt05nvPtkx92jI04Xiq5qaN2Op9uR7Rg5aWse+YBIpraajU1UtaFKwpQFsZqqqpgRQClSFpISVimymSJOYE1iS+LtXc86JI5HC3Q8TonHqzXHTc2HT2a4swVGKY7mx+RRM+w8MUecLtw7cPBbwx/Fv5vzGXdvXMNZzdP1mkfbLdfmHfcjbEIgIVgBW5WAP+ey/ig0Q5gwKLRRbGJklEQwibpVXISeT5+dMoREnRS7XWKzjfz4jQUyV2xzJkThqHbcmnd89WLDR06uc01rnHE0xnLRD2y2npNFy4PoiSZilWITE9oqjOhyfZWhbRyETEKYkpAMjDkTcrn+tSQuU+St3cg2ZeaNYYotlyFw4SPXu4aXZw33ugYd4eTj10gBVhcbJj+i1YF/3w7+KP5dn7XcPl1greVqFzjf7pjPG95RivWoiCnh0NRWo6ty/11jIcN6PeGMQlAMIZNUIFdCazXb0fOpkyN8jFRZ0Q+Rqc98dNlRt5rtKKQonNYV944WvHO15fjkmGta0dQtndtyPgysd4mTtuXhNGG1winFJglUYJMhZcHWhkVT4bOQ0XgRklYMObPJmUoUW8lcSuSdYWKbEu2ouVc3XCXP+XTJWVvx8rzhlXmLBo6OThAf2a23hDQ+24IP/Ps28EeugYsFN06O0M5y5Qcera+Yq5q344Yhl6SbraGuDNpotM5onUgJLrcDNeW5bFMiBqFzmba2XObAj54sWI+RShTTlJnGxEdPlwwWtkMiZ2HhHHcWHfc3AyfHLUYrqsrhtOFpP5C8cNw2PA0eoxNOK0aVsI3FCWQlVLXlqKuwIfHWZiRIJhuYgEimoXCwIfDOOLHLidYqbk01lzmwi8K1quJu1/LyrMOSWS6WqJBZrQbGGNDvcw9+7gH/2dkZxphvkBN69OgRt27d+obvr+uauq4B+MxnPsOv//qvA9BZy2lVY7TiyFWcjzvmbcXOB/qokKxKcOUArViPnk3w1FpTWQOiiDHgrGZIGZfhxNTUxvLqYk7OwptXO95ab7nsA5+5VrGWiQqF1oJVwjhF3r3c8vLiGtYY5hhAIwjBZWat5SwLMSRiFkaV0DqzMBW9JJJAHyL9FJk7A0noY6BPkZAEn+DcJ7wIIUMWxRQyUYS5czzIA6sxg9Ik0YRWuCcLlFEYrbAosjzvJ/i9jW+Wf/BHc3BmDGe1pakqrncNb681JzPD1c6yGSPJZ6wGcQok82SceLLtmbmas25OLYqnw8TUWsYYsUHxieWCqq740RsnKBG++HjN5893vH018n+6ecwTGWkyKKXRwGbyfP7hBR+7fovWOnRnMEkwQWitYTGveQUIUyDmzGgUYDi1issYkQy7IXExem7UFTbAaopchoCPCZs0D3pPhSIJCMI2JqYo3GwqvpYGGDJvIaSYeeU48jFZYlzhoEGR5UDCZ3ie/HNGM9eWk6bjelVjc2be1Vy0hnX0TD4iolBGyFlx5T3n40RtLDNdYZNiSoHKOHpJtMlwQ7fQKX7k7BpNNvzWg3N+62LFg/XI2au3uNAjDg1kchYux5H/+u4TfvzWXRpjuN522ATkjEWzOO64lyPTGEkpk7Vi0pETZ5lyJgfhcufZxcRZU2MSTCkzpkyOghd4kj1DSmQRlCqJkxgzMwwP4sTTYST5xHYV+KGTTIhjqart+SfpRT7R7z08rz3YGUejLSeu4dbJjDe0oaoVq8myi4oQQUQQC0kprvqRJ/2AE0ObLSYrkkpkZ+hzos6GM1uh54ZPnZ7hsvClp1d8cbXh4WbkJ86OSVZwUZETpAi73vOFdy/56OlNauM4bTU6AwiGUvG6HSaCL2vdlBQjgWVVMYVIisLlEOhT5npdo4FJMlMsB+SQhUdToBchZUFJSQJOJjHH8DB6LgePioLvE68eQYiB2oDTYFGE/IIf6PcYnucaqEVokrCwjiPjEDNhrKJxmr4PxJjQ2qBqC0rxsN9Cv8OJpgqajCLZRNKGTU6YqPiwqpm1FT92ekr0kf/6ZMWXVlue9p6zOzX3ZcKmsg5NIXE1TnzpwQU/fHJCbQwnTUXsWlJMRAuLruZmavA+IgAqMRphYSqiSiCKzRTZTpEz5zAZfBJ8yogIPYpHBHYq43MmJmEUIVnhxDieTgNP80RMwtAnXjua8SkDVlmMNhgS6X0Ggs99wqSqKj796U/zy7/8y+99LufML//yL/Mn/sSf+O/+7Oc+9zn+6T/9pwBscuTJ1LMZR0wWwLIdRnwOoAWlFaCAipw1oHBaYa0m1xplFNkKi7rmyNZ01DS65YevXWdZddyYH6GVpfeJSiummBmGTEBhncNpSz9MbH3inaunrIcN/TgQvKetoao083nDsqtpjYOo2PjAaspcX7RcX3TMKkcGgoKudlSVIWYIsZTjldNURtHnRFNrTuaOeefoRbj0gcZqmsoQJPGk73lnM/DVN5/w+GpLSAmNQWXzR93OH0h8O/yD/4aDAu/2A5d9j0uBnALn64FeBaLNZFuy5ZIVIYB4waLRRjFIwKuIkLjRNNysWpamoatb/szL9zjram6fLpjQPBw8ulb0AttdQhvFrDXUWrF+MvJ4DPzu4wc83V5ytduxHTxtZWhbw/WTBXeOGo4XjlQrno4T5z7w8tGce4uOxhjWPnIVIjecY9lZ4pTo+9K6po2lrjSbkDjuKl49nnFv3jGJcDEkjrRj5iw+J9692vLVp1f8ly884vH5lhATRoE7bHjv4XnybyeRNy+e8PqDdzk/v2CznXh8uaFXgVRLOWhqhVEVSjQqQSUapwzZlsRENKU17FrVMDOltfF//thHuH18zPXTY7w2PPUeZWGTYN0nQlJoY7Bo/CoSY+bX3nydrz19wqP1iqtdj0uaqMvvvj6vWbQWtGKXApsp88p8xktNy4m1GCX0OnKtrjlqHVopYoSQQWeoWs2khLYyXKsdJ87ik7CaIpXSWKUYU+LRNPKF7YZf+437vP3wCgkRB8R0IODX43ntwaMSHvU9D9ZrrlY7druR9XZHkIwoDUqjlMLaBusdJmgq0VRWgwXRiqwSx/OGa23DXFe43PKnX36FmydLrl87IirD1RjRVuOzYjOmkrSoNGjYDCPrnPiNt+/z4Pyc8/WWy34EwGhhPmu4MW84bh3aaoaU2E3CS3XNnarlyNQImi2Z61XLsnHoXPgXBRSKem7oJbFsLHcXDbe6hiEK2xhpK4tzmj4n3hlG7m96fu2/fo13Hl0gKdEYhT0kPP4AnucauIqJdy5XvP3oCRfnl2yvJjabHZlUOGb3QX1S+G1GT1AlRaU0GI0YRVSZZV1z7BoWqubUtPy5V+9xvVvy0rVjRGnOdyOIsJkyu50nU1olATbbiVUI/Od33uX++Yqnq57t4HHKIE5x7ajl1rLhZFZhKs06BdbbyI225W49Yy6OMQhrnbhRNzSudAD4mEpSJIOuYUiRxhhOq5qlrel9YjVFGmdx1jDlxMNp5MvDjt/6wjs8fNojMeIQdHp/1aUX0tLzuc99jr/6V/8qn/nMZ/jsZz/LP/yH/5DdbvfexPYfhZ/6qZ/i/v37/NzP/RxniyVGwTR5JvHcrirWQDdGehIjgUTiGpaFc5wai9+XiZmEZe243jbEMKGt43Rec+O4Iklk12f6CnbTRAwZjcYrxaJqOW1hlIQSxYmd8bFKuOgTG9nRj5FhCFhXNse3+y2hTxjRiNZl40lw5Qe0UoxTZjcmfBZOzo7Y+i0/9tIJt5dzJGl+/fUHnCxbHm+2xLifupDMbtdjjEacYTNlUkpohAubuJwGSE947eyIe9eW1M1BFeC/xbfKP/iDHPzwnVN8TKx3I30IfGR+zNPUczVOrOPIEEqbzC0zo5s7hqohBYix9BUfLSs+9uodrrYTTVXx0knLq9cdKW256i0uKrY+EnPCiiZl4VrT8lKl2eWEUoZb9ZyfnAeebntWfmKz9ax2nuwslzHwlc2W7SrQisI4zSRCHgKPTY9Risud58lmxCv40I0z3hp7/scffomP3jpCKfh//6evcW1e8bXznq0IViuyZMImsag0Sgnnu4kpZZSCN/ue803PNiZ+4tUzfuTuCYvj6jvwVL938Lz499qN2/R+4mq7Zesjr54cs/YjF9sR20emCAlhFjOLec3SVChlEBQxBY7mmk8uXuJ8u2M3eRZtxSvXWtbrFT4aqsqyWg34XnAYfIpcq1ruzuYEk9EWrpuan6hPeLQL/E56TD8Gtn1ElGZF5K3VjmGYsElhjGbnMn5KPOxHjFb0MbGeIuOUeOXWgq9tdvzJj9zi43duYFXFL/1vv8NLZ3N+72IFUyILRMlchUiVFK41bMeEDwkReGfyPN6NjF96l0/fOeNHbh9zcuS+A0/1ewvPYw++uZjhJXI+eLYpcWc+Y5cm6q1HRyEjBAXtFOm6irldopQiK0VIkUWt+HB3xHYcCSEyrxx3TxrW657Yb7CmYrWdGMeMRZG0sFx0/CRzJh0xRnNXzfkJp3i83fLb8Zx+CPR9JDnDSOTNr26ZhogVUFYxusTkE5sI1hg2U2S18Wwlcvek453dwB9/7RYfvXsNay3/n//1y9w9anl9vSH6TO8TUYR1iNRZyLXmqo/EXNa/tzcjD/qB9X95h0/fO+aHb51yNGu/Q0/1ewfPaw28vlwyBs/jYaJNnrN5Q8qRXZ/YTbFkxJUwF009Nxx5C2hEIBHpWsWtZkHYjXgfWVaOe9dm9P1ESltwjk0fiJNQaYPPiuvtjA/XjoEISrhJy4/Qcb7ynE9PShw4ZqQybFPk8TCwuZowubRXeieMMbGKE0YrxpzZ+MQ4Re5em3GxCfwPH7vHa9eX5CT86//8JqdNzburHcFkos4lE68dC6e4GCY2QywzM1rzsB95upno5QGfvnPKp24esajeXyj/QgL+n/qpn+LJkyf83b/7d3n48CF/7I/9Mf7Nv/k33zDE8Yfhr//1v87P/dzP8Zuf/xrLRc2NkzmvXD+hqSp0v+HRuicnIJVhh5wyOwMtCgcoBWI02RqGFDFKo1Bsfeb11QBAlxSRzKPNyBASM6s5aivWORIzxCRYDZU1LBYtEiKPh56UMsaU8uSto4aubsh2ZDUELnzCGsWNxnLUdiileCoTlzHirGHwwpMhoLc9XjK1Mcw6zQ9dW9IZhdWlRcLHxFsXa5xRNJVBJ2ECMppaC7t97//DfsSLMD9k+L8B3w7/4Pc5+P/9tS9zcjLj3ukRH79+wrI26Kni9y53xAQ5CllDDMLOQeMUohVJNNkK2cEuRpIuZeQnu4B6WLJBnRFiWvHW4xXbPrJwhmuzitW+1WbIkarSzLqaW0dLjBp4o++JIeEw9El45WzBWWep28ST9cT93Qgq85HFnNNFjVKKdQoMfaSpHLsQePNyh5trcImFtdyYW/74Szc4qi6os6VSij4FPv9khdPCrDZohO0gpCTUFh7tM8Jf2+zI78CxOQT8X4/nxb/ffvyQzjiuVw2vnh2znHe47SVfvVyTUkZlQSil57WPdNaiBFJOKCOMCtZSApWudgxZ+F+/9hSA201FDIrXL7ZsU2RuLKfLjpA9OWemEKkwdF3L2UnE5ok3xh0pw8w5VlJmmF5ZnhCf7ni66XkUPEHnMii+7NBKcb/v2YaRrjNsxsD91Y7mqQYFS1dxY1nx2VdeoTNvo6aItYZRwW+/+QiNUGsHFpwCJYpZbTj3AbGKr11tyDFw4g78+2/xPPbg//z2Q5Zdw535ER+5eUZTada7K7623kECFQSlFFHDLkTqfdVdAdopfKXoMxgMutL0CL/x7hMA7lYV2xR583LNLkZqbbg2nxFIBBUZY6DGMVs6rh9X6NhyP/SIgrZybCXSNpZj51hax9UQeDd6AplXuo5b8xatNG/Jls0UqK1hDIG31wN1qzEms6gdt44qPv3STarHFh1KhtWL8J/eeoJkwWlFU2liLK+rqxUPvSfmxJefbumnyLWqeaHP8nsRz2sN/MLjJ8xtxa3ZjFdPj7DG4Hcb3tqUvVBiIivFpAOiSj98EiEBziqiVtgsGGtptWbM8F/unwNw0ml2KfH21Y4pZpwzXO9aLmUip0BIEW0M885x+6jDqcA7oScJOG1Y50TXGWprOF00rIfA4xiIRrjXNlybVWileDhM7KZI21n6MfBwN3BttaYyZQbmqDH85Mu3+Z2HD6kTGG0YlPBgvSNn6MSAFbIIRikqFI+DR3Tiy5dr+hC43tTv676+sKHdn/3Zn+Vnf/Znv+Wf7/sJQWiqiv4kkwhYW8qI1hqqUs3GGoVkAaMxppQ1ohKiTiV7b0ApwafEMAqQ0GNmnGJR3EFKiTIpphBxVqgMNM6ilaKtHbbWDL1n6yNTyviQaJ1BhcRF9FymwJAFrRSnbYO1rmxotZByZkol45uA3ZR4IhNWlet+uOoZQ+bGrGLZ1UTgfBzRotn4wC5mlEBrFa0zbGIEo/A5s508Ph0y/H8Yvl3+AZxf9XiEWV3Rny0Rn2lqh9UGV1lqMkYpVAVZ9mopxpQ2Lp3ICrYh43VGkwkpMWZFTgJPBq7Gibc2PVMMtFpQGbYhoXOkMZqlcxitWcxbWlsCtnWc6GNiCoEbTYXyiXemiUdhYp0jWsGNWU1Xl3L7jZnD+5reZ/rk8ZJZ7Tz3H0NtFD4Kb1xsGKbIzXnN2bxhUpl3dgPWwPnkWU0RRJhXiqUzPFaZptJMKXO+HdmJfz4P7fsIz4N/O/EYFMkI4sDnyKKusMbgKkPOCg0oAUkgWlBktAJtNCBsfSCoMty2E+G8DyQF621gtQu8uxsJORPJqCisUwARnNF0pvBv1ljmrmI0pR9/HSPbKfDyfIaeAhfR81QiPRmbFXfmLSezcuCcVMbnRD8mdiEQcubpdiTnTG1KafvLD59wtR2519RcW84IleWt8xWSFVuJTDmjUMycZlk5rnLEOsWYE092E2sJz+WZfb/h2+XgdppQThOt0BzVWDJtcGijsZWhNkUlquxlGWUNBhCliBZESitWloRCMYTExX7YfLP1XAwjj3YTPkUsIFlYx4AiUWnNQju0UXRtRacsUy9cJc9migwx8fKyxmbD0xy4kKI6ZdHcWjTMW4tSimu5YogNky/88ynxZDeSyLTWkCTz1SdXrHYDd+uG611LMprr3QYfExsJRBGsUSysoUWxSRMY6EPi8Xpiqw5DJH8YnscauJ0mECGbGcdHC1JKkH1pOWwclWg0CqUghky0Cq00RimShYigYsnUY0r3xuUQATiZ4HLyPOxHIpmUM1nB2gc6W1TvZsZhtGLZ1XS2pt9mViHQSyKEzN2jhjprLrLncr8GGjR3Zh1t61AKTiQzxYRPsPWRkBOPtgNTThgUY4688fSCfgxca1quzVqCVVzsepTSJZ5N5Xrm1mCBDaFUUH3k8Xpk6N8fB7/rKj1/FDLC5BNXm4G3H19hjeZkZhEUrTU4XaSIomSCBzercK4Mm6UYQEqQLfuNz0tGQkJLwkVhNwVCEqwqJ/fHg6fPARvKFHdrSxbKGNhMgV0fGGIiIuQkpJBJMTNliPtrNii6qsZZR5RUJOaMpVOZ46pmVC1CBimqQmOMnA8DtTW4/ZBmECGg6KxBpghSFDic0fgkpJQJShFyZsyKIR4WmxeFmDL9EHiy2vH640ss8NLZCcYY5k2F0WWjC1qIPmKMoXIKZUqlyaCZpkhsSpUp5MzGezSCniJPe4+PmQoFEd7YDFyFACGyrAxLVwOCtcK6D6wvPbuUCFqQLCgv+CDskuARQFGJ4sg5FlVFSJFea46spUO4ueh4OUScKHIQkijWPvLWekdrNI1TGFuGibyC2lpy78micFZRV5ohC0GXwC7kTJ8TQzpw8EVg8oEeuPCaaqcxWXOtdjilaayhyH4JGUXwieBTUUqpNU1r0aKZJk+ygmhNAnzKmMZwNSTOJ8+UMtW+CvrWesdWBRqr6KJhpjJqKVSuzIFsrgKbEBhyIsREFcGHwERGLFg0RhSLqmbZ1OSUmBvD0jic09zpWvoUywaWwWrFegq8fXmFAyqrUAiDDwQNs8rRDyVYdFpRW8MulIN0FiGIsM2JTTjw70UgpszgA+dDz1ubK7QIdvQopaidKbJkuSS1wpQIU0Lv+Vc1pb0sTIGsy5aXBEYRjFVcTpFLnwgiGF0Orm9vBnYkOiPMtCapMtSotaafIttVZOsL/3wsClMi4BUkozC58O+oqlhWjpQynTEsnSOI4mbbsA2RSSVCEpyCSz9hwgqnBOcgx8wuJhJC11T4qbSMOK2pnaUfSn93SR0KQ84M6ZDweFGIMdEzcdn3vHu1IeaEjgEocuwCqAxJMsELkwdjFFVtqZwDDaGPSG0KB7PgVaayFjUGzsdIyOX5InB/u+MieFJraEXR5owxirpyrLcD2ytPnyJeSUla7DkXFERdqpA1mqOqSNF6SQwmMjeGgHCzbhlySaBNPlNpzS5FHm23VFpT7ePVMUbGnJjXBqN1UZ1EY7UprcSmrPsoCJK5mt4fBz+wAb9kSClzte5Zb3oAzs6WdK1hbg0pKbahTD5Pg2C6jrZyQCD4hA2WHBJOG8QqAokxeaqsWNaWEEtUJkkwKL663dJUCvGBmc8YLDfnkFTmrYstr7+7xjSK+ZGjcpbtOuIay2nVUIlhkwKynyM+to6Nj+xyxqC43jV86OSExdbxbr+mtobOOr7cT+hOcdRZrIGrfuSdfuR8iDQLzbJ2NLrI2yUyT7cTjYUcE8YokqaceA94MdCKmDKPL3esthPkzGoC5xSnbc2oNP0Y2KXIZhsZxFLNNY2DmUm4ZOn7gNYtqlKEmNgOI12jOe0sSyqsAj8kUoR//+SSU1Mx9iNLrdCiee1OhOj53Tef8GuvX1EfG27ebumc4fJywnQVt7uODst5nPZSeYrr1Yynmy1xKoeDl5YNP3H7Jmd73fR54zhqKx4+vkBpOFvWOKt4sh348qrnnX7kY/Wcm5Wj04YEZJV5fbNj0VmGPtPbjLKZnA9Dky8C69WWsbFsx5HHmw0pZT60PKVin/1M4GPEV4r1biSMmWyExXHpU62ypV+PuFmNWIMiA5qTrkZioBGLKIhTQmXNrz++4LipOZk71uNEcIGP3j4mKctX3n7Cb37xEjWD4zNLZxSxj4irOKkqaq1ZT5FtTIBhYRtWww4/ZUBxd97yJ+9d527b8l+vVsznNWeLjn//1bdwVnFn2VIrzaP1lq9sdry7G3n1yHBkHU7KAKdo+L2na+adZYwwqASuJEkOeP5IKTNOnrefXvJ0u0Vpy+2qxoii1RadhRAjO4nstpEwJLLJLI4q7h5ZrHH4VcDM6v1wpVAl4aSrQU3MVYUaFX6MqAi/9eSKRd1y0sE6TExT5JUbS1JKfOXxJb/15iV0wuzYYhX0m0jdVVxzRUd9lSNDDCjRHOua9TCRvaC14s6y4zO3zrjdzvn8+pyurThpGt6+v+FaG7kx73AiPLra8vow8Nau58NHS05thUMjCkJWvLnraRtLykI0EI3g04F/Lwo5JsaUePPxBQ/Pt+hKc7uZIVFwKHIG8ZnBCf0YCENZE+bLmjtLR2Ucm9GjqiIqoFRJLJzNOoL01CmhBDIZSfCbTy6Y24qEoMaId5GP3z1GtOZ3H1zw+XdWmKVmeVbhjKLvM01tOKuKn8RqimgBjeI6NY9DT4qCUZqbjeUnbp1x7bHj/rhjVlcsqorf6B/RzA23Fh3Ow4PNjteHHQ+HkVfbmqVxpZ1FFwGYt8eR49YREUylsU4z+u/xDL/sE+EZKT1ZCqZhYFnPqCpD1kUHuA8ZI4oYPMMQySnidx4qUD6RJaCdpdJgkiHnwM5A1kLMmRhLxiGnTBosqtIMJGwO/GhnETF84tqcPES8ztS1xWgHa/A20dSW2miCUUxZuBo8s2R42I/YynDnpEV5RYyR06ri4Q760YMRqsoSoyJGwyrF0qoRwQFXvWdRG7pOs/GZJ9tERPHKvGbwCR8yfcjEQ3brxUKE4CNhjKBgve25ftQwqy2NKsYtqzGhs2bcDIx+YFcrdlYRHUTvcRvBVBZnYElGNomVLSYvkxJ2khANzaRY50Q1szxVidpE/nRnqbH8xIevMw7CaCJL65h1FZvzCFVm0RhSpdlVsIrC294zH3q+cnEFFn7o1pJmEqbJc3PR8Pl+zXYayCZTt5ZKlw3rqg+spsgQEscYHo0DN2vHzbbmwkdeX08Imk8ez7kaA2HMrIeJGA8B/4tA9BmRksAYtEYpSA7mVYUxGqcNO5k4347k/VC11YoUMufnPUvbEH2CNGGNoXaaWaVZDMI7eUK3EKfMLiWMyqQBZBC2YWSUwN2jOf9T7ahxfPZDZ8ikWAdPVStcpVhdRuoqMw2BaX/oa2vNOnt2U+QrFxuMg49fX1IHoe8zZ11DWF3waBhIz4zrgMHHwqcQmQSWleXBeuSlec2NqmYVIl/b9CTglq3Y5kQc817U4Lv6mL5voS2YyiBG0aeIyYmpMpy6GqMMem9iOQ4CqQRTxpQkydOrkWUNPkTsFrQxJYNZKeZJ8ThFdG3IU2RMpTopOZN3I5OCoCPeKVSjWNSOH33phBwyq+AxFmyt8atErDIxRUJIkIXaaB6OA0czx1fXK4yzvHb9hAYFE9ydNfzXteLJbiDFhAUqYJcCYYr0KRNUZl5b3t5suD1rWFaWbYi8O/R44MO6YkeGAH0qngEHvBhIln0WOxJiQCfN9WbGzFYY0VjxTCngfUJyWU+UUURJnG97lq4hhoBdK5QpClJNbWiAczymc0hOjDEhaOpcpC8nExALZu6wdZFA//EPnZKUYiTROYOuTYkDDeSUIAmVVgwqcZFHZqPhyxcbbGN57doxTZ/o+8C1ruWrw45h8gSB/QmBYQxsd5FViHiB2ljeXW05q2vaWtHnzJMQiAivzec8nSZUUExRmML74+AHN+D/uveZIt+23U5UtQFTY41G14aFarCVJkUhT4GcMoIm+ESDQqVSfHNGcawNp03L23ZkSEUz1WqwFegsoCdarai1Yal/fxh2sej4xD3Ng93IQ+/ZhIHdEJCkudFZusowbw3Xq4bbswVnXQvGMKQAGRbWkHLm6dhTGcUQhMfDxMIZvI+86684qhu01lQKjivFhLD1iUpn+jEx9AHlSvvQNn/9vTkM7b4wyH7BkdICiMCj8xXWZHLnSqlvablVd+gzy7TzhBTxKTH5zMZFOjQimeQDTmnOnOPmvOZBDY/HkTyANcU7ImvB6kxjLAtnud60GFOGce7etfxPteKrl1u+Nozcl4G3NjtssLzsK2bOctI13J07PnFyxN3lNay2XE1btBLO2hoYeGsYmCvhaR/5vW3gxnLG1TbyaH3Fza6mdorOKcyR4TwlrkLEa+HpzvNoPWGqcr2rnAhkkpKyYB3w/GH2bwhJMtpqLtOAUg6VBI3BtS3NOJEbw7Ktio54zAzbgHSBjiKJN8SMC4pZctxxBuqOd+OEVpraGKrGULUVFqGtNGdNw4dOjt7j39mZ5k98QvHFJyu+vNqwmSLvXPWYwbBoDfPKsqwrbh51fOL6DV45u86sdqzGAaUVp0pBzryxWdOJod9NvL4eODWW7dZz/2rHNetwRlMBZ67inTBxETxjzlz1oRxsTJE13qVMNHvDu8MY04uBlJk4kdJak4ziMgzUWLLP+JgRK1S1QTvNrKpRKKaQ6NeRzXGgQUMWYoxooMuWa1qYqorLECAKlRhsZzDWYMlU1nBad9ybzakp83CLU8dnjOaLFyu+utmyw/NkmjCXI61VdMaybBy3jxs+fP2YV7przGzFKoxoDWcUHt+fNnS6yH++sVuzRLP1mXeGDSfW0VrLTFl0rXg3jZz7QKci66GonYkBHzObFImmcK+qDgR8USiNKwqQso9Omce7K242c6JP+BiJ+357NHSzmiylzWXcBWgVLYocI/iSXLCjYS5wbItQi8oKI6Zky62GWnBV8YI6q2r0fg380M2aRdXwpdWa14cdo/Y8GUZUMjS1YmHLGnhv5vj48TVOl3NEG4Yc6IzmpHV4hEd+TU3mfAhcbnvmyvL2o543nbDUlkprGqUJtWY7Ja5SoFWGPkQuhxHRgveJdUj45NG6zNG8H3zAA/4ysKr2JVsfIPsMSci6mGZYo2EOt/SMBs12mnjnak1DkclUJmNMuYGdUsQqkkLmpa5lsJm1jyQSprFUJKpKFSvttmIYJtqmplIV80aQaeRqmOglgVVkLexCMeyYNYqbteO4qkhZmFLRr1YCKz2woC2Lj5QDxWQ9u5zptAMcSQlZFZfKheswYWQ9BPqkmJLQGc1pU/HWbiDl0iumAXVw3nphUKWdDrIg+7Ltrp+IsUWyJSGMKdHUNbNlzcmtOS4qLlYDX3p8yayy5N2IsY5aWTptWFiNIrMeB14zFRdNzaPkCSjqZYUhYI3irK242VbsdiPLeQu5YdGVDNjDzcQ6RnRl8BJ5OsKYhGuN5qW64fbiFJWFESGJxqbM2k8sZjUXG4/F0NUwxsh2jMycodpbcowZgta0TUvVT4QQuFCBXc4cOcvLi5Zff7jGS+kX1woqOThMvhAkygq9jycEYesHTtsaQyZOiZACfUpsU+TTr77EwlQ8vdzxxcdPWbqKNAxopamUotWKTil2IfAgDtxzDUet4ol4Bsno1mF1ojWWu0dz7hzP2SXPzGjC5KmdZdTCO35k40sCIkgmYvBSjAOPa8fNbsbQb7kceoYplFadEDlpWtYhUDtNkzSbIAwx081rrlmDllz6YI1Da+hCwseiljHGzNxY7i6bsgYaICm0KKrDEvhCEH2GnFC6SF4qqxiJqDbTaoWNhm0U1v3EECOf+vDLLOqGp6sdX373EbP9jInVCq0NlVLMFKQUeDwO3BLHrLJcqciAIE5TNSXoP24sx03FLmWWzqHIzGYNabPhaZzYhohrLTkXwb5oBJxiYWpu2jlD9KymwBgyrRYup57jecNq9DilqY1mHSAAS2NwukGU4JWgjKCSKZX7mFkjjCmzNJaXj+a8vt4QnKCiwokCcyDgC4PAPgjkWW7TS8LNHJVRMGaiQO9Hosn8yIdu02rL5abna5eXtKKRFPcmfdBoTa0UowSufOCmVMyM46KiCK/MLLVSWBU5rh0nTcU4JuatJQFdVxN3isd+YsoR2xgmScRsGJPQZeG0qjira9IY8DGSYyanyGUM1I3lYhfKemwUfSgdLF1VZgw0ikhJcttsMbqIvmQFIWU6LLe7mi9dbpgcqCQl8WjeX+L3Axvwqz/k32JhPQUab2m0JedMzoq4Syxv1HTKkGOCBNZpZq1ikIRXCa0h7ZV3VjkwJeGkrnipa3BWIbYmj55N9lxNAaXgqHXUuaWyDidCxhCCoEXxQ9eP2YX9oISAJOHdqx2rbWDeVez8wJQyNhluzloW85qX6xPW/Y4sA2OGKQlDLAoTTVWzrGqcsVxOE5I1Z3XHygfEJOadYeksT6ay/9e6ZObUoX/6xSHkMuexz/ILEKbIw0cbnMB8XkHKxJy4Ggc+dnpGhcZPEZOFWimO5y2XOjKSMBZoDFLBo6uB0QautRUfW3RU2hJbhwyB82liFRIPR8+9caJra5paE51lisJqGwiS+R/u3eTheodWucjjJeErjzc83mVOu4on08BmnLBJ+HA349q1Iz5RG56utsR+YCOQjLDzZex8UVlOu5a6djwaJoyK3Fm0PJ4mrETuuIprleONbY9W0FnN3Goapfjyd/VBfX9CYhlOzQgohZpgpybeGa84Mw0Ohc6JoIqKz7XZDOeFy5hwSXACi6bmUgKBXIxkOpBK8Xg94kPiel3zseWCtnKsscgwcBkm3lmtyTmxNIb2eEnlGsoklKafEior/vjLN1jvPNHkZ8lgfu9iw3p8i8ooNn5iFyIGxavzOWfXjvlkW/Hk6gKVAyEVn5GrMKGA06bhbNbRNDXvbtdorXi1nXMVAzWKG86ysJY3RXBoOmtpjcFkxTscBiefO3wmJSnBvlIIRYbz8bbnrKpxKCQV75ukhJP5jGVVMY4BRzHhmtWGlYlFKUprpDLkSnO19SQi15ua15ZzmrriIoNKkZUfeTJO6O2Wo66isZbaGRxFAWgqA0X8+K0TtkPCp0BGUFm4f7VlNyWM1WzDRJ8CWik+1Mw5OWr4oeo6jy6vIEeSBPqcGcig4dg5TpqWpnI82O04HxUfXs5YTYFJNJWFY2PJGmplmDnD3JV5gt/7Lj+q71coKSarCkUWUBZCjDxcrbhma1pn8CESKfNL17sZlRjGXcBmjd3LCF+owKQEZQ0nrcXWlov1Fk/ketPw2vECbRxrydB7rlLgfBipteF219FUc9rGIkmKAEcsPeefvnWNx7uBlCNJyvDwu+sd45SojOViGulTwmnNq7OO68dLxBmebFYEifQJQhKMyqBg5iqO6xprLG9vt2yi4l7TsU2eFsUtq1koy1uqp8bQOkNjNEbB/fdxPz+wAb8okH0ph2fvNQwh0ofizCdZCCETfGAzG/FK00+ldaI1hoVRbFPCSyKRkSzUUbOTxC4kjmvHjXnNsq3JWEal2Ww861AC/pQFQSOqtAk5XeTpjChuzTouB4UoIaTMzkfe3fZAz3FoEImkLDSm4tZ8TlM7mrqhUpHaRGYezvvIOhWzmZmruNbOMErztB9RaG50M7QaWauJnBNZCRWmtCe5itYZwqGB9YWhZPVL9ubZvyTD5WrkqCuqUBlhGwM+RZ50PVYrNlMpMx9Xmmum4jxtGUhkldEJmmhYh8g6RY5njnsnLTfaGd4YplVgFS54GgJ2KjJyIGQp9tlOGY5tkQr78LJD+wyqtNdc+cQXLzdwueHmUUvS0PsSLL16vGQ+b+gaR2uEpskcRcVlVDw5D8QoLJuWe8dLnLE86j3OGl49XuL6nvPdgMSEKEVtNEtruN44jipTMtEHPH9ICfqlOPIBMBIYCdQzxbKqyEkQXUyvLnYDTIG1H2iNYmEUjbI8ThMDmaQFmwNjhF1KbGPkZOa4e9zy8vERT0bFdGX59fOBh+NASomPHy8AhVKaLCX7f71tMMCHTuZcMbFlwiPsQuaNyy1vXG5pK4e1MOVMpS2vHB8x7zrapqJTnmWbOfOWL194Nn1kTJnXTjtePT2hcpYnuy1OKz68WPLYj5zrAe8jAcEqzam1nNYNM2cPTrsvCJLKwDUaEE0S0FlzNY60SjPXFkJGAG0Ul9ueyXl241D2X2eYKcNTFRhV6Y3XwCSKUTIDkdOq5tZRy0uLJU+8MO4GfsdPXEweNLwWPCKZnM1+P7WcNTWShVfmcy5UYIwTU05sQ+b+Zsf97Q5nDNbAlBPWaF6eLehqQ+uWVNnTucBJEO73kX4o6lXXZjNeXi4xxnA5jVRK85HjI57sRs5VT/CRSRLOlHX9rK5Z1JZ0SLq9MOwNnYtiohRVmpwyl/2OtlMsjCtdDgqUUlyue6zS9MFTo5grzcwZHlHWQNHCWhlcUiUOzJFrrub2UcdZN+d8SAx5y3o3cjV5KmOYQiRTlPcQoTGGa3WNQXNvPsMmxZhGxpzZpsz9dc99ejpniSozSeHth5ZzFl1D5wy1nuiqyMmkeGsbmULJ4J8uG+4u5ig0D/ueShk+NJvxJBi2vhjepSQ4azi2FafO0RqDz9/rQ7uavYtWKWUDRewciklCLNPVw5RRSvji/UcYrait5biuObEVRkqQ7FVmiMLlLqJaAasxUmQ0K2s5rlpENEMn6K3ay8CZYs+sYDcNeK/onOXeyQJDCaT6kJm7or0+2kwv5Q+/3/SgoEJxWpeSTwhgrXDW1dzsirrG/See+zkwpcT1+YKTtqX3HiVFevSka6mNRdbCW9sNk9M0xnLSOm42LbVVXE7jd+cB/SBgf9b8AwXbfSZzNwbczmCc4XKImJD59196G21gXhluLhruLGqSh5wVIQt9yDxYTcV63oFOCiWKylZcnx9hjGZjJthcInvdXastoNj1I30fOXWOP3bzpEgabgeCh3ltaIxhNMJFKhWj9WVGNBgRzirHIInkA9oaXr7W8aHrmjFNfOlp4jf6gfU2cvdoye3lkpX3ZBHmteXG0YyqVgwp8IXzgbkt/dof6lpeXjY01nCxO2RXXwj2VVqVIe/rvGEobOxtxkomJEFpjdOK33j7LbSGRimuLypudRXbncerzCjFRfRi68vauvdpkb0s4rJpWNQVQ+X4zfU5BHBaoXQmxok4CZt+4sgZ/g+3TlAoxhzIoqi0pjYKJLGeysZzHiJKgVOK640mpIyfJnQF964vec1WDLFn4Sa++GDHg37i5ZMjXjpZsvEepTQnruLGYsHCN0wx89ubHV1l6Zzlbttwve2onWHlD/x7ERD2QY7em94oKV4PqgTsNmZUKt9kjeY/vfEWlS2S0idtxVnn8EEISRhzpo/CVQhkI0gDKpf91VrNSdtw3Fi2jeV3d5dILK1AzoAm0u+EzehZasOnri0RFDlovIBVBmctUUVW++Db+4BGsArO6posgp88WituHtfcPpnTB8vR08Qb2fN0O3Hn6JgbR3M204RSirO65na7YOYqppz5Qn+JtYrGWO41LTfbhqoyXB3498KgTBnCVXsFRADZr4u7EMi+yKQr0ags/Mf796lry9wajivL9bpinCJJitfIOmQ2QwSrirDLfnOvleJG1XGjrdhUji+/vUKFgNv7OyUSm2FiuwvMreYT15ZUGHqfIGkqZbFOSCrye6FUzB97jwKc1lS1JU+K6AMa+NBxx0dONFs/8ZsPJ+6fRy6C5/Z8wZ3lnNU0gTacNRW3Zy1ddry53fDmeoMomBnDDVdzo6qwRnHh358XyQc24Lf7zEKmZFWfmcuUE56U3kClGGOiqgVjilZpbSydKf1QsRZcr0gJdrno8jtvWFaWpDJWNDZrjNbElKitQYzmyFZc7xpGnZn6FXpS7LYTg85kp4go6qS5WE3Y1jGvHZ1YzP6QJb709+taoSxs/QRMpKSQZHg6ai5DYnYy467JrKcByYnJe8iZ465hZizGak5sR0DYpXLarOqKE7PXSNcUKYUDXiyeRfzq9z/0PuF9oqsUY/DUncI5ocqaTjvmtsJoR5wlnNLEAXY+MvQRYxXLE0dCaLKhSQZjyszJM+3g06bidlfjc+bNpyvspLi8WrOxEd9oVDIY0VztRkiGo84y0wa3v8g0lczbzClmWrEdJpxShJQZpeJil7nYwenRkk+fbrnvNtgM0+jROXGzbjntahpnudcsmHLmYjcxM5pXuhl3tGVpa4IVgj0YH70IKNnnPJ4pF8B71ZQkghhwopl2EX1STNF0EDrRzBsHmDK0Nhj6mBlTJkyC0XBUOyKZJhnqYJCoGYYdWmtCzixrx82uZfLwn999yC3T8uR8zcZkUmtptOHV60fcd5mr1YpKlZawxu3Xo6moWtVW44DLYaC1GZ8VAy1vngceXybuXL9BPa5Yug06JrbbHVESN7qW5XxOU1mO5i09mUebHmM0HzqqONWaVgyE0kt+wPPHPrEKz94/E4sQISghGEFb8BuPWigaFDpqHMUkEhziJjpdZAOHmPayiYqjpkbIzHB0ymGMxk8DnYEkkaUz3GprUIrPn684wXFxtWFtEr4xNNpw7VbD7qpivdrQAkutS183oL0iaWFhK06qlp2PVMaQiIQ049FWeLINvHxygzZueUevaJKQJo+SyFnb8eG2Q1eW613NJLAdJsaUuLdsuK01nauIQIj/7Z074HlB6b2C034tVA2oqXwtTJkqJ5zaS7tWmhaF9hmTNW2t0RpCrWiCKVWlnImTYJKitZagMxWGKhsQIcUNdVVUHI/rmluzhsFGPv/4CUscV1c7xgqkseQsXFs0rEUR+kgnwqmxVEYjIjCVGHbuKpbOsUpjUUNL0MuMR7vM463n5aObtHHHA3pctsQoWC3cmbcsK8esqZjblqQUq94T1B5NEwAAyY1JREFUsrDoLGc4GmUISXi/3pcf2Ggxq2fzakU9GqVIlPLOqMAoYWEMVa2oaoVOQM5479mETGw1D31kmwJZCa3W2NayM4m7dcNHlqcsK4czCu8zxkCF5jPHp0VjVzKby8CyqrCLlpWfeGe3Y7PzNMZyp+64ca3m8bbnifdYa6kqQ0yZcZ7QWeGMosuGeqqogWwMb1yuUBhuzY5p04ReOhKOt9db3titiEqhk+L3+h035nMWuqKxjk/evkklwpcvLzkXCFPAaUslB1v5F4VnQ7vPGsu+HuveI0owrkO7hN7/l0OmH0aeDpG8HbjfZC7HAAoaa2mOLLsc+Eg34zM3rnPaNFTG0vcRU1lImT9/6x4iGZ8yVxtPV8HJ2YIv+RVfPt9w+cQzry2fnHccnyjeuup5NxWlleVCEwbh3HokwGndcDprWdZzulkLwG/v7e0/dLagCpGXTy2fuHmNLzzY8J/Xl3inURF+991zPrRtWXYVc1fz5z76Ko1W/Kd373Mhgbd3W7RYZur92Xof8M3hvWBrn2AVC3am0EYzEFABWmUgJ9yomYKggpBDRK0joR15ow7scmnF6pxFzWCbIy91DX/8xnWuNWV+ZLMZsLbMRf25m7eLM7gIwzbQVYrl3SVfiT2ff3LJ+fnEUW0ZvWeaMm8PA3Xb0LY1s2s1w3pC6eJxMrOGW03Dy92cxdLhp8h/eP0+WVs+dPMap7uJ653hlWtnfOHRmi88fMyKIov4H9dbXl7MOKkblq7hT7/6Csoofuf8AZck7ntPJYaT6sC/FwIF7DOszwbHYxSMgt57xGQ6TMliBtCmcG/cJa7WkXw08q7LbGIkIcU8bW7pdeSVuubT129w1nQ0xuCn8N5e/3+9cZecMlGE7VXEdHBy7YivxIEvnq85Px9ZVo6xn5ii8HCcMJWjqizNzDHtAr7KkKCxitPGcGIrullLSolffeNtBMUrRwtm/ZYTk7h9+5SvXG757cePWcfAzCp+fRi5s15xVDmOqorPvnSTxjX8xsO3uSDzlp8wYliYwx78oiCB4tgGiFWoSOFihj56ctIsXYVSQhWErIQYE0OIXKhAXtS8WUf64rmLUwbbCV5nXm5afvTaKTfqjsY4eh/2AbHiz127Rc6ZBAyrktg7OZ7zO8OG1y/XDCFyXFWs/Y44CI+9R9cOYw3KKtKU8LUgKWN05sgZTkzLyazM+P3qu0/IaF5dHLHYDFxvDa9dP+GLjzZ85eqC7EDHzBfPr7g9b1nWjiNX8Sfv3EYZze+cP2FL5okPOAxHbfO+7ucHNuCHMqCDkv3AUKlwC5A1RAPJZFyl0HvHP7JClEHXDq0VFQk7KYISsFBXhlPtuN12tEZh972vUBxsDRprDFqX30VOnPuJ7dWO9VjUMKYMOgnRFN3rTY4YpZiLYlYZhiSkXA4qR5XjzrLhuKoYk2XsA9sQSHjYZZZk5rUjJU3Kipw0g49chMAmZpYpYKXIUYWceCSR1ba08FhTUVXmvd7eA14A5A+8+4YvxSRMMaErQGdygBiK46irXTkE5gn9zAnXwry23NYzXlvOmVuH02bPQUgh0ipFtoYsGlEJExQX64mvjY94sNqyGyNjyEiOxLZUp85TwKjENWoWTc2OyNwnBLg1q/mhkyUvnR7Re9isBy7HhCcTpOc4Za45QwzFoCtE4XzyPBxH1iFy2jiyCKmB2MA2BN447xGg0Y7TxqDNQaXnhUB/3WFz38uqjUbXGp1MWQiVRukinRijQgIo0WhnEWWoTGLwuTiNa8XMWW5WMz6+OGJpHZU1ReI4BkKE1mRmpihQRcmkNPDowvMwv8PbQ882RUYyjJEQhaSFVYjMjWdRGc6U48plEoLozFlX8drxnDvHM3oPT8896yGxyRNDDNyJcKYNURQ5KZRoJh+4v+vxMXKtaqhVQCnFpDLbKfKoL2ugE8vCOexBmvgFoWRWRUCr0lZRTIrYm0FKScKZkvqXrPY6BxqpNJIsug7oLHgSohWNtdywMz6xOOXYNtTaYrQCieQsaA3OWbIRdM5UY+KNy4HH/hEPxp6eTNCw80UZRSSw8ZEmC3OtuWlrnjaZuIuIFs6aiteWc866BaM3bFYDmymzSp5tjNyKmttOEzRESYgIo0+82Y/EmDk2rrQtoRCjGILnYT8iQC2GI1uhOax/LwrPujtQQJLS5bH/fEaIWZhSRlQm52KimlLpwhBj8Yoy9DspkhK0gc4Z7lYtH5kfc2oaGm2xGpBAzKXF0RlNVqBF8CFzf9PztXHivO+ZJDLkiBoFNe/ISjiPgUYyZ03Nra7hQo2kEMEZrncNHzlacGPWsR7g6eXEk83ESMbHyK0oHGVL7AWfE31MrKfIVZzwOdN5Qy7WYHhVVLEeTCMiQpMdjTFo9f7iwA90wM/X9W1BGeRVZt/XtTdY6GqNGCF4QStdHpzK1Lqm1gFlCzliBi9FNmnpGqyyRVZQK4wpsmFkhVWZLIJKmSYltt6zmjzbFPCUIF9n2MXEaDzJFBc1SVL+P/Js2LcMl9UYfCrGDjELqCIduuo9SwO3QofRiiFlBsn0ORJSRKNwaIjgVWLImasYmKSMMlsFMQd8PExMvnDsObgfKSkflq4yJEPXGrSB4EFr0Pspo7qy1BRJsBwSXoRBQ4virG5x+01Ua4VzBmsNWgQTM2TBaWiD5mmOPLjccj6NjCmVn0GxjhlvAslCZTUWjRbhat++hiis1tRaM4yBSzMRfLGNf+on3tn1XEPxatPQasNGEhsp9vVTyCgNThvIMEyRKQlPx5GVStisqJTCp8SFP9S0Xwj2fJNnlaZ9j4Xar4PPzLdmnQYr5HH/NRRJwBlN4wwbn8hh75yqEyFprtdNyc1K4autKurKoXLE5ojOgsoJNxl2KXFxNXAeAz5njFaoXAZ/rwjFcVQJU06oCEOMpGfr6N4W/nwz4ipLPxbBhU3veXS+49xYPmJbmpjZSmJHok+RlDNhX12LMTPg2aXE+ehZh4hVhqVWjCEyjYeWsheDr+thzLzXx79X5ycjiBFmMwMqk30ZnNRGkVFYY6h0Wa8kFgnXySRizlyrHE5pFAqtFEZrTGMg5aJ2kgWVFSpo+l1Zky7xxJQxSgOaPgUu8ohXCasUXkplPcREpHgHiJSF+nKYqPqBKUScM0wh88ZmywoNqcVKZhUiqxTZpYgITCL7djphCokL7bkInvMYqNAYpRlDZBcP/HtxKAuesD9p7uc45dl8nS5Z/bbWKFN4pvZBPlpRaUvtirGfZCEqwWtFysL1piqt47CPA4sUK1Lit5wUKgs6Jq6mQO8HVtnjc0ZpRU7CygcucsQroRIpUvBK8Ll41DxTFJUkPO1HjHGMAaw19MHze1vPWgwvu5ZKnokpBDYh4CUxShGbyTEzEhmz8HgaWIVQEosIY45M79P88oMd8MvvK6Q8U+nBlgVFG42xhoXSTCqDBaNK1l6kaJNiIDtIHshFM323NwnKUmSekBKw28rRT4m0H7zNqjjx9iGW4F4SosApjQa2ObGiyMkpUYw5oXMxxkq5DBrnLMQAQ/QoDVZrNIoQhc0wkZ3GJE9dKUYFQQlRQ2XUewF/pQyTZK68Z+sTSUOlLFkJUw5M73NY44BvAf+9xM0+9aoErs0rJsn0U8agcCiSFDk7KPMcSUoFQCh9r0og5ZKVgLLgNG3NbhzxqWxWUYQxJ1YpcNF7djmhlaLTGqsUVyFwESeCEhww5EwlEFMmBEEpIcXMNCXGaccuB7pyjGQKice7CbEGkxRLZ9mqzKgEL5nOqPcCykZrppR4MvQ8HSeihkZbkoZNCsTpEPC/MOyTHvKsoXofxGgDxpYN7Uw7BokMoWwwRiCKoExpg0xGyKEMtw0krgTImRgzUWeMFmytmc8bVrtdqQbs+bcOiXUOnPvCP2MUC2NBwVWMPKbwYcyZiylgAiW5ocqmmZIw+sx66MlG4WJJsIjA1TCRqkQTNfMcuSKzI+FVpnOapMBZTWMMIWfO+4HLKRCy4IwmkFlHTxoPSY8XAkWRg0XtA/7ySaVK8i0DaMW1WcUYA+M+yWD2sRmmBGpRF63xHGFUmY0Eck7EFDFGY8RgVVn/+n4k7BNmAWGVI9sQuUyJXkW0UsyxCLAOnkd4oAwFr3ygFoX3iZxL+BBTZjcGRik93i5DbTRGKXY+ko1i4Q01mssQ2OTIpDIzq5nIKKtprSWjeDpMnIcJL1LklxFi9PjpwL8XBdEluYuUKuZ7cyTPpLI1aAMnswpPZBoEJQojqmTorQGTEAM5Fw5OJLYSUDmTKMmxbBTWKmZdzWaYiKmUthLCOkZWIdCnwKgSdm+QqpRw6QOPlEcJeFGsfUAr8KEIxqgMIWa2U6AfJox2kIXGWnTQe4ECwUlgRmadA71EAonaKnxUVEYxM5aY4XwYuQilj79G4VVilRL5fXLwAx3wq732+bOpbHQx1yiT2xrjDGeV5cpHdB3eM2IxGrJNxXiIUvoRkZJ9qhRXY89JA8ZYUtQkwNQVuzAx9RNQWjAe+J4nfmJNRCWolcYpRUIIKhe9X6XwGiYy86SLS3JWKFPKM5vgSQq2MTCvKkJKmFx0fB2G8xSoosHVJWPgkmOmFEGVDN3MOvw4cd6PkMEaRWMdk8QixXRo6Xmx0Oq9jL4g7031P7vrVhs+crrk3aHHxIiaFFUuQU1QqbSBsQ+AMsgobF3g8W7LzdkcYww6ajLQzDTrKbBZ94AwSuL1zZZ3Nj3nPmK1Zm7K5jSkxFXwPE6eWjTBlMPB0li0aCRrBGHwidVuRDC867fcaBdlsYiOJdAZeDgFViriKo2x5e2kgSEXpaqTtuVR3/O17ZYpZlpV+ibX2ZNyLrb1Bzx3vFdNevZxLoIFKgqqUtjKUFnL3fkxD/oNOgbyKOioMEoxGWHtA2MuVR0RwAs7lXi83nI2a2HfN53EsDhRbP3Ak9UOBYxkvrjZ8HAc2EpCoTgylpm2jFk4nwJXEqlQxJDp+2Ioo1PZcJVVpChsh4BX0F9sONYGrzJ11ixNRaUVT6aJSwxRG7JSVLVhbhStKBZNxc225XE/8mC1Ju1l8WbKsckTUTKNOjidvgjI10kifl1vTwnCSikJrQ0vL1uebLasUiAh6KgxWhF0YrsPoLMGIuSg2KjIg82Os5lQ9HYqREONZhsCT3ZF5W6UxFe3Wx76kUGDTjA3hlYZxpS49IGeTJUVOSV8SDTKlsHhDMoKKcF6CCSreOtqw5G2eBVxophrR2WEhyHgtGaTI5lymDx2mrqxzJqKG82cS+95cLXGZ2GuHHNVs04TSSLNoaXxxWE/u1TWPvX7RqNhH/QrjbWGV07mPO53bGPRwzepZPiDg0ESQQtZlUx7CrDJgce7kWtN4bJSRd54phTrceJq26MUjCS+stvwJEwElXFZMcNQGc1OJVZxfwhIiiyZgVTUHSPYrMDuE7xjYCTze5srjnQZ+G2zYYHDacXD4Gm1pieCFSqtWVSGJghHXc3NquHJMPF4NRAlFx8S5diIJ5Np3+ce/IEN+PU+S/D74ayCupR3DCWL5ZTj43du8saDJzyZFFGEzhhu1BVjlaivPF20GG2IVorJkBHe8luO5zVoTZ8zl6PAOLGsLe+Gicf9yFXwrFXgvfy5gQ1lEIgp0yVDTIpX5zPm1uJT4kk/kLMwc4aoFduceZICN9sFv/XuQwzQtY7aOZSyPByn4n7ZVSjJmJSZa8Mr8yVd3dDUlu0w8rgfmYJws+uoNPgcECkOwlV16F99UbDWobR+TxZWREgxlUwDoIxmNp/zpz/5KX7zy1/ly+ueQOa4Mdw7bohE3nzas5gMTimmNuO14IGv7npuHi/Rtrj+jWHkwfmOs2rOO3HirasNj3c9T2LJeCVdNuALVYzl0i5zNHOI13zkbMlJ5ehT4q1NT45wTMVkElcp8bUp8NHlgn/ze19jxob5cUPXFkWfr60iTaW5Uc9JeColXG9qfuTolJOu41pneNL3vLmKrHeJe3XH0axil0fqAJWxLOyBgy8CkvbrXyqlahRkK9i6tEFYoziddfz5T32C//Crv8OX01P6HFk4x0uLjpULVFvF3BsGMt6VwCs44XeHLX/qdI6tFV48l2PijTc2vLSY8yAH3lpveDpNXKmSqcqqmIBtQrGozwGWdUUIwmvLGYvaMabEO5sesnDcWSYtPM0emXo+uTjh39y/jwsw6xyz2uGU4skQsU7xyW7JRMIEOMqGHzk5ZVnNODtu2Q4bnmx3+DHxUjenqxuuQk+NpnOGwxL4YqD2RltKlUCfDLjSUmu0wZia2eyIP/PDH+U3f+srfHm4YpDIrLLcnDUMOmAnxTw5RpfxDYgRJoQv7tb88UXL/5+9P322NLvy87BnT+90pjvmWBOqgMLURLNpNilKijBNm5b1xQpF6IO/+N8zw+EPDluSB9mUraZJmqZ7IIAGGlWFGrIyK/Pmnc/wDntY2x/2yQSaos2ijBSq0XdVZFRl1s2bJ8+7z95rr/Vbz0+bzMTERQh8fjbwoGu5yJkvN1vOxoFr8USTSCmRcuYm7jG1I8zEEILw7mrJ3DmmJJz1ExrNcV0xGuFCCVEmvtsc80dffIEJ0LWWrnFYrThfF8nl762WVGGiUh6H4m8d3mNZ1xwsG7a7gauzC/pd4kE942iuORtHHDDTjuau5vbmYr/uVC6qjn3TiWykFD+UZjlb8D/8/vf503/1Cb+UNb0IM+d4uGjZuoTrM7OgGTX4NhPJRJP5ZNpyMp9hNPQysg7C508HTtuKr2Ti6a7nwntu8CRdPg8ZuJZYZgkCJdcLmbcXHXNrGVPirJ+wYuhqxc4IlzngoufD2QH/56dPaURTzTWN1dikON9EFm3F466j8hNGAgrF35ivOGoXnBxUvFzveLbuCT7zoJ5Ra8t53KJVZmYdHV+v6PGNTfj/TaEMr+U8lbE0OM7Pe5iEw7bGOAVZuPUTvRdcZQjTRNBSugRaYxM8G0bubQYeziyrWctp64gpkpJgrcYnYfTCsq3x+x5SL3Hf0VR4I2hj6faOfyIKg+F+1xSzhrq8rSvXcK+ds2wavn0wpzOW1lY4bYlkng0bXm56uO5RVRmMmmvoaockYZw8fZqIRGqlqDT0PvMyTTRW0+rCd7+LNxW/DqUr9Val1N4IiaJRrQy/fPqSvIs8qmvquUY7uBHPtQ+0teGrzUCwea8rBBL8/GrL427Ht+9XnK4WvNM1+JSQlJg5wxiFTUgcz2t6H4miGKMUXSuKwSiyhXo06KRBFB2WD7sFL/qJeVuGlBau4VG3ZLXs+P2TJffrGfO2pa4tEeHp7Q1/fr2h7KoJknBgax687fCTsEvC4AOksoketRW3w8AvtlvmM8dxVxcd2138xiOH/eH2qvKRizwxuYRuoNYOawxPn5+RZcfjeUdcFjnPuR/Zhkhbaa58IOi9xExljMCnu5EHt2s+PFzxaDnjvdWMyYOPqZjNJBiCsJoZJBVowjaVW4dGMe2NvGrR5KCRDFXWvNe0PPcTKywZRWccp3XLqmv53nzOo7ZjZiuMLZX+57sNv7he8zG3iAMkc2Jq3l003PTCJk3c+IiXYjR2XFe8DANPph2N1RwYR76r8L+ZkKJ/z/qVah+0U6/Vta1WLI3i/PyKnHvutTWhrUlKuCHQk+hsxa0fiRSCtOiyfj7rJx4NO2xluN/NeDRfkUQYItQmE2JkColVa4lJI8nQR78vvWi8KZfXCkuOGkFRZcN7puPcDMxqwxzH3DhO64Z7dcO353MeNy0z53CVJajMk+2Wv7he88nVLWKKZOTY1DxYtgw+s4uJ8zixy5G5MzxoK86HgadhR6X3Joj5rsL/RkPv2cR7mRauDIZbZenqmsW85vmLa3IOHNctyyaTVWaTApuQqK3mJoTiSG72cyYCn623PLIN7x8sOF20vD2vSQm8j0UyGIXgE/PWFpWI5L20u+gskxaizZgBbNRYrZllzTta80J7jlzFkkxnK07bGfOu4dvzGfedY24qjLUMSnhitjzd9ZiLzGQSKWWOTMXDRUPfZ7YpMaSEQnNgao5dzYtpw2XyOKMwWmG/5hL8xib8f4nKs/81vaeZ6ASdshx3LVMewcFpU4HNrKPn5ZRYh4hKRQKE2retRaiTIQEfb3sGrXi3hk45REAEWmO4N2tY1hVdZYiptJAvp0DMMEriadpgksZrYYyCSCoW0EnYxoTJwqxyzK3ltHEoK2SrWDhHV1UoysH6sO6YK81aIpscsKoMc+CFKQqT9Zz3Iz7BybwtFY407s0cFCpnxnCnH3xjofYTkrAvtf4KyK+14nDe8p2Hh/RTT3KJd+az4tIYA19uEs/CCCmjWo1SZYhHYpmsF634F7c3bOrM7zeK1awlhqKrbpzm8apl1ThWe9Oimap51u8QBWOGX9xsqIwlNaloUWMZptM5c5U8W4GFdbyzqHnvsKO2YJzmYO44mldF8uEF23U0ynGTBl6mgDPQ1ZbgYfATm5j45HbDLiXeX3aEnPhqGDFa0yqDibAb7uZI3kjsjU7Jv9bp3CsrlNIsupbHx8fcXJ3DLPF+e4AAL/uRj25GXoQJFdVraYaQS5HWl27ov7q6pVeC1JpVWhB9QFJiqS3fms14WDd0Vhc/h7riy35XCh5kPlqvMUBqFJsYCq0KMAibEBliYN44Hs5nfOfogLqy6FoxazWrpgZRjD7wqO6oV5qNTryII1opGmcZB9iOI3Kj+Hy9YesDj2Ytk0lcbUd0LrJIlRVjuHM6fRPx2uE5g5K/nFEoYNm0vHtyzM2wRmrh3eUKyXDpRz7td7ycPIhCVaVIl8zeJXSESObPLtess/BDWzpVwZeB3QbD203LiXO4Pep6OTc8HwbiXq//8W6DwZIrYcwJiap0JES4lcCQhLl1PFh1fOtoQWsNulE0leKwazBK40Pg/bpjtlKsc+J5GtAG6sYyhsx2mpDg+XKzZYzCg/mMoBNXYcRkRacNVpfL7128mVB7DX/O6lfq5VjmI43WHC7mfPD4HrcvrwizxPurFTFlzqeRz/od1zFiZC8LN6VLn1PGREPI8CfbG7aV8MNO86FqmUIgpEStDQ/blmNbUVkDWui04+nQk4CghC+GHieGVAu7GAuUJZdOaC+RlyPMnONRV/POfIauILvMonUc2IacwcTEW1XHYdasdWSbI1Yr5pUjBINPI8MNfLresUmJ00VNnwPXe7BLrUyRHqmvV3X7xib85ax7tcns7/UJsIrWWY7ahvuLlqvrLX2MnJCRANMk3MTITiI6lwS+weBTZjul/QKC7RC5oBwcO584UBVZMkNOjJLYSSKkhMuaY1PTNIZApk9CnRVTTBxUFYeuJmVhF0PR91WWk2WLRZGzcL7bUVd63wa1GK3Rr0ThCpxqmMLA9ejZ+MjOJ8Y+Ya1ioGxcjbEcVI6YBTUqTCpW4GFPxriLNxX/mor61XMDDuYN7z045DuPjvniqy+47Ucetx2kxLYf+XK7Y+MDKilWdYVSMITE7RTJWYHT3PaBL696DIbrIfFAO0QyQ4hMktiIZ5qKlvmdbkY3mxOBPgu1KLYp4laK+21Llsx6CqyD50g73lvNyktWmWebDYvaUDtFYzSV2pOpKlvcpo1Fes+LKXPuA9s+sR2F2ihGErc+MDMVj9sZkyQqu8UHYQqpeFbckaLeSORXCf+v/9iToRpjOZ7NeHR4wC+ePOEyer514EghEVLkPE5sUkJ7WHUVWpc9az0EKJ5YrFPkmRkw3LAeEifZkHNmlwLbHLlNgfXe9ftUN3yrnZFUSbhMl7kOgXlnOXUNQTI3k+c2BObW8K3DeSFZ5Mznt7csGofSCq313r0SNBqnHI22PE07VFBspsjH47Z4CmgIWrj1nrlzPFp0hCyYvsd6hUhmRF6DFu7iNxyawuHX6leOu5RZpMZVnM4WvHW44vnnL1mHyDsrR4qZl1PmPI5sRSAoDtoKY8r6uxk87J/tJgW+0j0qK7Y+cl8sCdgmz60EbpNHe0WtNW+5hmZuiRmGlKi05nZMNLXmuCvFsNvJczsl5hjeXiywquiqv9hsWFQWZzVV5XDW7AlVpQv1ltY8GQd0GFn7wEfjmn4QnAVPZhM8rbHcb7rCJtKgoyKJMCaIcrf+3lRkeUXpKTN0ZMiFisKsaXi4OuCt1TE/fvKMtYl8e2HxUzHXupLAKILymWX7qz1wM4Yik1SwjoGnpgcUV4PnPlV5rjEy5MQuR6wIlYK37YymMfgsDDnSJFhHYTErne8oudB8QmSRDW8v5jityTrzvN/SBE1nDEYbnDX77VzQVKyMZgo78Ip1SnwWeny8wBphUsLaR1rnOG5qvCTUTmGiQgQmlUlfU+nxjU348/6fXw8VAVcGuU4XHSfzjvOXmRQz1mgkQo6KMcWC5QLmqmhFJxGiZLRSRYYTM/0YeEmZ9r+niynRTgduomebSoegxbLUFUdVhdKKmc0cqYoXfmDeWozSbNKESJENnVYVj5czQhQudyNntz1dZcAYNjkWGYjRBcWIwiqLjYXpvp7KgN1V9ixqR0yC1prDRpNd3lfQCgN5iq/8Ce4kPW8qXle4eK2oKO+2gvvHC7791glv3Vvx8ecJP0assSgFIWWu+xEyxKy41zYFjZlT6TQpTc6KFDLrbeAL2XLVTwx1B8BN9ryYBi78SCazyJZ7qua0bTHWEBWcuopfbnoOV5aqNtxOAdnTLd52LT88WbGJgS+ud3z2csOyKZfO29HTVo7GWLRV1Bgqo2gGSEG42nn6GPnqduRwVpGkGObY1pAbhcOU7hLQ+4S2hfJyF28gcjmUXiE5s35dcGVRN9xbrjheLPBTxOdMXdVklVBKc+tD4TbnzH1rqK3Bo4uhmy7fJKbMboh8mbdcDgPv6mLe0leZM++59IUuNneWlXI8aBuc0UTg2FR8tFlzv2upasOND+QkxJR52FZ872hFL4kvbrZ8er1mVTt8zlzawMwmOmewVqHRVM7g+h4ENj5y5ke+2g2sOosSQCns3GCtRucyEAqZsEc43s2Mv6F4RUjRam/C9Ssk4qpuebBYcbKY82UQkkBTWZLOZEVZf1Lwh7Up2N9aKZISvJE9xQ76IfE077iaRt7fm0juKsVZmriKxVJ14RwPVMO9tsMpTZLMce34Zd6xmllcZ7kNHgkJ0cJ9U/Od5ZwxJ57tej6/3LCsHSjhWic6m2iNAa1wlaXOBj2N5ASbsRRNnt32HHaOrMCgeNjOcK0m59Lxyrnw36Nk7gr8by6yQFa/ynJe4TlVzhx2HQ9Xhxy2C0JKJKB2FpUFpRR9TLzaJ06UoVEGjyEDUZX8MCVh1ye+pOflMPIdUwpllzpwHiY2MWBEUyfNYxM5dHX5ntlyahy/HHoezDpMp7j2HkkFEPPANnxrOSeQedH3PLndMNMWreBGeea2pjEGZ3XJSTGYMJAFtr4UbM4Gz7K1yJ4keWrKPKFVen9ZKCTJpL7+BviNTfj/TZFSSXgPZy0PDhYsuw6XLSsL865FkVnngNkpOgw7ApIzWYNxMJsZHBrvwetYrhT7MtrZtAVgHSMT+yHJkNnhqUNPtbQc1o7OKNRME13EVY4nux2Xw0iIiYVxHHUN4iFquMmRJ8OA3pUqRd9OfJsjllWNUmC0QrSQguClVOxRpaqwTYFGNBIzA5HbV06HQYiuGFCYrKjM3cTaG4tcNnZgf32kYIGBtx8c8Z337rM6mNHWllZajg9XGKV5mYTq5SUomIjEJFRa01SG04MaheZ2SkyxUJZyyijJ/HKzAeAsTOwkEHOpoG9CxE23/Oie4VHdcdSUy6fXmm6h+Wh7y5NNz26IPKwsD5el4iUIV2HiZ9e3JJ+ZtZb1PPG3K8OpLXP9TilEa6YhMvhI2FdLvQg3KTCPjjEL10w0ek0GNlPC7z83Tmvm9q/UNvJXJjK/Mp15rSjTYIzi3uqAx4enLJo5jbU8qGYcLDsqZTgLAfvsJRbF2iZ2MZCUYJ3m8KgmRCHFwqZ2uhB9lFJ8PgwA3PSpaPTJSM74KfHn4xqrNY/nM06bGms0W+05cDU/G255uh3YjYGZMdyfFRpZUAXp+cXQEzcZaxXXw0SrLA/aDqUKdUyUKujYGAmqFE5CKpjFQ2pCSuxM4GYYyRn6MeJFsErhNNT6bv29icg577tM5QzV++6SBu4frHh8ckxbN3TGYbqOtqkxWrEKE/Z5EeT2VthGTzT69fobvRBTwvuEoSRvSObTsQfgpo/79VdeQzTCz+IWaxyP2oaDxoGu2WWhqzIfTQNPdz27MTDHcjyvISWiLljPL4Ye2UGtFefGY08U95oGrRWz2jEkYReKKeaUE1lnppy49nCgHSFltgRuqgkhM4yRYAUjGqXUHSXqDUb+NU13fgW1p/zr3mrJw6MVVWWZW0NbN8zbGmo4nEZMMZRntKVriWSssRwddIwpICEXXwajsHvc7BdDWYMvxTOQEDIqCrsMP49bvr+E+3XNoWvRe1LPgXN8NO34qh8YpsjSWu53LXp/Bt+GwKe7HdELtTWcm5FOV9xrW1B7Dx+lSFHKxWU/azClxCYoZtkQsrAm8FINZApWO+qMRWEzr/0E/m3xV2en1IDOaKN4fHLMtx4+wGnNW6elKkoGH4WUoKLchCoML/sRpRRtZZi3NdV+4lJSMYTprOVbqzl1ZchkfvLiBi0COrObAiFnnoWBrITv2AWPmhkpwZHuGGNknjQhG/oM4gEUn23X3PpQWo97FrFI5uUw8e3DTFdrfEo82+2oK8uzfmJHBAM6a3RSTGRqSnJptaaryqOqpkjKqmDOVGG83sUbiizFvXkvv8qK0uJG8Z13HvLDD95Ha8WH9w8Bi8qKED2ZiDOGnKGK8Nl6h1GKRW05PqhpKsX81lBNJZubVYYf3F+y7Apf+h9/dkaOGY3h+mYiZfj0ugc0dWU5XcyIKI5qAS9Uk6ETQ1KJnU/UEf7kq3Ne7Aaup6IJVAZM1nw5DPwdrTmoasYQ+fzyhrpq+dl24Eoi0ZTXlEcY+kTlik6605a3mpYMPL8t2DzRxdgr35VY31i8GhB/dfCZOVTW8O79B7z/6CGNybx1tCQaRfLCqCJR4mv3T5vgbO3RGupGs1gUokNlNVlZEOic44cnhzza27P/V8+es0mBnDPn6wlRiqf9ALFQ0B7PGvqUOXUzjCgOUsVORzBCmoSqs/z0xRVn3rNOEWMVJpUW9FX0zKqK+/OOPgR+fn7Jct7wxTRyk8v6U1mhfOGwB1fa95UyzJwjA7VohNKhMkaV4au7+M2H/Eo+AYDRkIpR23unR3z44BhHYNk5MC1xigQNKcZ9YqHQAc7DiBZFVWvalaOrLPNk2SlFTqXb853livuPLJnMP3l2wVYiouDqthBSPp82pCCY+8cczVbEJJxWc5DAcSzoY60g+kyF4qfXa878yEYiRoNLChXhOnpaZzjpaoaU+HhzQ2cqXgwDt9kz6bLn6wmmWhgRjCisUsyrUh0+wLJLCrGALp2yu3gz8UrGs/8JGF6bVb5/75gPH5wgMfLwZIVPqqg8coGxl2uYwibN1eC5JdDs80BjC99eKQMousrxg+MDFvt9859cXGCkFIw3m4Kb/Wy3QYVMe+I4bWsm4LQuypBmUsxTWfVxzJhG8eP1NbcpspZQ9l+tsVFxKR7jDIu2YoiRT29vWVQ1T+LIjYoEU/INPcBIwb6qpKkwLKuyBzbGosmo/dfmr6mq/auT8Au892hFW9c0SrHdbKmU4uhoBXsN8WY3sqoqfnBwzETii80aU0HYOz6KhuJcJThdpBGDgSEKFZpP+g3GwKEtAyJRG4J4DnRDax2f3ez4+cWaVVXzg4Mlh7rm4KAuLrhT4GLY8sV6xy0Rn1Jh/boaWyskCS/8xP/t4gXOKjQQgmCt4qhuUV6RQ2H4w94kAs1BU5G14tPNQCRhKYYzSglRKcY7Sc8biyR7HIV6lXHBB2+dcHJvTlNlnn/1Jc5mHp+sIBmMMby82TLXNX//3jGblPjocsvWGrxkjNUIBu01zgm2tvQ5sbOBm95zAPzJ1Q1znTlpq2Lc1pS19WDZcjSr+Fcvr/hvvjzjpKn4h+8+pmpq/t7sIX0KXPQDT9Zbfny75qvtwG6MNEbz3qLBWYcKwifrkX/0yWdUtUYp2E6eWhvem8+ot5op7HGQ6XVBmaNFw2Q0//Tmhq33mBpiyGitizHJndPpG4vXqrJcKGXvv3vEu8tDDirY3J4TlObdd08hFsLYxXrLXFv+Z48esh09P73ZsDNFy5piZhoSldUstcG0mjFHRh25GUYOMPzLmwtQwsO6KrKfLrMeI/dcxVFb8ScXV/zR83MO65p/+OghRmf+xuERH6QDzoeRL/o1v5x6nk0DfpLi6VA1zCpDSsLzYeB/9fQzqueF1T+kRN0bTpsWmzTaS/ncyauRhczhrCFqxR+f37AZJqpKMcWMBCGnVHjcd/EbD2VUofJYBRZUrXjn8Ij3Dk45mTX0/RabFY/fOqHeO+tebXccuop/8PA+fYr8xeWGdfZMqdBHwi4izuC0pqs1o1IEndnGiXuD4U9uN2ijOK0qVFYw19xuPaeu5rCy/OTimn/6/JyjyvE/efAIKssP20O+FQ84mya+2N3yMgQ+HXbEkDEa5s5Qt6BT5tk08Y+efoazGotiCglnNCd72ph65eYqoAZQFRy2DQnFH19cs/Yj1ip8LIAFUZDj3fp7U5FV2fdezTxqDW8fHfDu8QEHbcXtzRqD8O1HJ0xTpK4sF+uemar4D45OuCHx2c2OaASfBCGzi4E5FbXVZKuIWfAm0Q8TlXX8eH1L5eAd3SARvmhg7QMPmpq20fzxzRV/9PKc47ri750cUpuav304o5fEhR95Mm75KnieTD1pKp3NZV1R1wrtFS/Hif/d8yfYi2LiOsaErTWndYsZNSoKOu5RzACVYtXWiFH8fLNl5wO11QTJxFzMw/LXvHT+1Un4gXlbs+xq2sru8YiZlIRWKQLQ1jXWWFbzYsLxfLglB0hRSFLYdqIMSRdt/swaOlu0fOuYuNgFko40WaH3wziL7EgSWU/7wWGlcFZBNkxSiBRXYWI9TogXaluqGuSSMEZJ4Aw3KSIOJAs5lu8TJGMnwy5FyuxtsX62qZiBJStEBWQh7S812RRdZDIZ9H97zuEufpNRnCNfa6mBo4MZD48WrDpHbQ3GKLwYjIooZVh1LbUxPDxYMkwTX64HrnrPEAUdM0olcqWYUmJmNYe2YuUsjc5cDBOfXvZkB50pJnJB4MhV+Clx1o/F1jtnFlqBZOLouXGWs7HnbL1hNxTnZqG4rPokDEEA4dJ7pN5vEl5Qir2RluJ6N+KDkJUim0JzSSnjayn84ZSYUsCQccbix0zSpbJ6twLfTLyaF3kNhVXwcLnk4WrBQdvSuAqdMzFknDNIFpaVoz5ccn+xxIfAR7/YcrlNTLE8W4IwxEgyQl1ZOm1ZKIvLmivveX47kirYao0RRfAFUjBK5GLIpXiyr3amVHTYF0y8nEYutj3bKWL38g8xRQMSgzAa2IQAVSG0iOTiyJoL1m4bPfHV8O2+qJdyJpiiCU8iTCFAzlhjmHwkleLcnYb6DUXWr+AZpbNOVLy9XPGDx/e5N+uoTZHjxJAwlcYqw7KtaZzm0cGS0Qc+XfeEXggxg1IkDYNEkhNaY1noioVxNNqwjomX/Yi3iUZrjGhiyNRa0UfPWV/WjlIwMzUpFozmCydcTCOX24H1WJIhqzVRRZJADOXysgseHERdpLxCQRfbIKx3E1Hk9WdNVOG1T7ZIfJJkxhjJOWOMhrFIjfIrlOBdvJnQ7LGclE6eUnzw8JjvPHjMUVujTUZlTVAK5wwaOGgrmtMVj44WTCHy1fA5u5D2ZyeoUTHZSBZNZR0LY1kZi9KaGx95MYwop2h1QicFCeZoxpS4GD1eBJ1hpjU2gMTAuSqzRy93PZvoaZVB50wwQhSFnjTBKPoUkAqSLoUNu58J0UNmFz0hJXLOvDpZRWWiSXs8c97LgEshJEyJUMm/Uxb/zU345V8jImrQxnDYtjSuJPxkIcaIGIfSpc3jTDE0GJXe937KmyYZJCSC2fN/cuGxxpiZjJClbFzZwCRFI+9FqI1hlMgkglOambJkJTwdiuZ/p4VBIjGmguoCTivHmiIxygIhFz2szeq1c6HsU/UpC9GXv6dTulg97zc1YzWvXM0TGY1mkkSMmVoXx9V4t9u8sfg3zQNWRnMy75i3Nc4V4cR2DKxqQCuM0TTOUTtLpfVrtGem8NHHkMhAyIm034A6bRhCqYD5KOWOIQoiDFOiqyw3MTJMqbSWjUYQfnFzC8C20mxjYJgmlGQWWfPuvOVMFa1fovCDBwrKzBkNKhe6iYIxCkEKQs8pRcxlvWHBOgNaEykbptOaMSSmIMxtSRijvcu43lQo9Ze1/K02HHQds7rGGkOKidvdxNGqRasyTF1pjW0dwZYhyaTyaz00CbKOTFnjyYixxbk5ptJVFFU0/jmhIowhYTT4lPFeMEbRWUsS4ZPNGoBbJ6yjZ/ABTWahHe/MOi4mzxASKEg64/duvY0un4dX7r9jSngpPhV2b28TKbpxu0/eUhYmEbQqpI2QS9Gm1gX3eM7023tIv6uxZ5+/lpSlTGMth92ceeNwClJIbHYTxjYoqzFaU1tL44orvZiMqCJBzSojWUg545MiThnlDDUwqozSmYQiCYySISZGn1CUfdGHCWM1nbaEnPnlrsw8XTthmwJTDGStqJXmnarlkpFdKjrsrBQhvyJDlXM4Uc75KSWCCEppXC6V06DKPmxtgR1EKfhPpWBKQhChtYbaGCTBS/rf5pP6nQ3Fr3mR7LGXi6blZLViphVGEpIym35i4WyhISpF4wxd45gGheiSQL8iyyrJ5BQJoggpg7U0WdGrhCQh5wLeSDGhYmYKgiYzSWQICa0KkjXkxGdTmXu6SsI6RsZYihJOaR60DVfe42N53UllfMroinJpVIVilkMmhExKAaXKHhhTJqk9Ecrqsl4lF0oZCp/LwHgjlkrKIPvV13g/v7EJ/6/NZwCQUfhYqouQCbFMRItAspqSWwlqbwyjTZHtKFVu91kgUMwTKl3QSjlEEIWVcqggGYXaowaFGH+l40Nysd3Oil2I3MQiYxiNgMo4NJW1dNYxryytMXtEk5CNwkVFyoUmlFTeE4PAIyiBVmscuiw2Vf6f0fp1ophKR6tUwTIc6JqlrRjvsJxvMEpC8mpoUilFP3qcKWWdkCJIoTUo7UAV3r5SRedqjKZ2pQugpHhBhCxIzBhTjLS0RLQUIxCnzes1H2Mm+JJk9ToxqFfrpBxcNzFydV0Srr5gzamz4tAZDl3NoqtYWMtZP7LeH4RWG4RMZYoUJyXBaJhEIMLMWCwayWWGRWleD4UHyQQpLXIfEpnMSdVy2jX0PvLj38bj+esQ+/WQ91jOfvRlj0oJ7ydCSNxsBxZdRV3p/QmZ0bpkavWrvdGUQzNJOfwaW+QMJNBZ4fLEgavLAG8u6y8FISQhUgzGQ05UGByZdYzsfCl6bJwQsmCBI+e452oWs5pVP3E2jNxEj7L7g0xeDeqW15LJjDljY6YxFqMUMavXHTVnCr4uvbqEKkq1mMyRrTlqGqaU+JTtf7/P5a9DvFp7wv4BCJvRM/lEcCUJiTFyu5uYtQ5Vl33vVddZKWgrjXEapaV05MnEnDFoppAKPls0Kml0XaN1mZGKsdD3Qip7Ubm0JlwGl4V1DEypJNm3JhJVwqE4rGqOTKnaLpzlhR+5SQGjFHYyJAFnFKJK8lSKL4IWRasNek8WQpdqf21MWXMIkbLGYyqTy6d1y1HdMGnhY25+Cw/or0G8rriV3C0r6IdAkoSgUUlIkrhd91TLjtpWlGyx5FBK60LCiSWfLMVTIYmi1qZcEqOgYsYmRWM1Bk2UREgZ8UKIpZOTELRoKq0IKG5SZJwGFIqrEAhZqJTi0FqObEVXNczHiYvJs02pGMdOoHIxy5LScEX2ahAtmdpYLAqR9LqD6cyeLIQglKQ9iKC14sQ2LF3FQOTLr7EGv7EJf0m28l8qsd70hdRgjeCtoU6WumrKYba/+SgFgTJfdNo2XPgRK2AUjEpQwbDUDtEl8epjQCKcdjWV1kSTX2tINYpdToiDSkpLpU+JiOLY7BFiORIQtIHDquK07eisZl41GD0QGGicRUZYq5G0d+YlKZwDIvvHuDcHK+gUVFJo0Uy5tNEzGkmC23c6juqW467lxt1Vtt5U5NdolH3CpeHZ9YbLTc+s0gx9T6WgaiqUq8ulQIOx5YZgDDw6aHkxDoR9ovWqqrSaVYhPhCBcB08YE+8uOypjEFUqSBIFreBaAmZWLo0isJMEPnKyxyj6KeC1oJ3hpG349vKAunactnP+4uaGj9a3ZcjHJ65yIGWIkkkBnNEkVVrj2iqyVmQUxhUNoRWF94EghSg0xkSlNG2reGc55/FyyeVwtwbfSMivEn32m/+T6zUPlls0wrJ1WNHs+oFhrKmMRdliViMpkHPkg4M5570n7Ycg075qe1hXhFAOs+0YIGROjyoaZ8uldD+KrZUqMgpX/ltyZkzCOkUemoYMbFIiUrqhD5uO9+dz6rrhQS38wt6w3QZqY0HBZZ6YJJXicamVYLVCh2IQlktDDGMVkgqObsxCyAmjisxMK0VtFA+7GY/nSzYhAWe/zSf1Oxn5VfVBKIeqgl++vObe8jn9omVZOSCzGQO7fuKwa7EFP4eQMAa+czDj3HuiL5X9uHfvXdmaLGU/246RpDSnbUtbOWLMiCqFLKMN0QraZpwUjdEgiVsdeWRrAFLMeARnNfdsxVuzlto4TqTF9RuG3YYaSzKwzoXEI1GQVCqv7pV2CfamdmCcQUXBKsOYysXD7iVoTilsbXk0n/N4tuJ2EuDpf9+P569N/PrgblaZj74653jecVw7WmswWrHuR5rK0lW2yM+UIqWIsoa3lh3rGAt1TIragwwr5whSZjE2sbjJv3c4p9amJNe5aHmN0ngl4DQul+7kIIJNgYWq9kVZwSuh0oYTW/HuvGNmLferlo/6LZ8MW2qjiap022Mq+UCOGZVLcVftc86sBGXKZUWlIvsZs+ARjNaklKhEYyrF467lfjvnxnv+mOf/1vfyG5vwZ8mkX+N7axR1CtzcToy3A84KdWc5NBWns5qQBB/KAdJUGhC+e3KEj4lJhDEJz9cDmUK/OT5Ysg6e22FEtPDB4YJ/8OE7/PT5GdfDQBDBA1OMXMqEzgYjilZpHrQtby3mgGMcA42DeW3QaF6st5i6JVZlY1oPHkmRD1YNT7ZlAJMEdTaMPqG1oq4UWQRNwYlOOqPSqz02k3JiFE8WmC8t45D42foadXtNvHOZfGMh+y7Tq6RLAY+POjbrDT+9vsGqzHHnuN/NUYdzgjL4/aVs2ThiSvx77z0s2NUQ2aXEJ7c9PmYMiQ8fHnG+G3m+3uGt4jvvHfK/eO8P+Kc//4TnN7dMSchobqPnST+ABac1K+v4YNbx/Yf3gYr1ZkNnFUezhso6Pr284JQZQpEEna8nFi383kHLx2vF2XYkieBQDF7QVtF1rtAmsqJWlqAjaAiSiFox5VS03zEzP6rwW+H//vQ5mhfkcCcrexPxWlKmy/CgdlAZuNhec359gZbEstI8tDMkTlxcD2xDcdVaVTXJZ/7W43tshsjtVEz8zrYTURUM7HcfHXMxDJytdySr+IN37/O//OAh/+Wf/YIvLtf0QUqnSScuBo/s9fNL5/ig6/jRO/eYcGzXWxZWcdQ1qKz56OUV3b7qsp4Sm23E28yPjld8vN3ycjcQo+CyYkwZZcC2qlRas8ZRiGlGK7JkAmX/7lMiRziYW3a7xP/z5Rm8PEN/PZPJu/h3DbXPjDJIBBw0IfDy4pyrl2DJdJXhnm2oK8vZZsN2CijgqKsxCX507z63PnM1TWxj4OV2IinQRvH+8YrL0XO2GwgWvvfggP/srQ/5o1884cvbNX2KpFQS+qcyIom9pNHyTt3xw4cHpGTY7iZmTnHQObS2fH6xZVEJqoIhZTZjwjvh9w8XfDxsy2cgltc/+vga210Kd5pKOVSKZHQpjOjISHFB1YPi5Mix3kb++bOXwMvS/biLNxO2zGrmXErhKoOTzCdfvORjCVQqc1A5VpWjBs43O3woxYF5bUne8x8+eoRJmvMwsY2Rm40niaCN4vsnh7wcRp7vekYL33644D/9g+/yR598wVebHUEyOmnW4nk+jUjKWAVLa/lWPeMHj47oU+b93rN0mpO2xirDR+c3pLYg1gef6LeBVBk+WMz4chi43QTyXuWRYkZMpq71/pKhcUpDLoWREEDrzJSFrXiIcDR37AbhX5xdoDj/S2qY/59v5xt9WP9/xF/WTxfF5/q2p1KKSSmcVqxiZvmg4/CwY73zuCq//vLk4dlmy5d9z5jLQIBoIQzCpYOL6+t9KwVqnZkmzzRNr5FPpAyhdAEUev91isZaIpoLP3HZ3/L+fMasrvE58+TylrM40OaRVa6prea91Yy5tcyt44d1y0+vb1h7j1IgQeEkk0fAgtYag2WQiCYjphhIRMnEoLBG80F9yHO1YzMGsgjut/Fw/rrErzmdvpq9OL/eYXJG5+KjkDN8/3HN/Qcn3Ow2JIloNAZDNIaff/WCP7+8YUzFEElSxo+Ja535Y39OTHv5TiqOtWncUptSeR9iYvSeIQSyF7xQ8LLO0kfFp5sNZ+sdv39wwFHXEqLwp5894+O8ZdVuuDfvcK3iR/cOOGgaHtSWRwcz/usvLzkbBlCC+IKxDb5cHK1WGDR9BF2UPmggRohjkcf93eNDPm0GLm4Gpqnotu/iDYRQKvsatCk/fErs/EROCZkisTd8+4MD7j845Ga3xSWLweComZj4fz/5ik/W21Lh2nPVJWQ2wJ+evSyDt7FIGL+4ueHByxY1ZUxSSEoMKe3JTYogQq0VrbLskvAXt2t+eXPL31kesuhm7KbAn312wadqYN46TpsGXcG3j5ccGM3jruPBvOWPvnrJ2TCWz9QENinCWBBzVhWu9LR31PIUw8EggvjSdfjOYsHTauB65wuW2NxhYd9IOH41Ma5L52hCiKnMvPmYSCny3r0VJ6cr+mmi7erXDSmmxJ+8vODj9Zp1iGU2SEAHmLTw4/Or8lxTJkbN8+sbHtQ1KkTM/mt7pHTAkyKmxKyyLCvLqBOf9js+Xm/4H8yXzOqWISZ+/vySZzJSt5ZDqcFpPjxcMrOat+sFjxYr/hv5iudDz14ngRZIU0a7YnRpMngpc3ZShCPkmMlDkfV+OF/y1PZcbibGkPYOxHfxJiLH/bSjFFyv1ophitxbKUJUTCGwDYm3j+Y8eHDExXqLq1JxkEfR68BPnl3w8e2atZTutkoZQpFm//jmihgLwUzlzK739OueOmoaMYQY2KZIn6SAXCbBVYbWGCYyv9zu+Ojmlj88PGJZV+x85KdfXfCZDBxky2FVY5zineWClbO8Xc/51nzFPzs/5zyMGA1xX1gMXsAIVhu0aNKe/iQmgdKFSjYVWdn7zZwzM3I1TPiQy3Dx14hvbML/r4cImLro71pTUbo2iuWqKRP3IsVpVJfbUiYXXZbSRQ+VpAhR29IiUkFjKOaBFkUyZX9rjGZpKybRnPuB3ggLLNpqKjQuG7wPPI0juxBohnII56w4G0ZuVUAF6IxhaSuatsYo8LkMr92bN5yIQ5Lwi+3Ica7YEcmq/NmVhs1UWjfe70tXGppWkwU+vd0iJpE9KFGvcZF38ZuPLIVUoV6fYKV71FaGxpQuklLCvaMlWk+oFFBRyFoKjzoJzT5J302JmBKgoS1DbDpkDGUTc0qRkpBSotWG07qhzprPhg3rKbKyDmsMc12GdLZj5Ozqhu3k6YxmlDJP8MlmxzketGJpE6d1w1urOVYXYw8FfHDQ8vbcEkLkX7Djvm7pVfGm7oyhwrCdPEYpNkMoFx6VcY0mZuHPXqzZqUiaCsXA/Ds4/d3Fv0Ps153aJ/3GKhZVw0Fr0ckwZY2KmUcnR0BAvBREoMlgI0Ji7gytM2wklQNDIFdlbkNNZd7JYnC5DOvanGmV4thZKqCXkSlGjusKbdR+D1SMXvjo4oarYeLjvC7VeTSf+4Gr6BENbdacNA2PuhabVSGWAe+uOh51FTEJf7xdc5pqdhSN68w4Kgy7fovSMI77PdBkbFOG7H5+vWHUiRQFndRdvvWmwpQkn715pVLQWsvcaVzOeBIo4eRkhsuZFCIhCUYrlDH4lGiNUFuNiiCpFNDEZkbZa5kzr8/hIXqUTGjJrHTxWdiEno0kjmuHUjWV0tismXzmk5sNt9PE53lDjAVZ/WwYOZeJpUrUaI7qinnT4LJlTGUtvT1ruOc0PkT+ld5yLzp6ElhFZysqLF+EDRroh1iIgCrjmiL1+OnlTVl/IaPTr+Aid/GbD0m/mhovHBbNwarl6Khh2il2fUJbxdFhR46BuF+D2WiMLbN2nSqdodKpKlUsqQQm0KG4Sbv9uvIhEeOIRbEyDpNhF0f6GJhrC42l0QqbFOsU+ermlhs/8Xy3JYvgE3zW99zgUTZTiebA1JzWLc5qRlNmP+8vK06jhpT5idpyEmv6HFBO0WiLFcMQI0YpdvszOOuMaTVRhE+2ZQ+MIaOS+m/TRf6/xDc24d/PnhU9nTHFcS/s3T1rzcxpDipNU1lk8iiJGF30poP3SFD0IaAEmmyIkhlTRFUFd6jLFGapXGT4ajdwUtV02dA4jTcWrQ1h6qnEoJVibi1OKc52A6MkUhZulCdGKWgoEbrG4pMw+YjPmtppjLWv32irNV6EmPczArpgvxBFyJmYE9hMhSXGSJKy0K3RaK04chalNFudymv47T2i3/1Qv9LkO2tIWYiSqChc3bZSHLSKrtaksccEX9aMZG52G/yQuPFF3z7ThiiU4R29HyzPas/5L5fXX173vDMfaI2j7gxzV5OUZtJrulywYSdNTaMtn1zvGGMioDjrJ2IsqLBdTiy7ijEKu9Ezx9BpzczWDK78cbWziEhBwGpNb/ZVKslMUgYwlcu02jGmVNa3UdRO06C5Vzu0clxGz9bHOw76mwoDWDCVoq5NMYvRMLO2IOgqYakVi84xjVskeCqlyZK53o74IXDlJyRCmzTm1fwH+6JkZq8VzYiCT2+2fHC94aA2LMyMPmVa3/LFbksdC63koKqpleHpdsduDOSQed6PTJLLDJSGw7YiyN41MgrKZmbWEPfr3RqNj6VzqbOiN3uSSoY+pQIyqDQz7QpAIclr8kVtFffqGgNcJl+KJXeqxjcS2qjC4sdQZ0NGUJVi2TlqpVFiacxevjhOZD9hlSJluBoHYh+5GT1pytRJoZNiK2V4V9myZ5TBytJG/WIz8N56y8xoZl3DERnrLc90T5MNKcOBq2i05qvdyBQSKsC5TPiYqVVxJJ3VjigFZS06YbSls4asUrlgGI28ovZkTW+lqHIyjEkIRJRTdNkQc5mnAqisLsUYV+EUnEfPNse7mtubjFRIchZFpRySoHKK+4sDBt0zt4pZnVnUDj+NaIm0WiE5cb0bYSxOt6RMlzRJFDtJpVgKZQ9UpehGhi82A4/amkZnqsaxyBblDNIr6gjKaFbOUqF4sh1L5z7Ci+3EMAmgEQNLWxGldO+zythK0RlN1BqyUGvNpErOp7JidKnMdmbFlDJBJaig044pS0HQqkJyrIzmsLIoZbkOkQH51bzNvyW+sQn/q9BKYa0mxcQwRIYuMOsss9bwcFFhVWaKsUz3K4UPkfVugmjYSSxaZSltuj5HVARr1X4kbd8yQfF0O7BSlnfnMypniRmsrliHgE+F3tOaUtm9RKNiaTsOOe0NPjTaKua1Y+dLq7nPoVxatC5upyiGJNz4iI+JnDK3JtKhXnP9Uy4ElwqL0QVVJrq80rmxfDifsQueZ2EqlIG7jP+NhdrTTYxROGNIIbMZJ/oxsJo1HM1r3j92GCLjGFCUZ9dPgbPrW5KHaz8xBcFhsArWKRYyit0LYfKvyFAfXe14XK35zvGStjN0ScA6Lr0n+sIeWNQ1S+f4ajPRh0Km2Exl+Ndq0JXi/rLlctsz+cBNBp2Fzlh0lanQDJJ5OUWGKaKi4orATJmCpo0FF6ottNqidS6UKyArxcoa/ubxAWkK/FxeYWXvMq43EvvqvrWlsJFVJhEIIrjKcjRv+c5BjdOZXSiOorVVbH3iq6s12QsX48Q4JXSCShQ7yWQphkqv0MAFW6z45e2OB88v+dsPj5jNHGOEWcwMEllvApIVnXEsreOl6lGisFmxGSNjEGpncJXmtKt52Y+QM30IXAN1W+OUw2pFnxJn00Q/RnLI3NiAQyOS6aV0Qm1tmGnLZITGlGFhkcyqcvzo4IDoI38hW6a8H667i994qH3Cb7OhyY64d+JOGrQzHNaOt2eOSimGWDw6jFKsQ+Cr6w3Gw8UwMQwRJRlHkcqKZLQumMKsFCoXz5An/cjPLtb8/tERy8oRssK5likmNkMkp0xtFQtjitpIBJMUu5SY4kRtDM5pTrqqFFpSxk+RrSiqzmKdwqHok3DmA7spkCNcm4QFjGimWIbbrYUWi8+ROv/qs3JkHH/z6BDxgZQ2DCJ3xltvMvYFT4OhwjKGyOA9yUPjGla14tE8U6myr1S20HfWk+f59RqXDFcx4r1gRWFE0Uu5KOr6VVm8zKlE4LPtwKl1fLDo6GpHRGOrml1KDMmjKTMkrTY4fHFhDoqbFOinRG0MdW1Y1pbr4MmSGVNiGz1OV1TaYYCQhEsfC6bbw21d9kCSYspC1gpTaVpd6Bmv6FdJMgtj+d5iSfCRT+KAx39ts/FvcMJfbkaiFDHnUi0K8NXlhsop3j6qOTqqUXEC57A4whTYjROXu0BnSxJekJaFOSEamDI0ZVCCUFpF2ZUW96e3PfeXcypjiCGxCZHeJ9Z+wmmL0ZqDuuJk0bG7mZCgyzCT1ThrMJ2iriwzih4rJWGHZyKzrB0OzW2MnMeAD4UUYASiGNIe/agl04rFmUyrLaedY8zC2RQ4MZaH1Zwv0u2+M5Fxdwn/m4tXRYA9Nsv7xNWQ+MXVNXpueaftuH/SQRgJ2hHbmhw9N+PAF9uBYypqXXCycY+BEIoVe01xU8770pKymR2Rf/n8kndPlkWnOgaGmNjuEufJ02JolUW3mncWM262ERuFlMohZYxhttDMG8dMGuIgiE/c5IloNAe6YkbF5RR4OniGMeInAV/QnuxJVGSYWY0LCmc1b60aRhG+3I3cs473lys+u7giA0YVisFdvLnYWzkwZeEaT9ptuJ9nPDhseHB/ybSOaGvp6pYUhZvthi9uBhoBpxVDLN4d5FJFz0CyBWmsJaNElfWp4E9f3vJ7D06Z25ogkXWaWPeR536k1hYnA8EkjmzDmUzkqCFIqcA5RVVrZs7xuCm+J1OI9ClxK5532jmr/WF8Nk4M0/51xUxW6XWl12RFlYp0SBt4ez5jFOHZMHBoHO8vDvhkfV0Y1ZQk7i5+86GMedWAfG0+1Y+Jn71c8/bRnJPlkgdHczY7IdcaV8+RKbHdeJ7dDHTaFIxiCqRUSmySC+c8qj1WUYpcxu8BHT+7GfjBqUZZSwjCThLXY+K872nRWMn4yTFXmqcIel/0skpRVRo7U8ydpVaAV4xB6MPIpUQetjWiLTfecz55+hAQyZAKnS/ncqZqpaiywWhDh/D2rGPIiWfjwKmu+PbikE/WVyUpUwqnzG/xKf1uh1JAVkgCL0UW+/xqxz8dP+Z7bz/gb7y94t0jzfOLCE1LZRTJR67XA59d75g5V9DTMeFjwZ7FXEh5Vu/3w1TO4mhAJfjp5ZZ3j5ZUVUUKQiSymQJnfqDGIDFzYGtO6pqb4DEKcioDxcoqbK1onOZYHATFECL9FFhXgXtNQ1cZrkLgzE+MsShFVA+TksLcVwojUGeLSwathUfzhkkSz/zISVXxYXfIL9I17EUCtXy9NfgNTvj3kAApA0IGhaJUID+8f8Dfeu+EeS1c30BKcOsnkg8MU2DyAXyCzjJ3jpALT9pFSJ1msoJWxdZYxeJK6jAMRHCJaBxnu8ifnp/Rk+gwVJJLFcCU33fUNZikC94zZ5zRPGzngGV5ULHuJ8bkGVXkMnimPnIVI+sQCm4x52JbHjKeCE6XboYyzG3DXGvu1y33m5akEqftSGdbqGGlFlRjQKnwtbVbd/HfIfZDu2V4Jpbh1R4u/cTvPVjx979/n0UtnN+UGZHbzUCOns1mYhiEC+upnOWorotxURK8TcVEw4GxoKMmp72DJHBFQrmMGPhyN/BffPIFwxRZzCs0mrrSdG1Zsw+lwWUDCD4nKmP43uECgKPDB1zc7ridRjbZczn0rKeJF37kcor4WNCLVAq8EKeEqRTalqHdzjUc1Jrvro54uJgxxMSjZuC4qakrx+nhimYc0aPH3a3BNxoie5M0MiMK7z3/8Pe/y//o2/eYcctnu0QaNTebgZwSfT8RJbOWDFpxWFVMKr02GEoapC7IVR0VZbyo4DrXKZJMQkzmeT/wn3/6BYMX2tZQKaGaWebLFsmZ48uJRW0QkWJS6Bw/PFpitOLo/oyz6y3XY+GgP/cjOW55kUdux4RPRReuHeTiVVMkJAosmkVds9KW9xcL3lt0DEl4sus4MBXLRcv7Svhi23OeR4y+u3C+idBWlbJnVihbkvMwwloHfvD4lH//g2Nmekc/GpI3bPtIiIE+RFRWbH3EVIrTpqaPiVGk1NjIxP36M6JLorQfjt3mRKoywSqebjz/9fNn9FOgUmCVxVWGRVcjObNKI6vWkAykrGit5TuzOTWW5aHjYjuxngLbFHgRR15ue/6Eic0QCDkVUIZS5AFAkV2ZV1AZ5rbiAMOH8wVvr2YEEmf9wMq0NF3NQznko3WPUlN5n+7izYWUi2JSRe7cryee3Ez8/R+8y4/eXdGYDWdXGivCzXYixEQ/JZRobqdIXRtmlcOosv+FCNlCrBUGhUm6rPNYzuar6LGVQtWa57uB/+uXz9hNkdaWLn1da9pOIVmxvDVUXQWUGdKyBvdn8Lzi5Wbixge2OXAePCFFzvqJtU/4VMhDpoI8ljWkTJG5WQwHbcMKx/tNx4OuYyvC0TBwahpmXc1DWfBkGLkmFEnS14hvbMKvVNF6Hq06Pnz7lD/84B3OrgdS2kH2/PmnN8wqQ1M5cjalkvrK0ZRikvCDas6DVcfT3ZbnecDOLJKEI1+VQ8IK0WUmo6iA1mj+7MU1QTJDEKaUERRbF5kQlnXF6crxeL7gT58FLvtIHzLWZLTOvOh7fFJ0kybteyxKQ6M1L4aRnoCkssjQZYaYulxksggqaUw2aK0ZiPQmcqsmZtpwr2oIAsYaHi9m9OJROfEy3pX431RoA8ppHhwv+MPvvMN//Pd+xFdfXSG+R8LAn/zkitWspmk0ISgW1jEkISYYY+kO/Y/feZu3u8TH12s+3/U4Z8mSOc623NUMBCvsVGJuNDNT81/++VNiTmxiYBcTouFKPGsVOXEVR/cO+PbJMf1fPON8N7AZY3EktfAXt2skZQ62G8ZcGtGKjHWGL7Y7NiEyjELcO1nXRjEtCotaQiFmWK1ptWbNxGWqmIeKg6ri+ycrsmRsY/juwSmbFBERPr+5Mz16I7Hfw09mC/7ed77Nf/R3/30++vMf46c18cktf/TlDcuuomsdIcOisUxTcandEfEp8T89fUA8zHy82fLJdkfyAa8Sh1OFsRnRhWHeJ8XB3NGJ5v/w8+d4EfoY2flIspqYEqMRTk3g/sry/XunpJ96zjc9FxKwSqNy5MdnVwTJrOobRBfUYciZThmexIE+JuIkaMBZRRZFqAvbPIdSbdNasXSOQUeuicxS5LCq+F7lmEIGhMcPjvmB94QkfL65W39vIvJQJDoPVwf83fe/w3/4/d/jo89+QRrX+OcDf/TiCcvOsqwrxgx1pct8nNJkA2OC/2B1TFgJn+96Pu8HzsPEkISjYjNJNgVdmAUOFw1dNvyTJ1f4IOymIrvxOjPVmSkFDrXnYDnj+0fH7H4Z2PrANgSM1hiV+ORqQ0CY78rcnc+Cz5m5s7wIA32M5Kyx2qFVKSamZXG2T6EMtoOm7Qw9kRsb6GLgqKr59rIuZnVkvvXgiLUE9Jnilzeb3/aj+t0NUSiBBwcr/vB77/MP/uYf8MkvfknfXzPd9vzjf/Y5h7MKhcIYQ+cMQyjqislmUoI/XK74cLng803Pl8MAORIlM48WR+kwBZvJSXMwr7Be848/eknMmW0MbKdIdJlAoCdx0tS8d2/Ge6sD/i9/8YzrfmITE9ZqsIpf3mwJKbOqHbu8r+ADjdW8yIE+7btSRpGtISdIq0KLymnvP2UyTaW5DSMbNJ1klrbi95YVSTJ1Dd+en3CTIlGE5/3Xc3r+xib8dW1YzRveOlrxzuqQMQRa7clKM46Z6CMhZyrrCJLxISAxQzZYbUoCnTPz2nGQawaVIHi0gqN5saHXCDELgyje7jo2YeBy8qRXm9arFxM1SWfGEOl9RLJmoSpSA0OI5YHpzEY83ic0VdF/a41GYdg76qLRUvRm2mhu1F54pTIkEBGSlv3Uv+FB19BpS4yJ22nifAxko3lYVcxtxbyqONd3lt5vKurWsZzXfPDgkB88Oib1PY2ZoM7cjpHN6LEI1sxJKbMZAilkEEvnKnZTRCnhaFbzUDoGLYRpwEZ4q+nKQDoKL8JNivzo9ICLzchXfY9QEIV5r13OoyJoYTd4tn1AK8eRraDJ3AwbUkgYMjsfWYepzKLszZpEl7bfNuy13FnRWYWpFDcxkW1GpT2yUUp3wSpFxvGtgxWHVYVI5mLyfLbe8PuVYvag4XjWcjJv+Xx9l3C9iagcHCxq3j9e8f7hAbfnT8jhFlJisxvZSEQjOFszhsjlZkQJpFgcQtN+VuTA1TxUsNXCsIuMg+bxvLiaOjRBMtcx8jcO5lzvPE/8SNxLL4q7bfEFSRm2Q+B2F9HZ8aBqcQ3c+jUhJcZcXKe3PmByW9rTTmG1JqVi2ub2e6tVCm01l+LBlCQ/hoI9FF3Wosqabx8ccVCVPfBlP/DL9ZZcKb4za7i3aLi3a3m2u9sD30RUuXgrvLuc81ZXs7l+hppuER/Y7HqyJExumTuHD4nLXULn4pJrtSlecVZzUNXcM2X9bdaBFOHBrCuXPqUJWbgOge/ND9mGkbOxaJIViqRyARz4Ykg4BGE3CRHN42rGWo0MqWCNg2SGHNnFgFBROQ26UFiMVuxSQEuRgLVGk53mKgWizlQomMq6y4ZCcEHzrdMDDm2FROHlOPLpZs2HLvHdruGobTjuWj67vdv/3lQ4q1nWDe+crHhvNWdzeUb0N+Q0selHdjljJLOY1Ywp4sdiWJkyNMYxSQBVHJinnBm00PcRnRSPmwat9matObONwg/mc66GIjkcJRH5NT8oX6SQ/RjZ9gm1qrlvalSV2YZEipkRYSuRKcTXUri8R9pqFH2IWAGbFdoYcIrbFEq3KUOSgvpGAREclneWK1bWMcXEV0PPV7uBXCneOW45qBsWVc3Tr7kHfmMT/kfHM46WM+4tWhoD682WuSukHonyWmv8Sne3nSZ8LIfUvbblZvSMCZzOKK1pjGEhjkoyy8qhXkmEsqBTxBhNGIsDKRRt3q8mn0vi5feulDebkdYYgjiWNjBJmbA2ShNzYJKiBbG5DIoAewOH4nSpAZ147Z6Z9zpavacSyZ560jlHhWLnAy/9yGUI3PMNt73DoJlVFbX7xj7Cv/Lx4cNDDpct7xwXjvPFxSXdLJMmIfhCIMl7XjQZrtY9YyzM3PcOVny53jKmTGWKO3JXWY6kYpTMQdOgUBRVV0JFTecsOYNXRVtoi9CicNhzwYSOIXGzm7i83HLUVMQEB26kjxFJmcoqRp8YRBglU2lFbTQ6lzmVKhUzI4XCxLKuC2C0VBZKe/3VGlSsmobGaM77gc93W74ce94fVlxuBypjOOpa5vWdG8SbiA9OlxzPWx7OW2wcefnVDZZAHwLbyaMp+2CUREZ4drMliVBbw3cPVjy52TFIkQ+KVjTOcuQqdlNi1dbFsZaSjCddBsnGlJj2viWV2bchFehcDqIpCDebiRdntxw6gzeOA1dx6z0xFWmjz8KQEiC02jJThqgyPmeqWC4RmqJTfdWIlld7OeXP80hxw2xaWgUvxonP+i3PxoEPhonzzRanNSfzlmVbAcNv6zH9zsa7qwWns477TQ1+5OJsgxPP7RTYBY9R5TIY9gnKy22PZKExhre7Oc9jX9aUQFaa2mgOrcN4Ydk4NNAYQ8qZNGpSSISY90OLGWv2FD1VuuKiNEFgPUZe3o4cuQoRYWUTm1xoYc5QvocIUxRaY5gbB6IYo2Cjeu1grUUVWovezy5FUFKSs7QfBJ/XDY1SnPuJz4YNT4YdD33L5WaD0YrDrmbV3O1/byreOZpz1M24P2tgnHi+/grJPf3o2U4TTisk1wVskuH5za7It7XiW7OOL/fmWTX7M9haDq1jSpnDukFRvGdCzhgdiCGTMnhdJLZVVnsk7T5jzDAG4Xo7cX7Zs3IVYxAWtlw0YyrwjG3ObGMEnamtodUGkzNeBBXLoLpRYNJrE+GS6O9zQaTkjACzuqFVihs/8vm44+U08t5uzrzZ0Wg4biq6r5kHfmOzxbeOlizmNYvaolViGgaOmpropUwkZ4XWmhhLlXznJ9Y+0hnHo7ajj8WZMabEJnm8ZCpt0KbYYyvKcA5khMT5NHLrQ1ksaq+n1wCZtL8eTClx3Y80YcPxrKKJjqO64jaUNk1tDL0O9Lkw/21WVK+G5ERQEaIqiZVEVazqDYXaQjFyMhpkj87zUg69bQhcTp5REiFFLnY9M1tsped19Vt5Pn8d4rv3D1nMag5mLVbD7e2W48M5/bDP8rPCakuIhe983fdc+8BB1/Ldw0Nu4sg2JIIfeelHdiHRKYvZH5JKsfeTKKSUJ/2Ocz/RS6KmaOlrown7lncm00fh+aZnlS557/4Bg4eHXcv5MLCLkXllcKNhI5GYhA7NSutiMpczIooASMrlc2D3h+neLVLpknRNv7YGLXAzeZ71PX1KjFF4dr3lqKtZ1o7TefvbeUC/4/GdoyWzpmZZWVSa6NcbTg4qblIkSXHpNkozhBGAs+2OdQw8XnT84cEp1zvPxeS5isJlnLidPFU2YDQ+F92+1aUKFRA+2eyKK6RKdNrgjMJpTdwPzikyU0q83PZ8HM753umc1jru1Q2SMuvoqbVGa82tRPZjAVRSKCyJfSVW5fLzVLpYyZShPHKp6kIZ0AMYpejBr6aJZ2PPGIUxRj6/vObefM6yqrg/a/gpt7+NR/Q7He/NFyzamtZoYhgZ+omTGYQ9ycvZYgY57ve/q7FnGz33mpYfro65GSZufJknuQ4TWx9plEF0qeorBZXWKBSi4MvNBo9iqyKN0hhTZL2vjJS1Kuv2Ygx8cbHh+8sZrbEcVzVk2IVIpTXGaHaUggwCrVhSljI4HBVRJ6JorNfFH8IWPnspHpYVGPaQhSFFLIorP/LltGOTCuf9yfU1x7MFy8rxYNb8dh7QX4N4d7VkXlfMjSb2I7fbLasDxRTLHJp1uphXUWRZZ9st25h40Db8YDnnrB+5jZHtlLmOnj6VM9iZTKCcdU5prM6kJHyx3RGAUSVapXF7wqJQupBCZoiJs+1I469456BjYStO6kjOwi5GWqVZK8U6BciwACrRCJBzJuzPcklljkXts/BcNskCV9hj5AEGSdQZ1t7z3A8MKTGEyJfXNxw2FUeN5bSr+PRrvJ/f2IS/doaYEkkSdaVwA6gQIe+NPZQFpRmmCVAMIbPxkaAzR9YxZU/0nrNh4iqVj++hK0ik611ho3dal0FJiUjyQGn1WKOplOJAW26S4EkYo9iEyDRuGW3gZH6frjUY3xZT3jyVQbScuZKAFY2JAknIQNUKOWlElcWZsqLGMJDQUiq5onMZAk6RnDNPdzs6UaxHzxQSWTKTKIZhh6pbmspw2t0l/G8qFpVjmjyptSznNZvBYfaDNo0tB5U1is00oPZYsHM/ERR8MOsIOnA2RL64mXgWBoIS7ruGGsvPt1cAHNjCGHk29YRbQBTWZGamYmYN9+qa8zAxJsFYzdUYGMc1sQt868ERh/MKR0tOCZ/S3nXP8KwfqFBsk+IqFqRc5UBbCDozJMFlocYyIRAUWQtKF/M6nxM5Zz69uuWoslwPI/2UyAoG5Xmx7kl5xqJzvLec/TYf0+9sNNmwG0ZmjeNo1bH1pYKvJDNzlsZonIKzbY9SsA2R88mjtea6G7lME+v1xFYyF+OEj4lD41iaij+/ugbgtK6otOaLYSi88Qi2VmhlqJVl4YRbCaScsBhuQmQIG8be8717Cw6XLeREDBEvidELKsPzONGi6KfIuZTqu27LLTdR/EYSmhpdCEH7mRJ0qb6mlJCc+fjqkgNtuRpHxpBBMjsJPLvekSIcz1re7e7W35uIOiiu40A+gEezjiEUt2WdM512dNZgs2Lb97B/1i+DJ2V4VG25TiPPdoGbmLkMEyElDnB0xvKL63IG32tbKmP4cuiZgkdT8NatsVTaMKsqNr4gqCtt2InwdJgIo/D91ZzV3KF3ipykDGv6hEqZM0ZcNAxZuKT8WVqXIfagMiMRmzUNBp/UXsqTwYDowvDPOfPLmyuOleFyGhl8Igv4EHnae6IYTrqad7rut/eQfsfDTZobP6HmigeLlp03GBGUKpj0ztgyIL6bUEq93gNRmceN5VZNXA2e27VwkyZEhCNd0WD42e01oDhpK5wxPBsGfEzYpNA1dEbjMLTKsAuRhGBQrKfIZ9OW0Xm+tWw4WFSYXSKnMjc1xiLDvdGBNmlSkCLbAUxbLrdBCxOCyaXTLqb44OQ9uEB0xvtQ8sDrKzbGcOlHwt6TZCeBZxvP28xYNZZ35x3/4mu8n9/YhP/kuOXppuez80v+5fPnTCazombmHKfWMdeGcSpvYtfVvNvNmFnLxTjxs5s1U45cDWV6ecyxUC6y4LBorWisZojCJJkksGgVSSwTEUwhmNz6yNYLtiptH60tScEL8dS1YzbreHm5Y+UKQeAv1pes9/jGXieUBeUg+Qy+JPJKK5TWeJNJJrFKhqBBvIBotHJoY7n2O15udiwrxzZFbkLEmszDrqOuO5y1pARxumMAv6n41tsn/OTsgv/Hl2f8n375lNEIx8oyn9W8VTUcotlsJjDQHSz4vZNTjoaeJ5sd/8WTr8g5cz55lNaEJEwp8SKMzIxFWTgwlk2c2O7pKQfzhgxsR0/Iwqjgegistx5dFcMNozWTZH6yG/jPZo6T5YJPP33OSVVhgX/+8oyLqTg3D26vH6xKBUtNmTGUSogyCrGaaCInqWJrEykqSBqrDDNb8bLf8fluYJsNl6PnbBtwleaDdsHyXk3duFIRXt8Njr+JeP/dE/5fz17wJ599wf/+o1/iJdOiOOgaTk1FFxWfvdiAVlSrmr9775iXwfPFrud/++VTXNJceE/TWJzSRCVcToEhC6IKevXKl+5nisLBvCJmwUch6Iw2QvaKqU9FZ2+KI2XM8EQmYlVx/3SFz5lHFDTxP7++YD0GtIGtTWBSoe9EYILJy36+SRFNJpjMKTVb4n5eAJw1tJXj6XbLJ1dr7s1qbkfPxXrEWs232hVH92bYCnaT52Z7R+l5E/Hw7UN+fHnOz198xT95+pQhJxo0h23Lqa7pBsWXL9eIzrh5ww8PD3iUPF/2Pf/HF2fYpLjJgUVVMVOGAbicPDsSojMzbbnoxzLYnYR5Z0mSCQmSViQDelKEIaNqVZIhUy6MZxKhq3n7cMUXz284kTIv92fXF1zFiNKawSZ2NhZhZAAdFT6Nr2VCooWgE0di6SUT9/IKqwyNq/hqs+bT61t2XcXtGHh5M2Ks5p3FAX/zfo0zhu2UuM7x3/ZW3sV/xzi9v+DHV+f87PyKf3b2FUMsa/CgqTikYjNEnl1vGRAWy5bfW6y4aCaeDSP/1bNrcs5s5S+vwYvRY5JBK5hXjrWPTMoTYmLWOiARUn5dgM0+44OgDdhKYVUxeH2iJuqDmtNFx5fPFA/2Z+cfb67ofdkztzaRXUI5imQsqjLnZwCtEJMJRnEohp68dw5XVMbQVRUvbjd8ullz2Dqup8DlZsI6xVvzjh+1hzir6YOw+ZpH8Dc24X+x3rGNHk8kZAgeTJupKsPtFNhMAy2a+UHDxbTjsGpRufyFFLCoLbc+kDNU2HI7S9DuGYIjicoaFtkgUfFOXZGSMFSKIRVDhLmp2ZoBbcpQh8tgpWAUf359zbdJhTCwHwqaV5ab9YAxmVwubJBBm8K8Vsli1d5BWKC2mg/nM5IIL9XIJiYQAQMpFS32tHc/1TqTMfzTyzP+4PSIQ8AZw3JW/xaf0u92fH59xVXo6VUhm/Rj4ritWNSO9Xpkswu0znD/wYLL2y120VGJYqYNt5Vh5jQX0WOSpsIUCY8oGqfQaG4l0VnDUWWZcuYH8wUxBMaq5jZ6tmNiRcUVI5VWSBCMLtr+GDP//NNn/I13HuADaOVwCDPtUPtqhFaQndrjDxVTLFIz5zQWjRZFheH35wdkisvgVfCIgpQMPsBm9GylbCraabJW/K9fPOd/Xt/nsRYWGN5Z3lW43kT8/OVLrqceQRBgiJHKWGbW4gdh7BMqw4PThovdyNrWEIQmlA7pqqm4iB4tUKHIYvApYfayrVcyxK6yKJv53mzBFATpiv6098JMOS7VUHTNsRDJnNJIFP7Zs6f8e0DvI9poFlXFsa7YSCDtNdKJTDCCbQxpEpQUIzutiglOjeb7szk2wZf9yHUMZSYGIME2Roa+ABNK6Qv+N19+wX/83mPepuXQGNqDuwr/m4jPrq7YTBORTMyZaUy4WtM5hd8Fpl1CSebksOPCB7ZDIkeh9tAoy6y13PYBYpGruqSoElgDEcWYhUplaqOoneHDblFmo6yiz6loo5Xhej/okXzCWoXWBlLmT16+5A9MZIgepTKtNSxNxfXkiUmhU0acEG3GVBrvy+ySFlXm6KQY1f1oWTCKT9c91zEiqrgCKzFsgjDuPEOIiAaTM//o80/5j959yLfmM5a1493VnaTnTcWX61t2yRPUXuYSE5XR1JVl2kamIaGVYrGouB0iJ7qYq9aiaZxmZh3boagorDa40iQseZguxqlO6WLahuZ7zZxdCGSb2eXEEBJLXbFRATSElFFKsGjEZ/70xTnf45QRUNbQJEuHZSNlaFdpyJpyeW0hjRklYCtd0PBS/AB+WC2JOvNVLgXAkiEolGhupsSGYuCldNlX//OXz/lP3nrMqa1ZVg63+ivO4X+63YEplXXnzN7EJbPRE3UElyHqooXahoCKBi+BMQaGlPABaq1JUqyM1d4pLxTQMxmFyZpWW+rOcmBqsoF1jKRUaDld7dhaT/x1J0eV0QqeDDsmSRzoCps1MWWWqqa2E95kbC46afb84CEl0n4QRO2Vqgrh0DZohEZVZbqbhGTNWvTe4VeISsrsnGTWEnna98wWCzrrGOWuuvCm4seXF/gsWAUra5BcNMy3w0TlI1UuDrqguU0evRsYpliG2lJh89fKImisykUyk4WgBeXKYKxBsdCWB63lnXZOdpnz2JP2luLVwnKhXak48IrXX3B2f/zynLX3HGZNIxpJ8E7VcGZGBqUxpjj4ikBjDZcx7YkB/GpaUsG7ixkGOGwarkNgkwJDgOtUJGc5Fg+BlIUUFde7kZ9dbzi475i1DfkODftG4icXV6/lhEtj6GMkCFyMA8tk6Iyi0QZrDZsh8XyzY0iJa/EMSsgSaLQmp7w3ZlN0rUVlGPdZtc2Kudasuoq3mxZbaZ7FnikmKq2pO8utdmxjKsjjYo4CBv5iu2F8+rRUe7OGJDyual7aka1OOK1JZCRlZspwm4SoimRnXwsha3jUdMyUYdW0xbFSyuDwVW1es6qDCKIyUWCdAj+5vuawciwaV77mLn7j8YvbG4LOOKtoraZPZT+5GD2LrGks1EqjOs2wmzgfenyM5RnqMlDuVJEB5SKQp60tZE0g7gdnyxm8aiveaVpslXnmPdELWRRVbZjrim0KCJlAKp4NSvOLfsN0nlkmg4sgMXPf1pzrkQ2RyihMNkjKNFh2KZR5KA3kIuNJOnOvaum05sjUrGNkK4mdylylsv78vgMLhQS0CZ6fXNxwWtWs2rrQFO7ijcRH61uCjjgN1ip8VKQsXPuJLiva/ZyRrQzD5DnbTcXoL0dGmyFFKgpIQCSDhrax5JTxBQVW9kBlmDWWt1xDsjUvw0TwE0KmbixXeCaJr/dA2ftG/GR9w0YiXXJlVikJ97XjWk8ErbCqzC6JZFpt2OydnAFQeb8HKh41MyoFR7bhJkd2OREA22iGlLA+E3KRh3sRNjHw59dr/s7pESeVo/+ae+A3NuHfjB7lNA5FvZ+ODiLomKmwGGtQRgOGKWdimrCUQcQxFq0duQzoGqVQqnydloyKZRK7J5OMUBmhHRXz2jKmyJAiQ054AzUG8woXl4txiEHhYyKYhK72Y785MTMVnbFEFffdBkWlNAeu4mkagT1yUxWH0g5Na6qiYtXCFIStj2hKtSLmwkTPwGjL0K/kzMU08bid0WkhhruE/03FxWYqPFylcbl8VALCdgqsFGin0VaDNmwR+nGgEoVIZvSCT5lEMU3SSmExjCLklLEqE1NmSyxf74QX256jrmUzBdaTZ5cSzmbaxkKfQBW3y5gK13ftA7th5KTpSDkRknBQN7RaM+aIkrL+Wm141NTs+og3GW32jqZaszKWVVMVmlQVGcbExTYhKGbOkSh25WjFlEEixJR4stnx4WrJ3OY9m/ouftNxuZvIOtMag9OlLJ9ypg+JuVJY57Bao5QmmMyLNJZCw34PjKnscznlvamVwuf02lBOMkxJ0CFCpXjRj9zrmsKejpFBMqMVmsoSYibt6VGJjNKKPgjr0fNg1hCzECRyWDc0dkufBZ3BKE1jNI+rhj8f4mviBaqYHnXOsHQVnVZEB9sp0g8RkqKtLNNYBjG1AW802ZeL77N+4NIHlrZhvFt/byRu+gmxisaUwUgoNK8+RGbKYZ3B7Ie0g86cpQGbS1HCp4RkQVCv97+MIoqQc3r9vbwSlBJUjpyPnoPWsfXF/2HMgraCswaX9kaBkkk5IVrYhcztEDioDKJy8cpparrRsU0JoxRWK2pjuF9VfOxTWfqa0nlXis4aDqqKRmmU0wyTMI2ehKKrDMMoVHsJbtB6L72FF/3A1Rg5tJkQ7hL+NxW30/4M1pri+1z2nyEkGmXKGWxK9d6rxHkuOnvgdSFAZA9qMaXS4Msv7PfAslZ3ezPMSx+Y15Y+RfpU1qDfk3Zk2iOD9yCWbODWB9ajZ1kZkoIxC0tXUWlDIGHQOIoX031X8Qu1w6tSzMsUk62ZtSxqRwWkXLrp196Ts6apDdEnrC50jxGQUAaMv9zteH8+p8V97TP4G5vwj6OQc/mwkRWSix23SaYwS01JQgSYVMaLZ2UM2ihCTsR9BzhnRaUtVmtCGYEmhWIGM5BZp1JlnabIqa7oQ2SbAj2C6MhcVRhgyqG4VOYMytBmy9I4WuuYUiBroTWOpa/ZSaJcJhWNMRw5x1kcUblUvLKiEFjEMuZEpTNTTuxiZO0jrXU0yhKs0FlTqBaqkDSqrPGSGGJi0kK8q66+sZh6IVYZsaqYxEgm2jKUszQWaw3aaqLKbEjsgueBrbC2/F7JQjJld6iVKclZLujNHCBG4VYSNyGglGLwgXfvRc52Oy6niV0WlHgW1iG6aLDTvnOgFcyNY2Udq7qinzy7IMzrmqO65nZKRMnUWjEzmkdNzceNxeR9EghorZkpSy+JWbYMOXAVBl6OAzNd02qLKDhoHH7PYx9HwRjFzkdup8jOJYK/O/DeREQvBdFqQOtCEMm6XBRxxRU5a0Xcr7PLGDk2FqcU3guSwUtpITe6eJUHKV1Gi0ZyZpDEQOJmiIwpsjWRs2liHSNDzkQvHNqKBsuUUyE9kclkOhxLXbGsKoboGZNwWNcc1hXrKRYEsYLWGE6risaUgbu4H8zVStFg2ElCkVlL4GUYeT4OHKiKqrJYk1k1FcFkiIqRQv+ZUmIThD4K8a7C/0Yi+H1nz0jJkhMkDSpltFXFaEhrRBTJZG5i4EBbNAoJBcMaBbTkIsOBfaW8rL+cMpMWRh249REZMie65cp7djEyKCEEYWkrmmzxOZKk7KtkaLWhE8VS22JUKZnGOVZdw3UfyjmrFTNruVfVPHUDKimiLkQenRUthkkJKmvWKnGePc/jSKcqamvRRjhsHEELBBiImP2ldxuE3b6wcxdvJpIXgi2VeYsGKUOvKZY1aOwedYciGqEnc2gslah9bpTLHpihMoWD7qOgNTj+P+39WaxtaVbfC/6+Zs65mt2eLuJEZERkA0FkJga70pDEvaZ8rystxL3lUhlKQsj1UJIlyzL2A9gvfkp4Qqp6sFSW7ZeyzEPJskG36sGyZJfABRZUpoEEA9kQmZEZmdGcfvdrrTnn14xRD2Oek3B9fYmEOHFOnLP+UkgR5+zYe609x/qaMf6Np6jSi1iHvBRIcCW03MsjF7UwOGuc7LiWTgMJmSysAQedBhY0HLYNFyVzXip7swX7fUtfB9OE4Nn1Dc82HW82I6TC/RXLO8ccT68VcZ6V2oTsOGcWrmUWI6rWGClekKIMUgkK65I5HTOHvpLKu2v8PrYH/rEIRIeK4NW6DBXHKEJGKK5OvHzlImdKURY+EDxop1DNsjM6jzihDZ5rk1fpvbGaE87k5S9VLdRg3dNgvFOwQ1ltzad3U62rEPC4ADtNR6MRmWj34jy0nueWO5xuEhvMT7hIpU2FJgTapFw4e9hVlXUSvri6x/V2xslQ2RRzIvBNICdl10cOmoBzjqU23KZnvw20MTC/b+m4jZV/aFjnjOJRsQNX2wZEhSRiGQ1eGFzmPK04zWY/N1JxQSmtoOrIY6UNDvFKFz3PTxZuR33CiSny1YEmOB4zF/eOmatD74+cq+Cd0naOi7FQnRBaiM7zXOjYKxFXhSrmgNK1jk9c3ufeSeYsF9ZSyFlYbBrms8A8KxfFLryiyt218Ot37vBd8yVvrXpOc2bHNTQxsJbCVd/xfDvHec+B6/iWblh2kWUI7MWGLkZS2B64HgaGKpZEWoTeOboYSFTrpqswSGVwCkVJUhlrZeO8aTciiHeUsdLgKGrOUs/tzUHh6DSh02XCeYdWWI2Vr5yYv31VZ6mPYiPsZh5YD4XiFD/lQlwLLfsEXKkTBc3TtoFPHu5zcpw5q4VRhKOU+Ro9u4sGTcK5VpKzTv3ZeeHXuMlL3ZLbyfirnfPGcUU5aFqem80JwXOYEt/Ka7rgmeHZC4GuCWwb/A8HvU47YbXn3QZPmSyCswojinOKryMZQdSaUt45E2YHRxkqHR4RaFrP9bmtf/fW2TzHvVlgS1YuSuXibE3wjhIcUgBVxCldG9jkTJnouQHHNd9yKB4v036uFdcGPnpplxNNZsddKydJeUMcO4uGeS+clmwUD5TzdeE/6h0+vFxwaxy5qJXW2R6rVdkJDdfnHTF4DvqWN/OGWWsZFXtNZBYjW1btw4NlHEFSq8cuBpLY2U+d7XlFYUOiBpt+J632541pLkoSImap2UTH1fkMVDnbJEBxzhKi66icpcTZxUhDQLCJdi0KDbSzSF9Gqrc1MDjHs3Tsq0eLkotNDZbLjo/qHmerzMZVNlKpSYneMe8irXpWrkwW7XB6XvlNuceHugU3y8iFFLMKjca9vRIbLs06cLCnibdDz14TaYJjPwYW0SP13Z0DH9sDv4JxN4Piw+SFOgURXGTbSLxz+HnHPETOyVxooRPPHh19EC4S9N5uQzuh4+XDAwBu3LhNrfdHy1PQQWMH9zVGm1AxgaXUjJ83xNFPoVz22lap8NHFHkMp3B1H1prRxnNlscM8RRovpATDmLkhKzatcJkWChQRu6x0gXUqbKr5DfvWvK6lKt577sSes+q57DsOmsiqj/z5vctEFB8bsjpG2XYXHhpU0SIUUVIHXYzkUXAVboXMPSqNeD7OjCYGLvLAnaTsuMC10HJKYVgLvYArwkHb8pevPwPAv3ztLVJ1OG95ELF6a6Jl5bgWcrG8iRZYUem6QBRvqbtOCcFxdxz5c1cvUWrlaMzcS4m2a/nw5V12h1Pa1tGPgfWm8rX+gnVTuRZbZKxkUbJX4qLy+kXmTso0QfENgJDE4T28Rc/dNHK9W/DMbM7JeuS/v/YMy+BpZzMGKhvSo3xKTyzc5BpSvDIGC5MRYxRwp2aOxSzkPtLtEIKnFDgumYX3XJ239FW4WAsazVXiWuz4q5evAfAv7n7TqDnR6DVaLQuiJKNG1KmT1eBJXlh2gVmIDKWYn3mEu5r5xO5lBhWOUuE0j8TW8937l1isTgnV0afKqs/cXm8YWrjUNvazqlLVLrI3V5XTXJhFm4JVp6xUaJ3jW6HnxjBwvZ1zvZ2zXAf+8uE1uhCJTcMqF87S+Eif0xMLMTpYQUneJoJOoIpyO2XulULjHd/d7uCBESVrZsdFnp3NOSZTLzKpNa3dYez47y7b+vevTr9pdeQtz0SLNdpqMrpDEZsitQSqCL5xdC6gauuxD3BHRl6e7VGqcj4WTmqmbTd8ZPcSy+6CRgKbVFgNibuppx+VnegQqUi2C6d0cGMzcFILsyZMnuvKqiZicHyz7bmxGXi+mfNct+BkPfCZy88SQ4AYucgD5+O2/h4WnGJnJq+M0bIfZJqQ362FExWic7wwW+J8oJTKqVqOw5XQsEERKWgTKE64FjtevXwIwC++/g5FgaC4YJPQgiKjTCm7Rv3pxFNdJXbRzoQqk42r5wLh6mLJqIUzKZxK4TBlXri0x1fLBY1UUhLGVHl76OmjcKlrIatNq5wjRsc3VxuOS8a33pwcneAwHdTbYunTz4SZTR8Y+O92rxGiZ+YbNrVwXoZ39ft8bA/8l2YRdZDUAjROZWB32VoAFkKaPExntSeNBZVKCXBp1vGR3V2kFv5jvctGlVHhLAt3zjPfc2mfa35ObgrJC+ocnUTaFs77jPNCUAtZiI2nqienyi4tvSv0WnBVuMOG3z6zoqhqvvq3jo65woYffvnDtCFw4/SUt46P8d4zSmaVhBWCenOp6Jzj+w6usEdguZgRPWxy4g9OVxx0DX0eOcuJqpWmmfPywQG1Ksc148pIVmU9bNtbDwtXd1qSwpgrY1/YrBPLvQadfOxdheg9t2OP5kpbHBqEg1nHn9+7RK7Cv8pvMWQLwToaBr5+tuK//dCLvLg4YVUyKVScF5biEO846hMy2R9GZzXoVBmKcNB1bGrmomRGVd7cbPj3N27Qi5DFhEFfPe957uiUn3z1+5g1kddu3+VL79ymVcfZ0HNcKzVVqofYKAsH3//sFa7HlsOdOU0InA4j/983b3Fpp+OdYeTeOJA2QjfzvPrMZWIVvjmsCeOKJMJ5vz3wPwxc3mkYq5Cq6T76UWhnFpRWMD1JULv4Fa+mw3BwdTbnh/Yvk4fM/yvfJiGkLNzpB37v+JwffukFnlss6V1hcHawXzSepvPcO03QOloXzfHMeXJVVn1it2txHi5yoorjKI/8+u1bbLSS1KZMXz1f8Z/jKf+XT1v9ffX2Pb70zm28QInKyZjZDNYli1MK9A9cO+Rq23Jtb4e5j5yuB/7dnZscdnNWvec0F272A/PO8+n9y8Tg+fpoB7qkwtmwrb+HgYNFJImQi1Foxl6YtQ68dfoTSlLH232PBDPBcDgut3P+m4NDknj+3+ktRrFJ93Ea+NL5Ka9+6Dov7e6wlsqgBUGZB0+zCNw7TdRoCaeRgIueWip9Tuw2HcE5Loo975Mh8/mje2zUpv6C8nrf88XTc/5PH3+FWQy8cXLK1+4e40UYQ+F8yKSiEI2aOI8Nn7iyy7XYcm1nQecbTvqRX77zFvthyToPnKbEzb5n0Tp+6PAyMTR8a7PGBaWvhZPNtv4eFvYWrdVPESjKkDMxeJyzdNw8aTXupoQExVePc3C5nfO/WR7gq/A/DTfJHqpW7uWRN9YDrz7/HNeWJ2xkmloCMxdwMzg+GXEdtGpOdjEEmxyMmd2mYVTPphY0Kzfp+dXTO2ykMGpFRHnjbMOltuUnv/8Vuhh5/e4xX751D+8tQfy8VFZajDngYB5tKvpM7Li2O2fmA+d95lfPjrnqZ6yzUSzVDXTR8eryCgBvpg2h2CVlkz7glJ4amURipm64L4SXiT6gCqU6UhVGLxy0c2Iwodc8erKYWCdVBTWRw3E/8OYqMEjhoIvkyW6s84FjGRFvYg8XHE49rQ8E5xlqIkwRpAIUtTF4nwvqp9CsKclvw8jXb9/h0s4cj/LschcvSl8SY96Yu9Dk3uMDXG1nUGzkFJ3Hu8AomSQezTy43RYHe7GhSuWsjoxJpvbfo3g6TwdqsE4TcaI9FKN3Be8tKU8sOXTIlXXJXJt3eG+BXYddwzBkll1jtDQxPurbJ2tem91lTeLZnY5RhTQl6761WVk65ORH7jx0zrFwkRMK0dntXzwgNvm6SJnkzT1DiyXp3hsTv/n6m7x0uEen8PL+Aa4IqYt84eiMIEAVRD3SOT68WOJSZS42yl57z1oKy9IgRSkjjEEYO+Gga0lj5ngz0Es1B6vtnfOhoEbjTKu/7/E7JSE70y+pKrWYXVsvwrXZDHVw0LYcth3rbNxPRp0Ek8qtzciX7xxxrpnr884ObSLMnOfW0CMqeA1T4rLDqbLrIj0VV8w8wYzPlIjjLOUpSHCilSmcSeLXv/otXjrYxSt8bG+fIEqMhd86PccPQJkEcBE+utxDUqGpjsYbNzyVSmqEOlpGQAqVsRUWMSJFORszQ0omxivbKedDgXFGrd4mPYYLdkhRMDqsKEMVmyB1M1Qd+03LbjdnSJVl0yApoeooRbizSXz9+JwzClfnHblGklRaH7g1bsyNTgHnUDc56eEZXSBqwHmFGJCihKBc1Erxti+rONQp61T43bdu8KGDXVqBjy13cCKIS/zBeI6fNnFRqI3y0s4BbhxpxdEFaKJjKEKKQklCzcLoKikKy7ZDChwNiQ2ZXG1asMXDgU5MFR+d0W4Qy1EI7oHxQK2mRRq8cHU+w6HsNw2Xu46+z7RNQKq5PuUq3LwY+dK9Y1YUnll0FDH3pZnz3Egbqpr1pffAZHYwI5Cc0Eqwy6UDdaaHWuVMVjtLiiiUyjmZ3/zWDT68v0crjo/u7iEiuJD50tn62zWIkr3wsfkuZKGTQOcDMRgvP/tKHdVonFGo3rE7a5EqnIxGTVMHXt9dDT62B36noM44zsE7PLaoBOWBx70D6jTiXsTAPAZ2QnwQz74XG0RsRB2ciT16MTpD9MYRdWJixFSs2w8m9o0eWjzBOyIekxR4GudBzMoJr7Q+ohh3LHhH8cqd9YrqKgfdnP1uBiKss/kZW0T9NJZSaJyjThu6OkvqTaVQm3ZyNAC7HViwzWoYWOfCODm1+O1h66HBqUVhO+8eeEcLTK5PVn+q5m9fUXbayE6IXGpmeAKCHcJ8FnqpD1wGzsaBXgpNnBE1EKqNvMdcqdVE3QQ72M18oMVzEBpysRqcNZFShM4HxDkWMRrtyFWcQPLKN0/OEZTndpY8s1wiufLOWW80DrXxpU6uP3PvSc6SnO87uPSlmKiuygMakSLMu8i9zZqTIbES06OE7X73UOCnZoeH6ZRltaFm2ICffu+5CtVb+u4ieC43LX46qF1rO+5liAhN8DTRsZmsi6NzhOnrnMOaI84MjCtW5zM8nXM0PpKrOZ51zrQEQR2iyswFCo7kbQ2sqrx5eg5aub5ccnU+xwP3NudUUVx19tma3DMWPjI4wVXFBXB4UjX7xVFtgqrYfjCfNdw8X7PK1iUTVRrZ6pgeBrx6HjjLefdtG0FMbHj/4G8TbmUWIwsfOGxbvA84V7nSzdGijNERvadpPJuS2NSCdzO6EB64NqXB6s9NezwOWu9pnKP1nlIdwQc6D0kLXpWiMAvRTD28uVFJrdzYrCAo12cLu4iIcLMfKZPg934TUSrsOs+I3RqssWhrulZlEKHotP55aLvIvdXAaUmc12R0o+0e/NDgpwXPgaVwmwp2aog5a14pVLEE2kUTWOK5HBvC1MC9FDvONJHVJucEOBkHUq20zvQYo7cLbUl2oVDU6DZumjZ5s/9ELcuhcZ7shSimj2oJOHUUKrH1iFPevLjAO3i2m3NtNkNUuTNk5H6TbKJsisCOD4wOjEVkl91UCtLwYHql2IV7Pg+8czqwypnN1Al/t3vwd7RS/uzP/uy0OXz7n1deeeXB3w/DwE/91E9x+fJldnZ2+PEf/3Fu3779nfyIBwgVSx1TZ91vDXZgFhOY6dRlr+JwYovP0gUWBGTaAJY+suMiCxdYxMhy1hCCw1mkAeqgIGy0gOj0awXnlBBg1jiaiSa0GyNLH5n7iHPQqKNpA4dtw0HT2mGvjcQ2Ih6SmEJ81kSaJnJRLUDMDPjvd+gEEdsk73fTUFtonDPqEl7x3iHq0QCnZWCTbYQ+Ullp/lP9fj+IeD/rDyAWbzU4WVj6iUOt+u2NwQcLkHHT1xw0LYexQ9RTnecwtBzGhv0ucrBouLJjAjAnJppVzF/3opo4ye53lobbOMdOjMTo+dBiwWHbsNe07MQOH00wNmsbnp3Pub6z4MrOjMs7HbMuoN5zkQtFlZ22YdHNuD2MDDI5DDCJhVWhKk2ItvhMDgSlGjey12qdDG+fDyLcGjYcj4mLUriohbOyrcH7eC9rsCkOX2wN9M7h1fJDrP6su+Sdde699QQ4iJHDEG1T8XAYGvabloNZy6Vlx9XdjsUs4rHhYEXJKBeugne4YJuVYN/ThNme67MZ+13LbowWZ+8tI6UNnmvtjGdmcy4vOi7PW2ZtIDTeLGiBZdOwaBve7keGotMA6/4aCFqENnrbjMQ6tVKVoI7BvD3xfpqudYEbY89FzmxKYV0Lp/XpoVS8n/Xnq8dNgl3Ptw/4f/TQH72n3m9KOdhtI/tt8+CCdhBaDmLLQddxuLD6a1tnfGm1i2VB2UgBnbqqk3d19I69NjDrPM92Lfttw07TsogNPniCj7TRc6XtuDqfcTifcbjoaNsATaCXiqpdhOdN5NaQTPM2nR0Itpb7Uui8x6lH1QTGtQpemPZgHtSfD3BjWHFWExclc1EL53W7/t3He70Hh+rxxfRMbqJYqDNWhVNHmJoWotaE9ZiD3p6P1ijwjsuxZT+am9jBouNwp8V7bw2Lac8Vp2x8wePx0U0nY/ue+z6yjIFrTcdOsEvtzFmQZoMneM+ltuVy27HbtuwvWtrWo9GzruZWttM07LUNd/piNSj2+nEWAudEabzVve3DpvV0zpkpRniQO0hsPDfTwErMOtT24IdE6fnkJz/JL//yL3/7G8Rvf4uf/umf5t/+23/LL/3SL7G/v8/f/bt/lx/7sR/jN37jN77TH4Mr4OJ0ACrKDDvYK/e7PfZ3iYJEs//K1VGcOaIocNoX2hBw0RFbz94iUMfCTrSHtSmF45osRl4dIXo6Md5WVz27XQPAC7NdtMI7mw3f7Ff0ojTBsx8aPrbcBQ/nNVGqsBmFECuHs87Gz3o/MMn8WIMzwRFMfsAFYmthSlUcIo6Zb/DeUxGzcgRSTZynxO1hYO0qxbup2/d0tVffr/oD4I+s4w7HEjvo+Gqd/vtdnyEYBzAXC4OrTqlRcL5yfDawaM1NpOsCz+639L1wGAMdcGtMvNMPpMky1rdm4dng2PGRK11r73v/KhxU/vB8xe+fniNSmLWBZ5sZn7hyiIuO85wYU+a4H2hD5NpywU5oqRW8CutaacW80X0wOoUPSlM9XdsgQUg1k1NmFgPOOzJCjA6C2Sbe26z51umGs5It/dBBqO5P9/v9gOL9qsEpF+bBJG+BdTK9YrHvjuk/HERHnQSWxSm1VWoDdzcj8y6yiIGuDezttpDg0rylazxHY+L2OJp9rIemteZKVFgSuNJZkvfH9w/AOV5bnfMHF6dQoQueSzT8hcsHhDZwWhNpKNwbRmLwfGhnyaXZHO8jXjJ9rjRhujwjSITQWqpp15grxqYWNiXReE+ZJl2dt0lrT+Vev+Gdoee8ZsbJrjjItv7u4z2tPxvB4LGAto5IjdVssrEL43RGwaOICJoF9YK0Sg6O46Fn1gU6Z2vg/jxCVfZmkSYoJzlzlBNFrYcZvSc4T8CxdIGr03v7/t1LZOf42rDhK+tznINFbLjiPd97aR8fp6aaJO44RyByfb5gv+vs8FaVTa1EHwix4AUk2AFeq6eZeOHjVH9d8Gad6HXKIfCsEO72a25shsm6u5qOZlt/D/79vd6D3XQwvp/MHaZDsqugD9ZAO7hHb9POokJ20KsjN471qrIbGzRA1wWuLGes15n9nYYmeE5y5p4kSjTBeGgcrjq8wDx4rrW2B7+8t0cV+Fq/4g835ziBLgb2afjkwR4Ez2nORrseRmLTcqVbsNN25gQkwkpsHORwRktqIDR2qQltwDkL91yXOl0yrcnWiu3Hay2cppHbKbFSIZlfkf1e3gW+4wN/jJFnn332v/jzs7Mz/vk//+f8y3/5L/krf+WvAPAv/sW/4OMf/zif//zn+aEf+qHv6Oe4nYZ5dLRAh6NzkY8eHnJjdcrZmOirCXVyNtu5eRsYSuI0b0goi9AyVGGtggShjMo7m55OWuZeuH1RSNEEtCTraIUEiy4gXllr4UsX5wA8ExY03uO80ARlTxv++6vPA+YxjVeu+o5SKidBoBN2CWyGxI3hjL6ayNhHj1NHY1GBXMTCUDJjKgiOto2mvG4jZxc9VNggqPPMRPnG+oTbJcMKSrAFso5PlyXi+1V/AHHHs9cGOueZi2PmAj/4wlW+dO+Ye3lgXSujmG1XcI493zCmypc3p5y5zOGs5UwSd0YlOyGvhf98+5TdWcuueF6/fUHfCuIF6QsVmBXHpUVLdcpxKbx57wgXHB+e7bBowLvMrIFn/Yz/80dfYEYLbcRHwAljFc6HgYpxuY83A79z64S+ZrJAnXs8lWW14LpzLRyPGxapIUlh1jYsmoZnFi03LwbInt6ZkL0m+MrRGd/oe+iV6o23rU8Zh/X9qkFdenabyFw9s2JTxR+4do3fOzvm9tThSSq4BM0IB8tIVuVLm3P+4+qY3abl3Ct3+o1xTFH03il7oaNz8M7xwBDEuNrFDvxa4NKypapyWgrv9MeoV16qS+be4X1l1niekRk/8fwLQKRt7OD3gpsz7sHJZsMmKM80HefjwNdOj+hHZSO2QWlUZpNOoEe4s1kzm/JTFk3Dso28uJhze0zUbCNtPKxc4XfPTninjoQBNOgDZ6GnCe/bHtx59pqGmTq64pi5yA9ev8bvXxxxa+xZlUISu3BGHHvBBJZf3pzx+eGYOR1nFPpNJU+0H+7Boo0sa+ReX9h0FY3gsoV7eTyHnTXKzkvlP63OcQFebHdZeo8rhYDjkpvxf7j+LMsQ6NpoGiuglMpdv2Ejwn4TOB83fHUzkKcQRPGCj46ZBtRBXzN3NysWwdOrMIsNO7HhI4sF7wwDkpS1F2qA1nn+YHXG1/KGMIJESxBOw3YPhoezB7t5YKeNLNSzUxxOHd937SpfOjvibhnZiFCcUVRjtmmjB14fL7g9HHPJd1wEpR97Rq3kleLuOpZNZEc879SeoavW8Bjsbtji2Zu1ZKmc18Jv5GNiCLxUdwhinfamCVySjp+49hzgaZtAmHQFGwrHfSK2nt3QcTomfvfijIsxA4JEhdYxk4j3jk2onNcBtzbr+UUTOYie613L8ZigehIVr461VH7/7ILbeYQM2k4BduNDCt762te+xnPPPcdsNuPVV1/l53/+53nxxRf5whe+QM6Zz3zmMw++9pVXXuHFF1/kc5/73H/1YY/jyPhHbK3Oz8+nJ52pzgMNC9+ywLMXILdLgkZ6KaCV81CZu8g7m/WUTGtepxc1sWEkh4kTrdbZbFpLQb2fuqbFGrnBO2KE41xs4fHGpx9F+Va/pguO45rYIOyGYLaawXNcNlQx4UTxynFNnJ9luhgZJ0swmsDl1kIfqB6Z6EqzCt+sZ/Z+vaepgSZ6diKk5KAJ5i6gwh0daHpHFxr6WSLicQrv8jk/MXiv6w/+12oQxmIpd8vYsOMCe23HK8s93txETnKmKpxTmAfPl8/PSFWYBc+VZcNZn7k7JmjujwghtJ7QBFZjpe08riqSlFIhRJg1gdubAe+dbWKqlEF57fyCZet5pyTOKezGliRKbCspZXJfKSL0CLfqhpvrkd0QOB8yd9eJeYxc8R6VyNoXxiL4rLTq+f2TE5wzesUsepZt5Jm2YzOMxM4jKIMK76SeW6c9sxjZLBKNeFqB7J6uDe/9WgN9hZ5MEyK77Yyl91yddXw877DjPCc5UURZdUrnPV+8uKAW41If7LS4Cqf5/vc12mDE3HjSpkC0Lq4W87SOOEKEo358kA+BKFLhi8endI3nribWWtiJLRcystvBUU5sciEplOg4TSNv9GuWwTNkYZUqu01k5o2i1iMMo+CLJVB+aX1i79dBGwNdjOw2keOaCC2gkEU5KiOn68TMe4auGN1THE/ZgOn924NV6IsQfeRK17FoInttw3e1u8yr51hHRicMrTKn5esXK0oVuhg4mLcIwnlKJjx3btqDHaH1DH1F4qRZKt+mKrQ4TodsWTUoIhVq4IvrE3ZCw506clFGlqEh1cIyhAcGAknt8HcnbXgn98x7GIol8i6bhhmO/djSq5BLxVWYE2xigE3cG+/pQmAnNrRUQmd02qzKvTJyelFYENi0GY/VX3nKREzv5x7sVEm50vnIvO3ofODKrOXlvMOyt+58UqXvLAjwK+tzqipN9CwXkVyF03GwZsc0jXJO8Y2jHydDjmxN36rWlG2D53hMCDqlO0PJlT8MpzQ+cqcmeq3sxMAGa1IcjwNDLSRnU/6jMnJ7k5j5QJ8r61RY+IY9HzhESa0wZDEqT/Z8sV8Z1UyhHT1tE9mjZVMzPoITT0I5KolTzTTRkRvBi00+6v0o7D8B39GB/9Of/jS/8Au/wPd8z/dw8+ZNfu7nfo4f/uEf5otf/CK3bt2ibVsODg7+2P/zzDPPcOvWrf/q9/z5n/95fu7nfu6/+POaTKEd28CV+YID34IIe00guhl9LWwk4arHSeBY85RuC322wJCM0WkwvRsi5jt9Zd6RnHKeMqUIzsMseFTU0nSZghhwdDjO04iLjlUt5Cpk53ljc06Ins2YSCKUYOLOJJb+2Ggll0LSwsw7huJYNs2UfFnwOD60M+fG2Wp6Eh7wzDTwXNPhvBCdidpEoU78tX0fKK1Hi436m/bp2e0eRv3Bf70GjWOqtCHwwu4eV5cdVGG3a3nROw7S/WTkDAq3yogEwDv63ro/FePjT0YXUCAsHM/tLc1ycT2YH/XMbMGqCoNWswPDTl0RuN0PeHGclMyQhVkb+P2TY5Zdy+kms66V4mzqM2jlrGRa7+jHyiZVdoIF2F2ZtRxIRWomqueTh/t89dQuneJs8VuUwCeWe8RYaMRTi1IFRgWS8mIbuU2xz5ObEjefEryfa2CpJgZvQuC5xZJndhaUXNmPLX7h2E8tx0OibYQWz92UcM2kK8mVVZnCBeMkuJxEiVIc1xYzCsq9YWRdrOseCdYtUmHKtMEpxAJ33EBQx0oqWYQShN+5OGN303CWEptiXVyCOWGcaebMQ5k8952HjONy6EhewWVicHxib5/Xzqz+ajCXqXkJfHK2S4yeUB1azeQgq5KL8EI34whFiukY9Okpv/e1/kTVArOC55nZgus7S7RWDpuGxi3Zzw1HeWB0EHzkTtkg0SYvfSmkav+/Wn6QNdjU4QhcnQUGVzhJiaFW6BzBBYpAqtU0KEx0DuBuSpyGwroUShFKI/ze+py9IbAuRoFIagLjUQoXkglYmvn911BQLvuWvWBZEMHDxxe7vL6yw2V2Jn6fied7ZrvE6PDFE4oZF2RMwPtsu4NqnerPQsaeFjyKPbio0vjA9fmSS/MZUoWDtiPg2QuJk5zoPQQcd+ukbfKOkpVNTZRa0SlAlQpk+9pLrZkF1JToRdDWynSQyijVyON+0lBVx60xE2LlohaSVLL3/N7qlP3YcTwmVpN3v8OZ/aYzZ72alVoVZlYoh03LRhWpmQbHy4t9Xl/bGmg0YZtAfSwucI1RzD2Wz5RVKQWuhY5z8n1Dv287OPwJ+I4O/D/6oz/64N+/7/u+j09/+tO89NJL/OIv/iLz+fw7+VYP8A//4T/kZ37mZx789/n5OS+88IJZXxbFRTW7zRBwCG1w9EUYSua8ZEYsHGQy5pk4rkqZDiNe1Giu4kjVEilDaBBXqN7EEGFSIxWMl4o6cxr09oG+IONqIBWjMIxRuJF6ZhLIpTKIMBa5/xJonKeXglR54DoAjqVvmHeBHJUsULQyOKaob0GKI6G8MFvyzE7geDUYjxcTx3h1XG47i1fWYrzHp+e8/1DqD/7rNThWoTqI4pgHz24bceppokdzYZ2Nrzx661R5f/9AZVSxUSpxmiQFrFOesjDkStcG+sldhWC2Y5ohe+vQqkwjcMAHx7Ek3AibUklF6Z3ja6sVh7mjT8JFsVRdps/9LHrOJVOqhXQpQnAN+23HIrYMS6VUR5lCjkwkZDaPu6qE/cDLl3e5c2d4cLnEG6fypfkcinKKjfTlKYqWfz/XwKSCFuMZN96xCAEtQhcjZyWzypmTlBiD2gXRm2uOFrMAy3WyXJrG0KgdgPpQCLEhSTUtijcRo2SlBpjFgIhttCZYhAsKfrJBLqIMUviWq+z7PDU5Cn29/4Osf9EXC1VqvNnpNb7hMDQczltyp2SFXoV1FdSbxW1RC4Rzu47v6pbcubMm33eqnd7Dc80cRLmQTDI/jT/18/yg4f2sPxF7nl5NnL0MAY9j1kTOS2FdKmelkAF11abm1dYDxdYv1cmVydnenIswlIqPwdY4FAmCDx6pQoXJRtGab246p6204ot15mtVRld5a9iwFwNVYF0LfancL4XoYaMVp9a1F5TgAjtNZC+25NbOCKNMtN/poluqkCXglo6P7C25dWJ0OJPLG6/7hdkCJ8K5ZnMxY7v+Paw92JwKdVoDPTshEtT0G+djZl0K56WYw41atoJW0KI4nQLc1Kal953BalFSqfjQoGL2wHjwETTZxbAJ3tynsJDBgLM1sNi+Xib3x2+lnsNa2YiyroVBqlluAi46NloefH4qglPPTmyY+zjVICQV1lKR+w1eMfplt4h8rI0cHQ8kk/jZJErgmdkML45NLQ9sQt8N/ky2nAcHB7z88su8/vrr/NW/+ldJKXF6evrHbni3b9/+X+R73UfXdXSTMOyPonglVKXmSpJC8ZY65oBVydweeo7GjAaPAovmvuJamcdAVrOdk6oE51E127leCqtSWesUuBBNEJIGoHFcDQ0OZxsRleKFFdBMXSYTK1UuRNHJNLhgtp4yWSQtmxlDNsVnF0x57F2g08hhFwg+cFoqv3tyD2KgBotlVlEaUbILXFsEvnRundXgHAFPRNlvWza1Ulw1d4Sn6cT/P8N7UX/wX6/BrHYLlCCUmkmpYdbOCc5zOpzzrfMVb/a9UXaqsrfTULLlMczmgbWYSLEWuwQqZgu7GjIXMXOWk4m+GluMUq74Dp7pZqjAuhTWFCrKuS/EDKlYl6lPNjoEaHygamVImWK6Iw78nFVv/OxZF/AqzF1kJ3Q8uzunCZE7KfP/ufEOEswBa6zVFkRxjNHx8Uu7/MfbdylirlUxOEKF6/M561RJCrU8XRve/xwPdQ1EcAVqEPqa6fuR3cayHo7PEt9crbmTk1kjCuzvtdSsFBH2fGCEB1kd5vRl7iObkjlLLZuSSU7wkwVsFoHoOGw6qMq6Vla+IE4ZvBKypaxWEXotJqJzdhnRSTCnYhZ6cw0M2eqmCQHF7Dv3QsNz3ZymidwuiX9309Iuq9Pp/weJSt/Cx3dmfP6OWe45Z44czjsuNRZAN5Y6id23a+DDqL+sagJdERKFoSbado53jqP79VfHyW5AWC4bSjZf9DZ4apj0PVP9OSBLZZMTpzj6nEm+QjTTilQq6uFSN8eJCbjXklEVRu8JxWyEZVqrpEB0SuM9ipClMpnjMWtau1h4C07CKzONLJuG5+Kc1kfu5pH/cHSTpKaxKipQrTk4OPjuvSX/6fTIDMGdOQjF6rjadawlMWRr9j3NrrAPew8uKmaS4ZWhFEoudG1LcI6TlPjWes2xmv5Na2V3d2YTyKrseceINVxdssZFFaVkZR0K58GCVFM0ao/HPWjc7U2J4KNU+mC3hSFUYnaWkIv9XQKCFrz36OQ8JdOEdLc0jLUSYqCLHlGhEXONvL6YEX3kbk786tEto7B5++wYHQWkc3xsMeO3752g1Zoy3kqZS01n658TRtUHjZY/CX+mUl2tVnz961/n+vXrfOpTn6JpGn7lV37lwd+/9tprvPnmm7z66qt/uh8Q7B/Fbj5jnThVzhaQEBytVxosAj44RxM8yybgcBQ1fv6IdY1iY5voBaOlB1ZHnNLUoEKGnTDjhcUuH13usudatHq0WtpkdYJGoWB0m0EK57nQl0KVacEALqowFuseDFSyCidDItdKVeXe0PPGxRk+OkJUGqxzEr0jBs+dvucPz06oTiEo6ifTVuCsHzkbeoY+4xLMXfNneYQfaDz0+vOKBKV4KN7jg2etGfV2iYzO0UTPrPXMOs9cLT151gaWi9Z8+6dFIKmN+9rGIwFuyshFLrbAqIm5q0BJcDm2fO/eHn/h0iEHs84O8eIYq1Kds/RJYOYDm1K4PfScjuYSJZjt3FFKrMfKui+cDomLUnkz9RQNRNdwezPwe0f3iJ1j3gTaEAnB03WBpgt8c93zm7fvUINAZ78HEbPReydV3h5HzvuCK56d+F8u1E8LHmYNildyUEYnpKpkdawRalRcmHzNvU2cmuhtuYyOtjUdhjJ1tIKSMJODEB0uOo7UeKh1El0+oF4I7LrAx2ZLPrHYZc83Ni0VqE6QABqd+f77yFCF43XmYl0oo9ihvSjrsZCzkJIYh1WFd4aeNNF73l5f8Fu379BGsz6OONNRtQ7XOt5cD/za0W2SU1yDrYPONr1bZeDmOLIaK6F49tyfvrP4QcfDrL8SbeI4AAM2PTqpmd4XxNvBKDiIztH6iBPTYTSNZ9FEnLNJeXJmWlEVgg+IVo4ksxahZmB0lAyC4AT2feQjiyUv7+6x3zbmry9Qlan+rKZnwdPXwnE/su4LUoTqK6rCJmdKssNdP00j7gwbRM3m+sZmzX8+ukvnbcLfTBaTPjpcC2/lns+d3Kao4PxE25kunG8NPe+sBy6GSqiBg7Bd/x7WHlzDZHiBCafFO869aYXc5PgVPLTe0TRmmU40qvO88VPX3IT/gwhZpuZHVO5UoyJauJrphFRM13nZNXzXbMHH5kvmRLKC4MjepqAEa0p3LjIW4axPbPpMTZXszXJ7nSolKUOqnCezET6STMDTOs+tzZrfOb6Lb+yCHKoHZ26RLnreHEd+8+SE7AUXmfIB7NB+XBJ380hfjHa772fv6vf5HXX4/8E/+Af8tb/213jppZe4ceMGn/3sZwkh8JM/+ZPs7+/zN//m3+RnfuZnuHTpEnt7e/y9v/f3ePXVV/9U6mzvBecifVFurNfcCz2bjbA3b7iXB85qwnlLJmtwjEHoqcydJ7iOeSicJ0GqjYNCDDSdR2pmEVo2kowPVc31NHqPRDMdHqvgHXx4Z0k9vYAWU0TjqJNdXGkdKRVS0Yl2AxEPHi4kg1MLbCjYxaVV+pj5ap/tpkql8Y5n6biVMnJf/S2ONId7fT9dxxyKQ7wnEjlJiZmLiBi3fH/27h70k4D3s/7AbvwalAvNvHZhyvjj1ciVWcvb/cY408CsGE//gsLGV5Yu0FTlMoETykTPgbZxLGeRlJVroeM4DKxqJVWBooQOCDZFukiVJnj+4v5lfjPfQZuARhARxJnuhBlsBmEYJvEbisdBVI5lxHuYO89MzDbPOTiTDf/x6IKLnMkqxOB4ZWfJjXXm3uT52MVAH5Tf6s9pcIRpihbEsXCBm8OaJZFRhXkIfHi5w2vv3WN+rPF+1qBZUyorKXx1teJWzqzSyGETuTmOHEvBReiKI3jIAUYvODX74jme02ay93TW4XLeAoau7rScb0bK/UyTgvncT+LetVZm3vPf7F7mt/IRyYs54ggUp+Y00TjGjVgjQ/SBhooA6yCTT7WjUajFOlDHaeDNe2suSiGrsBMDL+/N+NY4cHfMqEDrHNkLb296gnP4qf48joVG7uWRGTbFnYfIhxY7fIvz9/IxP7Z4X+sPTwnKiszXNytOcuK8z1xqPTfHkaOaEKBVjw/mkpO94qcchzY4AnbgUqe4IPhJBHml7bjQxLpM6aSDQmtmGQ02mZ95xw/sXeYLxyeUtqLVG6ebijij446pUorp83Ti5ToH61DMTtR5olr3VT2cpcTn+4GLXBic0kXHJ3bm3EyZu8MIzihLSYW3+p5GjVIp3pzYZr7lzjjQEUgqzGPDc8sdXufkPX7Sjyfe7z248YHaKedUvrJacWtMXOTCpRi4OfYckcDDTOzwr6hdElStweadZchMgVluOqyT4PrOjIuUjQpbBZ+Zpk12+csKHYG/MNvj99enNkt0U2aWV6SxC++qCjVPa6ADPwIR+lBMZ+kCjTjEWx2d1YFvnl1wXgrJK3MXeHEeeWccOc1mER+946JWvikbo5ZPDfyIpyVwJ480BIoKy2D6hm9y70/8fX5HB/63336bn/zJn+To6IirV6/yl/7SX+Lzn/88V69eBeAf/aN/hPeeH//xH2ccR37kR36Ef/pP/+l38iMewFfroOZauZPLgxv4JllKZK32YDLWbbocoinmq5iQSE1Z7YqDYGPJmk0MSTD7QplCrfJ0IGoIXJsv2G9aE1yK4Hc83xxW7HUNGymclETJlZ3QkNL9FMxv60G64DlsIyEJqSijQlftZxamiPtpavNC29HnOokfhTZ45t7TVc/NsdKGiJMpd0AFjxCCuf20nWcRPDvvUp39JOD9rD+w0VkbArUqb56vuTcOzErg6zWxmj7gwcGQBILy/GJBUEfKlXdWPRuUtC5WGMWTKuSguGK0sM26kHxFvPFJgzh2QuS7rhxydTYz8ZEI4g/5yrrn0LecpsSdoUdHiMGTxmLWmN5E4wCudVyNM+YeNmPmYsxEAhrVXDPUkqMV5c/t7ZKyUoZkvsIE9lxgHiJvjUpUQGSaVHhidMy91dwwJQvvv8tx4pOA97MGVczFhgpH65EhF1rneTP1bLROq4kjTVqja75hI551KbyVR9QpZV3Rauucjx4X1JJBG2UYrPbcRMcJwUGEj1064Eo3w6sScuHP7ezxpXTBFd9wXDO30gjJBLqlyBSCaCJIBQhw2LZ01TGmyibLg8241/rAAUgVPjafk/P99dwOaHMil+m4Pa4noadZzzkHBKWbvLhTDMyiY/EuBWtPAt7P+nPVtEBO4Gw9UrylK7+ZR1ZilFI7AClVKodhTuus6/720OO8Y+gLUp1leURH9RCTNVJSsal1UGfJyuJousCLy10ud93EuRY+udzhD/Oag6bhrBSO0v19HSTbhcF0KN8OBbs87+gS5hJVql088KylomqOZE7hpdkuNZvxBvcZAj6wQ8PttLHJ10TfVa8EL+y0tjYnVWbOs/uePNkPBt73PbhCjBZUedEPlFLx1fF2Hqekd1s3iihC5RJzQi30UrjtRgTHuC4gZmbgg1n1+Ol7p1SNW+9NcxKTx80dH9vd40rTAUqpmeKFb6SePQ2cS+ZIMm4DbgG1VCpTDbqJYBgssCsWTxaxDAj1DEE5k2wGBGoX44/NdxlymmrS0zjPwnt2iNwZlSZDmdZMQQkeltMeLNN0YP4unaKcqj5Wq+X5+Tn7+/v8Dz/2MtXbGKULkRYYtHAhxQ7tAkWqhRbgbIQ9cbRETPxzMWa67HHeIx4kVK7OZoziSJohQPSBVgKlZJro+e6dQw6ieZK/uVlzlitDzVxfLihOOM4DJymx33XM1HOURzusOWeblUaCV8ZSSKq4ELjUzLjWdgQKt0smidLiaRBWUuyGaOshjXogcGdYM4uBosrcR55pZlxvFzgVbpeBRYgcxI6o8H/7F5/n7OyMvb29R/z0ngzcr8Ef+svPItPBpAuBEB2bXLhXE+0U0NaXCq4SI1xatAiQihq33cHpKtNUT2jsAUtwvLScsdbp8I1d9JYuMgyFnSbw6atXuTZfMFThy+en3Bg39AIf3VmStHJz6Lmz7rm0M2fXB25c9IxSCcETcRzEiBfYjOZqIQ6eX8z5nr19AN5IPXnqDPjguEiFo2wx8dE5WudxRN5Zr5g5R1ZhEQMfmi/45O4ernreGjfMY+Ra17HrIv/X/+n3tjX4HuF+/X3vp5Ykb7zlGZGuCWxq4W4eaLHOZRKhOmXWBPZnDdWZFeEmFQKwGSqhGv3HBaNEPD+b0QdY5YI4ofWeXR8Zi1l1vrp/lWdnc0apfOX8lNvDwHktfGQxJ6PcySN308hB17H0gTubgaSWGN6IUcRC9aRa2ZSKOrg263h5vqQKvJl7Bsy+sXWwzpnTUqgTJaR1gVloeGezogvBzBSc52rT8vJsl8YF3s4bFiFwtWnZcQ3/j19+Y1t/7xHu198P/u+eM16xmjd5GyKDZO6OI3MfCc6zmZJEZ8Gz7BrUT7znXHB4NptErJOTV3AUJzw3mzMGN11ajc41x1NyJXSev7B7iWe7ORXla+s1d9OGMym8OF+as1QeOcqZ3caz0MC9YSRP9Re9Yx4jDZ6cKptSqAiXu46XZ0tElLdKz6BKFwLeCZshcV4KRQTvHF0ItC7yzrCiFUdBmAfP9XbGKzt7dOr5Vr+m8Z4rTcsegf/7v3ltW3/vIe7X4Cs/cIhEQKHVwCxEznLiTEZmLuLVsSkF9TCP5tlfUIZaGXPFeUd/kYl4QvBGEXfw7LwjB8dpyohTuuiNvpiE2Dj+4s4BV5qOQYSvbi64mXt6lBe7GYMIt8vIec3sNw2zxnF3lchTOn3jHHNvr22YTF2cg2fnM55v5wSFb5WeAaXzgQhsSuZcCqJGF269J2rg9tjTEShTANzV2PHRZgHquJ0HFjFyqWmZO8f/85e//ifW4J9JtPsw0WBJd/pAmmwR8qkKnQ+T84h1fWaYwt87j3OmsvY4Fm00NzCdUmk9aIDoPdE1gBKwD3hWpWKCthmOJIU7Y89YQIOw0gxqoyH1MKpw2LS0ko17OLWsMkoplaRq3YxoAUVXY8emKp0veOdoCZSq5mzhrbOFqll8irlr6KQwj96x20SuzjqkCBck5jGwiNECc7Z4KFj4wEaFjD6Y4iRnbiKdhxDMIco5ZTc05CJ2AY2OvkzPbd6gCfAgfuJJR2iKJTnfP2TvhYZOIKt5V+/Fhk2tfONizVrqlOZcEMwlRZxjlMILixknKVGSdXlRR5KKDmoKfm+exM47PrxYcpQSC00UgnGwtXKWTZjZTm5Vfa3kIujk1CJqiYJXuo4Xd5ak5DipiZ0ucmne0danZ8r0fmLuormJOXM7UcekCVLm3hGdI2GC26WPJFF89IRgrijeeWYzB9k89tWDRkUbS3PGWdhV42A5+eSfS+ZkHNhxgVGEb6039FoYMf42GNdVsLX4mdmMs5Kpk5OTOkedxNyDCNVjkwPv+Ei35E5OLMh4J7TebGgvkiDB0URAYBQhidFFqtj7boJ9Rj7UzVF1nJGZR89u2zCT8Aif0pOLpbPMhIpQcQiOASGpsvSOxpvfphMLoCwowXsiAVw1R582QjWev6WigjYWYoVzDw78C2+21CvqVH+e6hxvDxt6KYxULiSbBn3qjCZRrnYNF7UipWLfzVKAx2xT/MI03QI+1HWcjZWjmHBOaV2kamU1OR00wVv2TjExponhTRfVRM9h0/LSYkktwnFJVpNtZP40q3YfMpY+WM1hdBlBGZzRYOfR1kA3WVkuQqC6SeCvHsGsqJs2ENXhp8Zv9YJGZ2e/ZjIUmByAUmuay7OcmOEYRXi771lTKAFWWshiNpt1Eo9fm885j5NNtencqWr6kYQ1ZGLwOA8vtHNOS2Kmdlad+0iqlXU18XecOvdjNXt3xNLEUaVxnv3Y8ly7IEnlXAvL1rIx4rs8Bz62B/6hKtU7RlWGcaTxzsRrqgQniHdkB8EZV7DxwTygVahVaDSw0zrOyUg2Wow45awUno0d6iqpTmFFLhMIrDRzlEccjqpKXytOHYOvHNUBqWYrph7WuZBjNb6XOrNSEuHCVUK2RcY5h2jluA4ElM4FDkLDZrK2m8dAGAMuWDRyrebjXyi4+4ptJgH2JC4KwcaNvVRWkpjpdrN7WBhLZXBmmXVSEksXWHtBslJaE1UWL7QOli5Qoye2xjNNRZmFwKIN3HM2BVIHeOuQftjtkVxlo5lcK71Y4NtxKrw5bAjBDk6nKdH6wIrM28PGbBXHggBnQ2KYT9avOLMbE+GsFFgbRcO15mV4O1uwxbzxXI8t50XJ1XG5DdxmoKLMMAeCsQpV7SKak+LUFtDGWTpv13j2m4aNFs4lscfTK1p7mOilkrF16DxnZhrp1Sg6JugXshcabzomFz1dF81JZ0p/Dt6zcskoCQ5qgLs18XK7R09lVa1mVrWw8I51Ft5OPd57vMJFyTTB07vCrWyJpUOxjtVGK0OerD/V6JRJhXWpkBXvHC5avsNRzTi1hMvn2jnHxaiZl7qW4/MRFaGLZhObRBFn62zOpsHy2AHTB/PmP2gazjRxKpmDp4hS9n5iLCYa70UYS2EWKoOzg02arADrZGAQnCXFd02gTo25oJZcv84FVWveVawWPtrMSN6MLYoKG63sRM86VW4z0Ho7oK1qImKHvtt5pFRhLBXw9CKkKNNeC6UoucJQCprNKYVgpq0nJVFVmQfPs13HcS30Ba40Lcc6kBw0QFUxT3ZnBNwsZsTh1Qw1gvcQYX/WclQGjiRx8BQbZzxsqEB2sKmVKpnOBdZTBkyWigZHDXbRbADfBLt0FrNK9+qYzf1EPbS9sAQ4rpmX4oLgPaNUqEqvBQJc5MzbebBms8KFFKJ39C5zKys5WyCdpX9n6mAWmU6mprRUVr7iR0xsG02TdLeOeBxt67gcW1bVqLKX2pbTPiE6OU4p0+fCXKuKTAFb6mi9I/jI3MOuRnonXGhhl3d3DnxsD/znY6ZrGsQpm1xwOBZNwDuHFvtgZoBGOC2ZH/jwZRp1bPpk6bYVoLKWZF/nHA2Bhdr36XNhUwvntVBQ9kJHBu7ISJ+VqHahsBQ9T8gB55XSKK56QlXOUjYetzduWOMip6ngqhCdR6uF52hQ1t3IYbfDKI7jtObOesB7z4KG85QJ2AN1aq4winWE58GzDJGWBsFDqMxD4KgfWVdh1z+2j/ADj5v9SDv3prhfZ9YU5jvmPiEiDw5WEuHmMPI/vvxh9mcN55vEO8cblEKsynE/UHS6dIpxkK/MIiejcJwyd9JADnA5NmQVvj5uWDthjidTp5APJWIOA7lxZFGieO72I7nolCINwSvn68JYzblAxbpd3lc2qefy/pJS4Xa/4o2zDfPWPhOroeImn21w5nZRrXs8j4FlE5gFc6kgOA7nHW+teo6HzPU2P+In9WTiTj/QzQIqFiY45ErXBAJ+sse0LlNslbtl5H//8Re4vlhyvsp88eYJqzGxi+OrmujVzFNdgU4dy4Un58pQKiclU4twECPFC2/Vgc0gdHj6YPbEiIkpnXPUaDQ3L47TPlFViNgUqIues6GQRWj85FJVbMp5kgee29tF8dwZR948XzMLgVYdm1FAw+RXZnbIiPGyW+fZcZG90OCagHhhpza8OWw40cLwlCWdvl+4mwdmsTG+eqpkKl0XaP19n3zTn8UWTqTyIy9c59pyxtlq5CvvHHExVmZAj028xRnfuqmOvbnjogrnJXNSrXu6DoEK3JREn4TOeZsSMelEAnhnbk6IHV5OcqKKdT+71lJSN2NlEGicaaOyCD6YjeOLO0uKh7urzI3Vhtve01VlUyqts8BNgDEUm97iaL1nESKLEM0dKwT2c+QbOXG3Klfj02Oc8X7jTs1mGqEwDJWRSmi9ZXtopWbbU32rHKfEX/3ws+x1LUerxFfvruizMTZu+kSdbH9dMhefS00LNbGu1jioCMvYkKvwFj1rLbR4a4d5RYsQY4MGh9eJfaGOo5TJ1Yw0Wu/pfORMCqjQqEemPICEsqmZ67MdvPRcrNa8verx0dFmpVfBtQ7vPBHPEKuJ0DHzg5nzdD6YWArHfm25k1espXLVvbum22N7WgwRqpqTg3rrDgxS0ArVOXyEJkAn5lH/5z/0PIfzBV+/dcy//+JrrKmE6hmr2ckR7OtL9Xz54ogmRIoYXUMVTvrp0OKFlS/WHQ1T56gqXYDrszltE/jaasWmVoZe+J79A/aahuhgxyt/cH7OO7XHeZvteI10eL7Rj5wcnyLBUxAylSJwMSWF9Ait81PWgKMl0ubKhxYLNMBX+2P+YHUEmC+8E5ssaN5udg8LvjF6WNI6fVLMV1qTWlpoBNdZYFZoHD/857+L5w8P+YM3bvNb3/gtjkrGe8c6mVWcD8ZPTln4lYubzNpIQkgNaIW755nsqyWlDoXGBzSYR3lTHLs+8LHdHbo28p/OjjjdJO6ejPxvn7nMtVlHGwKHXcvnbt/id8o50XuzwqvWkf1Pq3Nu37xLjUqi0ldBe1tMRoTjPrGMkWXX0NdCh7lsvHL5gNg6fnd9xq+fHpnADfCYfubL5eJRPqYnFm30ZCxkiGZyCcP0IQmHazzaQhntcP2Xv/d7efHKFf7zN2/wy2+8w0mfaLxnTN/utnvvyKp87uSILkYKgkQL9ztdFRICXimu0rqAj/b1CHRtw8dnOyxD5Hf7Y86GwmlK/MUrl7ncdbTOcdkFPn92ytf04oFNY3AWFvO744p//8Y9NFojJSGcp0xDYCyVi2Ix9Yu2JUnPzJlg9Hv29/CN4/fzKb9978SsP6cQJKfwjbJ61I/qiYTzzug0KmhjTahUhJIFDWbvWhsTzvrG8QPf9RIvHuzwh2/f5fPfuMPxMFq9VcU7cxgRbxeFz5+cMIsNtYEaLeF7kyBXkGhUrg7wIZJDRnpYlMhHFgtmjef3Nmec1Uzt4fsv73HYRjoXuBzm/P75KV/OpyBG7Q14qI5v9AOfOzmjBKPejlKpInTqGGrlLBUWITDvImPOdAIIvLy/S4iO312f8P87vcNItQTWbMLmr+ft+vew4FRJtTBqRVudmhZiCcox4FuHzpS6rmh0/PD3vsyze3v83jdv8ztv/R4XWojOUdLU8AiOxkPSyq+v7rHwkRKEEhRXHJteGCmWrzTRDrVRykSZmdXAd3cL2pnn9/tT1rVy2o986vASl9qW1nn2fcN/Oj/iG3VtSdGmL8cL/O7mnOOju1RvVvFZKzJCp5GhVi7WlWXbsJw1eAptiTQoH9nbhQa+nM74Qn+KBtuDNZlt0Ovvcg9+bA/8MThwwW7dTaUUMZswLyyjI/jAWiskJc2Uo5MT+osNt85WrNU6Yp0XkgjBQ5QA2ZOdsJCI88ah1yIEPNmbx7QPNsZxar6oI5UWCK6hr5a622OHMq+eGxcXnDYNXWxoUS5SplaHz2pf0zgkCCclIdGTg3HE6pTGtieB0Zu3v/fgpwN/Vzw0cDRmshfWCF2wjm/EeGeC6Q62eDjoGjeJ1jw1YkmQYtSwg7YlRMepJCQrKcDd26fIReGt2ycc5cxpn9iJkTRUQmMjYU0w+sKyieAckpSabPQoLZZmG01zIiq4av78M+dpgo2213mgn3j9LfDavXPuzDv25w3zjePGKlGyUT5idMwas827OY4PDvvZifG5PezQQRkpEVz0uGic1yZ4sii3VhtqUE7U7BAttdc0J1UVL9tL58OAb8zNxIkj4tFiegrxjp0Yid6ZKLZAnsHbb98kHV3w5q1j1n2hH6uFzWTBBaYAQiWL0gUTnUs1hxXvzJvaAXhHdaYnwcqMKJ5WA30tbCQziI20GzzfOD3nqG3ZaxtuiHJ3GChZJhqEIzQebWxiJqpm6+lMQIxzLGkI1RInvbeAI4d1cdXDzWFAinJOITjLoLCas8+J23b4Hw6Cf6CT89FS60Vsotm2gSZOifIiOAncuHGPdNzzzaMzzmuhz0rXKGWigIVgieNFYNYGm5SO5nbm8Uio0FniqejUma92oGmBLjhGrfSlYCok82D/xvmGg6Zhr4nc8QO3BnPdidWmAaFxiIcbaZySnMV43Gq23V1ucN6Ro+3rbsr+QRxC5da6R6JyymiXFiAIxpFz4OK2/h4WQjDve8tA8Phs7ooaHF30eOfYFOvcF5QbN45Z31vxrdvHnOfMOheWMZCTXdKieryHjLKY+P9SBK2CF4/OLHOEYM2VLIIJpewM2TSensJKLFsCZ1bGb6zWHLWZnSYS2XCUEpJ0qg8Tk+Pg7jgavz/YeRO1Kfx80iEVlftu7BbYilKA2/2IZOXCW91Plj24KYrav0tm92N74E8o3sk0UosElalT4FG1EJDG2WFmhfKV2yfMXOR4SBTK1Bm1X4r4Schb7Re95xqWPhC9co7FMMeZSX5QNStMtQ3Lqdkfmne+UL1SitlvelV6VSQXRlF6qTb+9p7qFBc8wTuKVAZvHvv31wmc8VK7GDjoOlalTJmRDpdlou+Yr3Z1drM1QbDRNuyMZSnBWzwcjEXQxjaAmffU6iiDdS3rFDzTqWe28Fxo4QvfuMlO0/DOqic5hdahTqcIeQuB80WpUbjiGw66jiMZuZdGRJiCbCyES8U8zxsJUCth7riohbSx6VBfCp33xOA4L4XaY8moNXFe84PQm+AdTQzUKXjJeeNJV9Q6YB52nef6zi5HeUSYBHaDQnRogLVasFx1YumtYlaOAvfp21s8BIwqVKw72gRvQsViFEKd/KC9c8zngQspfO7r77ATG+5sBgat1v1Xo/64+yYH2YwLdnzgsGm4cHCeFBGojXWiCjZxqmLURhUhhMgqZbJUqhN6qTTqaXBsUkEFhiqsc2bl6gNKonpLCk8iZh07OQVVp9OGBQs8zx0sOS2ZqlP+xXA/UwIGJ2aWgCLY5q7iHgj03PbC+VBQJrvfGAKzEJAqpjVS2ytLVTww7zxrEb7w1h12ou3BI5XamPuciiLB8mS0KuI98+C5HDtWJXOeLYdGnFkhawXEhI8eB9WohKtSKTpQgjKI0uIIzjOUyvlEHdtoYaXFmhHuvhWj2Vonp3YW8EYvwtyUWTjPc7sLzvJAVTtzyFoeNOxGV+1zZA4gU0PQ1j83Ta+2eDjIU8hR6wMea4LlJODE1oOJWth1jg2Vz33zHRY+crsfSUFQB9mZyJbpHBWyaZmWTcNh03JW8rRnWmZE44yGI6KUKoRqbIrYela5MopRDrNYs7jBsU6FqpYOvamZlUxroKqx65038btOYnDPdDaws/3Ce67stZylYtNL56CfNJzBMfo6iZanSyaWizP1Pajv0mzzsT3wV1XC9GYUSxrVIMT7h2bMuSL6iJfCm2cr69RPyXiND3R4NCjVT04/KLVOh7X7vL9gG6IioNbJmvpcFp6FjTbHWhiLdQpUocNSVosIzSRaskOVubboRIdwakEK1em34+HVI86K9fJyxmE747yYMO88jyCKeBOulcmhyKtDVW1BnFxaTMy7PW09LJQsxBhw3k2dbKP5uPuj6alS5jEyZOHLt05ogqOXinOOWQwsnCfFMsWvm3BXqiX/BYHOe+ZNsBEfAupoNVDVwrpAaaJteOtSWFcLFLFgG89eF1l7G1t6tUNXL2JhRWofoIBxDTdSaUKgcdbpUOw9vLAz50P7u9weB+72A8dDQqppSWpQel9wzhGJE8PfuK06ORLwFPmgv58oRYneOlKq1klqpm6iYv7nKHQ+MEjlD++eEoPpO0IwzudMAiXIA59ypvyFUgVUab03+99qThjgaDHB+P1Uczc1FfpS6Ksd2GUKSNoJkZFqglpM9zSK8VmdqgnlJv7/iHXw46RXAjvkPT+b8aG9Xe6lxNE4cjKOD0TG0hqlyekUbKjmnMJUctvL5sODiBDxeGfP1uFpYuC+k7eo4PB0k/Dx68dnxq3GXOdmjWPuQEqlettHnXW1qNU4+W3wZjtYrCli3Hz/wBWIyXEP5+irMMp9331nfuWhIflKc9+hT42uoX5KmXZGPWy8ef27AI2bLh/YtPa5+YwP7e5xkmccp4HjoZ9+A9bwGKf1rZ2EkUVsnb6fJyHbGnxoKFUIwSyFwZoB0ZuJBJNrT8AxC4FUhNeOTgnOkxV88HTeMddADoIENap1tdoo1Vx1Gu9po3WwLJPJTYd/azKoM20l2IHemsg2pZw5zzx6klTCdMYcRBhFaIJ74NwTJ+v2onYObKZOmWIXyedmC67tzjkaMscpcVaSuTT6KbPCW3OjmRa8WhWV+2MAYyK8Gzy2B34ViGpdrV4qcYRmD3x24MylogpMzAVOxoQ460YsQgtAJ0LpeGBX6J2CeNa54h34GFi0DT4Im0kvMHcRxZGdJfrNgrNYZ51INGo3rqtta4WVq3GZvccLrFO1LoE6RO3ntniqVAjyIECsqrlRvLCzw27s2Bflnc2a07GfrhvyIJghqKMVc2LRBw9WkWmkvcXDgVRHqyba7ZMQEnT7HrLDYR3QIopkZaaOW5uR6pXGO5YhwiQS7zubDt2P/dbRcZIz3jli69hfNDiFfiyMIuz6hoLSu0pxRr9QFbNDdNY5jc5zfXfJJYmcpUScxGWheFYX59RgO5GKBYzMQ2BdMi7AQgMOS0zFVb730gHXdvZ4Zsh8uZ5w68JqsBQht3ZYbAnMxQ78dVp8ELGrx5ZS8VCgSZlF29g2VQgV5l1Aik1oBGszSlY6PMcpQXB0k8Uc2HNLbaU64/HTQEnKOhW8g3kb2W0jUsQOVFrZDQ0lWkhW9pPwLE8/y9mlNXrH8ztLlsXR12o5JNHSwFdn54gXyHY4j+rpWrP59M6aKt5Z46Z65eOH+1ye7XIpFr4m59weBrvkYOE0qtVEa0S8w5KpHQ/SJ/VdbnZbfGeQqrTTSWtIlSCeeWPat6oVUaO1SnV06jkbE+JhFhv2GhMRtg6SjJNVtmlIXFH6sXJPE7M2sGwa8JM2RcV41c4xqB2cwqSlq1gTRKsd0q4t5+xKYFAhYNPRSGB1kanBLoUigDh73VVw0aZWjoA4JQXllUt7PNPtsMrK65xzd+jxbcCJIztLNm+wg6Nzjgs1vZ9Xh3qlbE16HhpKVloPqsqA0BZzudHiLIxquhD67OhwHOeMekfnAju+BQczdQxdeVCDIUItyiZljoKjbTy7bcRVyNWco1ofqM4O2hmZXPAm3jzYdMh7rs5nFjCohQbLYhLv6Dcb1Fu9OjGtRxcda2xy1P6RNTA75eXdfS4v5lxxtgbeTf0UJKcUr6hTGg1m54llDzwII/RqFlPvAo/dgf9+9yDlQqPmlRq8ohF2N8YhrffjkVU5loHOO7JY77FTZW73Mm72wwN7TNSSTL0q41CQqlxZRC7HhrmzUKVv5YspUlltdITSZ0Wq4qujBhO4tUQ+9eFrvH1zwyCZTSr0WYhNxCGQKtkBPuDEo7EAsCqT08r08g99Q5ccQxoY8Awpk3KmyY4N5mxBMTqS4JgTSMGS5gQrgonbw2OWn/aBxv3fZZFK3dhFq8GhHRyOgYuxkqMlL/oCt+tA13r7YFY7jF9pLa3560dnMHUM1CtOLUF6tRk5csoL3YIXZkv2JNLuBL54foKLnrHahrXSSklmBQogwSHBBJ0/+anv5quv3eV8NXA6ZlYi7M1a4ibAqBSMFtRXuzyE4OmrcQQdFvT27KzlgI7VOtHXTJ8zQyosCaxqxRVw1ZFRqk8sCNZNGJVSKzWo6V7Y1uB7hfu/x4qQk/mZoxblvpM956lQw5TsqMpxHgg4ZOaI6piJYzealc4b682D512nbhCi5CScS+bQtzw/n9MRaGeRr21OwUEvQlZhrNh4YbTXJsEunY0L/M3/9s/zu1/8FqfnPacpsRJh2USCh5p5EIQ4ViWJWQ2Pao0M1Kad+65hScNm05M9JM0MKbMgsKbisk5jeaEEYdZE1Nsl21Izba3/o7+3Lf5seLD+VaGOdRqOKzUIe6XhLE+UrIkWeJySddcbiM4sYufOJtLvrEa0VuvGTtbSFEcaMxe5su8XPB875t7TLlveGM4o3hlVVoRSilFosk05jSamdOL4iVe+i9du3uH8InOeMutaWTRGwJditeEQijrOtUJURhUYK05MTL7XNBz6OXnMVGCUwqYUdkpgIzZjcM4msgVlx0d7Lxmc+yMUBLb1917iwRqoimbwlpNKjbA7Bta52qXOG73qOI3WTGudXUxdYD9GVJU3hw1SFSYrWULACYyj2Uo/vzPn+mzOXANt6/nK5oxAIIkpJEc/8bfK9Nqm82frPP/HVz7Cl79xh82Q2dRCr8J+aLg12aqrDRQYq9r3ic7MYtQa0QHHZd+wQ2SzSgy+MlDoU2VRgl0QvNVb8ZV1FDpnNahFpoavu1+Cf2INPnZJu2+//TYvvPDCo34ZHzi89dZbfOhDH3rUL+OJwDe+8Q0+9rGPPeqX8YHDtgbfG2zXwD8dtvX33mBbf386bOvvvcN2D/7T4U+qwcfuwC8ivPbaa3ziE5/grbfeeuKjqs/Pz3nhhRf+1O9VVbm4uOC5557D++1s+73A6ekph4eHvPnmm+zv7z/ql/PQsa3BxwvbNfA7w7b+3lts6+87w7b+3nts9+DvDO+2Bh87So/3nueffx6Avb29J36xuY8/y3t9Gj4Q7yfuf2D29/efmvqDbQ0+Ltiugd85tvX33mFbf985tvX33mK7B3/neDc1uL2ObrHFFltsscUWW2yxxROM7YF/iy222GKLLbbYYostnmA8lgf+ruv47Gc/S9d1j/qlPHQ8Te/1g4Kn7Zk8be/3g4Cn6Zk8Te/1g4Kn6Zk8Te/1g4Kn7Zm8X+/3sRPtbrHFFltsscUWW2yxxRbvHR7LDv8WW2yxxRZbbLHFFlts8d5ge+DfYosttthiiy222GKLJxjbA/8WW2yxxRZbbLHFFls8wdge+LfYYosttthiiy222OIJxvbAv8UWW2yxxRZbbLHFFk8wHrsD/z/5J/+ED3/4w8xmMz796U/zm7/5m4/6Jb0n+Nmf/Vmcc3/sn1deeeXB3w/DwE/91E9x+fJldnZ2+PEf/3Fu3779CF/x04snsQa39ffBwbb+tvX3KPEk1h9sa/CDhCexBh+H+nusDvz/+l//a37mZ36Gz372s/zO7/wO3//938+P/MiPcOfOnUf90t4TfPKTn+TmzZsP/vn1X//1B3/30z/90/ybf/Nv+KVf+iV+7dd+jRs3bvBjP/Zjj/DVPp14kmtwW3+PP7b1t62/R4knuf5gW4MfBDzJNfjI608fI/zgD/6g/tRP/dSD/6616nPPPac///M//whf1XuDz372s/r93//9/4t/d3p6qk3T6C/90i89+LOvfOUrCujnPve59+kVbqH65Nbgtv4+GNjWn2Fbf48GT2r9qW5r8IOCJ7UGH4f6e2w6/CklvvCFL/CZz3zmwZ957/nMZz7D5z73uUf4yt47fO1rX+O5557jox/9KH/jb/wN3nzzTQC+8IUvkHP+Y+/9lVde4cUXX3xi3vsHAU96DW7r7/HGtv629fco8aTXH2xr8HHHk16Dj7r+HpsD/71796i18swzz/yxP3/mmWe4devWI3pV7x0+/elP8wu/8Av8u3/37/hn/+yf8cYbb/DDP/zDXFxccOvWLdq25eDg4I/9P0/Ke/+g4EmuwW39Pf7Y1t/BH/t/noT3/UHCk1x/sK3BDwKe5Bp8HOovvmffaYv/Vfzoj/7og3//vu/7Pj796U/z0ksv8Yu/+IvM5/NH+Mq2eBqwrb8tHiW29bfFo8a2Brd4lHgc6u+x6fBfuXKFEMJ/oUq+ffs2zz777CN6VQ8PBwcHvPzyy7z++us8++yzpJQ4PT39Y1/zpL73xxVPUw1u6+/xw7b+Tv/Y1zyJ7/txxtNUf7CtwccRT1MNPor6e2wO/G3b8qlPfYpf+ZVfefBnIsKv/Mqv8Oqrrz7CV/ZwsFqt+PrXv87169f51Kc+RdM0f+y9v/baa7z55ptP5Ht/XPE01eC2/h4/bOtvW3+PEk9T/cG2Bh9HPE01+Ejq7z2T/74H+Ff/6l9p13X6C7/wC/rlL39Z/9bf+lt6cHCgt27detQv7c+Mv//3/77+6q/+qr7xxhv6G7/xG/qZz3xGr1y5onfu3FFV1b/9t/+2vvjii/of/sN/0N/+7d/WV199VV999dVH/KqfPjypNbitvw8GtvW3rb9HiSe1/lS3NfhBwZNag49D/T1WB35V1X/8j/+xvvjii9q2rf7gD/6gfv7zn3/UL+k9wU/8xE/o9evXtW1bff755/UnfuIn9PXXX3/w933f69/5O39HDw8PdbFY6F//639db968+Qhf8dOLJ7EGt/X3wcG2/rb19yjxJNaf6rYGP0h4Emvwcag/p6r63s0Ltthiiy222GKLLbbYYovHCY8Nh3+LLbbYYosttthiiy22eO+xPfBvscUWW2yxxRZbbLHFE4ztgX+LLbbYYosttthiiy2eYGwP/FtsscUWW2yxxRZbbPEEY3vg32KLLbbYYosttthiiycY2wP/FltsscUWW2yxxRZbPMHYHvi32GKLLbbYYostttjiCcb2wL/FFltsscUWW2yxxRZPMLYH/i222GKLLbbYYosttniCsT3wb7HFFltsscUWW2yxxROM7YF/iy222GKLLbbYYostnmD8/wHZ2/AfaUr7UgAAAABJRU5ErkJggg==",
-      "text/plain": [
-       "<Figure size 1000x2000 with 85 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Let's fetch the data over our AOI for all our Items\n",
     "# Here we use `futures.ThreadPoolExecutor` to run the requests in parallel\n",
@@ -1170,119 +592,77 @@
     "bbox_worker = partial(\n",
     "    fetch_bbox_array,\n",
     "    bbox=bounds,\n",
-    "    assets=(\"B04\", \"B03\", \"B02\"),  #(\"red\", \"green\", \"blue\"), in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
+    "    assets=[\n",
+    "        \"B04\",\n",
+    "        \"B03\",\n",
+    "        \"B02\",\n",
+    "    ],  # (\"red\", \"green\", \"blue\"), in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
     "    color_formula=\"gamma RGB 3.5, saturation 1.7, sigmoidal RGB 15 0.35\",\n",
     "    width=64,\n",
     "    height=64,\n",
     ")\n",
     "\n",
     "with futures.ThreadPoolExecutor(max_workers=10) as executor:\n",
-    "    future_work = [\n",
-    "        executor.submit(bbox_worker, scene) for scene in sceneid\n",
-    "    ]\n",
+    "    future_work = [executor.submit(bbox_worker, scene) for scene in sceneid]\n",
     "\n",
-    "    for f in tqdm(futures.as_completed(future_work), total=len(future_work)):               \n",
+    "    for f in tqdm(futures.as_completed(future_work), total=len(future_work)):\n",
     "        pass\n",
     "\n",
-    "results_rgb  = list(_filter_futures(future_work))\n",
+    "results_rgb = list(_filter_futures(future_work))\n",
     "\n",
     "print(\"diplay all results\")\n",
     "\n",
-    "fig = plt.figure(figsize=(10,20))\n",
+    "fig = plt.figure(figsize=(10, 20))\n",
     "col = 5\n",
     "row = math.ceil(len(dates) / col)\n",
     "for i in range(1, len(results_rgb) + 1):\n",
     "    fig.add_subplot(row, col, i)\n",
-    "    plt.imshow(reshape_as_image(results_rgb[i-1][1]))"
+    "    plt.imshow(reshape_as_image(results_rgb[i - 1][1]))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "93982f5e7e9a4a01838b940b72b43b8c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "  0%|          | 0/85 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x2000 with 85 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "## Fetch NDVI\n",
     "\n",
     "bbox_worker = partial(\n",
     "    fetch_bbox_array,\n",
     "    bbox=bounds,\n",
-    "    expression=\"(B08-B04)/(B08+B04)\",  # (nir-red)/(nir+red), in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
+    "    assets=[\n",
+    "        \"B08\",\n",
+    "        \"B04\",\n",
+    "    ],\n",
+    "    expression=\"(b1-b2)/(b1+b2)\",  # (nir-red)/(nir+red), in next STAC item version (see https://github.com/cogeotiff/rio-tiler-pds/issues/63)\n",
     "    width=64,\n",
     "    height=64,\n",
     ")\n",
     "\n",
     "with futures.ThreadPoolExecutor(max_workers=10) as executor:\n",
-    "    future_work = [\n",
-    "        executor.submit(bbox_worker, scene) for scene in sceneid\n",
-    "    ]\n",
+    "    future_work = [executor.submit(bbox_worker, scene) for scene in sceneid]\n",
     "\n",
-    "    for f in tqdm(futures.as_completed(future_work), total=len(future_work)):               \n",
+    "    for f in tqdm(futures.as_completed(future_work), total=len(future_work)):\n",
     "        pass\n",
     "\n",
-    "results_ndvi  = list(_filter_futures(future_work))\n",
+    "results_ndvi = list(_filter_futures(future_work))\n",
     "\n",
-    "fig = plt.figure(figsize=(10,20))\n",
+    "fig = plt.figure(figsize=(10, 20))\n",
     "col = 5\n",
     "row = math.ceil(len(dates) / col)\n",
-    "for i in range(1, len(results_rgb) + 1):\n",
+    "for i in range(1, len(results_ndvi) + 1):\n",
     "    fig.add_subplot(row, col, i)\n",
-    "    plt.imshow(results_ndvi[i-1][1][0])"
+    "    plt.imshow(results_ndvi[i - 1][1][0])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x15a569cd0>"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 960x720 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "stats = [_stats(data, mask) for _, data, mask in results_ndvi]\n",
     "\n",
@@ -1308,7 +688,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "py39",
+   "display_name": "titiler (3.13.9)",
    "language": "python",
    "name": "python3"
   },
@@ -1322,12 +702,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.13 (main, May 24 2022, 21:13:51) \n[Clang 13.1.6 (clang-1316.0.21.2)]"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "2590a9e34ee6c8bdce5141410f2a072bbabd2a859a8a48acdaa85720923a90ef"
-   }
+   "version": "3.13.9"
   }
  },
  "nbformat": 4,
diff --git a/docs/src/examples/notebooks/Working_with_STAC_simple.ipynb b/docs/src/examples/notebooks/Working_with_STAC_simple.ipynb
index e52aeb858..d91400788 100644
--- a/docs/src/examples/notebooks/Working_with_STAC_simple.ipynb
+++ b/docs/src/examples/notebooks/Working_with_STAC_simple.ipynb
@@ -13,7 +13,7 @@
     "\n",
     "> The SpatioTemporal Asset Catalog (STAC) specification aims to standardize the way geospatial assets are exposed online and queried. A 'spatiotemporal asset' is any file that represents information about the earth captured in a certain space and time. The initial focus is primarily remotely-sensed imagery (from satellites, but also planes, drones, balloons, etc), but the core is designed to be extensible to SAR, full motion video, point clouds, hyperspectral, LiDAR and derived data like NDVI, Digital Elevation Models, mosaics, etc.\n",
     "\n",
-    "Ref: https://github.com/radiantearth/stac-spechttps://github.com/radiantearth/stac-spec\n",
+    "Ref: https://github.com/radiantearth/stac-spec\n",
     "\n",
     "Using STAC makes data indexation and discovery really easy. In addition to the Collection/Item/Asset (data) specifications, data providers are also encouraged to follow a STAC API specification:  https://github.com/radiantearth/stac-api-spec\n",
     "\n",
@@ -47,20 +47,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "%pylab is deprecated, use %matplotlib inline and import the required libraries.\n",
-      "Populating the interactive namespace from numpy and matplotlib\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import httpx\n",
     "\n",
@@ -73,30 +64,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "titiler_endpoint = \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")\n",
     "stac_item = \"https://earth-search.aws.element84.com/v1/collections/sentinel-2-l2a/items/S2A_30TVT_20221112_0_L2A\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "scrolled": true,
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'type': 'Feature', 'stac_version': '1.0.0', 'id': 'S2A_30TVT_20221112_0_L2A', 'properties': {'created': '2022-11-14T06:54:49.284Z', 'platform': 'sentinel-2a', 'constellation': 'sentinel-2', 'instruments': ['msi'], 'eo:cloud_cover': 0.005979, 'proj:epsg': 32630, 'mgrs:utm_zone': 30, 'mgrs:latitude_band': 'T', 'mgrs:grid_square': 'VT', 'grid:code': 'MGRS-30TVT', 'view:sun_azimuth': 169.467826196677, 'view:sun_elevation': 24.259740600657594, 's2:degraded_msi_data_percentage': 0, 's2:nodata_pixel_percentage': 0.000226, 's2:saturated_defective_pixel_percentage': 0, 's2:dark_features_percentage': 0, 's2:cloud_shadow_percentage': 0.002296, 's2:vegetation_percentage': 10.348745, 's2:not_vegetated_percentage': 2.478484, 's2:water_percentage': 87.111628, 's2:unclassified_percentage': 0.002548, 's2:medium_proba_clouds_percentage': 0.003716, 's2:high_proba_clouds_percentage': 0.000508, 's2:thin_cirrus_percentage': 0.001755, 's2:snow_ice_percentage': 0.050325, 's2:product_type': 'S2MSI2A', 's2:processing_baseline': '04.00', 's2:product_uri': 'S2A_MSIL2A_20221112T111321_N0400_R137_T30TVT_20221112T145700.SAFE', 's2:generation_time': '2022-11-12T14:57:00.000000Z', 's2:datatake_id': 'GS2A_20221112T111321_038601_N04.00', 's2:datatake_type': 'INS-NOBS', 's2:datastrip_id': 'S2A_OPER_MSI_L2A_DS_ATOS_20221112T145700_S20221112T111315_N04.00', 's2:granule_id': 'S2A_OPER_MSI_L2A_TL_ATOS_20221112T145700_A038601_T30TVT_N04.00', 's2:reflectance_conversion_factor': 1.0193600036007, 'datetime': '2022-11-12T11:18:11.455000Z', 's2:sequence': '0', 'earthsearch:s3_path': 's3://sentinel-cogs/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A', 'earthsearch:payload_id': 'roda-sentinel2/workflow-sentinel2-to-stac/d5f624f4b32b7ca4b39180d6eceea7fd', 'earthsearch:boa_offset_applied': True, 'processing:software': {'sentinel2-to-stac': '0.1.0'}, 'updated': '2022-11-14T06:54:49.284Z'}, 'geometry': {'type': 'Polygon', 'coordinates': [[[-4.337121116089946, 47.8459059875105], [-2.86954302848021, 47.85361872923358], [-2.8719559380291044, 46.865637260938634], [-4.312398603410253, 46.85818510451771], [-4.337121116089946, 47.8459059875105]]]}, 'links': [{'rel': 'self', 'href': 'https://earth-search.aws.element84.com/v1/collections/sentinel-2-l2a/items/S2A_30TVT_20221112_0_L2A'}, {'rel': 'canonical', 'href': 's3://sentinel-cogs/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/S2A_30TVT_20221112_0_L2A.json', 'type': 'application/json'}, {'rel': 'license', 'href': 'https://sentinel.esa.int/documents/247904/690755/Sentinel_Data_Legal_Notice'}, {'rel': 'derived_from', 'href': 'https://earth-search.aws.element84.com/v1/collections/sentinel-2-l1c/items/S2A_30TVT_20221112_0_L1C', 'type': 'application/geo+json'}, {'rel': 'parent', 'href': 'https://earth-search.aws.element84.com/v1/collections/sentinel-2-l2a'}, {'rel': 'collection', 'href': 'https://earth-search.aws.element84.com/v1/collections/sentinel-2-l2a'}, {'rel': 'root', 'href': 'https://earth-search.aws.element84.com/v1/'}], 'assets': {'aot': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/AOT.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Aerosol optical thickness (AOT)', 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.001, 'offset': 0}], 'roles': ['data', 'reflectance']}, 'blue': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B02.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Blue (band 2) - 10m', 'eo:bands': [{'name': 'blue', 'common_name': 'blue', 'description': 'Blue (band 2)', 'center_wavelength': 0.49, 'full_width_half_max': 0.098}], 'gsd': 10, 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 10, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'coastal': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B01.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Coastal aerosol (band 1) - 60m', 'eo:bands': [{'name': 'coastal', 'common_name': 'coastal', 'description': 'Coastal aerosol (band 1)', 'center_wavelength': 0.443, 'full_width_half_max': 0.027}], 'gsd': 60, 'proj:shape': [1830, 1830], 'proj:transform': [60, 0, 399960, 0, -60, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 60, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'granule_metadata': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/granule_metadata.xml', 'type': 'application/xml', 'roles': ['metadata']}, 'green': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B03.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Green (band 3) - 10m', 'eo:bands': [{'name': 'green', 'common_name': 'green', 'description': 'Green (band 3)', 'center_wavelength': 0.56, 'full_width_half_max': 0.045}], 'gsd': 10, 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 10, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'nir': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B08.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'NIR 1 (band 8) - 10m', 'eo:bands': [{'name': 'nir', 'common_name': 'nir', 'description': 'NIR 1 (band 8)', 'center_wavelength': 0.842, 'full_width_half_max': 0.145}], 'gsd': 10, 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 10, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'nir08': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B8A.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'NIR 2 (band 8A) - 20m', 'eo:bands': [{'name': 'nir08', 'common_name': 'nir08', 'description': 'NIR 2 (band 8A)', 'center_wavelength': 0.865, 'full_width_half_max': 0.033}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'nir09': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B09.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'NIR 3 (band 9) - 60m', 'eo:bands': [{'name': 'nir09', 'common_name': 'nir09', 'description': 'NIR 3 (band 9)', 'center_wavelength': 0.945, 'full_width_half_max': 0.026}], 'gsd': 60, 'proj:shape': [1830, 1830], 'proj:transform': [60, 0, 399960, 0, -60, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 60, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'red': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B04.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Red (band 4) - 10m', 'eo:bands': [{'name': 'red', 'common_name': 'red', 'description': 'Red (band 4)', 'center_wavelength': 0.665, 'full_width_half_max': 0.038}], 'gsd': 10, 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 10, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'rededge1': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B05.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Red edge 1 (band 5) - 20m', 'eo:bands': [{'name': 'rededge1', 'common_name': 'rededge', 'description': 'Red edge 1 (band 5)', 'center_wavelength': 0.704, 'full_width_half_max': 0.019}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'rededge2': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B06.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Red edge 2 (band 6) - 20m', 'eo:bands': [{'name': 'rededge2', 'common_name': 'rededge', 'description': 'Red edge 2 (band 6)', 'center_wavelength': 0.74, 'full_width_half_max': 0.018}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'rededge3': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B07.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Red edge 3 (band 7) - 20m', 'eo:bands': [{'name': 'rededge3', 'common_name': 'rededge', 'description': 'Red edge 3 (band 7)', 'center_wavelength': 0.783, 'full_width_half_max': 0.028}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'scl': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/SCL.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Scene classification map (SCL)', 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint8', 'spatial_resolution': 20}], 'roles': ['data', 'reflectance']}, 'swir16': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B11.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'SWIR 1 (band 11) - 20m', 'eo:bands': [{'name': 'swir16', 'common_name': 'swir16', 'description': 'SWIR 1 (band 11)', 'center_wavelength': 1.61, 'full_width_half_max': 0.143}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'swir22': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B12.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'SWIR 2 (band 12) - 20m', 'eo:bands': [{'name': 'swir22', 'common_name': 'swir22', 'description': 'SWIR 2 (band 12)', 'center_wavelength': 2.19, 'full_width_half_max': 0.242}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'thumbnail': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/thumbnail.jpg', 'type': 'image/jpeg', 'title': 'Thumbnail image', 'roles': ['thumbnail']}, 'tileinfo_metadata': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/tileinfo_metadata.json', 'type': 'application/json', 'roles': ['metadata']}, 'visual': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/TCI.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'True color image', 'eo:bands': [{'name': 'red', 'common_name': 'red', 'description': 'Red (band 4)', 'center_wavelength': 0.665, 'full_width_half_max': 0.038}, {'name': 'green', 'common_name': 'green', 'description': 'Green (band 3)', 'center_wavelength': 0.56, 'full_width_half_max': 0.045}, {'name': 'blue', 'common_name': 'blue', 'description': 'Blue (band 2)', 'center_wavelength': 0.49, 'full_width_half_max': 0.098}], 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'roles': ['visual']}, 'wvp': {'href': 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/WVP.tif', 'type': 'image/tiff; application=geotiff; profile=cloud-optimized', 'title': 'Water vapour (WVP)', 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'unit': 'cm', 'scale': 0.001, 'offset': 0}], 'roles': ['data', 'reflectance']}, 'aot-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/AOT.jp2', 'type': 'image/jp2', 'title': 'Aerosol optical thickness (AOT)', 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.001, 'offset': 0}], 'roles': ['data', 'reflectance']}, 'blue-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B02.jp2', 'type': 'image/jp2', 'title': 'Blue (band 2) - 10m', 'eo:bands': [{'name': 'blue', 'common_name': 'blue', 'description': 'Blue (band 2)', 'center_wavelength': 0.49, 'full_width_half_max': 0.098}], 'gsd': 10, 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 10, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'coastal-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B01.jp2', 'type': 'image/jp2', 'title': 'Coastal aerosol (band 1) - 60m', 'eo:bands': [{'name': 'coastal', 'common_name': 'coastal', 'description': 'Coastal aerosol (band 1)', 'center_wavelength': 0.443, 'full_width_half_max': 0.027}], 'gsd': 60, 'proj:shape': [1830, 1830], 'proj:transform': [60, 0, 399960, 0, -60, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 60, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'green-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B03.jp2', 'type': 'image/jp2', 'title': 'Green (band 3) - 10m', 'eo:bands': [{'name': 'green', 'common_name': 'green', 'description': 'Green (band 3)', 'center_wavelength': 0.56, 'full_width_half_max': 0.045}], 'gsd': 10, 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 10, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'nir-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B08.jp2', 'type': 'image/jp2', 'title': 'NIR 1 (band 8) - 10m', 'eo:bands': [{'name': 'nir', 'common_name': 'nir', 'description': 'NIR 1 (band 8)', 'center_wavelength': 0.842, 'full_width_half_max': 0.145}], 'gsd': 10, 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 10, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'nir08-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B8A.jp2', 'type': 'image/jp2', 'title': 'NIR 2 (band 8A) - 20m', 'eo:bands': [{'name': 'nir08', 'common_name': 'nir08', 'description': 'NIR 2 (band 8A)', 'center_wavelength': 0.865, 'full_width_half_max': 0.033}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'nir09-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B09.jp2', 'type': 'image/jp2', 'title': 'NIR 3 (band 9) - 60m', 'eo:bands': [{'name': 'nir09', 'common_name': 'nir09', 'description': 'NIR 3 (band 9)', 'center_wavelength': 0.945, 'full_width_half_max': 0.026}], 'gsd': 60, 'proj:shape': [1830, 1830], 'proj:transform': [60, 0, 399960, 0, -60, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 60, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'red-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B04.jp2', 'type': 'image/jp2', 'title': 'Red (band 4) - 10m', 'eo:bands': [{'name': 'red', 'common_name': 'red', 'description': 'Red (band 4)', 'center_wavelength': 0.665, 'full_width_half_max': 0.038}], 'gsd': 10, 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 10, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'rededge1-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B05.jp2', 'type': 'image/jp2', 'title': 'Red edge 1 (band 5) - 20m', 'eo:bands': [{'name': 'rededge1', 'common_name': 'rededge', 'description': 'Red edge 1 (band 5)', 'center_wavelength': 0.704, 'full_width_half_max': 0.019}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'rededge2-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B06.jp2', 'type': 'image/jp2', 'title': 'Red edge 2 (band 6) - 20m', 'eo:bands': [{'name': 'rededge2', 'common_name': 'rededge', 'description': 'Red edge 2 (band 6)', 'center_wavelength': 0.74, 'full_width_half_max': 0.018}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'rededge3-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B07.jp2', 'type': 'image/jp2', 'title': 'Red edge 3 (band 7) - 20m', 'eo:bands': [{'name': 'rededge3', 'common_name': 'rededge', 'description': 'Red edge 3 (band 7)', 'center_wavelength': 0.783, 'full_width_half_max': 0.028}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'scl-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/SCL.jp2', 'type': 'image/jp2', 'title': 'Scene classification map (SCL)', 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint8', 'spatial_resolution': 20}], 'roles': ['data', 'reflectance']}, 'swir16-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B11.jp2', 'type': 'image/jp2', 'title': 'SWIR 1 (band 11) - 20m', 'eo:bands': [{'name': 'swir16', 'common_name': 'swir16', 'description': 'SWIR 1 (band 11)', 'center_wavelength': 1.61, 'full_width_half_max': 0.143}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'swir22-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B12.jp2', 'type': 'image/jp2', 'title': 'SWIR 2 (band 12) - 20m', 'eo:bands': [{'name': 'swir22', 'common_name': 'swir22', 'description': 'SWIR 2 (band 12)', 'center_wavelength': 2.19, 'full_width_half_max': 0.242}], 'gsd': 20, 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'scale': 0.0001, 'offset': -0.1}], 'roles': ['data', 'reflectance']}, 'visual-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/TCI.jp2', 'type': 'image/jp2', 'title': 'True color image', 'eo:bands': [{'name': 'red', 'common_name': 'red', 'description': 'Red (band 4)', 'center_wavelength': 0.665, 'full_width_half_max': 0.038}, {'name': 'green', 'common_name': 'green', 'description': 'Green (band 3)', 'center_wavelength': 0.56, 'full_width_half_max': 0.045}, {'name': 'blue', 'common_name': 'blue', 'description': 'Blue (band 2)', 'center_wavelength': 0.49, 'full_width_half_max': 0.098}], 'proj:shape': [10980, 10980], 'proj:transform': [10, 0, 399960, 0, -10, 5300040], 'roles': ['visual']}, 'wvp-jp2': {'href': 's3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/WVP.jp2', 'type': 'image/jp2', 'title': 'Water vapour (WVP)', 'proj:shape': [5490, 5490], 'proj:transform': [20, 0, 399960, 0, -20, 5300040], 'raster:bands': [{'nodata': 0, 'data_type': 'uint16', 'bits_per_sample': 15, 'spatial_resolution': 20, 'unit': 'cm', 'scale': 0.001, 'offset': 0}], 'roles': ['data', 'reflectance']}}, 'bbox': [-4.337121116089946, 46.85818510451771, -2.86954302848021, 47.85361872923358], 'stac_extensions': ['https://stac-extensions.github.io/grid/v1.0.0/schema.json', 'https://stac-extensions.github.io/eo/v1.0.0/schema.json', 'https://stac-extensions.github.io/mgrs/v1.0.0/schema.json', 'https://stac-extensions.github.io/projection/v1.0.0/schema.json', 'https://stac-extensions.github.io/processing/v1.1.0/schema.json', 'https://stac-extensions.github.io/view/v1.0.0/schema.json', 'https://stac-extensions.github.io/raster/v1.1.0/schema.json'], 'collection': 'sentinel-2-l2a'}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "item = httpx.get(stac_item).json()\n",
     "print(item)"
@@ -104,53 +89,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Name: aot | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: blue | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: coastal | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: granule_metadata | Format: application/xml\n",
-      "Name: green | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: nir | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: nir08 | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: nir09 | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: red | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: rededge1 | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: rededge2 | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: rededge3 | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: scl | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: swir16 | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: swir22 | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: thumbnail | Format: image/jpeg\n",
-      "Name: tileinfo_metadata | Format: application/json\n",
-      "Name: visual | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: wvp | Format: image/tiff; application=geotiff; profile=cloud-optimized\n",
-      "Name: aot-jp2 | Format: image/jp2\n",
-      "Name: blue-jp2 | Format: image/jp2\n",
-      "Name: coastal-jp2 | Format: image/jp2\n",
-      "Name: green-jp2 | Format: image/jp2\n",
-      "Name: nir-jp2 | Format: image/jp2\n",
-      "Name: nir08-jp2 | Format: image/jp2\n",
-      "Name: nir09-jp2 | Format: image/jp2\n",
-      "Name: red-jp2 | Format: image/jp2\n",
-      "Name: rededge1-jp2 | Format: image/jp2\n",
-      "Name: rededge2-jp2 | Format: image/jp2\n",
-      "Name: rededge3-jp2 | Format: image/jp2\n",
-      "Name: scl-jp2 | Format: image/jp2\n",
-      "Name: swir16-jp2 | Format: image/jp2\n",
-      "Name: swir22-jp2 | Format: image/jp2\n",
-      "Name: visual-jp2 | Format: image/jp2\n",
-      "Name: wvp-jp2 | Format: image/jp2\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "for it, asset in item[\"assets\"].items():\n",
     "    print(\"Name:\", it, \"| Format:\", asset[\"type\"])"
@@ -158,111 +101,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_4dedface77624f4f356320fe75cbcb89 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_4dedface77624f4f356320fe75cbcb89&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_4dedface77624f4f356320fe75cbcb89 = L.map(\n",
-       "                &quot;map_4dedface77624f4f356320fe75cbcb89&quot;,\n",
-       "                {\n",
-       "                    center: [47.355901916875645, -3.6033320722850783],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 8,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_7c9edabdd8965ad118f657027aae5c16 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_4dedface77624f4f356320fe75cbcb89);\n",
-       "        \n",
-       "    \n",
-       "\n",
-       "        function geo_json_be5e4e43590e2a26418b5db83b03350d_onEachFeature(feature, layer) {\n",
-       "            layer.on({\n",
-       "            });\n",
-       "        };\n",
-       "        var geo_json_be5e4e43590e2a26418b5db83b03350d = L.geoJson(null, {\n",
-       "                onEachFeature: geo_json_be5e4e43590e2a26418b5db83b03350d_onEachFeature,\n",
-       "            \n",
-       "        });\n",
-       "\n",
-       "        function geo_json_be5e4e43590e2a26418b5db83b03350d_add (data) {\n",
-       "            geo_json_be5e4e43590e2a26418b5db83b03350d\n",
-       "                .addData(data)\n",
-       "                .addTo(map_4dedface77624f4f356320fe75cbcb89);\n",
-       "        }\n",
-       "            geo_json_be5e4e43590e2a26418b5db83b03350d_add({&quot;assets&quot;: {&quot;aot&quot;: {&quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/AOT.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: 0, &quot;scale&quot;: 0.001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Aerosol optical thickness (AOT)&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;aot-jp2&quot;: {&quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/AOT.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: 0, &quot;scale&quot;: 0.001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Aerosol optical thickness (AOT)&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;blue&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.49, &quot;common_name&quot;: &quot;blue&quot;, &quot;description&quot;: &quot;Blue (band 2)&quot;, &quot;full_width_half_max&quot;: 0.098, &quot;name&quot;: &quot;blue&quot;}], &quot;gsd&quot;: 10, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B02.tif&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 10}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Blue (band 2) - 10m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;blue-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.49, &quot;common_name&quot;: &quot;blue&quot;, &quot;description&quot;: &quot;Blue (band 2)&quot;, &quot;full_width_half_max&quot;: 0.098, &quot;name&quot;: &quot;blue&quot;}], &quot;gsd&quot;: 10, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B02.jp2&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 10}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Blue (band 2) - 10m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;coastal&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.443, &quot;common_name&quot;: &quot;coastal&quot;, &quot;description&quot;: &quot;Coastal aerosol (band 1)&quot;, &quot;full_width_half_max&quot;: 0.027, &quot;name&quot;: &quot;coastal&quot;}], &quot;gsd&quot;: 60, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B01.tif&quot;, &quot;proj:shape&quot;: [1830, 1830], &quot;proj:transform&quot;: [60, 0, 399960, 0, -60, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 60}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Coastal aerosol (band 1) - 60m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;coastal-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.443, &quot;common_name&quot;: &quot;coastal&quot;, &quot;description&quot;: &quot;Coastal aerosol (band 1)&quot;, &quot;full_width_half_max&quot;: 0.027, &quot;name&quot;: &quot;coastal&quot;}], &quot;gsd&quot;: 60, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B01.jp2&quot;, &quot;proj:shape&quot;: [1830, 1830], &quot;proj:transform&quot;: [60, 0, 399960, 0, -60, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 60}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Coastal aerosol (band 1) - 60m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;granule_metadata&quot;: {&quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/granule_metadata.xml&quot;, &quot;roles&quot;: [&quot;metadata&quot;], &quot;type&quot;: &quot;application/xml&quot;}, &quot;green&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.56, &quot;common_name&quot;: &quot;green&quot;, &quot;description&quot;: &quot;Green (band 3)&quot;, &quot;full_width_half_max&quot;: 0.045, &quot;name&quot;: &quot;green&quot;}], &quot;gsd&quot;: 10, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B03.tif&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 10}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Green (band 3) - 10m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;green-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.56, &quot;common_name&quot;: &quot;green&quot;, &quot;description&quot;: &quot;Green (band 3)&quot;, &quot;full_width_half_max&quot;: 0.045, &quot;name&quot;: &quot;green&quot;}], &quot;gsd&quot;: 10, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B03.jp2&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 10}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Green (band 3) - 10m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;nir&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.842, &quot;common_name&quot;: &quot;nir&quot;, &quot;description&quot;: &quot;NIR 1 (band 8)&quot;, &quot;full_width_half_max&quot;: 0.145, &quot;name&quot;: &quot;nir&quot;}], &quot;gsd&quot;: 10, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B08.tif&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 10}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;NIR 1 (band 8) - 10m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;nir-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.842, &quot;common_name&quot;: &quot;nir&quot;, &quot;description&quot;: &quot;NIR 1 (band 8)&quot;, &quot;full_width_half_max&quot;: 0.145, &quot;name&quot;: &quot;nir&quot;}], &quot;gsd&quot;: 10, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B08.jp2&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 10}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;NIR 1 (band 8) - 10m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;nir08&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.865, &quot;common_name&quot;: &quot;nir08&quot;, &quot;description&quot;: &quot;NIR 2 (band 8A)&quot;, &quot;full_width_half_max&quot;: 0.033, &quot;name&quot;: &quot;nir08&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B8A.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;NIR 2 (band 8A) - 20m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;nir08-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.865, &quot;common_name&quot;: &quot;nir08&quot;, &quot;description&quot;: &quot;NIR 2 (band 8A)&quot;, &quot;full_width_half_max&quot;: 0.033, &quot;name&quot;: &quot;nir08&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B8A.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;NIR 2 (band 8A) - 20m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;nir09&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.945, &quot;common_name&quot;: &quot;nir09&quot;, &quot;description&quot;: &quot;NIR 3 (band 9)&quot;, &quot;full_width_half_max&quot;: 0.026, &quot;name&quot;: &quot;nir09&quot;}], &quot;gsd&quot;: 60, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B09.tif&quot;, &quot;proj:shape&quot;: [1830, 1830], &quot;proj:transform&quot;: [60, 0, 399960, 0, -60, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 60}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;NIR 3 (band 9) - 60m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;nir09-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.945, &quot;common_name&quot;: &quot;nir09&quot;, &quot;description&quot;: &quot;NIR 3 (band 9)&quot;, &quot;full_width_half_max&quot;: 0.026, &quot;name&quot;: &quot;nir09&quot;}], &quot;gsd&quot;: 60, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B09.jp2&quot;, &quot;proj:shape&quot;: [1830, 1830], &quot;proj:transform&quot;: [60, 0, 399960, 0, -60, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 60}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;NIR 3 (band 9) - 60m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;red&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.665, &quot;common_name&quot;: &quot;red&quot;, &quot;description&quot;: &quot;Red (band 4)&quot;, &quot;full_width_half_max&quot;: 0.038, &quot;name&quot;: &quot;red&quot;}], &quot;gsd&quot;: 10, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B04.tif&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 10}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Red (band 4) - 10m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;red-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.665, &quot;common_name&quot;: &quot;red&quot;, &quot;description&quot;: &quot;Red (band 4)&quot;, &quot;full_width_half_max&quot;: 0.038, &quot;name&quot;: &quot;red&quot;}], &quot;gsd&quot;: 10, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B04.jp2&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 10}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Red (band 4) - 10m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;rededge1&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.704, &quot;common_name&quot;: &quot;rededge&quot;, &quot;description&quot;: &quot;Red edge 1 (band 5)&quot;, &quot;full_width_half_max&quot;: 0.019, &quot;name&quot;: &quot;rededge1&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B05.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Red edge 1 (band 5) - 20m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;rededge1-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.704, &quot;common_name&quot;: &quot;rededge&quot;, &quot;description&quot;: &quot;Red edge 1 (band 5)&quot;, &quot;full_width_half_max&quot;: 0.019, &quot;name&quot;: &quot;rededge1&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B05.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Red edge 1 (band 5) - 20m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;rededge2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.74, &quot;common_name&quot;: &quot;rededge&quot;, &quot;description&quot;: &quot;Red edge 2 (band 6)&quot;, &quot;full_width_half_max&quot;: 0.018, &quot;name&quot;: &quot;rededge2&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B06.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Red edge 2 (band 6) - 20m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;rededge2-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.74, &quot;common_name&quot;: &quot;rededge&quot;, &quot;description&quot;: &quot;Red edge 2 (band 6)&quot;, &quot;full_width_half_max&quot;: 0.018, &quot;name&quot;: &quot;rededge2&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B06.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Red edge 2 (band 6) - 20m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;rededge3&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.783, &quot;common_name&quot;: &quot;rededge&quot;, &quot;description&quot;: &quot;Red edge 3 (band 7)&quot;, &quot;full_width_half_max&quot;: 0.028, &quot;name&quot;: &quot;rededge3&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B07.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Red edge 3 (band 7) - 20m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;rededge3-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.783, &quot;common_name&quot;: &quot;rededge&quot;, &quot;description&quot;: &quot;Red edge 3 (band 7)&quot;, &quot;full_width_half_max&quot;: 0.028, &quot;name&quot;: &quot;rededge3&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B07.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Red edge 3 (band 7) - 20m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;scl&quot;: {&quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/SCL.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;data_type&quot;: &quot;uint8&quot;, &quot;nodata&quot;: 0, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Scene classification map (SCL)&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;scl-jp2&quot;: {&quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/SCL.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;data_type&quot;: &quot;uint8&quot;, &quot;nodata&quot;: 0, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Scene classification map (SCL)&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;swir16&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 1.61, &quot;common_name&quot;: &quot;swir16&quot;, &quot;description&quot;: &quot;SWIR 1 (band 11)&quot;, &quot;full_width_half_max&quot;: 0.143, &quot;name&quot;: &quot;swir16&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B11.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;SWIR 1 (band 11) - 20m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;swir16-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 1.61, &quot;common_name&quot;: &quot;swir16&quot;, &quot;description&quot;: &quot;SWIR 1 (band 11)&quot;, &quot;full_width_half_max&quot;: 0.143, &quot;name&quot;: &quot;swir16&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B11.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;SWIR 1 (band 11) - 20m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;swir22&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 2.19, &quot;common_name&quot;: &quot;swir22&quot;, &quot;description&quot;: &quot;SWIR 2 (band 12)&quot;, &quot;full_width_half_max&quot;: 0.242, &quot;name&quot;: &quot;swir22&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/B12.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;SWIR 2 (band 12) - 20m&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;swir22-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 2.19, &quot;common_name&quot;: &quot;swir22&quot;, &quot;description&quot;: &quot;SWIR 2 (band 12)&quot;, &quot;full_width_half_max&quot;: 0.242, &quot;name&quot;: &quot;swir22&quot;}], &quot;gsd&quot;: 20, &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/B12.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: -0.1, &quot;scale&quot;: 0.0001, &quot;spatial_resolution&quot;: 20}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;SWIR 2 (band 12) - 20m&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;thumbnail&quot;: {&quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/thumbnail.jpg&quot;, &quot;roles&quot;: [&quot;thumbnail&quot;], &quot;title&quot;: &quot;Thumbnail image&quot;, &quot;type&quot;: &quot;image/jpeg&quot;}, &quot;tileinfo_metadata&quot;: {&quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/tileinfo_metadata.json&quot;, &quot;roles&quot;: [&quot;metadata&quot;], &quot;type&quot;: &quot;application/json&quot;}, &quot;visual&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.665, &quot;common_name&quot;: &quot;red&quot;, &quot;description&quot;: &quot;Red (band 4)&quot;, &quot;full_width_half_max&quot;: 0.038, &quot;name&quot;: &quot;red&quot;}, {&quot;center_wavelength&quot;: 0.56, &quot;common_name&quot;: &quot;green&quot;, &quot;description&quot;: &quot;Green (band 3)&quot;, &quot;full_width_half_max&quot;: 0.045, &quot;name&quot;: &quot;green&quot;}, {&quot;center_wavelength&quot;: 0.49, &quot;common_name&quot;: &quot;blue&quot;, &quot;description&quot;: &quot;Blue (band 2)&quot;, &quot;full_width_half_max&quot;: 0.098, &quot;name&quot;: &quot;blue&quot;}], &quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/TCI.tif&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;roles&quot;: [&quot;visual&quot;], &quot;title&quot;: &quot;True color image&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;visual-jp2&quot;: {&quot;eo:bands&quot;: [{&quot;center_wavelength&quot;: 0.665, &quot;common_name&quot;: &quot;red&quot;, &quot;description&quot;: &quot;Red (band 4)&quot;, &quot;full_width_half_max&quot;: 0.038, &quot;name&quot;: &quot;red&quot;}, {&quot;center_wavelength&quot;: 0.56, &quot;common_name&quot;: &quot;green&quot;, &quot;description&quot;: &quot;Green (band 3)&quot;, &quot;full_width_half_max&quot;: 0.045, &quot;name&quot;: &quot;green&quot;}, {&quot;center_wavelength&quot;: 0.49, &quot;common_name&quot;: &quot;blue&quot;, &quot;description&quot;: &quot;Blue (band 2)&quot;, &quot;full_width_half_max&quot;: 0.098, &quot;name&quot;: &quot;blue&quot;}], &quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/TCI.jp2&quot;, &quot;proj:shape&quot;: [10980, 10980], &quot;proj:transform&quot;: [10, 0, 399960, 0, -10, 5300040], &quot;roles&quot;: [&quot;visual&quot;], &quot;title&quot;: &quot;True color image&quot;, &quot;type&quot;: &quot;image/jp2&quot;}, &quot;wvp&quot;: {&quot;href&quot;: &quot;https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/WVP.tif&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: 0, &quot;scale&quot;: 0.001, &quot;spatial_resolution&quot;: 20, &quot;unit&quot;: &quot;cm&quot;}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Water vapour (WVP)&quot;, &quot;type&quot;: &quot;image/tiff; application=geotiff; profile=cloud-optimized&quot;}, &quot;wvp-jp2&quot;: {&quot;href&quot;: &quot;s3://sentinel-s2-l2a/tiles/30/T/VT/2022/11/12/0/WVP.jp2&quot;, &quot;proj:shape&quot;: [5490, 5490], &quot;proj:transform&quot;: [20, 0, 399960, 0, -20, 5300040], &quot;raster:bands&quot;: [{&quot;bits_per_sample&quot;: 15, &quot;data_type&quot;: &quot;uint16&quot;, &quot;nodata&quot;: 0, &quot;offset&quot;: 0, &quot;scale&quot;: 0.001, &quot;spatial_resolution&quot;: 20, &quot;unit&quot;: &quot;cm&quot;}], &quot;roles&quot;: [&quot;data&quot;, &quot;reflectance&quot;], &quot;title&quot;: &quot;Water vapour (WVP)&quot;, &quot;type&quot;: &quot;image/jp2&quot;}}, &quot;bbox&quot;: [-4.337121116089946, 46.85818510451771, -2.86954302848021, 47.85361872923358], &quot;collection&quot;: &quot;sentinel-2-l2a&quot;, &quot;geometry&quot;: {&quot;coordinates&quot;: [[[-4.337121116089946, 47.8459059875105], [-2.86954302848021, 47.85361872923358], [-2.8719559380291044, 46.865637260938634], [-4.312398603410253, 46.85818510451771], [-4.337121116089946, 47.8459059875105]]], &quot;type&quot;: &quot;Polygon&quot;}, &quot;id&quot;: &quot;S2A_30TVT_20221112_0_L2A&quot;, &quot;links&quot;: [{&quot;href&quot;: &quot;https://earth-search.aws.element84.com/v1/collections/sentinel-2-l2a/items/S2A_30TVT_20221112_0_L2A&quot;, &quot;rel&quot;: &quot;self&quot;}, {&quot;href&quot;: &quot;s3://sentinel-cogs/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A/S2A_30TVT_20221112_0_L2A.json&quot;, &quot;rel&quot;: &quot;canonical&quot;, &quot;type&quot;: &quot;application/json&quot;}, {&quot;href&quot;: &quot;https://sentinel.esa.int/documents/247904/690755/Sentinel_Data_Legal_Notice&quot;, &quot;rel&quot;: &quot;license&quot;}, {&quot;href&quot;: &quot;https://earth-search.aws.element84.com/v1/collections/sentinel-2-l1c/items/S2A_30TVT_20221112_0_L1C&quot;, &quot;rel&quot;: &quot;derived_from&quot;, &quot;type&quot;: &quot;application/geo+json&quot;}, {&quot;href&quot;: &quot;https://earth-search.aws.element84.com/v1/collections/sentinel-2-l2a&quot;, &quot;rel&quot;: &quot;parent&quot;}, {&quot;href&quot;: &quot;https://earth-search.aws.element84.com/v1/collections/sentinel-2-l2a&quot;, &quot;rel&quot;: &quot;collection&quot;}, {&quot;href&quot;: &quot;https://earth-search.aws.element84.com/v1/&quot;, &quot;rel&quot;: &quot;root&quot;}], &quot;properties&quot;: {&quot;constellation&quot;: &quot;sentinel-2&quot;, &quot;created&quot;: &quot;2022-11-14T06:54:49.284Z&quot;, &quot;datetime&quot;: &quot;2022-11-12T11:18:11.455000Z&quot;, &quot;earthsearch:boa_offset_applied&quot;: true, &quot;earthsearch:payload_id&quot;: &quot;roda-sentinel2/workflow-sentinel2-to-stac/d5f624f4b32b7ca4b39180d6eceea7fd&quot;, &quot;earthsearch:s3_path&quot;: &quot;s3://sentinel-cogs/sentinel-s2-l2a-cogs/30/T/VT/2022/11/S2A_30TVT_20221112_0_L2A&quot;, &quot;eo:cloud_cover&quot;: 0.005979, &quot;grid:code&quot;: &quot;MGRS-30TVT&quot;, &quot;instruments&quot;: [&quot;msi&quot;], &quot;mgrs:grid_square&quot;: &quot;VT&quot;, &quot;mgrs:latitude_band&quot;: &quot;T&quot;, &quot;mgrs:utm_zone&quot;: 30, &quot;platform&quot;: &quot;sentinel-2a&quot;, &quot;processing:software&quot;: {&quot;sentinel2-to-stac&quot;: &quot;0.1.0&quot;}, &quot;proj:epsg&quot;: 32630, &quot;s2:cloud_shadow_percentage&quot;: 0.002296, &quot;s2:dark_features_percentage&quot;: 0, &quot;s2:datastrip_id&quot;: &quot;S2A_OPER_MSI_L2A_DS_ATOS_20221112T145700_S20221112T111315_N04.00&quot;, &quot;s2:datatake_id&quot;: &quot;GS2A_20221112T111321_038601_N04.00&quot;, &quot;s2:datatake_type&quot;: &quot;INS-NOBS&quot;, &quot;s2:degraded_msi_data_percentage&quot;: 0, &quot;s2:generation_time&quot;: &quot;2022-11-12T14:57:00.000000Z&quot;, &quot;s2:granule_id&quot;: &quot;S2A_OPER_MSI_L2A_TL_ATOS_20221112T145700_A038601_T30TVT_N04.00&quot;, &quot;s2:high_proba_clouds_percentage&quot;: 0.000508, &quot;s2:medium_proba_clouds_percentage&quot;: 0.003716, &quot;s2:nodata_pixel_percentage&quot;: 0.000226, &quot;s2:not_vegetated_percentage&quot;: 2.478484, &quot;s2:processing_baseline&quot;: &quot;04.00&quot;, &quot;s2:product_type&quot;: &quot;S2MSI2A&quot;, &quot;s2:product_uri&quot;: &quot;S2A_MSIL2A_20221112T111321_N0400_R137_T30TVT_20221112T145700.SAFE&quot;, &quot;s2:reflectance_conversion_factor&quot;: 1.0193600036007, &quot;s2:saturated_defective_pixel_percentage&quot;: 0, &quot;s2:sequence&quot;: &quot;0&quot;, &quot;s2:snow_ice_percentage&quot;: 0.050325, &quot;s2:thin_cirrus_percentage&quot;: 0.001755, &quot;s2:unclassified_percentage&quot;: 0.002548, &quot;s2:vegetation_percentage&quot;: 10.348745, &quot;s2:water_percentage&quot;: 87.111628, &quot;updated&quot;: &quot;2022-11-14T06:54:49.284Z&quot;, &quot;view:sun_azimuth&quot;: 169.467826196677, &quot;view:sun_elevation&quot;: 24.259740600657594}, &quot;stac_extensions&quot;: [&quot;https://stac-extensions.github.io/grid/v1.0.0/schema.json&quot;, &quot;https://stac-extensions.github.io/eo/v1.0.0/schema.json&quot;, &quot;https://stac-extensions.github.io/mgrs/v1.0.0/schema.json&quot;, &quot;https://stac-extensions.github.io/projection/v1.0.0/schema.json&quot;, &quot;https://stac-extensions.github.io/processing/v1.1.0/schema.json&quot;, &quot;https://stac-extensions.github.io/view/v1.0.0/schema.json&quot;, &quot;https://stac-extensions.github.io/raster/v1.1.0/schema.json&quot;], &quot;stac_version&quot;: &quot;1.0.0&quot;, &quot;type&quot;: &quot;Feature&quot;});\n",
-       "\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x1271af700>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "bounds = featureBounds(item)\n",
     "\n",
     "m = Map(\n",
     "    tiles=\"OpenStreetMap\",\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=8\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2),\n",
+    "    zoom_start=8,\n",
     ")\n",
     "\n",
     "geo_json = GeoJson(data=item)\n",
@@ -272,28 +120,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'visual': {'bounds': [-4.337134709547373, 46.85817595750231, -2.869529638083867, 47.85370180403547], 'minzoom': 7, 'maxzoom': 13, 'band_metadata': [['b1', {}], ['b2', {}], ['b3', {}]], 'band_descriptions': [['b1', ''], ['b2', ''], ['b3', '']], 'dtype': 'uint8', 'nodata_type': 'Nodata', 'colorinterp': ['red', 'green', 'blue'], 'height': 10980, 'driver': 'GTiff', 'overviews': [2, 4, 8, 16], 'count': 3, 'width': 10980, 'nodata_value': 0.0}, 'red': {'bounds': [-4.337134709547373, 46.85817595750231, -2.869529638083867, 47.85370180403547], 'minzoom': 7, 'maxzoom': 13, 'band_metadata': [['b1', {}]], 'band_descriptions': [['b1', '']], 'dtype': 'uint16', 'nodata_type': 'Nodata', 'colorinterp': ['gray'], 'height': 10980, 'driver': 'GTiff', 'overviews': [2, 4, 8, 16], 'count': 1, 'width': 10980, 'nodata_value': 0.0}, 'blue': {'bounds': [-4.337134709547373, 46.85817595750231, -2.869529638083867, 47.85370180403547], 'minzoom': 7, 'maxzoom': 13, 'band_metadata': [['b1', {}]], 'band_descriptions': [['b1', '']], 'dtype': 'uint16', 'nodata_type': 'Nodata', 'colorinterp': ['gray'], 'height': 10980, 'driver': 'GTiff', 'overviews': [2, 4, 8, 16], 'count': 1, 'width': 10980, 'nodata_value': 0.0}, 'green': {'bounds': [-4.337134709547373, 46.85817595750231, -2.869529638083867, 47.85370180403547], 'minzoom': 7, 'maxzoom': 13, 'band_metadata': [['b1', {}]], 'band_descriptions': [['b1', '']], 'dtype': 'uint16', 'nodata_type': 'Nodata', 'colorinterp': ['gray'], 'height': 10980, 'driver': 'GTiff', 'overviews': [2, 4, 8, 16], 'count': 1, 'width': 10980, 'nodata_value': 0.0}}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Get Tile URL\n",
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/stac/info\",\n",
-    "    params = (\n",
+    "    params=(\n",
     "        (\"url\", stac_item),\n",
     "        # Get info for multiple assets\n",
-    "        (\"assets\",\"visual\"), (\"assets\",\"red\"), (\"assets\",\"blue\"), (\"assets\",\"green\"),\n",
-    "    )\n",
+    "        (\"assets\", \"visual\"),\n",
+    "        (\"assets\", \"red\"),\n",
+    "        (\"assets\", \"blue\"),\n",
+    "        (\"assets\", \"green\"),\n",
+    "    ),\n",
     ").json()\n",
     "print(r)"
    ]
@@ -307,105 +150,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_25dfe02a3eb4c84964feca006427f815 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_25dfe02a3eb4c84964feca006427f815&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_25dfe02a3eb4c84964feca006427f815 = L.map(\n",
-       "                &quot;map_25dfe02a3eb4c84964feca006427f815&quot;,\n",
-       "                {\n",
-       "                    center: [47.355901916875645, -3.6033320722850783],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 10,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_1c0f8aeef219fc3dfe25e926bd49259b = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_25dfe02a3eb4c84964feca006427f815);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_dad5014b613f03a33cbfea22243c5531 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv1%2Fcollections%2Fsentinel-2-l2a%2Fitems%2FS2A_30TVT_20221112_0_L2A\\u0026assets=visual&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;ESA&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 14, &quot;maxZoom&quot;: 14, &quot;minZoom&quot;: 8, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_25dfe02a3eb4c84964feca006427f815);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x1271d35e0>"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/stac/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/stac/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": stac_item,\n",
     "        \"assets\": \"visual\",\n",
     "        \"minzoom\": 8,  # By default titiler will use 0\n",
-    "        \"maxzoom\": 14, # By default titiler will use 24\n",
-    "    }\n",
+    "        \"maxzoom\": 14,  # By default titiler will use 24\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=10\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=10\n",
     ")\n",
     "\n",
     "tiles = TileLayer(\n",
@@ -413,7 +173,7 @@
     "    min_zoom=r[\"minzoom\"],\n",
     "    max_zoom=r[\"maxzoom\"],\n",
     "    opacity=1,\n",
-    "    attr=\"ESA\"\n",
+    "    attr=\"ESA\",\n",
     ")\n",
     "tiles.add_to(m)\n",
     "m"
@@ -428,107 +188,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_1fd5bfb4f8f7cc1c3dbc343f5e85ca76 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_1fd5bfb4f8f7cc1c3dbc343f5e85ca76&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_1fd5bfb4f8f7cc1c3dbc343f5e85ca76 = L.map(\n",
-       "                &quot;map_1fd5bfb4f8f7cc1c3dbc343f5e85ca76&quot;,\n",
-       "                {\n",
-       "                    center: [47.355901916875645, -3.6033320722850783],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 12,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_57b776ac0a2e1daf784a3806dd7e26c6 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_1fd5bfb4f8f7cc1c3dbc343f5e85ca76);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_0c7f952be5bd9f9517b62403d6724e90 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv1%2Fcollections%2Fsentinel-2-l2a%2Fitems%2FS2A_30TVT_20221112_0_L2A\\u0026assets=visual\\u0026asset_bidx=visual%7C3%2C1%2C2&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;ESA&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 14, &quot;maxZoom&quot;: 14, &quot;minZoom&quot;: 8, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_1fd5bfb4f8f7cc1c3dbc343f5e85ca76);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x1271c2550>"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Get Tile URL\n",
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/stac/tilejson.json\",\n",
-    "    params = {\n",
+    "    f\"{titiler_endpoint}/stac/WebMercatorQuad/tilejson.json\",\n",
+    "    params={\n",
     "        \"url\": stac_item,\n",
-    "        \"assets\": \"visual\",\n",
-    "        \"asset_bidx\": \"visual|3,1,2\",\n",
+    "        \"assets\": \"visual|indexes=1,2,3\",\n",
     "        \"minzoom\": 8,  # By default titiler will use 0\n",
-    "        \"maxzoom\": 14, # By default titiler will use 24\n",
-    "    }\n",
+    "        \"maxzoom\": 14,  # By default titiler will use 24\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=12\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=12\n",
     ")\n",
     "\n",
     "tiles = TileLayer(\n",
@@ -536,7 +212,7 @@
     "    min_zoom=r[\"minzoom\"],\n",
     "    max_zoom=r[\"maxzoom\"],\n",
     "    opacity=1,\n",
-    "    attr=\"ESA\"\n",
+    "    attr=\"ESA\",\n",
     ")\n",
     "tiles.add_to(m)\n",
     "m"
@@ -544,96 +220,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_781a60796e83ac86c32d21edb364066a {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_781a60796e83ac86c32d21edb364066a&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_781a60796e83ac86c32d21edb364066a = L.map(\n",
-       "                &quot;map_781a60796e83ac86c32d21edb364066a&quot;,\n",
-       "                {\n",
-       "                    center: [47.355901916875645, -3.6033320722850783],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 11,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_daa9ef09ab351532c789b3866bceb7a6 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_781a60796e83ac86c32d21edb364066a);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_1d7422992949e9c6b73b69c8ef990292 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv1%2Fcollections%2Fsentinel-2-l2a%2Fitems%2FS2A_30TVT_20221112_0_L2A\\u0026assets=red\\u0026assets=green\\u0026assets=blue\\u0026rescale=0%2C2000&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;ESA&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 14, &quot;maxZoom&quot;: 14, &quot;minZoom&quot;: 8, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_781a60796e83ac86c32d21edb364066a);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x1271c2ac0>"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Get Tile URL\n",
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/stac/tilejson.json\",\n",
-    "    params = (\n",
+    "    f\"{titiler_endpoint}/stac/WebMercatorQuad/tilejson.json\",\n",
+    "    params=(\n",
     "        (\"url\", stac_item),\n",
     "        (\"assets\", \"red\"),\n",
     "        (\"assets\", \"green\"),\n",
@@ -646,12 +240,11 @@
     "        (\"minzoom\", 8),\n",
     "        (\"maxzoom\", 14),\n",
     "        (\"rescale\", \"0,2000\"),\n",
-    "    )\n",
+    "    ),\n",
     ").json()\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=11\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=11\n",
     ")\n",
     "\n",
     "tiles = TileLayer(\n",
@@ -659,7 +252,7 @@
     "    min_zoom=r[\"minzoom\"],\n",
     "    max_zoom=r[\"maxzoom\"],\n",
     "    opacity=1,\n",
-    "    attr=\"ESA\"\n",
+    "    attr=\"ESA\",\n",
     ")\n",
     "tiles.add_to(m)\n",
     "m"
@@ -669,234 +262,32 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Apply Expression between assets"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_a90d7df0e5f9051860007b480f32d04f {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_a90d7df0e5f9051860007b480f32d04f&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_a90d7df0e5f9051860007b480f32d04f = L.map(\n",
-       "                &quot;map_a90d7df0e5f9051860007b480f32d04f&quot;,\n",
-       "                {\n",
-       "                    center: [47.355901916875645, -3.6033320722850783],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 10,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_72a1de140f966b497407b18d023604ac = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_a90d7df0e5f9051860007b480f32d04f);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_67ddf8efcbcbfee36b3a98497d3dce92 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv1%2Fcollections%2Fsentinel-2-l2a%2Fitems%2FS2A_30TVT_20221112_0_L2A\\u0026expression=%28nir-red%29%2F%28nir%2Bred%29\\u0026asset_as_band=true\\u0026rescale=-1%2C1\\u0026colormap_name=viridis&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;ESA&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 14, &quot;maxZoom&quot;: 14, &quot;minZoom&quot;: 8, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_a90d7df0e5f9051860007b480f32d04f);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x127257040>"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Get Tile URL\n",
-    "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/stac/tilejson.json\",\n",
-    "    params = (\n",
-    "        (\"url\", stac_item),\n",
-    "        (\"expression\", \"(nir-red)/(nir+red)\"),  # NDVI\n",
-    "        # We need to tell rio-tiler that each asset is a Band \n",
-    "        # (so it will select the first band within each asset automatically)\n",
-    "        (\"asset_as_band\", True),\n",
-    "        (\"rescale\", \"-1,1\"),\n",
-    "        (\"minzoom\", 8),\n",
-    "        (\"maxzoom\", 14),\n",
-    "        (\"colormap_name\", \"viridis\"),\n",
-    "    )\n",
-    ").json()\n",
-    "\n",
-    "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=10\n",
-    ")\n",
-    "\n",
-    "tiles = TileLayer(\n",
-    "    tiles=r[\"tiles\"][0],\n",
-    "    min_zoom=r[\"minzoom\"],\n",
-    "    max_zoom=r[\"maxzoom\"],\n",
-    "    opacity=1,\n",
-    "    attr=\"ESA\"\n",
-    ")\n",
-    "tiles.add_to(m)\n",
-    "m"
+    "Use an expression to calculate a band index (NDVI) based on information contained in multiple assets."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe srcdoc=\"&lt;!DOCTYPE html&gt;\n",
-       "&lt;head&gt;    \n",
-       "    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot; /&gt;\n",
-       "    \n",
-       "        &lt;script&gt;\n",
-       "            L_NO_TOUCH = false;\n",
-       "            L_DISABLE_3D = false;\n",
-       "        &lt;/script&gt;\n",
-       "    \n",
-       "    &lt;style&gt;html, body {width: 100%;height: 100%;margin: 0;padding: 0;}&lt;/style&gt;\n",
-       "    &lt;style&gt;#map {position:absolute;top:0;bottom:0;right:0;left:0;}&lt;/style&gt;\n",
-       "    &lt;script src=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://code.jquery.com/jquery-1.12.4.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;script src=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js&quot;&gt;&lt;/script&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css&quot;/&gt;\n",
-       "    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdn.jsdelivr.net/gh/python-visualization/folium/folium/templates/leaflet.awesome.rotate.min.css&quot;/&gt;\n",
-       "    \n",
-       "            &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width,\n",
-       "                initial-scale=1.0, maximum-scale=1.0, user-scalable=no&quot; /&gt;\n",
-       "            &lt;style&gt;\n",
-       "                #map_949b64d69382b3e2759447a9eac55ed2 {\n",
-       "                    position: relative;\n",
-       "                    width: 100.0%;\n",
-       "                    height: 100.0%;\n",
-       "                    left: 0.0%;\n",
-       "                    top: 0.0%;\n",
-       "                }\n",
-       "            &lt;/style&gt;\n",
-       "        \n",
-       "&lt;/head&gt;\n",
-       "&lt;body&gt;    \n",
-       "    \n",
-       "            &lt;div class=&quot;folium-map&quot; id=&quot;map_949b64d69382b3e2759447a9eac55ed2&quot; &gt;&lt;/div&gt;\n",
-       "        \n",
-       "&lt;/body&gt;\n",
-       "&lt;script&gt;    \n",
-       "    \n",
-       "            var map_949b64d69382b3e2759447a9eac55ed2 = L.map(\n",
-       "                &quot;map_949b64d69382b3e2759447a9eac55ed2&quot;,\n",
-       "                {\n",
-       "                    center: [47.355901916875645, -3.6033320722850783],\n",
-       "                    crs: L.CRS.EPSG3857,\n",
-       "                    zoom: 10,\n",
-       "                    zoomControl: true,\n",
-       "                    preferCanvas: false,\n",
-       "                }\n",
-       "            );\n",
-       "\n",
-       "            \n",
-       "\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_5745ee5f5b0d40a6f5961fa333337f18 = L.tileLayer(\n",
-       "                &quot;https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;Data by \\u0026copy; \\u003ca href=\\&quot;http://openstreetmap.org\\&quot;\\u003eOpenStreetMap\\u003c/a\\u003e, under \\u003ca href=\\&quot;http://www.openstreetmap.org/copyright\\&quot;\\u003eODbL\\u003c/a\\u003e.&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 18, &quot;maxZoom&quot;: 18, &quot;minZoom&quot;: 0, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_949b64d69382b3e2759447a9eac55ed2);\n",
-       "        \n",
-       "    \n",
-       "            var tile_layer_3a72af2adacf5116b930cf7817b9e5d2 = L.tileLayer(\n",
-       "                &quot;http://127.0.0.1:8081/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https%3A%2F%2Fearth-search.aws.element84.com%2Fv1%2Fcollections%2Fsentinel-2-l2a%2Fitems%2FS2A_30TVT_20221112_0_L2A\\u0026expression=%28nir_b1-red_b1%29%2F%28nir_b1%2Bred_b1%29\\u0026rescale=-1%2C1\\u0026colormap_name=viridis&quot;,\n",
-       "                {&quot;attribution&quot;: &quot;ESA&quot;, &quot;detectRetina&quot;: false, &quot;maxNativeZoom&quot;: 14, &quot;maxZoom&quot;: 14, &quot;minZoom&quot;: 8, &quot;noWrap&quot;: false, &quot;opacity&quot;: 1, &quot;subdomains&quot;: &quot;abc&quot;, &quot;tms&quot;: false}\n",
-       "            ).addTo(map_949b64d69382b3e2759447a9eac55ed2);\n",
-       "        \n",
-       "&lt;/script&gt;\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
-      ],
-      "text/plain": [
-       "<folium.folium.Map at 0x1271c3f10>"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Get Tile URL\n",
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/stac/tilejson.json\",\n",
-    "    params = (\n",
+    "    f\"{titiler_endpoint}/stac/WebMercatorQuad/tilejson.json\",\n",
+    "    params=(\n",
     "        (\"url\", stac_item),\n",
-    "        # if you don't use `asset_as_band=True` option you need to pass the band indexes within the expression\n",
-    "        (\"expression\", \"(nir_b1-red_b1)/(nir_b1+red_b1)\"),  # NDVI\n",
+    "        (\"assets\", \"nir\"),\n",
+    "        (\"assets\", \"red\"),\n",
+    "        (\"expression\", \"(b1-b2)/(b1+b2)\"),  # NDVI\n",
     "        (\"rescale\", \"-1,1\"),\n",
     "        (\"minzoom\", 8),\n",
     "        (\"maxzoom\", 14),\n",
     "        (\"colormap_name\", \"viridis\"),\n",
-    "    )\n",
+    "    ),\n",
     ").json()\n",
     "\n",
     "m = Map(\n",
-    "    location=((bounds[1] + bounds[3]) / 2,(bounds[0] + bounds[2]) / 2),\n",
-    "    zoom_start=10\n",
+    "    location=((bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2), zoom_start=10\n",
     ")\n",
     "\n",
     "tiles = TileLayer(\n",
@@ -904,7 +295,7 @@
     "    min_zoom=r[\"minzoom\"],\n",
     "    max_zoom=r[\"maxzoom\"],\n",
     "    opacity=1,\n",
-    "    attr=\"ESA\"\n",
+    "    attr=\"ESA\",\n",
     ")\n",
     "tiles.add_to(m)\n",
     "m"
@@ -920,7 +311,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "py39",
+   "display_name": "titiler (3.13.9)",
    "language": "python",
    "name": "python3"
   },
@@ -934,12 +325,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.13 (main, May 24 2022, 21:13:51) \n[Clang 13.1.6 (clang-1316.0.21.2)]"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "2590a9e34ee6c8bdce5141410f2a072bbabd2a859a8a48acdaa85720923a90ef"
-   }
+   "version": "3.13.9"
   }
  },
  "nbformat": 4,
diff --git a/docs/src/examples/notebooks/Working_with_Statistics.ipynb b/docs/src/examples/notebooks/Working_with_Statistics.ipynb
index d9f2ac5e4..83adc19c0 100644
--- a/docs/src/examples/notebooks/Working_with_Statistics.ipynb
+++ b/docs/src/examples/notebooks/Working_with_Statistics.ipynb
@@ -2,139 +2,95 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "source": [
-    "# Working with Statistics"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "# Working with Statistics"
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Intro\n",
     "\n",
     "Titiler allows you to get statistics and summaries of your data without having to load the entire dataset yourself. These statistics can be summaries of entire COG files, STAC items, or individual parts of the file, specified using GeoJSON.\n",
     "\n",
-    "Below, we will go over some of the statistical endpoints in Titiler - `/bounds`, `/info`, and `/statistics`.\n",
+    "Below, we will go over some of the statistical endpoints in Titiler - `/info` and `/statistics`.\n",
     "\n",
     "(Note: these examples will be using the `/cog` endpoint, but everything is also available for `/stac` and `/mosaicjson` unless otherwise noted)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 16,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-06T14:25:40.161502Z",
+     "start_time": "2023-04-06T14:25:40.153667Z"
+    },
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "# setup\n",
     "import httpx\n",
     "import json\n",
     "\n",
-    "titiler_endpoint = \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")\n",
     "cog_url = \"https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif\""
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-06T14:25:40.153667Z",
-     "end_time": "2023-04-06T14:25:40.161502Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "## Bounds\n",
-    "\n",
-    "The `/bounds` endpoint returns the bounding box of the image/asset. These bounds are returned in the projection EPSG:4326 (WGS84), in the format `(minx, miny, maxx, maxy)`."
-   ],
    "metadata": {
     "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'bounds': [57.664053823239804, -20.55473177712791, 57.84021477996238, -20.25261582755764]}\n"
-     ]
-    }
-   ],
+   },
    "source": [
-    "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/bounds\",\n",
-    "    params = {\n",
-    "        \"url\": cog_url,\n",
-    "    }\n",
-    ").json()\n",
+    "## Info\n",
     "\n",
-    "bounds = r[\"bounds\"]\n",
-    "print(r)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-06T14:25:40.781598Z",
-     "end_time": "2023-04-06T14:25:40.921234Z"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "For a bit more information, you can get summary statistics from the `/info` endpoint. This includes info such as:\n",
-    "- Bounds (identical to the `/bounds` endpoint)\n",
-    "- Min and max zoom\n",
+    "The `/info` endpoint returns general metadata about the image/asset.\n",
+    "\n",
+    "- Bounds\n",
+    "- CRS \n",
     "- Band metadata, such as names of the bands and their descriptions\n",
     "- Number of bands in the image\n",
     "- Overview levels\n",
-    "- Image width and height\n",
-    "\n",
-    "These are statistics available in the metadata of the image, so should be fast to read.\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+    "- Image width and height"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{\"bounds\": [57.664053823239804, -20.55473177712791, 57.84021477996238, -20.25261582755764], \"minzoom\": 10, \"maxzoom\": 18, \"band_metadata\": [[\"b1\", {}], [\"b2\", {}], [\"b3\", {}]], \"band_descriptions\": [[\"b1\", \"\"], [\"b2\", \"\"], [\"b3\", \"\"]], \"dtype\": \"uint8\", \"nodata_type\": \"Mask\", \"colorinterp\": [\"red\", \"green\", \"blue\"], \"count\": 3, \"width\": 38628, \"driver\": \"GTiff\", \"overviews\": [2, 4, 8, 16, 32, 64, 128], \"height\": 66247}\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-06T14:25:42.410135Z",
+     "start_time": "2023-04-06T14:25:42.355858Z"
+    },
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/cog/info\",\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": cog_url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "print(json.dumps(r))"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-06T14:25:42.355858Z",
-     "end_time": "2023-04-06T14:25:42.410135Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Statistics\n",
     "\n",
@@ -144,98 +100,86 @@
     "- Percentiles\n",
     "\n",
     "Statistics are generated both for the image as a whole and for each band individually."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{\"b1\": {\"min\": 0.0, \"max\": 255.0, \"mean\": 36.94901407469342, \"count\": 574080.0, \"sum\": 21211690.0, \"std\": 48.282133573955264, \"median\": 3.0, \"majority\": 1.0, \"minority\": 246.0, \"unique\": 256.0, \"histogram\": [[330584.0, 54820.0, 67683.0, 57434.0, 30305.0, 14648.0, 9606.0, 5653.0, 2296.0, 1051.0], [0.0, 25.5, 51.0, 76.5, 102.0, 127.5, 153.0, 178.5, 204.0, 229.5, 255.0]], \"valid_percent\": 93.75, \"masked_pixels\": 38272.0, \"valid_pixels\": 574080.0, \"percentile_2\": 0.0, \"percentile_98\": 171.0}, \"b2\": {\"min\": 0.0, \"max\": 255.0, \"mean\": 57.1494356187291, \"count\": 574080.0, \"sum\": 32808348.0, \"std\": 56.300819175100656, \"median\": 37.0, \"majority\": 5.0, \"minority\": 0.0, \"unique\": 256.0, \"histogram\": [[271018.0, 34938.0, 54030.0, 69429.0, 70260.0, 32107.0, 29375.0, 9697.0, 2001.0, 1225.0], [0.0, 25.5, 51.0, 76.5, 102.0, 127.5, 153.0, 178.5, 204.0, 229.5, 255.0]], \"valid_percent\": 93.75, \"masked_pixels\": 38272.0, \"valid_pixels\": 574080.0, \"percentile_2\": 5.0, \"percentile_98\": 180.0}, \"b3\": {\"min\": 0.0, \"max\": 255.0, \"mean\": 51.251764562430324, \"count\": 574080.0, \"sum\": 29422613.0, \"std\": 39.65505035854822, \"median\": 36.0, \"majority\": 16.0, \"minority\": 252.0, \"unique\": 254.0, \"histogram\": [[203263.0, 150865.0, 104882.0, 42645.0, 30652.0, 25382.0, 12434.0, 2397.0, 1097.0, 463.0], [0.0, 25.5, 51.0, 76.5, 102.0, 127.5, 153.0, 178.5, 204.0, 229.5, 255.0]], \"valid_percent\": 93.75, \"masked_pixels\": 38272.0, \"valid_pixels\": 574080.0, \"percentile_2\": 14.0, \"percentile_98\": 158.0}}\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-06T14:25:42.866905Z",
+     "start_time": "2023-04-06T14:25:42.816337Z"
+    },
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/cog/statistics\",\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": cog_url,\n",
-    "    }\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "print(json.dumps(r))"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-06T14:25:42.816337Z",
-     "end_time": "2023-04-06T14:25:42.866905Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
-    "This endpoint is far more configurable than `/bounds` and `info`. You can specify which bands to analyse, how to generate the histogram, and pre-process the image.\n",
+    "This endpoint is far more configurable than `/info`. You can specify which bands to analyse, how to generate the histogram, and pre-process the image.\n",
     "\n",
     "For example, if you wanted to get the statistics of the [VARI](https://www.space4water.org/space/visible-atmospherically-resistant-index-vari) of the image you can use the `expression` parameter to conduct simple band math:"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{\"(b2-b1)/(b1+b2-b3)\": {\"min\": -1.7976931348623157e+308, \"max\": 1.7976931348623157e+308, \"mean\": null, \"count\": 574080.0, \"sum\": null, \"std\": null, \"median\": -0.15384615384615385, \"majority\": -0.4, \"minority\": -149.0, \"unique\": 18718.0, \"histogram\": [[5646.0, 10176.0, 130905.0, 97746.0, 50184.0, 95842.0, 60322.0, 21478.0, 13552.0, 12204.0], [-1.0, -0.8, -0.6, -0.3999999999999999, -0.19999999999999996, 0.0, 0.20000000000000018, 0.40000000000000013, 0.6000000000000001, 0.8, 1.0]], \"valid_percent\": 93.75, \"masked_pixels\": 38272.0, \"valid_pixels\": 574080.0, \"percentile_2\": -3.5, \"percentile_98\": 3.3870967741935485}}\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-06T14:25:43.393610Z",
+     "start_time": "2023-04-06T14:25:43.304442Z"
+    },
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
     "    f\"{titiler_endpoint}/cog/statistics\",\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": cog_url,\n",
-    "        \"expression\": \"(b2-b1)/(b1+b2-b3)\", # expression for the VARI\n",
-    "        \"histogram_range\": \"-1,1\"\n",
-    "    }\n",
+    "        \"expression\": \"(b2-b1)/(b1+b2-b3)\",  # expression for the VARI\n",
+    "        \"histogram_range\": \"-1,1\",\n",
+    "    },\n",
     ").json()\n",
     "\n",
     "print(json.dumps(r))"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-06T14:25:43.304442Z",
-     "end_time": "2023-04-06T14:25:43.393610Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "Alternatively, if you would like to get statistics for only a certain area, you can specify an area via a feature or a feature collection.\n",
     "\n",
     "(Note: this endpoint is not available in the mosaicjson endpoint, only `/cog` and `/stac`)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-06T14:25:43.877434Z",
+     "start_time": "2023-04-06T14:25:43.867923Z"
+    },
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "mahebourg = \"\"\"\n",
@@ -284,55 +228,40 @@
     "  ]\n",
     "}\n",
     "\"\"\""
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-06T14:25:43.867923Z",
-     "end_time": "2023-04-06T14:25:43.877434Z"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{\"type\": \"FeatureCollection\", \"features\": [{\"type\": \"Feature\", \"geometry\": {\"type\": \"Polygon\", \"coordinates\": [[[57.70358910197049, -20.384114558699935], [57.68564920588395, -20.384114558699935], [57.68209507552771, -20.39855066753664], [57.68666467170024, -20.421074640746554], [57.70341985766697, -20.434397129770545], [57.72999121319131, -20.42392955694521], [57.70358910197049, -20.384114558699935]]]}, \"properties\": {\"statistics\": {\"b1\": {\"min\": 0.0, \"max\": 255.0, \"mean\": 88.5634794986129, \"count\": 619641.0, \"sum\": 54877563.0, \"std\": 55.18714964714274, \"median\": 77.0, \"majority\": 52.0, \"minority\": 253.0, \"unique\": 256.0, \"histogram\": [[67233.0, 110049.0, 129122.0, 90849.0, 77108.0, 44091.0, 44606.0, 37790.0, 18033.0, 760.0], [0.0, 25.5, 51.0, 76.5, 102.0, 127.5, 153.0, 178.5, 204.0, 229.5, 255.0]], \"valid_percent\": 62.0, \"masked_pixels\": 379783.0, \"valid_pixels\": 619641.0, \"percentile_2\": 4.0, \"percentile_98\": 208.0}, \"b2\": {\"min\": 0.0, \"max\": 255.0, \"mean\": 112.07155594933195, \"count\": 619641.0, \"sum\": 69444131.0, \"std\": 42.64508357271268, \"median\": 107.0, \"majority\": 103.0, \"minority\": 1.0, \"unique\": 256.0, \"histogram\": [[6004.0, 31108.0, 107187.0, 126848.0, 130731.0, 73650.0, 107827.0, 33264.0, 2403.0, 619.0], [0.0, 25.5, 51.0, 76.5, 102.0, 127.5, 153.0, 178.5, 204.0, 229.5, 255.0]], \"valid_percent\": 62.0, \"masked_pixels\": 379783.0, \"valid_pixels\": 619641.0, \"percentile_2\": 34.0, \"percentile_98\": 189.0}, \"b3\": {\"min\": 0.0, \"max\": 255.0, \"mean\": 84.54690377170006, \"count\": 619641.0, \"sum\": 52388728.0, \"std\": 44.64862735915829, \"median\": 77.0, \"majority\": 53.0, \"minority\": 254.0, \"unique\": 256.0, \"histogram\": [[40704.0, 130299.0, 138014.0, 85866.0, 86381.0, 91182.0, 41872.0, 4116.0, 993.0, 214.0], [0.0, 25.5, 51.0, 76.5, 102.0, 127.5, 153.0, 178.5, 204.0, 229.5, 255.0]], \"valid_percent\": 62.0, \"masked_pixels\": 379783.0, \"valid_pixels\": 619641.0, \"percentile_2\": 11.0, \"percentile_98\": 170.0}}}}]}\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-06T14:25:45.709013Z",
+     "start_time": "2023-04-06T14:25:44.592051Z"
+    },
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
     "# NOTE: This is a POST request, unlike all other requests in this example\n",
     "r = httpx.post(\n",
     "    f\"{titiler_endpoint}/cog/statistics\",\n",
     "    data=mahebourg,\n",
-    "    params = {\n",
+    "    params={\n",
     "        \"url\": cog_url,\n",
-    "    }\n",
+    "        \"max_size\": 1024,\n",
+    "    },\n",
+    "    timeout=20,\n",
     ").json()\n",
     "\n",
-    "print(json.dumps(r))\n"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "start_time": "2023-04-06T14:25:44.592051Z",
-     "end_time": "2023-04-06T14:25:45.709013Z"
-    }
-   }
+    "print(json.dumps(r))"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
-   "source": [],
-   "metadata": {
-    "collapsed": false
-   }
+   "source": []
   }
  ],
  "metadata": {
@@ -344,14 +273,14 @@
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
   }
  },
  "nbformat": 4,
diff --git a/docs/src/examples/notebooks/Working_with_Zarr.ipynb b/docs/src/examples/notebooks/Working_with_Zarr.ipynb
new file mode 100644
index 000000000..f1939df86
--- /dev/null
+++ b/docs/src/examples/notebooks/Working_with_Zarr.ipynb
@@ -0,0 +1,279 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "# Working with Zarr"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "## Intro\n",
+    "\n",
+    "`titiler.xarray` is a submodule designed specifically for working with multidimensional dataset. With version `0.25.0`, we've introduced a default application with only support for Zarr dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-06T14:25:40.161502Z",
+     "start_time": "2023-04-06T14:25:40.153667Z"
+    },
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# setup\n",
+    "import httpx\n",
+    "import json\n",
+    "from IPython.display import Image\n",
+    "\n",
+    "# Developmentseed Demo endpoint. Please be kind. Ref: https://github.com/developmentseed/titiler/discussions/1223\n",
+    "# titiler_endpoint = \"https://xarray.titiler.xyz\"\n",
+    "\n",
+    "# Or launch your own local instance with:\n",
+    "# uv run --group server uvicorn titiler.xarray.main:app --host 127.0.0.1 --port 8080 --reload\n",
+    "titiler_endpoint = \"http://127.0.0.1:8080\"\n",
+    "\n",
+    "zarr_url = \"https://nasa-power.s3.us-west-2.amazonaws.com/syn1deg/temporal/power_syn1deg_monthly_temporal_lst.zarr\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "## Dataset Metadata\n",
+    "\n",
+    "The `/dataset/dict` endpoint returns general metadata about the Zarr Dataset\n",
+    "\n",
+    "Endpoint: `/dataset/dict`\n",
+    "\n",
+    "QueryParams:\n",
+    "- **url**: Zarr store URL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-04-06T14:25:42.410135Z",
+     "start_time": "2023-04-06T14:25:42.355858Z"
+    },
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "r = httpx.get(\n",
+    "    f\"{titiler_endpoint}/dataset/dict\",\n",
+    "    params={\n",
+    "        \"url\": zarr_url,\n",
+    "    },\n",
+    ").json()\n",
+    "\n",
+    "print(json.dumps(r, indent=2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### List of available variables\n",
+    "\n",
+    "Endpoint: `/dataset/keys`\n",
+    "\n",
+    "QueryParams:\n",
+    "- **url**: Zarr store URL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r = httpx.get(\n",
+    "    f\"{titiler_endpoint}/dataset/keys\",\n",
+    "    params={\n",
+    "        \"url\": zarr_url,\n",
+    "    },\n",
+    ").json()\n",
+    "\n",
+    "print(json.dumps(r, indent=2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Variable Info\n",
+    "\n",
+    "We can use `/info` endpoint to get more `Geo` information about a specific variable.\n",
+    "\n",
+    "QueryParams:\n",
+    "- **url**: Zarr store URL\n",
+    "- **variable**: Variable's name (e.g `AIRMASS`, found in `/dataset/keys` response)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r = httpx.get(\n",
+    "    f\"{titiler_endpoint}/info\",\n",
+    "    params={\"url\": zarr_url, \"variable\": \"AIRMASS\"},\n",
+    ").json()\n",
+    "\n",
+    "print(json.dumps(r, indent=2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Or as a GeoJSON feature"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r = httpx.get(\n",
+    "    f\"{titiler_endpoint}/info.geojson\",\n",
+    "    params={\"url\": zarr_url, \"variable\": \"AIRMASS\"},\n",
+    ").json()\n",
+    "\n",
+    "print(json.dumps(r, indent=2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Knowledge\n",
+    "\n",
+    "Looking at the `info` response we can see that the `AIRMASS` variable has `348` (count) bands, each one corresponding to as specific `TIME` (day).\n",
+    "\n",
+    "We can also see that the data is stored as `float32` which mean that we will have to apply linear rescaling in order to get output image as PNG/JPEG.\n",
+    "\n",
+    "The `min/max` values are also indicated with `valid_max=31.73` and `valid_min=1.0`.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dimension Reduction\n",
+    "\n",
+    "We cannot visualize all the `bands` at once, so we need to perform dimension reduction to go from array in shape (348, 360, 180) to a 1b (1, 360, 180) or 3b (3, 360, 180) image. \n",
+    "\n",
+    "To do it, we have two methods whitin `titiler.xarray`:\n",
+    "- using `bidx=`: same as for COG we can select a band index\n",
+    "- using `sel={dimension}=value`: which will be using xarray `.sel` method"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r = httpx.get(\n",
+    "    f\"{titiler_endpoint}/bbox/-180,-90,180,90.png\",\n",
+    "    params=(\n",
+    "        (\"url\", zarr_url),\n",
+    "        (\"variable\", \"AIRMASS\"),\n",
+    "        # Select 1 specific band\n",
+    "        (\"bidx\", 50),\n",
+    "        (\"rescale\", \"1,20\"),\n",
+    "        (\"colormap_name\", \"viridis\"),\n",
+    "    ),\n",
+    "    timeout=10,\n",
+    ")\n",
+    "\n",
+    "Image(r.content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r = httpx.get(\n",
+    "    f\"{titiler_endpoint}/bbox/-180,-90,180,90.png\",\n",
+    "    params=(\n",
+    "        (\"url\", zarr_url),\n",
+    "        (\"variable\", \"AIRMASS\"),\n",
+    "        # Select 1 specific time slices\n",
+    "        (\"sel\", \"time=2003-06-30\"),\n",
+    "        (\"rescale\", \"1,20\"),\n",
+    "        (\"colormap_name\", \"viridis\"),\n",
+    "    ),\n",
+    "    timeout=10,\n",
+    ")\n",
+    "\n",
+    "Image(r.content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r = httpx.get(\n",
+    "    f\"{titiler_endpoint}/bbox/-180,-90,180,90.png\",\n",
+    "    params=(\n",
+    "        (\"url\", zarr_url),\n",
+    "        (\"variable\", \"AIRMASS\"),\n",
+    "        # Select 3 specific time slices to create a 3 band image\n",
+    "        (\"sel\", \"time=2003-06-30\"),\n",
+    "        (\"sel\", \"time=2004-06-30\"),\n",
+    "        (\"sel\", \"time=2005-06-30\"),\n",
+    "        (\"rescale\", \"1,10\"),\n",
+    "    ),\n",
+    "    timeout=10,\n",
+    ")\n",
+    "\n",
+    "Image(r.content)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3.13 (3.13.7)",
+   "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.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/docs/src/examples/notebooks/Working_with_nonWebMercatorTMS.ipynb b/docs/src/examples/notebooks/Working_with_nonWebMercatorTMS.ipynb
index c9e728f6b..e2744b8c3 100644
--- a/docs/src/examples/notebooks/Working_with_nonWebMercatorTMS.ipynb
+++ b/docs/src/examples/notebooks/Working_with_nonWebMercatorTMS.ipynb
@@ -36,7 +36,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -51,18 +51,20 @@
     "    TileLayer,\n",
     "    WMSLayer,\n",
     "    GeoJSON,\n",
-    "    projections\n",
+    "    projections,\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "titiler_endpoint = \"http://127.0.0.1:8081\" # \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
-    "url = \"https://s3.amazonaws.com/opendata.remotepixel.ca/cogs/natural_earth/world.tif\" # Natural Earth WORLD tif"
+    "titiler_endpoint = (\n",
+    "    \"https://titiler.xyz\"  # Developmentseed Demo endpoint. Please be kind.\n",
+    ")\n",
+    "url = \"https://s3.amazonaws.com/opendata.remotepixel.ca/cogs/natural_earth/world.tif\"  # Natural Earth WORLD tif"
    ]
   },
   {
@@ -74,31 +76,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "scrolled": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Supported TMS:\n",
-      "- LINZAntarticaMapTilegrid\n",
-      "- EuropeanETRS89_LAEAQuad\n",
-      "- CanadianNAD83_LCC\n",
-      "- UPSArcticWGS84Quad\n",
-      "- NZTM2000\n",
-      "- NZTM2000Quad\n",
-      "- UTM31WGS84Quad\n",
-      "- UPSAntarcticWGS84Quad\n",
-      "- WorldMercatorWGS84Quad\n",
-      "- WGS1984Quad\n",
-      "- WorldCRS84Quad\n",
-      "- WebMercatorQuad\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(f\"{titiler_endpoint}/tileMatrixSets\").json()\n",
     "\n",
@@ -119,28 +101,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "7d78a0adf5954e65b3f46db3cf943f7a",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Map(center=[0, 0], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_text'…"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/tilejson.json\", params = {\"url\": url}\n",
+    "    f\"{titiler_endpoint}/cog/WebMercatorQuad/tilejson.json\", params={\"url\": url}\n",
     ").json()\n",
     "\n",
     "m = Map(center=(0, 0), zoom=2, basemap={}, crs=projections.EPSG3857)\n",
@@ -161,28 +127,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "8c5d6ab05bce4aef9e29ff7ebd0ac02f",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Map(center=[0, 0], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_text'…"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/WorldCRS84Quad/tilejson.json\", params = {\"url\": url}\n",
+    "    f\"{titiler_endpoint}/cog/WorldCRS84Quad/tilejson.json\", params={\"url\": url}\n",
     ").json()\n",
     "\n",
     "m = Map(center=(0, 0), zoom=1, basemap={}, crs=projections.EPSG4326)\n",
@@ -203,43 +153,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "0615b0bb04ad46198d05f6eb95ed8e6b",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Map(center=[50, 65], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_tex…"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r = httpx.get(\n",
-    "    f\"{titiler_endpoint}/cog/EuropeanETRS89_LAEAQuad/tilejson.json\", params = {\"url\": url}\n",
+    "    f\"{titiler_endpoint}/cog/EuropeanETRS89_LAEAQuad/tilejson.json\", params={\"url\": url}\n",
     ").json()\n",
     "\n",
     "my_projection = {\n",
-    "    'name': 'EPSG:3035',\n",
-    "    'custom': True, #This is important, it tells ipyleaflet that this projection is not on the predefined ones.\n",
-    "    'proj4def': '+proj=laea +lat_0=52 +lon_0=10 +x_0=4321000 +y_0=3210000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs',\n",
-    "    'origin': [6500000.0, 5500000.0],\n",
-    "    'resolutions': [\n",
-    "        8192.0,\n",
-    "        4096.0,\n",
-    "        2048.0,\n",
-    "        1024.0,\n",
-    "        512.0,\n",
-    "        256.0\n",
-    "    ]\n",
+    "    \"name\": \"EPSG:3035\",\n",
+    "    \"custom\": True,  # This is important, it tells ipyleaflet that this projection is not on the predefined ones.\n",
+    "    \"proj4def\": \"+proj=laea +lat_0=52 +lon_0=10 +x_0=4321000 +y_0=3210000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs\",\n",
+    "    \"origin\": [6500000.0, 5500000.0],\n",
+    "    \"resolutions\": [8192.0, 4096.0, 2048.0, 1024.0, 512.0, 256.0],\n",
     "}\n",
     "\n",
     "m = Map(center=(50, 65), zoom=0, basemap={}, crs=my_projection)\n",
@@ -273,7 +200,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.13"
+   "version": "3.9.18"
   },
   "vscode": {
    "interpreter": {
diff --git a/docs/src/external_links.md b/docs/src/external_links.md
index 9cd60516a..be8a6de95 100644
--- a/docs/src/external_links.md
+++ b/docs/src/external_links.md
@@ -13,24 +13,38 @@
 
 * David McCracken's Blog on [Plotly Dash Interactive Mapping - Dash Leaflet & TiTiler](https://www.pywram.com/t/blog-plotly-dash-interactive-mapping-dash-leaflet-titiler/287)
 
+## TiTiler extensions/plugins
+
+* [stac-utils/titiler-pgstac](https://github.com/stac-utils/titiler-pgstac): TiTiler extension which connects to a PgSTAC database to create dynamic mosaics based on search queries.
+
+* [developmentseed/titiler-xarray](https://github.com/developmentseed/titiler-xarray): TiTiler extension for xarray
+
+* [developmentseed/titiler-image](https://github.com/developmentseed/titiler-image): TiTiler demo application for Sentinel-2 Digital Twin dataset
+
+
 ## Projects / Demo using TiTiler
 
 * ESA Charter Mapper [geobrowser](https://docs.charter.uat.esaportal.eu/webPortal/geobrowser/titiler/)
 
 * [developmentseed/titiler-digitaltwin](https://github.com/developmentseed/titiler-digitaltwin): TiTiler demo application for Sentinel-2 Digital Twin dataset
 
-* [developmentseed/titiler-pds](https://github.com/developmentseed/titiler-pds): TiTiler demo application for Sentinel-2 and Landsat-8 AWS Public Datasets
-
 * [developmentseed/titiler-mvt](https://github.com/developmentseed/titiler-mvt): TiTiler demo application to create Mapbox Vector Tiles from COG
 
+* [developmentseed/titiler-pds](https://github.com/developmentseed/titiler-pds): TiTiler demo application for Sentinel-2 and Landsat-8 AWS Public Datasets
+
 * [stac-utils/stac-fastapi](https://github.com/stac-utils/stac-fastapi): STAC API implementation with FastAPI.
 
 * [c-core-labs/stac-api](https://github.com/c-core-labs/stac-api): STAC compliant API implementation (built from stac-fastapi)
 
-* [lambgeo/titiler-layer](https://github.com/lambgeo/titiler-layer): TiTiler Lambda layers for easy deployment on AWS
+* [developmentseed/titiler-lambda-layer](https://github.com/developmentseed/titiler-lambda-layer): TiTiler Lambda layers for easy deployment on AWS
 
 * [Terradue/Stars](https://github.com/Terradue/Stars): Spatio Temporal Asset Runtime Services
 
+* [developmentseed/rio-viz](https://github.com/developmentseed/rio-viz): Visualize Cloud Optimized GeoTIFF in browser
+
+* [developmentseed/pearl-backend](https://github.com/developmentseed/pearl-backend): PEARL (Planetary Computer Land Cover Mapping) Platform API and Infrastructure
+
+* [microsoft/planetary-computer-apis](https://github.com/microsoft/planetary-computer-apis): Microsoft Planetary Computer APIs
 
 ## Conferences / presentations / videos
 
diff --git a/docs/src/img/api_docs.png b/docs/src/img/api_docs.png
new file mode 100644
index 000000000..18724abd4
Binary files /dev/null and b/docs/src/img/api_docs.png differ
diff --git a/docs/src/img/browser.png b/docs/src/img/browser.png
new file mode 100644
index 000000000..965b6b9ac
Binary files /dev/null and b/docs/src/img/browser.png differ
diff --git a/docs/src/img/false_color.png b/docs/src/img/false_color.png
new file mode 100644
index 000000000..f9491c553
Binary files /dev/null and b/docs/src/img/false_color.png differ
diff --git a/docs/src/img/full_ndvi.png b/docs/src/img/full_ndvi.png
new file mode 100644
index 000000000..f01e1aed7
Binary files /dev/null and b/docs/src/img/full_ndvi.png differ
diff --git a/docs/src/img/ndvi_without_color.png b/docs/src/img/ndvi_without_color.png
new file mode 100644
index 000000000..866432048
Binary files /dev/null and b/docs/src/img/ndvi_without_color.png differ
diff --git a/docs/src/img/server_logs.png b/docs/src/img/server_logs.png
new file mode 100644
index 000000000..90cae500d
Binary files /dev/null and b/docs/src/img/server_logs.png differ
diff --git a/docs/src/img/stac_api_docs.png b/docs/src/img/stac_api_docs.png
new file mode 100644
index 000000000..abb1034b4
Binary files /dev/null and b/docs/src/img/stac_api_docs.png differ
diff --git a/docs/src/img/stac_asset_info.png b/docs/src/img/stac_asset_info.png
new file mode 100644
index 000000000..dc309f089
Binary files /dev/null and b/docs/src/img/stac_asset_info.png differ
diff --git a/docs/src/img/stac_asset_preview.png b/docs/src/img/stac_asset_preview.png
new file mode 100644
index 000000000..465ded0e5
Binary files /dev/null and b/docs/src/img/stac_asset_preview.png differ
diff --git a/docs/src/img/stac_preview_map.png b/docs/src/img/stac_preview_map.png
new file mode 100644
index 000000000..f3a316adb
Binary files /dev/null and b/docs/src/img/stac_preview_map.png differ
diff --git a/docs/src/img/stac_render.png b/docs/src/img/stac_render.png
new file mode 100644
index 000000000..d767e72ad
Binary files /dev/null and b/docs/src/img/stac_render.png differ
diff --git a/docs/src/img/stac_tile_zxy.png b/docs/src/img/stac_tile_zxy.png
new file mode 100644
index 000000000..26efcfc15
Binary files /dev/null and b/docs/src/img/stac_tile_zxy.png differ
diff --git a/docs/src/intro.md b/docs/src/intro.md
deleted file mode 100644
index 8941f6aa0..000000000
--- a/docs/src/intro.md
+++ /dev/null
@@ -1,129 +0,0 @@
-
-![](https://user-images.githubusercontent.com/10407788/203526990-f58783cf-a288-4801-8fa6-ee511de91a48.png)
-
-`TiTiler` is a set of python modules whose goal are to help users in creating a dynamic tile server. To learn more about `dynamic tiling` please refer to the [docs](dynamic_tiling.md).
-
-Users can choose to extend or use `TiTiler` as it is.
-
-## Default Application
-
-`TiTiler` comes with a default (complete) application with support for COG, STAC, and MosaicJSON. You can install and start the application locally by doing:
-
-```bash
-# Update pip
-python -m pip install -U pip
-
-# Install titiler packages
-python -m pip install uvicorn titiler.application
-
-# Start application using uvicorn
-uvicorn titiler.application.main:app
-
-> INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-See default endpoints documentation pages:
-
-* [`/cog` - Cloud Optimized GeoTIFF](endpoints/cog.md)
-* [`/mosaicjson` - MosaicJSON](endpoints/mosaic.md)
-* [`/stac` - Spatio Temporal Asset Catalog](endpoints/stac.md)
-* [`/tms` - TileMatrixSets](endpoints/tms.md)
-
-#### Settings
-
-The default application can be customized using environment variables defined in `titiler.application.settings.ApiSettings` class. Each variable needs to be prefixed with `TITILER_API_`.
-
-- `NAME` (str): name of the application. Defaults to `titiler`.
-- `CORS_ORIGINS` (str, `,` delimited origins): allowed CORS origin. Defaults to `*`.
-- `CACHECONTROL` (str): Cache control header to add to responses. Defaults to `"public, max-age=3600"`.
-- `ROOT_PATH` (str): path behind proxy.
-- `DEBUG` (str): adds `LoggerMiddleware` and `TotalTimeMiddleware` in the middleware stack.
-- `DISABLE_COG` (bool): disable `/cog` endpoints.
-- `DISABLE_STAC` (bool): disable `/stac` endpoints.
-- `DISABLE_MOSAIC` (bool): disable `/mosaic` endpoints.
-- `LOWER_CASE_QUERY_PARAMETERS` (bool): transform all query-parameters to lower case (see https://github.com/developmentseed/titiler/pull/321).
-
-## Customized, minimal app
-
-`TiTiler` has been developed so users can build their own app using only the portions they need. Using [TilerFactories](advanced/tiler_factories.md), users can create a fully customized application with only the endpoints needed.
-
-When building a custom application, you may wish to only install the `core` and/or `mosaic` modules. To install these from PyPI:
-
-```bash
-# Update pip
-python -m pip install -U pip
-
-# Install titiler.core and uvicorn packages
-python -m pip install titiler.core uvicorn
-```
-
-These can then be used like:
-
-```py
-# app.py
-import uvicorn
-from titiler.core.factory import TilerFactory
-from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
-
-from fastapi import FastAPI
-
-app = FastAPI()
-cog = TilerFactory()
-app.include_router(cog.router)
-add_exception_handlers(app, DEFAULT_STATUS_CODES)
-
-
-if __name__ == '__main__':
-    uvicorn.run(app=app, host="127.0.0.1", port=8080, log_level="info")
-```
-
-![](img/custom_app.png)
-
-## Extending TiTiler's app
-
-If you want to include all of Titiler's built-in endpoints, but also include
-customized endpoints, you can import and extend the app directly.
-
-```bash
-python -m pip install titiler.application uvicorn # also installs titiler.core and titiler.mosaic
-```
-
-These can then be used like:
-
-
-```py
-# Add private COG endpoints requiring token validation
-from fastapi import APIRouter, Depends, HTTPException, Security
-from fastapi.security.api_key import APIKeyQuery
-
-from titiler.application.main import app
-from titiler.core.factory import TilerFactory
-
-
-api_key_query = APIKeyQuery(name="access_token", auto_error=False)
-
-
-def token_validation(access_token: str = Security(api_key_query)):
-    """stupid token validation."""
-    if not access_token:
-        raise HTTPException(status_code=403, detail="Missing `access_token`")
-
-    # if access_token == `token` then OK
-    if not access_token == "token":
-        raise HTTPException(status_code=403, detail="Invalid `access_token`")
-
-    return True
-
-
-# Custom router with token dependency
-router = APIRouter(dependencies=[Depends(token_validation)])
-tiler = TilerFactory(router_prefix="private/cog", router=router)
-
-app.include_router(tiler.router, prefix="/private/cog", tags=["Private"])
-
-
-if __name__ == '__main__':
-    uvicorn.run(app=app, host="127.0.0.1", port=8080, log_level="info")
-```
-
-More on [customization](advanced/customization.md)
diff --git a/docs/src/migrations/v1_migration.md b/docs/src/migrations/v1_migration.md
new file mode 100644
index 000000000..ab85ff18a
--- /dev/null
+++ b/docs/src/migrations/v1_migration.md
@@ -0,0 +1,282 @@
+# Migration Guide: TiTiler 0.26 to 1.0
+
+This guide covers the breaking changes and new features when upgrading from TiTiler 0.26 to 1.0.
+
+## Breaking Changes
+
+### Data Type Changes
+
+#### UINT8 Output for JPEG/PNG
+
+**Impact:** High - Affects all automatic image format outputs
+
+When no output format is explicitly specified, TiTiler now returns `UINT8` datatype for JPEG and PNG formats.
+
+```python
+# If your data needs specific datatypes, explicitly specify the format
+# Example: Request with explicit format control
+# In this case, if the input data is in uint16, the ouput png will be in UINT16
+response = requests.get("/tiles/1/2/3.png?url=data_in_uint16.tif")
+```
+
+**Action Required:** Review your endpoints that rely on automatic format detection. If you need specific data type handling, consider explicitly specifying the output format and rescaling parameters.
+
+### WMTS Changes
+
+#### WMTS Endpoint Restructuring
+
+**Impact:** High - Affects all WMTS usage
+
+The `/{tileMatrixSetId}/WMTSCapabilities.xml` endpoints have been removed from the default factories. WMTS functionality is now provided through a dedicated extension.
+
+```python
+# Before (0.26)
+# WMTS available at: /{tileMatrixSetId}/WMTSCapabilities.xml
+
+# Now (1.0)
+from titiler.extensions import wmtsExtension
+
+# Add extension to factory
+factory = TilerFactory(
+    router_prefix="/cog",
+    extensions=[wmtsExtension()]
+)
+
+# WMTS now available at: /WMTSCapabilities.xml
+```
+
+Additionally, the WMTS response now supports all TileMatrixSets as separate layers.
+
+**Action Required:**
+1. Add `wmtsExtension` to your factory configurations
+2. Update client applications to use the new `/WMTSCapabilities.xml` endpoint path
+3. Update any code that expects a single layer to handle multiple TileMatrixSets
+
+### titiler.core Changes
+
+#### Point Endpoint Response Model
+
+**Impact:** Medium - Affects `/point` endpoint consumers
+
+The `/point` endpoint now includes a `band_description` attribute in its response model.
+
+```python
+# Before (0.26)
+class Point(BaseModel):
+    coordinates: List[float]
+    values: List[Optional[float]]
+    # ... other fields
+
+# Now (1.0)
+class Point(BaseModel):
+    coordinates: List[float]
+    values: List[Optional[float]]
+    band_description: List[str] | None  # New field
+    # ... other fields
+```
+
+**Action Required:** Update client code that parses `/point` responses to handle the new `band_description` field.
+
+### titiler.mosaic Changes
+
+#### Point Endpoint Response Restructuring
+
+**Impact:** High - Affects mosaic `/point` endpoint consumers
+
+The response model for the mosaic `/point` endpoint has been completely restructured for better clarity.
+
+```python
+# Before (0.26)
+class Point(BaseModel):
+    coordinates: List[float]
+    values: List[Tuple[str, List[Optional[float]], List[str]]]
+
+# Now (1.0)
+class AssetPoint(BaseModel):
+    name: str
+    values: list[float | None]
+    band_names: list[str]
+    band_descriptions: list[str] | None = None
+
+class Point(BaseModel):
+    coordinates: list[float]
+    assets: list[AssetPoint]
+```
+
+**Migration Example:**
+```python
+# Before (0.26)
+response = {
+    "coordinates": [-122.5, 37.5],
+    "values": [
+        ("asset1", [100.0, 200.0], ["B1", "B2"]),
+        ("asset2", [150.0, 250.0], ["B1", "B2"])
+    ]
+}
+
+# Now (1.0)
+response = {
+    "coordinates": [-122.5, 37.5],
+    "assets": [
+        {
+            "name": "asset1",
+            "values": [100.0, 200.0],
+            "band_names": ["B1", "B2"],
+            "band_descriptions": None
+        },
+        {
+            "name": "asset2",
+            "values": [150.0, 250.0],
+            "band_names": ["B1", "B2"],
+            "band_descriptions": None
+        }
+    ]
+}
+```
+
+**Action Required:** Update all client code that parses mosaic `/point` responses to use the new structure.
+
+#### MosaicJSON Dependency Now Optional
+
+**Impact:** Medium - Affects installations and imports
+
+The `cogeo-mosaic` package is now an optional dependency.
+
+```bash
+# Before (0.26)
+pip install titiler.mosaic
+
+# Now (1.0) - Install with MosaicJSON support
+pip install "titiler.mosaic[mosaicjson]"
+```
+
+**Action Required:** Update your installation commands if you use MosaicJSON functionality.
+
+#### Backend Attribute No Longer Has Default
+
+**Impact:** High - Affects custom mosaic implementations
+
+The `MosaicTilerFactory.backend` attribute no longer has a default value and must be explicitly specified.
+
+```python
+# Before (0.26)
+# Backend had a default value
+factory = MosaicTilerFactory()
+
+# Now (1.0)
+# Must explicitly set backend
+from titiler.mosaic.backends import MosaicBackend
+
+factory = MosaicTilerFactory(
+    backend=MosaicBackend
+)
+```
+
+**Action Required:** Explicitly set the `backend` attribute when creating `MosaicTilerFactory` instances.
+
+#### MosaicJSON Endpoints Moved to Extension
+
+**Impact:** Medium - Affects mosaic endpoint structure
+
+The `/` and `/validate` endpoints are now provided by the `MosaicJSONExtension` instead of being included by default.
+
+```python
+# Before (0.26)
+# Endpoints available by default
+factory = MosaicTilerFactory()
+
+# Now (1.0)
+from titiler.mosaic.extensions import MosaicJSONExtension
+
+factory = MosaicTilerFactory(
+    extensions=[MosaicJSONExtension()]
+)
+```
+
+**Action Required:** Add `MosaicJSONExtension` to your factory if you need the `/` and `/validate` endpoints.
+
+### titiler.extensions Changes
+
+#### rio-cogeo Version Update
+
+**Impact:** Low - Dependency version change
+
+The `rio-cogeo` requirement has been updated to `7.0,<8.0`.
+
+**Action Required:** Review the [rio-cogeo changelog](https://github.com/cogeotiff/rio-cogeo/blob/main/CHANGES.md) for any breaking changes that might affect your usage.
+
+## New Features
+
+### titiler.mosaic
+
+#### New Optional Endpoints
+
+Three new optional endpoints are available for mosaic operations:
+
+- `/feature` - Feature-based queries
+- `/bbox` - Bounding box queries
+- `/statistics` - Statistical analysis
+
+```python
+# Enable in your factory
+factory = MosaicTilerFactory(
+    add_feature=True,  # Enables /feature endpoint
+    add_bbox=True,     # Enables /bbox endpoint
+    add_statistics=True # Enables /statistics endpoint
+)
+```
+
+#### WMTS Extension for Mosaics
+
+A dedicated WMTS extension is now available for mosaic factories:
+
+```python
+from titiler.mosaic.extensions import wmtsExtension
+
+factory = MosaicTilerFactory(
+    extensions=[wmtsExtension()]
+)
+```
+
+#### OGC Maps API Support
+
+Optional OGC Maps API `/map` endpoint is now available:
+
+```python
+factory = MosaicTilerFactory(
+    add_map=True  # Enables /map endpoint
+)
+```
+
+## Dependency Updates
+
+### Core Dependencies
+
+- `rio-tiler`: Updated to `>=8.0,<9.0`
+- `rio-cogeo`: Updated to `7.0,<8.0`
+
+**Action Required:** Test your application with the new versions and review their respective changelogs for any behavioral changes.
+
+## Migration Checklist
+
+Use this checklist to ensure a smooth migration:
+
+- [ ] Update WMTS usage to use the new `wmtsExtension`
+- [ ] Update client code parsing `/point` responses (both core and mosaic)
+- [ ] Explicitly set `backend` attribute for `MosaicTilerFactory`
+- [ ] Add `MosaicJSONExtension` if using MosaicJSON endpoints
+- [ ] Update installation to include `[mosaicjson]` extra if needed
+- [ ] Review and test automatic image format outputs (UINT8 behavior)
+- [ ] Update dependency versions: `rio-tiler` and `rio-cogeo`
+- [ ] Test with new Python 3.11+ requirement (from 0.25)
+- [ ] Update any hardcoded WMTS endpoint paths in client applications
+- [ ] Consider adopting new optional endpoints (`/feature`, `/bbox`, `/statistics`)
+- [ ] Review OGC Maps API support for your use cases
+
+## Getting Help
+
+If you encounter issues during migration:
+
+1. Check the [GitHub Issues](https://github.com/developmentseed/titiler/issues)
+2. Review the [full CHANGELOG](https://github.com/developmentseed/titiler/blob/main/CHANGES.md)
+3. Join the discussions in the [TiTiler repository](https://github.com/developmentseed/titiler)
diff --git a/docs/src/migrations/v2_migration.md b/docs/src/migrations/v2_migration.md
new file mode 100644
index 000000000..9cc460366
--- /dev/null
+++ b/docs/src/migrations/v2_migration.md
@@ -0,0 +1,243 @@
+# Migrating from TiTiler 1.x to 2.0
+
+!!! note
+
+    This migration guide was generated with the help of Claude AI
+
+
+This document describes the breaking changes and migration steps required when upgrading from TiTiler 1.1.1 to 2.0.0.
+
+## Overview
+
+TiTiler 2.0.0 introduces several breaking changes primarily focused on:
+
+1. **Tile sizing**: Replaced `tile_scale` with direct `tilesize` parameter
+2. **Dependency simplification**: changed per-asset band indexes (`bidx`) option for multi-asset readers
+3. **rio-tiler 9.0 compatibility**: Removed `MultiBandTilerFactory` and related classes
+
+## Breaking Changes
+
+### 1. Tile Size Parameter Changes
+
+#### Removed: `tile_scale` and `@{scale}x` suffix
+
+The `tile_scale` parameter and `@{scale}x` URL suffix have been removed from all endpoints.
+
+**Before (1.x):**
+```
+GET /tiles/WebMercatorQuad/10/512/384@2x.png?url=...
+GET /tilejson.json?url=...&tile_scale=2
+GET /map.html?url=...&tile_scale=2
+GET /WMTSCapabilities.xml?url=...&tile_scale=2
+```
+
+**After (2.0):**
+```
+GET /tiles/WebMercatorQuad/10/512/384.png?url=...&tilesize=512
+GET /tilejson.json?url=...&tilesize=512
+GET /map.html?url=...&tilesize=256
+GET /WMTSCapabilities.xml?url=...  # can't overwrite tilesize anymore
+```
+
+#### New: `tilesize` query parameter
+
+A new `tilesize` query parameter is available for tile and tilejson endpoints:
+
+| Endpoint | Old Default | New Default |
+|----------|-------------|-------------|
+| `/tiles/{tms}/{z}/{x}/{y}` | 256x256 (scale=1) | TileMatrix's `tileHeight x tileWidth` |
+| `/tilejson.json` | 256 | 512 |
+| `/map.html` | 256 | 256 |
+
+**Migration Steps:**
+1. Replace `@2x` suffix with `tilesize=512` query parameter
+2. Replace `@4x` suffix with `tilesize=1024` query parameter
+3. Replace `tile_scale=N` with `tilesize=N*256` query parameter
+4. Update any client code that constructs tile URLs with scale suffix
+
+### 2. Dependency Class Renames
+
+Several dependency classes have been renamed to reflect their simplified functionality.
+
+#### Renamed Classes
+
+| Old Name (1.x) | New Name (2.0) |
+|----------------|----------------|
+| `AssetsBidxExprParams` | `AssetsExprParams` |
+
+**Migration Steps:**
+```python
+# Before (1.x)
+from titiler.core.dependencies import AssetsBidxExprParams, AssetsBidxExprParamsOptional
+
+# After (2.0)
+from titiler.core.dependencies import AssetsExprParams
+```
+
+#### Removed Classes
+
+The following classes have been removed entirely:
+
+- `titiler.core.dependencies.AssetsBidxParams`
+- `titiler.core.dependencies.BandsParams`
+- `titiler.core.dependencies.BandsExprParamsOptional`
+- `titiler.core.dependencies.BandsExprParams`
+
+**Migration Steps:**
+
+If you were using `BandsParams` or `BandsExprParams` with a custom `MultiBandReader`:
+- Consider migrating to a `MultiBaseReader` approach with assets
+- Or use expressions to select specific bands
+
+### 3. Removed Functions
+
+The following functions have been removed:
+
+- `titiler.core.dependencies.parse_asset_indexes()`
+- `titiler.core.dependencies.parse_asset_expression()`
+
+These were used internally for parsing `asset_indexes` and `asset_expression` query parameters.
+
+### 4. Removed: `MultiBandTilerFactory`
+
+The `MultiBandTilerFactory` class has been completely removed because `MultiBandReader` is no longer available in rio-tiler 9.0.
+
+**Before (1.x):**
+```python
+from titiler.core.factory import MultiBandTilerFactory
+from rio_tiler.io import MultiBandReader
+
+class MyBandReader(MultiBandReader):
+    ...
+
+tiler = MultiBandTilerFactory(reader=MyBandReader)
+```
+
+**Migration Steps:**
+
+1. Convert your `MultiBandReader` to a `MultiBaseReader` that exposes bands as assets
+2. Use `MultiBaseTilerFactory` instead
+
+```python
+# After (2.0)
+from titiler.core.factory import MultiBaseTilerFactory
+from rio_tiler.io import MultiBaseReader
+
+class MyAssetReader(MultiBaseReader):
+    # Expose bands as assets
+    ...
+
+tiler = MultiBaseTilerFactory(reader=MyAssetReader)
+```
+
+### 5. `assets` parameter is mandatory for MultiBaseReader
+
+##### Info and statistics
+
+`/info` and `/statistics` endpoints now require `assets=` parameter to be set. Users can use special notation `assets=:all:` to get info/statistics for all assets.
+
+**Before (1.x):**
+```
+GET /stac/info?url=...
+```
+
+**After (2.0):**
+
+```
+GET /stac/info?url=...&assets=:all:
+```
+
+##### Expression 
+
+The `expression` parameter cannot be used to define `assets` and thus `assets` parameter must be provided.
+
+**Before (1.x):**
+```
+GET /stac/tiles/WebMercatorQuad/10/512/384.png?url=...&expression=B02_b1+B03_b1
+```
+
+**After (2.0):**
+
+```
+GET /stac/tiles/WebMercatorQuad/10/512/384.png?url=...&assets=B02&assets=B03&expression=b1+b2
+```
+
+### 6. `bidx` Parameter Ignored for MultiBaseReader
+
+The `bidx` (band index) parameter is now **ignored** by `MultiBaseTilerFactory` endpoints. Previously, you could use `bidx` to select bands across all assets.
+
+**Before (1.x):**
+```
+GET /stac/tiles/WebMercatorQuad/10/512/384.png?url=...&assets=B02&assets=B03&bidx=1
+```
+
+**After (2.0):**
+
+Use new `asset` notation: `assets={AssetName}|bidx=1,2,3`
+
+```
+GET /stac/tiles/WebMercatorQuad/10/512/384.png?url=...&assets=B02|bidx=1&assets=B03|bidx=1
+```
+
+### 7. Removed: `asset_indexes` and `asset_expression` Options
+
+The `asset_indexes` and `asset_expression` query parameters have been removed from `dependencies.py`.
+
+**Before (1.x):**
+```
+GET /stac/preview.png?url=...&asset_indexes=data|1,2,3
+GET /stac/preview.png?url=...&asset_expression=data|b1*b2
+```
+
+**After (2.0):**
+
+Use new `asset` notation: `assets={AssetName}|bidx=1,2,3` or `assets={AssetName}|expression=b1*2`
+
+```
+GET /stac/preview.png?url=...&assets=B01|bidx=1,2,3
+GET /stac/preview.png?url=...&assets=B01|expression=b1*2
+```
+
+### 8. Extension Changes
+
+#### COG and STAC Viewers
+
+The `cogViewerExtension` and `stacViewerExtension` now force `tilesize=256` in their tile requests.
+
+#### WMTS Capabilities
+
+The `tile_scale` parameter has been removed from `/WMTSCapabilities.xml` endpoints in both `titiler.extensions` and `titiler.mosaic`.
+
+## API Endpoint Changes Summary
+
+| Endpoint Pattern | Change |
+|-----------------|--------|
+| `/tiles/{tms}/{z}/{x}/{y}@{scale}x` | **Removed** - Use `tilesize` query param |
+| `/tiles/{tms}/{z}/{x}/{y}@{scale}x.{format}` | **Removed** - Use `tilesize` query param |
+| `/tilejson.json?tile_scale=N` | **Removed** - Use `tilesize=N*256` |
+| `/map.html?tile_scale=N` | **Removed** - Use `tilesize=N*256` |
+| `/WMTSCapabilities.xml?tile_scale=N` | **Removed** |
+
+## Code Migration Checklist
+
+- [ ] Replace all `@{scale}x` tile URL suffixes with `tilesize` parameter
+- [ ] Replace `tile_scale` query parameter with `tilesize`
+- [ ] Update imports: `AssetsBidxExprParams` → `AssetsExprParams`
+- [ ] Remove usage of `AssetsBidxParams`, `BandsParams`, `BandsExprParams`, `BandsExprParamsOptional`
+- [ ] Migrate `MultiBandTilerFactory` usage to `MultiBaseTilerFactory`
+- [ ] Remove `bidx` parameter from multi-asset requests (use `expression` instead)
+- [ ] Remove `asset_indexes` and `asset_expression` parameters
+- [ ] Use `assets=:all:` for `/info` and `/statistics` endpoints for `MultiBaseTilerFactory`
+
+## Dependency Updates
+
+TiTiler 2.0 requires:
+- rio-tiler >= 9.0
+
+Make sure to update your `pyproject.toml` accordingly.
+
+## Need Help?
+
+If you encounter issues during migration:
+- Check the [CHANGES.md](https://github.com/developmentseed/titiler/blob/main/CHANGES.md) for detailed release notes
+- Open an issue at [https://github.com/developmentseed/titiler/issues](https://github.com/developmentseed/titiler/issues)
diff --git a/docs/src/mosaics.md b/docs/src/mosaics.md
deleted file mode 100644
index 1695bca95..000000000
--- a/docs/src/mosaics.md
+++ /dev/null
@@ -1,16 +0,0 @@
-
-[Work in Progress]
-
-![](img/africa_mosaic.png)
-
-`Titiler` has native support for reading and creating web map tiles from **MosaicJSON**.
-
-> MosaicJSON is an open standard for representing metadata about a mosaic of Cloud-Optimized GeoTIFF (COG) files.
-
-Ref: https://github.com/developmentseed/mosaicjson-spec
-
-
-### Links
-
-- https://medium.com/devseed/cog-talk-part-2-mosaics-bbbf474e66df
-- https://github.com/developmentseed/cogeo-mosaic
diff --git a/docs/src/overrides/partials/integrations/analytics/plausible.html b/docs/src/overrides/partials/integrations/analytics/plausible.html
new file mode 100644
index 000000000..6be309101
--- /dev/null
+++ b/docs/src/overrides/partials/integrations/analytics/plausible.html
@@ -0,0 +1,46 @@
+<script async src="https://plausible.io/js/pa-R2Q1HtPCYFGHi3KhWj03p.js"></script>
+
+<!-- Vendored from https://gitlab.com/notpushkin/material-plausible-plugin/ under the BSD 0 clause license. -->
+<script>
+  window.plausible=window.plausible||function(){(plausible.q=plausible.q||[]).push(arguments)},plausible.init=plausible.init||function(i){plausible.o=i||{}};
+  plausible.init()
+
+  /* Register event handlers after documented loaded */
+  document.addEventListener("DOMContentLoaded", function () {
+    /* Set up search tracking */
+    if (document.forms.search) {
+      var query = document.forms.search.query;
+      query.addEventListener("blur", function () {
+        if (this.value)
+          plausible("Search", { props: { search_term: this.value } });
+      });
+    }
+
+    /* Set up feedback, i.e. "Was this page helpful?" */
+    document$.subscribe(function () {
+      var feedback = document.forms.feedback;
+      if (typeof feedback === "undefined") return;
+
+      /* Send feedback to Plausible */
+      for (var button of feedback.querySelectorAll("[type=submit]")) {
+        button.addEventListener("click", function (ev) {
+          ev.preventDefault();
+
+          var page = document.location.pathname;
+          var value = this.getAttribute("data-md-value");
+          plausible(`Feedback: ${value}`);
+
+          /* Disable form and show note, if given */
+          feedback.firstElementChild.disabled = true;
+          var note = feedback.querySelector(
+            ".md-feedback__note [data-md-value='" + value + "']"
+          );
+          if (note) note.hidden = false;
+        });
+
+        /* Show feedback */
+        feedback.hidden = false;
+      }
+    });
+  });
+</script>
diff --git a/docs/src/packages/application.md b/docs/src/packages/application.md
new file mode 120000
index 000000000..9f698a377
--- /dev/null
+++ b/docs/src/packages/application.md
@@ -0,0 +1 @@
+../../../src/titiler/application/README.md
\ No newline at end of file
diff --git a/docs/src/packages/core.md b/docs/src/packages/core.md
new file mode 120000
index 000000000..fff7ecdd5
--- /dev/null
+++ b/docs/src/packages/core.md
@@ -0,0 +1 @@
+../../../src/titiler/core/README.md
\ No newline at end of file
diff --git a/docs/src/packages/extensions.md b/docs/src/packages/extensions.md
new file mode 120000
index 000000000..6fcc9e3d1
--- /dev/null
+++ b/docs/src/packages/extensions.md
@@ -0,0 +1 @@
+../../../src/titiler/extensions/README.md
\ No newline at end of file
diff --git a/docs/src/packages/mosaic.md b/docs/src/packages/mosaic.md
new file mode 120000
index 000000000..cf87cb31c
--- /dev/null
+++ b/docs/src/packages/mosaic.md
@@ -0,0 +1 @@
+../../../src/titiler/mosaic/README.md
\ No newline at end of file
diff --git a/docs/src/packages/xarray.md b/docs/src/packages/xarray.md
new file mode 120000
index 000000000..dc85e70b9
--- /dev/null
+++ b/docs/src/packages/xarray.md
@@ -0,0 +1 @@
+../../../src/titiler/xarray/README.md
\ No newline at end of file
diff --git a/docs/src/security.md b/docs/src/security.md
new file mode 120000
index 000000000..42cce94fd
--- /dev/null
+++ b/docs/src/security.md
@@ -0,0 +1 @@
+../../SECURITY.md
\ No newline at end of file
diff --git a/docs/src/advanced/Algorithms.md b/docs/src/user_guide/algorithms.md
similarity index 76%
rename from docs/src/advanced/Algorithms.md
rename to docs/src/user_guide/algorithms.md
index eb823e9fb..4d0ec8a7d 100644
--- a/docs/src/advanced/Algorithms.md
+++ b/docs/src/user_guide/algorithms.md
@@ -6,11 +6,25 @@ The algorithms are meant to overcome the limitation of `expression` (using [nume
 
 We added a set of custom algorithms:
 
-- `hillshade`: Create hillshade from elevation dataset
-- `contours`: Create contours lines (raster) from elevation dataset
-- `terrarium`: Mapzen's format to encode elevation value in RGB values (https://github.com/tilezen/joerd/blob/master/docs/formats.md#terrarium)
-- `terrainrgb`: Mapbox's format to encode elevation value in RGB values (https://docs.mapbox.com/data/tilesets/guides/access-elevation-data/)
+- `hillshade`: Create hillshade from elevation dataset (parameters: azimuth (45), angle_altitude(45))
+- `contours`: Create contours lines (raster) from elevation dataset (parameters: increment (35), thickness (1))
+- `slope`: Create degrees of slope from elevation dataset
+- `terrarium`: [Mapzen's format](https://github.com/tilezen/joerd/blob/master/docs/formats.md#terrarium) to encode elevation value in RGB values  `elevation = (red * 256 + green + blue / 256) - 32768`
+- `terrainrgb`: [Mapbox](https://docs.mapbox.com/data/tilesets/guides/access-elevation-data/)/[Maptiler](https://docs.maptiler.com/guides/map-tilling-hosting/data-hosting/rgb-terrain-by-maptiler/)'s format to encode elevation value in RGB values `elevation = -10000 + ((red * 256 * 256 + green * 256 + blue) * 0.1)`
 - `normalizedIndex`: Normalized Difference Index (e.g NDVI)
+- `cast`: Cast data to integer
+- `floor`: Round data to the smallest integer
+- `ceil`: Round data to the largest integer
+
+- `min`: Return **Min** values along the `bands` axis.
+- `max`: Return **Max** values along the `bands` axis.
+- `median`: Return **Median** values along the `bands` axis.
+- `mean`: Return **Mean** values along the `bands` axis.
+- `std`: Return the **Standard Deviation** along the `bands` axis.
+- `var`: Return **Variance** along the `bands` axis.
+- `sum`: Return **Sum** along the `bands` axis.
+- `grayscale`: Return a **grayscale** version of an image using ITU-R 601-2 luma transformation.
+- `bitonal`: All values larger than 127 are set to 255 (white), all other values to 0 (black).
 
 ### Usage
 
@@ -78,7 +92,7 @@ This base class defines that algorithm:
 
 - can have`parameters` (enabled by `extra = "allow"` pydantic config)
 
-Here is a simple example of a custom Algorithm:
+Here is a simple example of a custom algorithm:
 
 ```python
 from titiler.core.algorithm import BaseAlgorithm
@@ -109,7 +123,7 @@ class Multiply(BaseAlgorithm):
 
 Using a Pydantic's `BaseModel` class to construct the custom algorithm enables two things **parametrization** and **type casting/validation**.
 
-If we look at the `Multiply` algorithm, we can see it needs a `factor` parameter. In Titiler (in the post_process dependency) we will pass this parameter via query string (e.g `/preview.png?algo=multiply&algo_parameter={"factor":3}`) and pydantic will make sure we use the right types/values.
+If we look at the `Multiply` algorithm, we can see it needs a `factor` parameter. In TiTiler (in the post_process dependency) we will pass this parameter via query string (e.g `/preview.png?algo=multiply&algo_parameter={"factor":3}`) and pydantic will make sure we use the right types/values.
 
 ```python
 # Available algorithm
@@ -131,7 +145,7 @@ def post_process_dependency(
 
 ## Dependency
 
-To be able to use your own algorithm in titiler's endpoint you need to create a `Dependency` to tell the application what algorithm are available.
+To be able to use your own algorithm in TiTiler's endpoint, you need to create a `Dependency` to tell the application which algorithms are available.
 
 To ease the dependency creation, we added a `dependency` property in the `titiler.core.algorithm.Algorithms` class, which will return a FastAPI dependency to be added to the endpoints.
 
@@ -154,7 +168,7 @@ endpoints = TilerFactory(process_dependency=PostProcessParams)
 
 ### Order of operation
 
-When creating a map tile (or other images), we will fist apply the `algorithm` then the `rescaling` and finally the `color_formula`.
+When creating a map tile (or other images), we will first apply the `algorithm`, then the `rescaling`, and finally the `color_formula`.
 
 ```python
 with reader(url as src_dst:
diff --git a/docs/src/dynamic_tiling.md b/docs/src/user_guide/dynamic_tiling.md
similarity index 82%
rename from docs/src/dynamic_tiling.md
rename to docs/src/user_guide/dynamic_tiling.md
index 15b9ebaf6..7b96a25a1 100644
--- a/docs/src/dynamic_tiling.md
+++ b/docs/src/user_guide/dynamic_tiling.md
@@ -5,9 +5,9 @@
 
 TiTiler's first goal is to create a lightweight but performant dynamic tile server... but what do we mean by this?
 
-When you zoom/pan on a web map, you are visualizing either vector or raster data that is loaded by your web client (e.g Chrome). Vector Tiles are rendered **On the Fly**, meaning the map library (e.g MapboxGL) will apply styling on the vector it receives to create a visual representation on the map. This is possible because vector data can be encoded and compressed very efficiently and result in each tile being only couple of kilo octets.
+When you zoom/pan on a web map, you are visualizing either vector or raster data that is loaded by your web client (e.g Chrome). Vector Tiles are rendered **On the Fly**, meaning the map library (e.g Mapbox GL-JS) will apply the styling on the vector it receives to create a visual representation on the map. This is possible because vector data can be encoded and compressed very efficiently and result in each tile being only a couple of kilo octets.
 
-On the other side, raster data is a really dense format, a `256 x 256 x 3` tile (True color image) needs to encode `196 608` values, and depending on the data type (Integer, Float, Complex), a raster tile can be really heavy. Depending on the dataset data type, some operations might be needed in order to obtain a visual representation (e.g. rescaling, colormap, ... ). Map library will almost only accept Uint8 RGB(A) tile encoded as PNG, JPEG or Webp.
+On the other side, raster data is a really dense format, a `256 x 256 x 3` tile (True color image) needs to encode `196 608` values, and depending on the data type (Integer, Float, Complex), a raster tile can be really heavy. Depending on the dataset data type, some operations might be needed in order to obtain a visual representation (e.g. rescaling, colormap, ... ). The map library will almost only accept Uint8 RGB(A) tile encoded as PNG, JPEG or Webp.
 
 ## **Static tiling**
 
@@ -68,9 +68,9 @@ The goal of the `Dynamic Tiling` process is to get rid of all the pre-processing
 
 ## Summary
 
-With `Static` tile generation you are often limited because you are visualizing data that is fixed and stored somewhere on a disk. With `Dynamic tiling`, users have the possibility to apply their own choice of processing (e.g rescaling, masking) before creating the `image`.
+With `Static` tile generation, you are often limited because you are visualizing data that is fixed and stored somewhere on a disk. With `Dynamic tiling`, users have the possibility to apply their own choice of processing (e.g rescaling, masking) before creating the `image`.
 
-Static tiling will always be faster than dynamic tiling, but a cache layer can be set up in front of the dynamic tiler, but using a dynamic tiler often means that same tile won't be serve twice (because users can set multiple options).
+Static tiling will always be faster to load than dynamic tiling, but a cache layer can be set up in front of the dynamic tiler. Using a dynamic tiler often means that the same tile won't be served twice (because users can set multiple options).
 
 ## Links
 [https://medium.com/devseed/cog-talk-part-1-whats-new-941facbcd3d1](https://medium.com/devseed/cog-talk-part-1-whats-new-941facbcd3d1)
diff --git a/docs/src/user_guide/getting_started.md b/docs/src/user_guide/getting_started.md
new file mode 100644
index 000000000..29a1a2118
--- /dev/null
+++ b/docs/src/user_guide/getting_started.md
@@ -0,0 +1,382 @@
+[TiTiler](https://developmentseed.org/titiler) is a modern map tile server that helps developers quickly serve geospatial data on the web. Think of it as a specialized tool that takes large geographic files (like satellite imagery) and slices them into small, web-friendly map tiles that load efficiently in browser-based maps.
+
+Built on FastAPI, TiTiler makes working with Cloud-Optimized GeoTIFFs, Spatio Temporal Asset Catalog and other spatial data formats straightforward, even if you're not a GIS expert. It handles all the complex work of processing geographic data and serving it through simple API endpoints that any web developer can use.
+
+In the past, putting maps on websites was a real pain. Developers had to use bulky tools like GeoServer that were hard to set up, or spend hours making thousands of **static** tiny map images with tools like gdal2tiles that couldn't be changed later. TiTiler makes this so much easier. It creates **dynamic** map pieces right when you need them, instead of making them all beforehand. It works great with modern cloud data and doesn't need complicated setup. This means less headache and more time to focus on building cool map features that users will love.
+
+## Dynamic vs. Static Tiles: What's the Difference?
+
+Static tiles are like pre-printed map pieces stored in folders. Once created, they're locked—changing anything means starting over. They use lots of storage, but load quickly.
+
+TiTiler's dynamic tiles work like a chef cooking to order. When someone views your map, TiTiler grabs just the data needed and creates tiles on the spot. This lets you instantly change colors, adjust contrast, or highlight different features. Your map becomes flexible and responsive, adapting to what users need right now, rather than being stuck with choices made earlier.
+
+More on [Dynamic Tiling](dynamic_tiling.md)
+
+## Let's Get TiTiler Up and Running!
+
+Now that we understand the advantage of TiTiler's dynamic approach, let's get it running on your local machine. Follow these steps:
+
+### **1. Create Your Project Workspace**
+
+First, let's create a dedicated space for our TiTiler project. Open your terminal (Command Prompt or PowerShell on Windows, Terminal on macOS/Linux) and run:
+
+```bash
+# Works on all operating systems
+mkdir Titiler
+cd Titiler
+```
+
+> 💡 **Pro Tip**: Keeping your TiTiler project in its own folder makes it easier to manage and prevents conflicts with other Python projects.
+
+### **2. Set Up a Python Virtual Environment**
+a. Create the virtual environment:
+   ```bash
+   python -m venv titiler
+   ```
+b. Activate the virtual environment:
+   - **For Linux/macOS:**
+     ```bash
+     source titiler/bin/activate
+     ```
+   - **For Windows:**
+     ```bash
+     titiler\Scripts\activate
+     ```
+
+### **3. Install TiTiler and Its Dependencies**
+
+With your environment activated, install TiTiler and the web server it needs:
+
+```bash
+pip install titiler.core uvicorn
+```
+
+> ⚠️  **Warning**: Previously, TiTiler was available via a `titiler` metapackage, but that's no longer the case.
+> In late 2025, we [dropped support for this metapackage](https://github.com/developmentseed/titiler/issues/294).
+
+This command installs the core TiTiler package and Uvicorn, a lightning-fast ASGI server.
+
+> 💡 **What's happening**: TiTiler.core contains the essential functionality for serving map tiles. Uvicorn is the engine that will run our FastAPI application.
+
+### **4. Create Your TiTiler Application**
+
+Now for the fun part! Create a file named `main.py` with the following code:
+
+```python
+from fastapi import FastAPI
+from titiler.core.factory import TilerFactory
+
+from starlette.middleware.cors import CORSMiddleware
+
+app = FastAPI()
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins (for development - be more specific in production)
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Create a TilerFactory for Cloud-Optimized GeoTIFFs
+cog = TilerFactory()
+
+# Register all the COG endpoints automatically
+app.include_router(cog.router, tags=["Cloud Optimized GeoTIFF"])
+
+
+# Optional: Add a welcome message for the root endpoint
+@app.get("/")
+def read_index():
+    return {"message": "Welcome to TiTiler"}
+```
+
+> 💡 **Code Breakdown**:
+>
+> - We create a FastAPI app and add CORS middleware to allow web maps to access our images
+> - The `TilerFactory()` creates all the endpoints needed for serving COG tiles
+> - We include those endpoints in our app with `app.include_router()`
+> - A simple home endpoint provides a welcome message
+
+### **5. Launch Your TiTiler Server**
+
+Run the following command to start the server:
+```bash
+uvicorn main:app --reload
+```
+You should see an output similar to this:
+
+![server logs](../img/server_logs.png)
+
+> 💡 **The `--reload` flag** automatically restarts the server whenever you change your code - perfect for development!
+
+### **6. Explore Your TiTiler API**
+
+Open your browser and go to:
+
+``` http://127.0.0.1:8000/ ``` - See your welcome message
+
+![browser](../img/browser.png)
+
+```  http://127.0.0.1:8000/docs ``` - Explore the interactive API documentation. The `/docs` page is your mission control center. It shows all the endpoints TiTiler created for you and lets you test them directly in your browser:
+
+![api docs](../img/api_docs.png)
+
+## Visualizing Your Geospatial Data
+
+Now that your server is running, let's see what it can do with real data!
+
+### **Quick Preview of Your Raster**
+
+To get a quick preview of any Cloud-Optimized GeoTIFF, use:
+
+```bash
+http://127.0.0.1:8000/preview?url=file:///path_to_your_raster.tif
+```
+> ⚠️ **Note**: Replace the path with the actual path to your COG file. Remember to use the full path for local files.
+
+## Visualizing a Specific Tile (Z, X, Y)
+
+When working with web maps, understanding tile coordinates is essential. Let's break down what Z, X, Y values mean:
+
+- **Z (zoom level)**: How far in/out you're zoomed. Lower numbers (0-5) show the whole world with less detail; higher numbers (15-22) show smaller areas with more detail.
+- **X (column)**: Horizontal position, increasing eastward.
+- **Y (row)**: Vertical position, increasing southward.
+
+At zoom level 0, there's just 1 tile for the whole world. Each zoom level increase splits each tile into 4 more detailed tiles.
+
+### **Why Visualize Specific Tiles?**
+
+- **Performance**: Load only what users can see
+- **Debugging**: Inspect problematic tiles
+- **Specific Analysis**: Extract data from exact locations
+
+### **Finding Z, X, Y for Your Image**
+
+The `rio_tiler` and `morecantile` library makes this straightforward:
+
+```python
+from rio_tiler.io import Reader
+import morecantile
+
+# Web Mercator is the default tiling scheme for most web map clients
+WEB_MERCATOR_TMS = morecantile.tms.get("WebMercatorQuad")
+
+with Reader('/path/to/your/raster.tif', tms=WEB_MERCATOR_TMS) as src:
+    bbox = src.get_geographic_bounds("epsg:4326")
+    zoom = 15
+    # Find all tiles covering the bounding box
+    tiles = list(src.tms.tiles(bbox[0], bbox[1], bbox[2], bbox[3], zoom))
+    for t in tiles:
+        print("Tile coordinate (x, y, z):", t.x, t.y, t.z)
+```
+
+### **Viewing a Specific Tile in TiTiler**
+
+For example, if your tile has coordinates `x=5412, y=12463, z=15`, you would access the specific tile with:
+
+```bash
+http://127.0.0.1:8000/tiles/WebMercatorQuad/15/5412/12463.png?url=raster.tif
+```
+
+URL components explained:
+
+- **`WebMercatorQuad/`**: The tiling scheme (this should match your raster's CRS - TiTiler will reproject on-the-fly if needed, but using the correct scheme improves performance and accuracy)
+- **`{z}/{x}/{y}`**: Your tile coordinates
+- **`.png`**: Output format (alternatives: `.jpg`, `.webp`, `.tif`)
+- **`?url=raster.tif`**: Source raster file
+
+More on [Tiling Schemes](tile_matrix_sets.md)
+
+### **Creating a Web Map with Leaflet**
+
+[Leaflet](https://leafletjs.com/) is a lightweight, open-source JavaScript library for interactive maps. It lets you combine base maps (like OpenStreetMap) with overlays from custom tile servers such as TiTiler.
+
+The following code (in **map.html**) loads a base map, adds your TiTiler raster overlay, and automatically sets the map's view to the raster's bounds:
+
+---
+
+<details>
+  <summary><strong>map.html Code</strong></summary>
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Leaflet Basemap + TiTiler Raster Overlay</title>
+  <meta charset="utf-8">
+  <meta name="viewport" content="initial-scale=1.0">
+  <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
+  <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
+</head>
+<body>
+  <div id="map" style="width: 100%; height: 600px;"></div>
+  <script>
+    // Initialize the map with OpenStreetMap as the basemap
+    var map = L.map('map').setView([0, 0], 2);
+    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+      maxZoom: 19,
+      attribution: '&copy; OpenStreetMap contributors'
+    }).addTo(map);
+
+    /// Define the local raster path and TiTiler endpoint
+    // Replace with your own full GeoTIFF path - use the appropriate format for your OS.
+    var rasterPath = 'file:///path_to_your_raster.tif';
+
+    // Fetch the raster's bounding box from TiTiler and adjust the map view accordingly
+    var tileJSONUrl = 'http://127.0.0.1:8000/WebMercatorQuad/tilejson.json?url=' + encodeURIComponent(rasterPath) + "&tilesize=256";
+    console.log(tileJSONUrl)
+    fetch(tileJSONUrl)
+      .then(response => response.json())
+      .then(data => {
+        console.log("Bounds data:", data.bounds);
+        if (data && data.bounds) {
+          // data.bounds is [minX, minY, maxX, maxY]
+          var b = data.bounds;
+          // Convert to Leaflet bounds: [[southWest_lat, southWest_lng], [northEast_lat, northEast_lng]]
+          var leafletBounds = [[b[1], b[0]], [b[3], b[2]]];
+          map.fitBounds(leafletBounds);
+
+          // Add the TiTiler raster overlay with some transparency
+          L.tileLayer(data.tiles[0], {
+            tileSize: 256,
+            opacity: 0.7,
+            maxZoom: data.maxzoom
+          }).addTo(map);
+
+        } else {
+          console.error("No bounds returned from TiTiler.");
+        }
+      })
+      .catch(error => console.error("Error fetching bounds:", error));
+
+  </script>
+</body>
+</html>
+```
+</details>
+
+---
+
+## Troubleshooting Common Issues
+
+### **CORS Issues**
+
+If you encounter "Access to fetch at X has been blocked by CORS policy" errors in your browser console, make sure you:
+
+- Have included the CORS middleware in `main.py` as shown above
+- Restart your TiTiler server after making changes
+
+### **File Not Found Errors**
+
+When using `file:///` URLs:
+- Make sure to use the absolute path to your file with the correct format for your operating system:
+
+  - Windows: `file:///C:/Users/username/data/image.tif`
+  - macOS: `file:///Users/username/data/image.tif`
+  - Linux: `file:///home/username/data/image.tif`
+
+### **No Tiles Showing**
+
+If your map loads but your tiles don't appear:
+
+- Check the browser console for errors
+- Verify that your GeoTIFF is Cloud-Optimized (use `rio cogeo validate` from the rio-cogeo package)
+- Try different zoom levels - your data might not be visible at all scales
+
+---
+*Created by [Dimple Jain](https://jaiindimple.github.io)*
+
+
+## Default Application
+
+`TiTiler` comes with a default (complete) application with support for COG, STAC, and MosaicJSON. You can install and start the application locally by doing:
+
+```bash
+# Update pip
+python -m pip install -U pip
+
+# Install titiler packages
+python -m pip install uvicorn titiler.application
+
+# Start application using uvicorn
+uvicorn titiler.application.main:app
+
+> INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+See the default endpoints documentation pages:
+
+* [`/cog` - Cloud Optimized GeoTIFF](../endpoints/cog.md)
+* [`/mosaicjson` - MosaicJSON](../endpoints/mosaic.md)
+* [`/stac` - Spatio Temporal Asset Catalog](../endpoints/stac.md)
+* [`/tileMatrixSets` - Tiling Schemes](../endpoints/tms.md)
+* [`/algorithms` - Algorithms](../endpoints/algorithms.md)
+* [`/colorMaps` - ColorMaps](../endpoints/colormaps.md)
+
+#### Settings
+
+The default application can be customized using environment variables defined in `titiler.application.settings.ApiSettings` class. Each variable needs to be prefixed with `TITILER_API_`.
+
+- `NAME` (str): name of the application. Defaults to `titiler`.
+- `CORS_ORIGINS` (str, `,` delimited origins): allowed CORS origin. Defaults to `*`.
+- `CORS_ALLOW_METHODS` (str, `,` delimited methods): allowed CORS methods. Defaults to `GET`.
+- `CACHECONTROL` (str): Cache control header to add to responses. Defaults to `"public, max-age=3600"`.
+- `ROOT_PATH` (str): path behind proxy.
+- `DEBUG` (str): adds `LoggerMiddleware` and `TotalTimeMiddleware` in the middleware stack.
+- `DISABLE_COG` (bool): disable `/cog` endpoints.
+- `DISABLE_STAC` (bool): disable `/stac` endpoints.
+- `DISABLE_MOSAIC` (bool): disable `/mosaic` endpoints.
+- `LOWER_CASE_QUERY_PARAMETERS` (bool): transform all query-parameters to lower case (see https://github.com/developmentseed/titiler/pull/321).
+- `GLOBAL_ACCESS_TOKEN` (str | None): a string which is required in the `?access_token=` query param with every request.
+
+
+#### Extending TiTiler's app
+
+If you want to include all of Titiler's built-in endpoints, but also include
+customized endpoints, you can import and extend the app directly.
+
+```bash
+python -m pip install titiler.application uvicorn # also installs titiler.core and titiler.mosaic
+```
+
+These can then be used like:
+
+```py
+# Add private COG endpoints requiring token validation
+from fastapi import APIRouter, Depends, HTTPException, Security
+from fastapi.security.api_key import APIKeyQuery
+
+from titiler.application.main import app
+from titiler.core.factory import TilerFactory
+
+import uvicorn
+
+api_key_query = APIKeyQuery(name="access_token", auto_error=False)
+
+
+def token_validation(access_token: str = Security(api_key_query)):
+    """stupid token validation."""
+    if not access_token:
+        raise HTTPException(status_code=401, detail="Missing `access_token`")
+
+    # if access_token == `token` then OK
+    if not access_token == "token":
+        raise HTTPException(status_code=401, detail="Invalid `access_token`")
+
+    return True
+
+
+# Custom router with token dependency
+router = APIRouter(dependencies=[Depends(token_validation)])
+tiler = TilerFactory(router_prefix="private/cog", router=router)
+
+app.include_router(tiler.router, prefix="/private/cog", tags=["Private"])
+
+
+if __name__ == '__main__':
+    uvicorn.run(app=app, host="127.0.0.1", port=8080, log_level="info")
+```
+
+More on [customization](../advanced/customization.md)
diff --git a/docs/src/output_format.md b/docs/src/user_guide/output_format.md
similarity index 94%
rename from docs/src/output_format.md
rename to docs/src/user_guide/output_format.md
index 8d32ad577..31882086d 100644
--- a/docs/src/output_format.md
+++ b/docs/src/user_guide/output_format.md
@@ -2,7 +2,7 @@
 `TiTiler` supports the common output format for map tiles: JPEG, PNG and WEBP.
 
 While some formats (e.g PNG) are able to encode Uint16 or Float datatypes, most web browsers only supports 8 bit data (meaning that it has to be between 0 and 255).
-It's on the user to know what datatype is the input source (COG), and what kind of `post processing` there is to do to create a valid web map tile.
+It's on the user to know what datatype is the input source (COG), and what kind of `post processing` is required to create a valid web map tile.
 
 `TiTiler` also has support for more complex output data formats, such as JPEG2000 or GeoTIFF. While it might not be useful for FrontEnd display (most browsers can't decode GeoTIFF natively), some users could want to transmit the data as `raw` values to some applications (non-web display).
 
@@ -47,7 +47,7 @@ print(data.shape)
 data, mask = data[0:-1], data[-1]
 ```
 
-Notebook: [Working_with_NumpyTile](examples/notebooks/Working_with_NumpyTile.ipynb)
+Notebook: [Working_with_NumpyTile](../examples/notebooks/Working_with_NumpyTile.ipynb)
 
 ## JSONResponse
 
diff --git a/docs/src/user_guide/rendering.md b/docs/src/user_guide/rendering.md
new file mode 100644
index 000000000..b679ecd4e
--- /dev/null
+++ b/docs/src/user_guide/rendering.md
@@ -0,0 +1,133 @@
+# Rendering Options
+
+When using Titiler to visualize imagery, there are some helper options that change how the data appears on the screen. You can:
+
+1. Adjust the band values using basic color-oriented image operations
+2. Apply color maps to create heat maps, colorful terrain based on band value
+3. Rescale images on a per-band basis
+
+## Color Map
+
+Color maps are arrays of colors, used to map pixel values to specific colors. For example, it is possible to map a single band DEM, where the pixel values denote height, to a color map which shows higher values as white:
+
+![color map example](../img/colormap.png)
+
+TiTiler supports both default colormaps (each with a name) and custom color maps.
+
+### Default Colormaps
+
+Default colormaps pre-made, each with a given name. These maps come from the `rio-tiler` library, which has taken colormaps packaged with Matplotlib and has added others that are commonly used with raster data.
+
+A list of available color maps can be found in Titiler's Swagger docs, or in the [rio-tiler documentation](https://cogeotiff.github.io/rio-tiler/colormap/#default-rio-tilers-colormaps).
+
+To use a default colormap, simply use the parameter `colormap_name`:
+
+```python
+import httpx
+
+resp = httpx.get(
+    "https://titiler.xyz/cog/preview",
+    params={
+        "url": "<YOUR DATASET URL HERE>",
+        "colormap_name": "<YOUR COLORMAP NAME HERE>" # e.g. autumn_r
+    }
+)
+```
+
+You can take any of the colormaps listed on `rio-tiler`, and add `_r` to reverse it.
+
+### Custom Colormaps
+
+If you'd like to specify your own colormap, you can specify your own using an encoded JSON:
+
+```python
+import httpx
+
+response = httpx.get(
+    "https://titiler.xyz/cog/preview",
+    params={
+        "url": "<YOUR DATASET URL HERE>",
+        "bidx": "1",
+        "colormap": json.dumps({
+            "0": "#e5f5f9",
+            "10": "#99d8c9",
+            "255": "#2ca25f",
+        })
+    }
+)
+```
+
+TiTiler supports colormaps that are both discrete (where pixels will be one of the colors that you specify) and linear (where pixel colors will blend between the given colors).
+
+For more information, please check out [rio-tiler's docs](https://cogeotiff.github.io/rio-tiler/colormap/).
+
+It is also possible to add a [colormap dependency](../examples/code/tiler_with_custom_colormap) to automatically apply
+a default colormap.
+
+## Color Formula
+
+Color formulae are simple commands that apply color corrections to images. This is useful for reducing artefacts like atmospheric haze, dark shadows, or muted colors.
+
+Titiler supports color formulae as defined in [Mapbox's `rio-color` plugin](https://github.com/mapbox/rio-color). These include the operations ([taken from the `rio-color` docs](https://github.com/mapbox/rio-color#operations)):
+
+- **Gamma** adjustment: adjusts RGB values according to a power law, effectively brightening or darkening the midtones. It can be very effective in satellite imagery for reducing atmospheric haze in the blue and green bands.
+
+- **Sigmoidal** contrast adjustment: can alter the contrast and brightness of an image in a way that matches human's non-linear visual perception. It works well to increase contrast without blowing out the very dark shadows or already-bright parts of the image.
+
+- **Saturation**: can be thought of as the "colorfulness" of a pixel. Highly saturated colors are intense and almost cartoon-like, low saturation is more muted, closer to black and white. You can adjust saturation independently of brightness and hue, but the data must be transformed into a different color space.
+
+In TiTiler, color_formulae are applied through the `color_formula` parameter as a string. An example of this option in action:
+
+```python
+import httpx
+
+response = httpx.get(
+    "https://titiler.xyz/cog/preview",
+    params={
+        "url": "<YOUR DATASET URL HERE>",
+        "color_formula": "gamma rg 1.3, sigmoidal rgb 22 0.1, saturation 1.5"
+    }
+)
+```
+
+## Rescaling
+
+Rescaling is the act of adjusting the minimum and maximum values when rendering an image. In an image with a single band, the rescaled minimum value will be set to black, and the rescaled maximum value will be set to white. This is useful if you want to accentuate features that only appear at a certain pixel value (e.g. you have a DEM, but you want to highlight how the terrain changes between sea level and 100m).
+
+All TiTiler endpoinds returning *image* support `rescale` parameter. The parameter should be in form of `"rescale={min},{max}"`.
+
+```python
+import httpx
+
+response = httpx.get(
+    "https;//titiler.xyz/cog/preview",
+    params={
+        "url": "<YOUR DATASET URL HERE>",
+        "rescale": "0,100",
+    },
+)
+```
+
+TiTiler supports rescaling on a per-band basis, using multiple `rescale` parameters.
+
+```python
+import httpx
+
+response = httpx.get(
+    "https;//titiler.xyz/cog/preview",
+    params=(
+        ("url", "<YOUR DATASET URL HERE>"),
+        ("rescale", "0,100"),
+        ("rescale", "0,1000"),
+        ("rescale", "0,10000"),
+    ),
+)
+```
+
+By default, TiTiler will rescale the bands using the min/max values of the input datatype. For example, PNG images 8 or 16-bit unsigned pixels, giving a possible range of 0 to 255 or 0 to 65,536, so Titiler will use these ranges to rescale to the output format.
+
+For certain datasets (e.g. DEMs), this default behaviour can make the image seem washed out (or even entirely one color),
+so if you see this happen look into rescaling your images to something that makes sense for your data.
+
+It is also possible to add a [rescaling dependency](../api/titiler/core/dependencies/#ImageRenderingParams) to automatically apply
+a default rescale.
diff --git a/docs/src/tile_matrix_sets.md b/docs/src/user_guide/tile_matrix_sets.md
similarity index 91%
rename from docs/src/tile_matrix_sets.md
rename to docs/src/user_guide/tile_matrix_sets.md
index eea52d992..3488ff54e 100644
--- a/docs/src/tile_matrix_sets.md
+++ b/docs/src/user_guide/tile_matrix_sets.md
@@ -26,7 +26,7 @@ $ curl http://127.0.0.1:8000/tileMatrixSets | jq '.tileMatrixSets[] | .id'
 "WebMercatorQuad"
 ```
 
-You can easily add more TileMatrixSet support, see [custom tms](advanced/customization.md#custom-tms).
+You can easily add more TileMatrixSet support, see [custom tms](../advanced/customization.md#custom-tms).
 
 
-Notebook: [Working_with_nonWebMercatorTMS](examples/notebooks/Working_with_nonWebMercatorTMS.ipynb)
+Notebook: [Working_with_nonWebMercatorTMS](../examples/notebooks/Working_with_nonWebMercatorTMS.ipynb)
diff --git a/docs/src/user_guide/titiler_with_stac.md b/docs/src/user_guide/titiler_with_stac.md
new file mode 100644
index 000000000..fdd11cf1e
--- /dev/null
+++ b/docs/src/user_guide/titiler_with_stac.md
@@ -0,0 +1,397 @@
+In our [previous post](https://developmentseed.org/titiler/user_guide/getting_started/), we set up TiTiler for serving Cloud-Optimized GeoTIFFs. Now let's explore how TiTiler works with STAC (SpatioTemporal Asset Catalog) - a standardized way to describe and organize geospatial data.
+
+> **Prerequisites**: For Python environment and TiTiler setup, check out the [Getting Started with TiTiler](https://developmentseed.org/titiler/user_guide/getting_started/#lets-get-titiler-up-and-running) post.
+
+## What is [STAC](https://stacspec.org/en)?
+
+STAC is like a library catalog for satellite imagery. Instead of searching through folders, you get structured JSON files that tell you:
+
+- **What**: Type of imagery, bands available, resolution
+- **Where**: Geographic location (bounding box, geometry)
+- **When**: Capture date and time
+- **How**: Direct links to the actual data files (assets)
+
+## Our Example Dataset
+
+Throughout this tutorial, we'll use openly available Maxar satellite imagery from the Bay of Bengal Cyclone Mocha event:
+```bash
+https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json
+```
+
+This STAC item contains:
+
+| Asset | Description | Bands |
+|-------|-------------|-------|
+| `visual` | True color RGB | Red, Green, Blue |
+| `ms_analytic` | Multispectral | Coastal, Blue, Green, Yellow, Red, RedEdge, NIR1, NIR2 |
+| `pan_analytic` | Panchromatic | Single band (high resolution) |
+| `data-mask` | Valid data mask | Single band |
+
+
+> **Tip**: Explore other open datasets at [STAC Index](https://stacindex.org/catalogs) to practice with different imagery
+
+## Setting Up TiTiler for STAC
+
+Make sure your `main.py` includes the STAC router:
+
+```python
+from fastapi import FastAPI
+from titiler.core.factory import TilerFactory, MultiBaseTilerFactory
+from starlette.middleware.cors import CORSMiddleware
+from rio_tiler.io import STACReader
+
+app = FastAPI(title="TiTiler")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# COG endpoints
+cog = TilerFactory()
+app.include_router(cog.router, prefix="/cog", tags=["COG"])
+
+# STAC endpoints
+stac = MultiBaseTilerFactory(reader=STACReader)
+app.include_router(stac.router, prefix="/stac", tags=["STAC"])
+
+@app.get("/")
+def read_index():
+    return {"message": "Welcome to TiTiler!"}
+```
+
+**What's new for STAC**: We import `STACReader` from `rio_tiler.io` and use `MultiBaseTilerFactory` (instead of `TilerFactory`) to create STAC endpoints - this factory understands how to read multiple assets from a single STAC item.
+
+Start the server:
+```bash
+uvicorn main:app --reload
+```
+
+Open your browser and go to:
+```  http://127.0.0.1:8000/docs ``` - Explore the interactive API documentation.
+
+![](../img/stac_api_docs.png)
+
+***
+
+## 1. Getting STAC Item Info `/stac/info`:
+
+Before visualizing, let's understand what's in our STAC item. The `/stac/info` endpoint returns metadata about available assets and their properties.
+
+### List all available assets
+
+```bash
+http://127.0.0.1:8000/stac/assets?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json
+```
+
+### Basic Info Request
+
+```bash
+http://127.0.0.1:8000/stac/info?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=:all:
+```
+
+!!! note
+
+    `assets=:all:` special notation tells titiler to fetch info for all available asset 
+
+### Info for Specific Asset
+
+To get detailed information about a specific asset:
+
+```bash
+http://127.0.0.1:8000/stac/info?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=visual
+```
+
+![](../img/stac_asset_info.png)
+
+***
+
+## 2. Quick Preview: `/stac/preview`
+
+The `/stac/preview` endpoint generates a downsampled image of your data - perfect for quick visualization.
+
+### Preview the Visual Asset (RGB)
+
+```bash
+http://127.0.0.1:8000/stac/preview?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=visual
+```
+
+True Color visual asset:
+![](../img/stac_asset_preview.png)
+
+### Preview with Output Format
+
+You can specify the output format:
+
+```bash
+# JPEG output (smaller file size)
+http://127.0.0.1:8000/stac/preview.jpg?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=visual
+
+# WebP output (modern format, good compression)
+http://127.0.0.1:8000/stac/preview.webp?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=visual
+```
+
+***
+
+## 3. Map Tiles: `/stac/tiles/{tileMatrixSetId}/{z}/{x}/{y}`
+
+For web maps, you need tiles - small image pieces that load progressively as users pan and zoom. This is the most powerful endpoint for building interactive maps.
+
+### Finding Tile Coordinates (Z, X, Y)
+
+To request a specific tile, you need to know its coordinates. You can calculate these from the STAC item's bounding box using the `morecantile` library.
+
+**Important**: STAC items have two types of bounding boxes:
+
+- **`bbox`** - Always in WGS84 (lon/lat) - **use this for tile calculations**
+- **`proj:bbox`** - In the asset's projection (e.g., UTM meters) - don't use this directly
+
+```python
+import httpx
+import morecantile
+
+# Fetch the STAC item
+stac_url = "https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json"
+item = httpx.get(stac_url).json()
+
+# Get the WGS84 bbox (not proj:bbox!)
+bbox = item["bbox"]  # [92.724, 20.481, 92.761, 20.530]
+
+# Calculate center point
+lon = (bbox[0] + bbox[2]) / 2  # 92.743
+lat = (bbox[1] + bbox[3]) / 2  # 20.506
+zoom = 15
+
+# Load the WebMercatorQuad TileMatrixSet
+tms = morecantile.tms.get("WebMercatorQuad")
+
+# Get the tile containing this point
+tile = tms.tile(lon, lat, zoom)
+print(f"z={tile.z}, x={tile.x}, y={tile.y}")
+# Output: z=15, x=24825, y=14476
+```
+
+> **Tip**: Install morecantile with `python -m pip install morecantile`
+
+### Basic Tile Request
+
+```bash
+http://127.0.0.1:8000/stac/tiles/WebMercatorQuad/15/24825/14476.png?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=visual
+```
+![](../img/stac_tile_zxy.png)
+
+
+**URL breakdown**:
+
+- `WebMercatorQuad`: Standard web map projection (EPSG:3857)
+- `15`: Zoom level
+- `24825`: X tile coordinate
+- `14476`: Y tile coordinate
+- `.png`: Output format
+
+### Using `assets` Parameter
+
+The `assets` parameter specifies which asset(s) to render:
+
+```bash
+# Single asset (visual - RGB)
+&assets=visual
+
+# Multiple assets (for band combinations from different assets)
+&assets=ms_analytic&assets=pan_analytic
+```
+
+### Passing per Asset options using `{name}|{options}={...}`
+
+When working with multi-band asset, you can extend the **asse**t option to select specific bands or apply expression:
+
+!!! note
+
+    Support of `options` in asset's name may depends on implementation. `rio-tiler`'s STACReader supports both `indexes=` and `expression=`: 
+
+    - Indexes: `assets=ms_analytic|indexes=1,2,3`
+    - Expression: `assets=ms_analytic|expression=b1+b2`
+
+
+```bash
+# Select band 3 (Green) from ms_analytic
+http://127.0.0.1:8000/stac/tiles/WebMercatorQuad/15/24825/14476.png?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=ms_analytic|indexes=3
+```
+
+**Band indices for `ms_analytic`**:
+
+| Index | Band Name | Common Name |
+|-------|-----------|-------------|
+| 1 | BAND_C | Coastal |
+| 2 | BAND_B | Blue |
+| 3 | BAND_G | Green |
+| 4 | BAND_Y | Yellow |
+| 5 | BAND_R | Red |
+| 6 | BAND_RE | Red Edge |
+| 7 | BAND_N | NIR (Near Infrared) |
+| 8 | BAND_N2 | NIR2 |
+
+### Creating RGB Composites with `{asset}|indexes={}`
+
+Create false-color composites by specifying 3 bands:
+
+```bash
+# Natural Color (Red, Green, Blue - bands 5,3,2)
+&assets=ms_analytic|indexes=5,3,2
+
+# False Color Infrared (NIR, Red, Green - bands 7,5,3)
+&assets=ms_analytic|indexes=7,5,3
+
+# Agriculture (NIR, Green, Blue - bands 7,3,2)
+&assets=ms_analytic|indexes=7,3,2
+```
+
+### Using `rescale` - Adjust Value Range
+
+**Important**: Raw satellite data often has values outside the 0-255 display range. Without rescaling, images may appear black or washed out.
+
+> **Tip**: If your image appears black or too dark, try adjusting the rescale max value. Adjust based on your data min-max.
+
+**Full example - False Color Infrared with rescale**:
+```bash
+http://127.0.0.1:8000/stac/tiles/WebMercatorQuad/15/24825/14476.png?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=ms_analytic&asset_bidx=ms_analytic|7,5,3&rescale=0,2000
+```
+
+![](../img/false_color.png)
+
+### Using `expression` - Band Math
+
+The `expression` parameter lets you perform calculations across bands. This is powerful for creating vegetation indices, water indices, and more.
+
+**Syntax**: Bands are referenced as `b{index}` (e.g., `b7` for NIR band in the `ms_analytic` asset).
+
+!!! important
+
+    For STAC, the band index `b{index}` within an expression corresponds to the index of the resulting image created using multiple assets. 
+    If you combine two assets with 2 bands each, the resulting images will have 4 bands, thus an expression could accept `b1 -> b4`.
+
+    ```
+    # select bands 1 & 2 for two assets and apply an expression
+    assets=visual|indexes=1,2&assets=ms_analytic|indexes=1,2&expression=(b1+b2+b3+b4)/4
+    ```
+
+!!! warning
+
+    The `+` sign in URLs is interpreted as a space! Use `%2B` instead of `+` in your expressions, otherwise you'll get a syntax error.
+
+
+#### NDVI (Normalized Difference Vegetation Index)
+
+NDVI highlights vegetation: `(NIR - Red) / (NIR + Red)`
+
+```bash
+http://127.0.0.1:8000/stac/tiles/WebMercatorQuad/15/24825/14476.png?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=ms_analytic&expression=(b7-b5)/(b7%2Bb5)&rescale=-1,1
+```
+
+![](../img/ndvi_without_color.png)
+
+#### NDWI (Normalized Difference Water Index)
+
+NDWI highlights water bodies: `(Green - NIR) / (Green + NIR)`
+
+```bash
+http://127.0.0.1:8000/stac/tiles/WebMercatorQuad/15/24825/14476.png?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=ms_analytic&expression=(b3-b7)/(b3%2Bb7)&rescale=-1,1
+```
+
+#### Simple Band Ratio
+
+```bash
+# NIR/Red ratio (vegetation vigor)
+&assets=ms_analytic&expression=b7/b5
+```
+
+### Using `colormap_name` - Apply Color Palettes
+
+When using expressions (which return single-band results), apply colormaps to make the data meaningful:
+
+**[List of Available colormaps](https://titiler.xyz/colorMaps)**
+
+#### NDVI with Colormap
+
+```bash
+http://127.0.0.1:8000/stac/tiles/WebMercatorQuad/15/24825/14476.png?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=ms_analytic&expression=(b7-b5)/(b7%2Bb5)&colormap_name=rdylgn&rescale=-1,1
+```
+
+- `colormap_name=rdylgn`: Red-Yellow-Green colormap (red=low NDVI, green=high NDVI)
+- `rescale=-1,1`: NDVI values range from -1 to 1
+
+#### Water Index with Blue Colormap
+
+```bash
+http://127.0.0.1:8000/stac/tiles/WebMercatorQuad/15/24825/14476.png?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=ms_analytic&expression=(b3-b7)/(b3%2Bb7)&colormap_name=blues&rescale=-1,1
+```
+
+### Visualize at the Image Extent or Crop to Custom Bounds
+
+**NDVI on Image Extent**
+```bash
+http://127.0.0.1:8000/stac/bbox/92.724,20.481,92.761,20.530.png?url=https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json&assets=ms_analytic&expression=(b7-b5)/(b7%2Bb5)&colormap_name=rdylgn&rescale=-1,1
+```
+
+![](../img/full_ndvi.png)
+
+**URL breakdown:**
+
+  - `/stac/bbox/92.724,20.481,92.761,20.530.png` - Bounding box: `minLon,minLat,maxLon,maxLat`                                                 
+  - Get these values from the STAC item's `bbox` field
+
+***
+### Using with Leaflet
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>STAC + TiTiler Map</title>
+  <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
+  <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
+</head>
+<body>
+  <div id="map" style="width: 100%; height: 600px;"></div>
+  <script>
+    var map = L.map('map').setView([20.506, 92.743], 14);
+
+    // Base map
+    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+      attribution: '&copy; OpenStreetMap'
+    }).addTo(map);
+
+    // TiTiler STAC layer
+    var stacUrl = 'https://maxar-opendata.s3.amazonaws.com/events/BayofBengal-Cyclone-Mocha-May-23/ard/46/033111333030/2023-05-22/10300110E84B5A00.json';
+    var tileUrl = `http://127.0.0.1:8000/stac/tiles/WebMercatorQuad/{z}/{x}/{y}.png?url=${encodeURIComponent(stacUrl)}&assets=visual`;
+
+    L.tileLayer(tileUrl, {
+      opacity: 0.8,
+      maxZoom: 18
+    }).addTo(map);
+  </script>
+</body>
+</html>
+```
+
+**To view the map:**
+
+  1. Save the code as `map.html`                                                
+  2. Make sure TiTiler server is running (`uvicorn main:app --reload`)          
+  3. Open `map.html` in your browser (double-click or drag into browser)
+
+![](../img/stac_preview_map.png)
+
+## Common Issues
+
+**Asset not found**: Check asset names in the STAC item JSON - they're case-sensitive.
+
+**Black/white tiles**: Your data values might be outside the default range. Use `rescale` to adjust.
+
+**Slow tiles**: Large files take time. Consider using overviews or lower zoom levels for previews.
+
+---
+*Created by [Dimple Jain](https://jaiindimple.github.io)*
\ No newline at end of file
diff --git a/plans/openapi-params-from-dependencies.prompt.md b/plans/openapi-params-from-dependencies.prompt.md
new file mode 100644
index 000000000..3ab136bbc
--- /dev/null
+++ b/plans/openapi-params-from-dependencies.prompt.md
@@ -0,0 +1,84 @@
+# OpenAPI schema from FastAPI dependencies
+
+## Problem
+
+In the WMTS extension, we construct an endpoint which can accept query-parameter or use `render` configuration to inject them as tile layers. Because the tile's dependencies are not part of the endpoint function signature, so FastAPI won't include them in the OpenAPI schema automatically. This means they won't be documented in the interactive API docs or available for client code generation.
+
+We then need to manually extract the query parameter definitions from a set of dependencies and add them to the OpenAPI schema for the endpoint.
+
+See issue [#1345](https://github.com/developmentseed/titiler/issues/1345)
+
+## Utility function
+
+Add to your utils module:
+
+```python
+from fastapi._compat import get_definitions, get_flat_models_from_fields, get_model_name_map
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import get_dependant, get_flat_params
+from fastapi.openapi.utils import _get_openapi_operation_parameters
+
+def dependencies_to_openapi_params(
+    dependencies: list[Callable],
+) -> list[dict[str, Any]]:
+    """Extract OpenAPI query parameter schemas from a list of FastAPI dependencies."""
+    all_fields = []
+    seen: set[str] = set()
+    for dep in dependencies:
+        dependant = get_dependant(path="", call=dep)
+        for field in get_flat_params(dependant):
+            if field.name not in seen:
+                seen.add(field.name)
+                all_fields.append(field)
+
+    if not all_fields:
+        return []
+
+    flat_models = get_flat_models_from_fields(all_fields, known_models=set())
+    model_name_map = get_model_name_map(flat_models)
+    field_mapping, _ = get_definitions(fields=all_fields, model_name_map=model_name_map)
+
+    combined = Dependant(path="")
+    combined.query_params = all_fields
+    return _get_openapi_operation_parameters(
+        dependant=combined,
+        model_name_map=model_name_map,
+        field_mapping=field_mapping,
+    )
+```
+
+## Usage in a route
+
+Pass the result to `openapi_extra` in the route decorator:
+
+```python
+@router.get(
+    "/some-endpoint",
+    openapi_extra={
+        "parameters": dependencies_to_openapi_params(my_dependencies),
+    },
+)
+def my_endpoint(...):
+    ...
+```
+
+## Implementation plan
+
+1. **Add utility to `titiler/core/titiler/core/utils.py`**
+   - Add imports: `get_definitions`, `get_flat_models_from_fields`, `get_model_name_map` from `fastapi._compat`; `Dependant` from `fastapi.dependencies.models`; `get_flat_params` from `fastapi.dependencies.utils`; `_get_openapi_operation_parameters` from `fastapi.openapi.utils`
+   - Add the `dependencies_to_openapi_params` function (see above)
+   - Export it from `titiler.core.utils`
+
+2. **Use in the extension route** (e.g. `titiler/extensions/titiler/extensions/wmts.py`)
+   - Import `dependencies_to_openapi_params` from `titiler.core.utils`
+   - Before registering the route, build the list of `tile_dependencies`
+   - Pass `"parameters": dependencies_to_openapi_params(tile_dependencies)` to `openapi_extra` on the `@router.get(...)` decorator
+
+3. **Tests**
+   - In `titiler/core/tests/test_utils.py`: add `test_dependencies_to_openapi_params` covering empty list, single dep, multiple deps merged, `required` flag, and deduplication
+
+## Notes
+
+- Parameters are deduplicated by name across all dependencies.
+- `required`, `schema`, and `description` are derived from the `Query(...)` annotations on each dependency.
+- This uses FastAPI internals (`_get_openapi_operation_parameters`, `_compat`) — tested against FastAPI 0.135+.
diff --git a/pyproject.toml b/pyproject.toml
index b691b6110..83589a081 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -2,7 +2,7 @@
 name = "titiler"
 description = "A modern dynamic tile server built on top of FastAPI and Rasterio/GDAL."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 license = {file = "LICENSE"}
 authors = [
     {name = "Vincent Sarago", email = "vincent@developmentseed.com"},
@@ -21,31 +21,63 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: GIS",
 ]
-version="0.11.7"
+version="2.0.1"
 dependencies = [
-    "titiler.core==0.11.7",
-    "titiler.extensions==0.11.7",
-    "titiler.mosaic==0.11.7",
-    "titiler.application==0.11.7",
+    "titiler-core",
+    "titiler-xarray",
+    "titiler-extensions",
+    "titiler-mosaic[mosaicjson]",
+    "titiler-application",
 ]
 
-[project.optional-dependencies]
+[dependency-groups]
 dev = [
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "httpx",
+    "obstore",
+    "zarr>=3,<4.0",
+    "h5netcdf",
+    "h5py",
+    "fsspec",
+    "s3fs>=2025.2.0",
+    "aiohttp",
+    "requests",
+    "pystac[validation]>=1.0.0,<2.0.0",
+    "brotlipy",
+    "boto3",
+    "owslib",
     "pre-commit",
+    "IPython",
+    "jupyter",
+    "matplotlib",
+    "folium",
+]
+telemetry = [
+    "opentelemetry-api",
+    "opentelemetry-sdk",
+    "opentelemetry-instrumentation-fastapi",
+    "opentelemetry-instrumentation-logging",
+    "opentelemetry-exporter-otlp",
 ]
 docs = [
-    "nbconvert",
-    "mkdocs",
-    "mkdocs-jupyter",
-    "mkdocs-material",
-    "pygments",
-    "pdocs",
+    "black>=23.10.1",
+    "mkdocs>=1.4.3",
+    "mkdocs-jupyter>=0.24.5",
+    "mkdocs-material[imaging]>=9.5",
+    "griffe-inherited-docstrings>=1.0.0",
+    "mkdocstrings[python]>=0.25.1",
+]
+server = [
+    "uvicorn",
 ]
 
 [project.urls]
@@ -55,33 +87,20 @@ Issues = "https://github.com/developmentseed/titiler/issues"
 Source = "https://github.com/developmentseed/titiler"
 Changelog = "https://developmentseed.org/titiler/release-notes/"
 
-[tool.hatch.build.targets.sdist]
-exclude = [
-  ".binder",
-  ".pytest_cache",
-  ".ruff_cache",
-  ".vscode",
-  ".dockerignore",
-  "src/",
-  "deployment/",
-  "docs/",
-  "scripts/",
-  "dockerfiles/",
-  "docker-compose.yml",
-  ".github",
-  ".history",
-  ".bumpversion.cfg",
-  ".flake8",
-  ".gitignore",
-  ".pre-commit-config.yaml",
-  "AUTHORS.txt",
-  "CHANGES.md",
-  "CONTRIBUTING.md",
-]
+[tool.uv]
+package = false
+
+[tool.uv.sources]
+titiler-core = { workspace = true }
+titiler-extensions = { workspace = true }
+titiler-mosaic = { workspace = true }
+titiler-application = { workspace = true }
+titiler-xarray = { workspace = true }
 
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+[tool.uv.workspace]
+members = [
+  "src/titiler/*"
+]
 
 [tool.coverage.run]
 branch = true
@@ -107,7 +126,7 @@ known_third_party = [
 ]
 default_section = "THIRDPARTY"
 
-[tool.ruff]
+[tool.ruff.lint]
 select = [
     "D1",  # pydocstyle errors
     "E",  # pycodestyle errors
@@ -121,9 +140,20 @@ ignore = [
     "B008",  # do not perform function calls in argument defaults
     "B905",  # ignore zip() without an explicit strict= parameter, only support with python >3.10
 ]
+exclude = [
+    "*.ipynb"
+]
 
 [tool.mypy]
 no_implicit_optional = true
 strict_optional = true
 namespace_packages = true
 explicit_package_bases = true
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore::rasterio.errors.NotGeoreferencedWarning",
+]
+
+[tool.commitizen]
+name = "cz_conventional_commits"
diff --git a/release-please-config.json b/release-please-config.json
new file mode 100644
index 000000000..562196a46
--- /dev/null
+++ b/release-please-config.json
@@ -0,0 +1,53 @@
+{
+  "packages": {
+    ".": {
+      "release-type": "python",
+      "package-name": "titiler",
+      "changelog-path": "CHANGES.md",
+      "changelog-type": "github",
+      "changelog-sections": [
+        { "type": "feat", "section": "Features", "hidden": false },
+        { "type": "fix", "section": "Bug Fixes", "hidden": false },
+        { "type": "perf", "section": "Performance Improvements", "hidden": false },
+        { "type": "revert", "section": "Reverts", "hidden": false },
+        { "type": "docs", "section": "Documentation", "hidden": false },
+        { "type": "refactor", "section": "Code Refactoring", "hidden": false },
+        { "type": "style", "section": "Styles", "hidden": true },
+        { "type": "chore", "section": "Miscellaneous Chores", "hidden": true },
+        { "type": "test", "section": "Tests", "hidden": true },
+        { "type": "build", "section": "Build System", "hidden": true },
+        { "type": "ci", "section": "Continuous Integration", "hidden": true }
+      ],
+      "pull-request-title-pattern": "chore: release ${version}",
+      "bump-minor-pre-major": true,
+      "bump-patch-for-minor-pre-major": false,
+      "include-component-in-tag": false,
+      "include-v-in-tag": false,
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "pyproject.toml",
+          "jsonpath": "$.project.version"
+        },
+        { "type": "generic", "path": "src/titiler/core/titiler/core/__init__.py" },
+        { "type": "generic", "path": "src/titiler/xarray/titiler/xarray/__init__.py" },
+        { "type": "generic", "path": "src/titiler/extensions/titiler/extensions/__init__.py" },
+        { "type": "generic", "path": "src/titiler/mosaic/titiler/mosaic/__init__.py" },
+        { "type": "generic", "path": "src/titiler/application/titiler/application/__init__.py" },
+        { "type": "generic", "path": "src/titiler/xarray/pyproject.toml" },
+        { "type": "generic", "path": "src/titiler/extensions/pyproject.toml" },
+        { "type": "generic", "path": "src/titiler/mosaic/pyproject.toml" },
+        { "type": "generic", "path": "src/titiler/application/pyproject.toml" },
+        { "type": "generic", "path": "deployment/aws/lambda/Dockerfile" },
+        { "type": "generic", "path": "deployment/k8s/charts/Chart.yaml" }
+      ]
+    },
+    "deployment/k8s/charts": {
+      "release-type": "helm",
+      "package-name": "titiler-helm",
+      "changelog-path": "deployment/k8s/charts/CHANGELOG.md",
+      "include-component-in-tag": true,
+      "component": "helm"
+    }
+  }
+}
diff --git a/scripts/build b/scripts/build
new file mode 100755
index 000000000..bb337a56e
--- /dev/null
+++ b/scripts/build
@@ -0,0 +1,15 @@
+#! /usr/bin/env bash
+
+SUBPACKAGES=(
+    "core"
+    "xarray"
+    "mosaic"
+    "application"
+    "extensions"
+)
+rm -rf dist
+for PACKAGE in "${SUBPACKAGES[@]}"
+do
+    echo "building titiler-${PACKAGE}"
+    uv build --package titiler-${PACKAGE}
+done
diff --git a/scripts/publish b/scripts/publish
deleted file mode 100755
index 7e548c6ec..000000000
--- a/scripts/publish
+++ /dev/null
@@ -1,22 +0,0 @@
-#! /usr/bin/env bash
-
-SUBPACKAGE_DIRS=(
-    "core"
-    "mosaic"
-    "application"
-    "extensions"
-)
-
-for PACKAGE_DIR in "${SUBPACKAGE_DIRS[@]}"
-do
-    echo "publishing titiler-${PACKAGE_DIR}"
-    pushd ./src/titiler/${PACKAGE_DIR}
-    rm -rf dist
-    python -m build
-    twine upload dist/*
-    popd
-done
-
-rm -rf dist
-python -m build
-twine upload dist/*
diff --git a/scripts/test b/scripts/test
new file mode 100755
index 000000000..beb1409d8
--- /dev/null
+++ b/scripts/test
@@ -0,0 +1,15 @@
+#! /usr/bin/env bash
+
+SUBPACKAGE_DIRS=(
+    "core"
+    "xarray"
+    "mosaic"
+    "application"
+    "extensions"
+)
+
+for PACKAGE_DIR in "${SUBPACKAGE_DIRS[@]}"
+do
+    echo "Running tests for titiler-${PACKAGE_DIR}"
+    uv run pytest src/titiler/${PACKAGE_DIR}
+done
diff --git a/src/titiler/application/LICENSE b/src/titiler/application/LICENSE
new file mode 100644
index 000000000..eb4365951
--- /dev/null
+++ b/src/titiler/application/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Development Seed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/titiler/application/README.md b/src/titiler/application/README.md
index d8ca172eb..ee9dde7a7 100644
--- a/src/titiler/application/README.md
+++ b/src/titiler/application/README.md
@@ -6,19 +6,19 @@
 ## Installation
 
 ```bash
-$ pip install -U pip
+python -m pip install -U pip
 
 # From Pypi
-$ pip install titiler.application
+python -m pip install titiler.application
 
 # Or from sources
-$ git clone https://github.com/developmentseed/titiler.git
-$ cd titiler && pip install -e titiler/application
+git clone https://github.com/developmentseed/titiler.git
+cd titiler && python -m pip install -e src/titiler/core -e src/titiler/extensions -e src/titiler/mosaic -e src/titiler/xarray -e src/titiler/application
 ```
 
 Launch Application
 ```bash
-$ pip install uvicorn
+$ python -m pip install uvicorn
 $ uvicorn titiler.application.main:app --reload
 ```
 
@@ -30,9 +30,7 @@ titiler/
     ├── tests/                   - Tests suite
     └── titiler/application/     - `application` namespace package
         ├── templates/
-        |   ├── index.html       - demo landing page
-        |   ├── cog_index.html   - demo viewer for `/cog`
-        |   └── stac_index.html  - demo viewer for `/stac`
+        |   └── index.html       - Landing page
         ├── main.py              - Main FastAPI application
         └── settings.py          - demo settings (cache, cors...)
 ```
diff --git a/src/titiler/application/pyproject.toml b/src/titiler/application/pyproject.toml
index f88aa0750..0a48b0709 100644
--- a/src/titiler/application/pyproject.toml
+++ b/src/titiler/application/pyproject.toml
@@ -1,8 +1,8 @@
 [project]
-name = "titiler.application"
+name = "titiler-application"
 description = "A modern dynamic tile server built on top of FastAPI and Rasterio/GDAL."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 authors = [
     {name = "Vincent Sarago", email = "vincent@developmentseed.com"},
 ]
@@ -21,31 +21,36 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: GIS",
 ]
 dynamic = ["version"]
 dependencies = [
-    "titiler.core==0.11.7",
-    "titiler.extensions[cogeo,stac]==0.11.7",
-    "titiler.mosaic==0.11.7",
-    "starlette-cramjam>=0.3,<0.4",
-    "python-dotenv",
+    "titiler-core[telemetry]==2.0.1",  # x-release-please-version
+    "titiler-xarray==2.0.1",  # x-release-please-version
+    "titiler-extensions[cogeo,stac]==2.0.1",  # x-release-please-version
+    "titiler-mosaic[mosaicjson]==2.0.1",  # x-release-please-version
+    "starlette-cramjam>=0.4,<0.6",
+    "pydantic-settings~=2.0",
 ]
 
 [project.optional-dependencies]
+server = [
+    "uvicorn[standard]>=0.12.0",
+]
+
+[dependency-groups]
 test = [
     "pytest",
     "pytest-cov",
     "pytest-asyncio",
     "httpx",
     "brotlipy",
-]
-server = [
-    "uvicorn[standard]>=0.12.0,<0.19.0",
+    "boto3",
 ]
 
 [project.urls]
@@ -55,14 +60,15 @@ Issues = "https://github.com/developmentseed/titiler/issues"
 Source = "https://github.com/developmentseed/titiler"
 Changelog = "https://developmentseed.org/titiler/release-notes/"
 
-[build-system]
-requires = ["pdm-pep517"]
-build-backend = "pdm.pep517.api"
-
-[tool.pdm.version]
-source = "file"
+[tool.hatch.version]
 path = "titiler/application/__init__.py"
 
-[tool.pdm.build]
-includes = ["titiler/application"]
-excludes = ["tests/", "**/.mypy_cache", "**/.DS_Store"]
+[tool.hatch.build.targets.sdist]
+only-include = ["titiler"]
+
+[tool.hatch.build.targets.wheel]
+only-include = ["titiler"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/src/titiler/application/tests/conftest.py b/src/titiler/application/tests/conftest.py
index 967990102..b883ab570 100644
--- a/src/titiler/application/tests/conftest.py
+++ b/src/titiler/application/tests/conftest.py
@@ -34,6 +34,7 @@ def app(set_env) -> TestClient:
 
 def mock_RequestGet(src_path):
     """Mock Requests."""
+
     # HTTP
     class MockResponse:
         def __init__(self, data):
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zattrs b/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zattrs
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zattrs
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zgroup b/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zgroup
new file mode 100644
index 000000000..3b7daf227
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zgroup
@@ -0,0 +1,3 @@
+{
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zmetadata b/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zmetadata
new file mode 100644
index 000000000..061ce5cb0
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/.zmetadata
@@ -0,0 +1,119 @@
+{
+    "metadata": {
+        ".zattrs": {},
+        ".zgroup": {
+            "zarr_format": 2
+        },
+        "dataset/.zarray": {
+            "chunks": [
+                1,
+                250,
+                500
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                2,
+                1000,
+                2000
+            ],
+            "zarr_format": 2
+        },
+        "dataset/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "time",
+                "y",
+                "x"
+            ],
+            "valid_max": 1000.0,
+            "valid_min": 0.0
+        },
+        "time/.zarray": {
+            "chunks": [
+                2
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<i8",
+            "fill_value": null,
+            "filters": null,
+            "order": "C",
+            "shape": [
+                2
+            ],
+            "zarr_format": 2
+        },
+        "time/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "time"
+            ],
+            "calendar": "proleptic_gregorian",
+            "units": "days since 2022-01-01 00:00:00"
+        },
+        "x/.zarray": {
+            "chunks": [
+                2000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                2000
+            ],
+            "zarr_format": 2
+        },
+        "x/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "x"
+            ]
+        },
+        "y/.zarray": {
+            "chunks": [
+                1000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                1000
+            ],
+            "zarr_format": 2
+        },
+        "y/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "y"
+            ]
+        }
+    },
+    "zarr_consolidated_format": 1
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/.zarray b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/.zarray
new file mode 100644
index 000000000..1114507a2
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/.zarray
@@ -0,0 +1,24 @@
+{
+    "chunks": [
+        1,
+        250,
+        500
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        2,
+        1000,
+        2000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/.zattrs b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/.zattrs
new file mode 100644
index 000000000..92811b655
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/.zattrs
@@ -0,0 +1,9 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "time",
+        "y",
+        "x"
+    ],
+    "valid_max": 1000.0,
+    "valid_min": 0.0
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.0
new file mode 100644
index 000000000..193516262
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.1 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.1
new file mode 100644
index 000000000..02f3eb367
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.1 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.2 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.2
new file mode 100644
index 000000000..27ee5dd95
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.2 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.3 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.3
new file mode 100644
index 000000000..9a5a77329
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.0.3 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.0
new file mode 100644
index 000000000..7483a4407
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.1 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.1
new file mode 100644
index 000000000..1351e3dc7
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.1 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.2 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.2
new file mode 100644
index 000000000..7bebebde0
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.2 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.3 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.3
new file mode 100644
index 000000000..cfe62a706
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.1.3 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.0
new file mode 100644
index 000000000..70cd4693f
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.1 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.1
new file mode 100644
index 000000000..5b2412be6
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.1 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.2 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.2
new file mode 100644
index 000000000..05912ac30
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.2 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.3 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.3
new file mode 100644
index 000000000..0a0772799
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.2.3 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.0
new file mode 100644
index 000000000..4c596c1fd
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.1 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.1
new file mode 100644
index 000000000..dff32093b
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.1 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.2 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.2
new file mode 100644
index 000000000..3c3e8b338
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.2 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.3 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.3
new file mode 100644
index 000000000..692ca6dbe
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/0.3.3 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.0
new file mode 100644
index 000000000..78d0463ae
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.1 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.1
new file mode 100644
index 000000000..2b8487a3d
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.1 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.2 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.2
new file mode 100644
index 000000000..a14ed689f
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.2 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.3 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.3
new file mode 100644
index 000000000..803e1cad7
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.0.3 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.0
new file mode 100644
index 000000000..98af409b5
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.1 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.1
new file mode 100644
index 000000000..ccd75df31
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.1 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.2 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.2
new file mode 100644
index 000000000..35b639d06
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.2 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.3 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.3
new file mode 100644
index 000000000..5c608e707
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.1.3 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.0
new file mode 100644
index 000000000..5401c33b3
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.1 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.1
new file mode 100644
index 000000000..076551c44
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.1 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.2 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.2
new file mode 100644
index 000000000..8b7d1f4e7
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.2 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.3 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.3
new file mode 100644
index 000000000..e3aa4636d
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.2.3 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.0
new file mode 100644
index 000000000..bf3cf57ed
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.1 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.1
new file mode 100644
index 000000000..d5aa1af89
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.1 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.2 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.2
new file mode 100644
index 000000000..3fe725ab5
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.2 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.3 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.3
new file mode 100644
index 000000000..4636302ed
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/dataset/1.3.3 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/.zarray b/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/.zarray
new file mode 100644
index 000000000..5a5b33285
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        2
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<i8",
+    "fill_value": null,
+    "filters": null,
+    "order": "C",
+    "shape": [
+        2
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/.zattrs b/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/.zattrs
new file mode 100644
index 000000000..342871520
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/.zattrs
@@ -0,0 +1,7 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "time"
+    ],
+    "calendar": "proleptic_gregorian",
+    "units": "days since 2022-01-01 00:00:00"
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/0
new file mode 100644
index 000000000..db2a2a192
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/time/0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/.zarray b/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/.zarray
new file mode 100644
index 000000000..4a4ca60db
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        2000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        2000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/.zattrs b/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/.zattrs
new file mode 100644
index 000000000..4b15671e1
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "x"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/0
new file mode 100644
index 000000000..fc622fb50
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/x/0 differ
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/.zarray b/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/.zarray
new file mode 100644
index 000000000..cc70c6c0f
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        1000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        1000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/.zattrs b/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/.zattrs
new file mode 100644
index 000000000..64ccf306f
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "y"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/0 b/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/0
new file mode 100644
index 000000000..09c474b91
Binary files /dev/null and b/src/titiler/application/tests/fixtures/dataset_3d.zarr/y/0 differ
diff --git a/src/titiler/application/tests/fixtures/item.json b/src/titiler/application/tests/fixtures/item.json
index f8e447265..40cb1a7ba 100644
--- a/src/titiler/application/tests/fixtures/item.json
+++ b/src/titiler/application/tests/fixtures/item.json
@@ -1,18 +1,10 @@
 {
     "type": "Feature",
-    "stac_version": "1.0.0-beta.1",
-    "stac_extensions": [
-        "eo",
-        "view",
-        "proj"
-    ],
+    "stac_version": "1.1.0",
     "id": "S2A_34SGA_20200318_0_L2A",
-    "bbox": [
-        23.293255090449595,
-        31.505183020453355,
-        24.296453548295318,
-        32.51147809805106
-    ],
+    "properties": {
+        "datetime": "2020-03-18T09:11:33Z"
+    },
     "geometry": {
         "type": "Polygon",
         "coordinates": [
@@ -40,91 +32,31 @@
             ]
         ]
     },
-    "properties": {
-        "datetime": "2020-03-18T09:11:33Z",
-        "platform": "sentinel-2a",
-        "constellation": "sentinel-2",
-        "instruments": [
-            "msi"
-        ],
-        "gsd": 10,
-        "data_coverage": 73.85,
-        "view:off_nadir": 0,
-        "eo:cloud_cover": 89.84,
-        "proj:epsg": 32634,
-        "sentinel:latitude_band": "S",
-        "sentinel:grid_square": "GA",
-        "sentinel:sequence": "0",
-        "sentinel:product_id": "S2A_MSIL2A_20200318T085701_N0214_R007_T34SGA_20200318T115254",
-        "created": "2020-05-12T21:03:26.671Z",
-        "updated": "2020-05-12T21:03:26.671Z"
-    },
-    "collection": "sentinel-s2-l2a-cogs",
+    "links": [
+        {
+            "rel": "self",
+            "href": "https://myurl.com/item.json",
+            "type": "application/json"
+        }
+    ],
     "assets": {
         "B01": {
-            "title": "Band 1 (coastal)",
-            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
             "href": "https://myurl.com/B01.tif",
-            "proj:shape": [
-                1830,
-                1830
-            ],
-            "proj:transform": [
-                60,
-                0,
-                699960,
-                0,
-                -60,
-                3600000,
-                0,
-                0,
-                1
-            ]
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "title": "Band 1 (coastal)"
         },
         "B09": {
-            "title": "Band 9",
-            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
             "href": "https://myurl.com/B09.tif",
-            "proj:shape": [
-                1830,
-                1830
-            ],
-            "proj:transform": [
-                60,
-                0,
-                699960,
-                0,
-                -60,
-                3600000,
-                0,
-                0,
-                1
-            ]
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "title": "Band 9"
         }
     },
-    "links": [
-        {
-            "rel": "self",
-            "href": "s3://sentinel-cogs/sentinel-s2-l2a-cogs/2020/S2A_34SGA_20200318_0_L2A/S2A_34SGA_20200318_0_L2A.json",
-            "type": "application/json"
-        },
-        {
-            "rel": "parent",
-            "href": "https://myurl.com/v0/collections/sentinel-s2-l2a"
-        },
-        {
-            "rel": "collection",
-            "href": "https://myurl.com/v0/collections/sentinel-s2-l2a"
-        },
-        {
-            "rel": "root",
-            "href": "https://myurl.com/v0/"
-        },
-        {
-            "title": "Source STAC Item",
-            "rel": "derived_from",
-            "href": "https://myurl.com/collections/sentinel-s2-l2a/items/S2A_34SGA_20200318_0_L2A",
-            "type": "application/json"
-        }
-    ]
+    "bbox": [
+        23.293255090449595,
+        31.505183020453355,
+        24.296453548295318,
+        32.51147809805106
+    ],
+    "stac_extensions": [],
+    "collection": "sentinel-s2-l2a-cogs"
 }
diff --git a/src/titiler/application/tests/fixtures/items_bands.json b/src/titiler/application/tests/fixtures/items_bands.json
new file mode 100644
index 000000000..3f3c724bd
--- /dev/null
+++ b/src/titiler/application/tests/fixtures/items_bands.json
@@ -0,0 +1,75 @@
+{
+    "stac_version": "1.1.0",
+    "stac_extensions": [
+        "https://stac-extensions.github.io/eo/v2.0.0/schema.json"
+    ],
+    "type": "Feature",
+    "id": "item-with-bands",
+    "bbox": [
+        -81.3085227080129,
+        32.10817938759764,
+        -78.81735409341113,
+        34.22870275071835
+    ],
+    "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+            [
+                [
+                    -81.3085227080129,
+                    32.10817938759764
+                ],
+                [
+                    -78.81735409341113,
+                    32.10817938759764
+                ],
+                [
+                    -78.81735409341113,
+                    34.22870275071835
+                ],
+                [
+                    -81.3085227080129,
+                    34.22870275071835
+                ],
+                [
+                    -81.3085227080129,
+                    32.10817938759764
+                ]
+            ]
+        ]
+    },
+    "properties": {
+        "datetime": "2016-05-03T13:21:30.040Z"
+    },
+    "links": [
+        {
+            "rel": "self",
+            "href": "https://myurl.com/item_bands.json"
+        },
+        {
+            "rel": "collection",
+            "href": "https://myurl.com/catalog.json"
+        }
+    ],
+    "assets": {
+        "rgb": {
+            "href": "https://myurl.com/rgb.tif",
+            "title": "lowres",
+            "bands": [
+                {
+                    "name": "band1",
+                    "eo:common_name": "red"
+                },
+                {
+                    "name": "band2",
+                    "eo:common_name": "green"
+                },
+                {
+                    "name": "band3",
+                    "eo:common_name": "blue"
+                }
+            ]
+        }
+    },
+    "collection": "collection"
+}
\ No newline at end of file
diff --git a/src/titiler/application/tests/fixtures/rgb.tif b/src/titiler/application/tests/fixtures/rgb.tif
new file mode 100644
index 000000000..6ff979535
Binary files /dev/null and b/src/titiler/application/tests/fixtures/rgb.tif differ
diff --git a/src/titiler/application/tests/routes/test_cog.py b/src/titiler/application/tests/routes/test_cog.py
index bacd1cae2..a7b1fb8d0 100644
--- a/src/titiler/application/tests/routes/test_cog.py
+++ b/src/titiler/application/tests/routes/test_cog.py
@@ -4,7 +4,7 @@
 import os
 from io import BytesIO
 from unittest.mock import patch
-from urllib.parse import parse_qsl, urlencode, urlparse
+from urllib.parse import parse_qsl, urlparse
 
 import numpy
 import pytest
@@ -12,18 +12,6 @@
 from ..conftest import DATA_DIR, mock_rasterio_open, parse_img
 
 
-@patch("rio_tiler.io.rasterio.rasterio")
-def test_bounds(rio, app):
-    """test /bounds endpoint."""
-    rio.open = mock_rasterio_open
-
-    response = app.get("/cog/bounds?url=https://myurl.com/cog.tif")
-    assert response.status_code == 200
-    body = response.json()
-    assert len(body["bounds"]) == 4
-    assert response.headers["Cache-Control"] == "private, max-age=3600"
-
-
 @patch("rio_tiler.io.rasterio.rasterio")
 def test_info(rio, app):
     """test /info endpoint."""
@@ -33,7 +21,7 @@ def test_info(rio, app):
     assert response.status_code == 200
     body = response.json()
     assert len(body["bounds"]) == 4
-    assert body["band_descriptions"] == [["b1", ""]]
+    assert body["band_descriptions"] == [["b1", "b1"]]
     assert body["dtype"] == "uint16"
     assert body["colorinterp"] == ["gray"]
     assert body["nodata_type"] == "None"
@@ -43,7 +31,7 @@ def test_info(rio, app):
     assert response.headers["content-type"] == "application/geo+json"
     body = response.json()
     assert body["geometry"]
-    assert body["properties"]["band_descriptions"] == [["b1", ""]]
+    assert body["properties"]["band_descriptions"] == [["b1", "b1"]]
     assert body["properties"]["dtype"] == "uint16"
     assert body["properties"]["colorinterp"] == ["gray"]
     assert body["properties"]["nodata_type"] == "None"
@@ -62,21 +50,21 @@ def test_wmts(rio, app):
         "http://testserver/cog/WMTSCapabilities.xml?url=https"
         in response.content.decode()
     )
-    assert "<ows:Identifier>cogeo</ows:Identifier>" in response.content.decode()
     assert (
-        "http://testserver/cog/tiles/WebMercatorQuad/{TileMatrix}/{TileCol}/{TileRow}@1x.png?url=https"
+        "http://testserver/cog/tiles/WebMercatorQuad/{TileMatrix}/{TileCol}/{TileRow}.png?url=https"
+        in response.content.decode()
+    )
+    assert (
+        "<ows:SupportedCRS>http://www.opengis.net/def/crs/EPSG/0/3857</ows:SupportedCRS>"
         in response.content.decode()
     )
 
     response = app.get(
-        "/cog/WMTSCapabilities.xml?url=https://myurl.com/cog.tif&tile_scale=2&tile_format=jpg"
+        "/cog/WMTSCapabilities.xml?url=https://myurl.com/cog.tif&use_epsg=true"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/xml"
-    assert (
-        "http://testserver/cog/tiles/WebMercatorQuad/{TileMatrix}/{TileCol}/{TileRow}@2x.jpg?url=https"
-        in response.content.decode()
-    )
+    assert "<ows:SupportedCRS>EPSG:3857</ows:SupportedCRS>" in response.content.decode()
 
 
 @patch("rio_tiler.io.rasterio.rasterio")
@@ -86,7 +74,7 @@ def test_tile(rio, app):
 
     # full tile
     response = app.get(
-        "/cog/tiles/8/87/48?url=https://myurl.com/cog.tif&rescale=0,1000"
+        "/cog/tiles/WebMercatorQuad/8/87/48?url=https://myurl.com/cog.tif&rescale=0,1000"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpeg"
@@ -96,7 +84,7 @@ def test_tile(rio, app):
     assert meta["height"] == 256
 
     response = app.get(
-        "/cog/tiles/8/87/48@2x?url=https://myurl.com/cog.tif&rescale=0,1000&color_formula=Gamma R 3"
+        "/cog/tiles/WebMercatorQuad/8/87/48?url=https://myurl.com/cog.tif&rescale=0,1000&tilesize=512&color_formula=Gamma R 3"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpeg"
@@ -105,25 +93,19 @@ def test_tile(rio, app):
     assert meta["height"] == 512
 
     response = app.get(
-        "/cog/tiles/8/87/48.jpg?url=https://myurl.com/cog.tif&rescale=0,1000"
+        "/cog/tiles/WebMercatorQuad/8/87/48.jpg?url=https://myurl.com/cog.tif&rescale=0,1000"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpg"
 
     response = app.get(
-        "/cog/tiles/8/87/48.jpeg?url=https://myurl.com/cog.tif&rescale=0,1000"
+        "/cog/tiles/WebMercatorQuad/8/87/48.jpeg?url=https://myurl.com/cog.tif&rescale=0,1000"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpeg"
 
     response = app.get(
-        "/cog/tiles/8/87/48@2x.jpg?url=https://myurl.com/cog.tif&rescale=0,1000"
-    )
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "image/jpg"
-
-    response = app.get(
-        "/cog/tiles/8/87/48@2x.tif?url=https://myurl.com/cog.tif&nodata=0&bidx=1"
+        "/cog/tiles/WebMercatorQuad/8/87/48.tif?url=https://myurl.com/cog.tif&nodata=0&bidx=1&tilesize=512"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
@@ -133,14 +115,16 @@ def test_tile(rio, app):
     assert meta["width"] == 512
     assert meta["height"] == 512
 
-    response = app.get("/cog/tiles/8/87/48.npy?url=https://myurl.com/cog.tif&nodata=0")
+    response = app.get(
+        "/cog/tiles/WebMercatorQuad/8/87/48.npy?url=https://myurl.com/cog.tif&nodata=0"
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/x-binary"
     data = numpy.load(BytesIO(response.content))
     assert data.shape == (2, 256, 256)
 
     response = app.get(
-        "/cog/tiles/8/87/48.npy?url=https://myurl.com/cog.tif&nodata=0&return_mask=false"
+        "/cog/tiles/WebMercatorQuad/8/87/48.npy?url=https://myurl.com/cog.tif&nodata=0&return_mask=false"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/x-binary"
@@ -150,7 +134,7 @@ def test_tile(rio, app):
     # Test brotli compression
     headers = {"Accept-Encoding": "br"}
     response = app.get(
-        "/cog/tiles/8/87/48.npy?url=https://myurl.com/cog.tif&nodata=0&return_mask=false",
+        "/cog/tiles/WebMercatorQuad/8/87/48.npy?url=https://myurl.com/cog.tif&nodata=0&return_mask=false",
         headers=headers,
     )
     assert response.status_code == 200
@@ -159,7 +143,7 @@ def test_tile(rio, app):
     # Exclude png from compression middleware
     headers = {"Accept-Encoding": "br"}
     response = app.get(
-        "/cog/tiles/8/87/48.png?url=https://myurl.com/cog.tif&nodata=0&return_mask=false",
+        "/cog/tiles/WebMercatorQuad/8/87/48.png?url=https://myurl.com/cog.tif&nodata=0&return_mask=false",
         headers=headers,
     )
     assert response.status_code == 200
@@ -168,7 +152,7 @@ def test_tile(rio, app):
     # Test gzip fallback
     headers = {"Accept-Encoding": "gzip"}
     response = app.get(
-        "/cog/tiles/8/87/48.npy?url=https://myurl.com/cog.tif&nodata=0&return_mask=false",
+        "/cog/tiles/WebMercatorQuad/8/87/48.npy?url=https://myurl.com/cog.tif&nodata=0&return_mask=false",
         headers=headers,
     )
     assert response.status_code == 200
@@ -176,19 +160,23 @@ def test_tile(rio, app):
 
     # partial
     response = app.get(
-        "/cog/tiles/8/84/47?url=https://myurl.com/cog.tif&rescale=0,1000"
+        "/cog/tiles/WebMercatorQuad/8/84/47?url=https://myurl.com/cog.tif&rescale=0,1000"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
 
     response = app.get(
-        "/cog/tiles/8/84/47?url=https://myurl.com/cog.tif&nodata=0&rescale=0,1000&colormap_name=viridis"
+        "/cog/tiles/WebMercatorQuad/8/84/47?url=https://myurl.com/cog.tif&nodata=0&rescale=0,1000&colormap_name=viridis"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
 
-    cmap = urlencode(
-        {
+    # valid colormap
+    response = app.get(
+        "/cog/tiles/WebMercatorQuad/8/53/50.png",
+        params={
+            "url": "https://myurl.com/above_cog.tif",
+            "bidx": 1,
             "colormap": json.dumps(
                 {
                     "1": [58, 102, 24, 255],
@@ -196,34 +184,31 @@ def test_tile(rio, app):
                     "3": "#b1b129",
                     "4": "#ddcb9aFF",
                 }
-            )
-        }
-    )
-    response = app.get(
-        f"/cog/tiles/8/53/50.png?url=https://myurl.com/above_cog.tif&bidx=1&{cmap}"
+            ),
+        },
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
 
-    cmap = urlencode({"colormap": json.dumps({"1": [58, 102]})})
+    # invalid colormap shape
     response = app.get(
-        f"/cog/tiles/8/53/50.png?url=https://myurl.com/above_cog.tif&bidx=1&{cmap}"
+        "/cog/tiles/WebMercatorQuad/8/53/50.png",
+        params={
+            "url": "https://myurl.com/above_cog.tif",
+            "bidx": 1,
+            "colormap": json.dumps({"1": [58, 102]}),
+        },
     )
     assert response.status_code == 400
 
-    cmap = urlencode({"colormap": {"1": "#ddcb9aFF"}})
+    # bad resampling
     response = app.get(
-        f"/cog/tiles/8/53/50.png?url=https://myurl.com/above_cog.tif&bidx=1&{cmap}"
-    )
-    assert response.status_code == 400
-
-    response = app.get(
-        "/cog/tiles/8/53/50.png?url=https://myurl.com/above_cog.tif&bidx=1&resampling=somethingwrong"
+        "/cog/tiles/WebMercatorQuad/8/53/50.png?url=https://myurl.com/above_cog.tif&bidx=1&resampling=somethingwrong"
     )
     assert response.status_code == 422
 
     response = app.get(
-        "/cog/tiles/8/87/48@2x.tif?url=https://myurl.com/cog.tif&nodata=0&bidx=1&return_mask=false"
+        "/cog/tiles/WebMercatorQuad/8/87/48.tif?url=https://myurl.com/cog.tif&nodata=0&bidx=1&return_mask=false&tilesize=512"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
@@ -239,44 +224,41 @@ def test_tilejson(rio, app):
     """test /tilejson endpoint."""
     rio.open = mock_rasterio_open
 
-    response = app.get("/cog/tilejson.json?url=https://myurl.com/cog.tif")
+    response = app.get(
+        "/cog/WebMercatorQuad/tilejson.json?url=https://myurl.com/cog.tif"
+    )
     assert response.status_code == 200
     body = response.json()
-    assert body["tilejson"] == "2.2.0"
+    assert body["tilejson"] == "3.0.0"
     assert body["version"] == "1.0.0"
     assert body["scheme"] == "xyz"
     assert len(body["tiles"]) == 1
     assert body["tiles"][0].startswith(
-        "http://testserver/cog/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https"
+        "http://testserver/cog/tiles/WebMercatorQuad/{z}/{x}/{y}?url=https"
     )
     assert body["minzoom"] == 5
     assert body["maxzoom"] == 9
     assert body["bounds"]
     assert body["center"]
 
-    response = app.get(
-        "/cog/tilejson.json?url=https://myurl.com/cog.tif&tile_format=png&tile_scale=2"
-    )
-    assert response.status_code == 200
-    body = response.json()
-    assert body["tiles"][0].startswith(
-        "http://testserver/cog/tiles/WebMercatorQuad/{z}/{x}/{y}@2x.png?url=https"
-    )
-
     cmap_dict = {
         "1": [58, 102, 24, 255],
         "2": [100, 177, 41],
         "3": "#b1b129",
         "4": "#ddcb9aFF",
     }
-    cmap = urlencode({"colormap": json.dumps(cmap_dict)})
     response = app.get(
-        f"/cog/tilejson.json?url=https://myurl.com/above_cog.tif&bidx=1&{cmap}"
+        "/cog/WebMercatorQuad/tilejson.json",
+        params={
+            "url": "https://myurl.com/above_cog.tif",
+            "bidx": 1,
+            "colormap": json.dumps(cmap_dict),
+        },
     )
     assert response.status_code == 200
     body = response.json()
     assert body["tiles"][0].startswith(
-        "http://testserver/cog/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url=https"
+        "http://testserver/cog/tiles/WebMercatorQuad/{z}/{x}/{y}?url=https"
     )
     query = dict(parse_qsl(urlparse(body["tiles"][0]).query))
     assert json.loads(query["colormap"]) == cmap_dict
@@ -340,11 +322,11 @@ def test_preview(rio, app):
 
 @patch("rio_tiler.io.rasterio.rasterio")
 def test_part(rio, app):
-    """test /crop endpoint."""
+    """test /bbox endpoint."""
     rio.open = mock_rasterio_open
 
     response = app.get(
-        "/cog/crop/-56.228,72.715,-54.547,73.188.png?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256"
+        "/cog/bbox/-56.228,72.715,-54.547,73.188.png?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
@@ -355,7 +337,7 @@ def test_part(rio, app):
     assert meta["driver"] == "PNG"
 
     response = app.get(
-        "/cog/crop/-56.228,72.715,-54.547,73.188.jpg?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256&return_mask=false"
+        "/cog/bbox/-56.228,72.715,-54.547,73.188.jpg?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256&return_mask=false"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpg"
@@ -366,7 +348,7 @@ def test_part(rio, app):
     assert meta["driver"] == "JPEG"
 
     response = app.get(
-        "/cog/crop/-56.228,72.715,-54.547,73.188/128x128.png?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256"
+        "/cog/bbox/-56.228,72.715,-54.547,73.188/128x128.png?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
@@ -376,7 +358,7 @@ def test_part(rio, app):
     assert meta["driver"] == "PNG"
 
     response = app.get(
-        "/cog/crop/-56.228,72.715,-54.547,73.188.png?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256&width=512&height=512"
+        "/cog/bbox/-56.228,72.715,-54.547,73.188.png?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256&width=512&height=512"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
@@ -386,7 +368,7 @@ def test_part(rio, app):
     assert meta["driver"] == "PNG"
 
     response = app.get(
-        "/cog/crop/-56.228,72.715,-54.547,73.188.npy?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256"
+        "/cog/bbox/-56.228,72.715,-54.547,73.188.npy?url=https://myurl.com/cog.tif&rescale=0,1000&max_size=256"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/x-binary"
@@ -417,7 +399,9 @@ def test_tile_outside_bounds_error(rio, app):
     """raise 404 when tile is not found."""
     rio.open = mock_rasterio_open
 
-    response = app.get("/cog/tiles/15/0/0?url=https://myurl.com/cog.tif&rescale=0,1000")
+    response = app.get(
+        "/cog/tiles/WebMercatorQuad/15/0/0?url=https://myurl.com/cog.tif&rescale=0,1000"
+    )
     assert response.status_code == 404
     assert response.headers["Cache-Control"] == "private, max-age=3600"
 
diff --git a/src/titiler/application/tests/routes/test_mosaic.py b/src/titiler/application/tests/routes/test_mosaic.py
index 3e092329d..efcd01c8c 100644
--- a/src/titiler/application/tests/routes/test_mosaic.py
+++ b/src/titiler/application/tests/routes/test_mosaic.py
@@ -4,7 +4,7 @@
 from typing import Any, Callable
 from unittest.mock import patch
 
-import mercantile
+import morecantile
 from cogeo_mosaic.backends import FileBackend
 from cogeo_mosaic.mosaic import MosaicJSON
 
@@ -42,53 +42,44 @@ def test_read_mosaic(app):
     MosaicJSON(**response.json())
 
 
-def test_bounds(app):
-    """test GET /mosaicjson/bounds endpoint"""
-    response = app.get("/mosaicjson/bounds", params={"url": MOSAICJSON_FILE})
-    assert response.status_code == 200
-    body = response.json()
-    assert len(body["bounds"]) == 4
-    assert body["bounds"][0] < body["bounds"][2]
-    assert body["bounds"][1] < body["bounds"][3]
-
-
 def test_info(app):
     """test GET /mosaicjson/info endpoint"""
     response = app.get("/mosaicjson/info", params={"url": MOSAICJSON_FILE})
     assert response.status_code == 200
     body = response.json()
-    assert body["minzoom"] == 7
-    assert body["maxzoom"] == 9
-    assert body["name"] == "mosaic"  # mosaic.name is not set
     assert body["quadkeys"] == []
+    assert body["mosaic_minzoom"] == 7
+    assert body["mosaic_maxzoom"] == 9
+    assert body["mosaic_tilematrixset"]
 
     response = app.get("/mosaicjson/info.geojson", params={"url": MOSAICJSON_FILE})
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
     body = response.json()
     assert body["geometry"]
-    assert body["properties"]["minzoom"] == 7
-    assert body["properties"]["maxzoom"] == 9
-    assert body["properties"]["name"] == "mosaic"  # mosaic.name is not set
     assert body["properties"]["quadkeys"] == []
+    assert body["properties"]["mosaic_minzoom"] == 7
+    assert body["properties"]["mosaic_maxzoom"] == 9
+    assert body["properties"]["mosaic_tilematrixset"]
 
 
 def test_tilejson(app):
-    """test GET /mosaicjson/tilejson.json endpoint"""
+    """test GET /mosaicjson/WebMercatorQuad/tilejson.json endpoint"""
     mosaicjson = read_json_fixture(MOSAICJSON_FILE)
-    response = app.get("/mosaicjson/tilejson.json", params={"url": MOSAICJSON_FILE})
+    response = app.get(
+        "/mosaicjson/WebMercatorQuad/tilejson.json", params={"url": MOSAICJSON_FILE}
+    )
     assert response.status_code == 200
     body = response.json()
     TileJSON(**body)
 
     assert (
-        "http://testserver/mosaicjson/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url="
+        "http://testserver/mosaicjson/tiles/WebMercatorQuad/{z}/{x}/{y}?url="
         in body["tiles"][0]
     )
     assert body["minzoom"] == mosaicjson["minzoom"]
     assert body["maxzoom"] == mosaicjson["maxzoom"]
     assert body["bounds"] == mosaicjson["bounds"]
-    assert body["center"] == mosaicjson["center"]
 
 
 def test_point(app):
@@ -102,22 +93,23 @@ def test_point(app):
         )
     assert response.status_code == 200
     body = response.json()
-    assert len(body["values"]) == 1
-    assert body["values"][0][0].endswith(".tif")
-    assert body["values"][0][1] == [9943, 9127, 9603]
+    assert len(body["assets"]) == 1
+    assert body["assets"][0]["name"].endswith(".tif")
+    assert body["assets"][0]["values"] == [9943, 9127, 9603]
 
 
 def test_tile(app):
     """Test GET /mosaicjson/tiles endpoint"""
     mosaicjson = read_json_fixture(MOSAICJSON_FILE)
     bounds = mosaicjson["bounds"]
-    tile = mercantile.tile(*mosaicjson["center"])
-    partial_tile = mercantile.tile(bounds[0], bounds[1], mosaicjson["minzoom"])
+    tms = morecantile.tms.get("WebMercatorQuad")
+    tile = tms.tile(*mosaicjson["center"])
+    partial_tile = tms.tile(bounds[0], bounds[1], mosaicjson["minzoom"])
 
     with patch.object(FileBackend, "_read", mosaic_read_factory(MOSAICJSON_FILE)):
         # full tile
         response = app.get(
-            f"/mosaicjson/tiles/{tile.z}/{tile.x}/{tile.y}",
+            f"/mosaicjson/tiles/WebMercatorQuad/{tile.z}/{tile.x}/{tile.y}",
             params={"url": MOSAICJSON_FILE},
         )
         assert response.status_code == 200
@@ -126,8 +118,8 @@ def test_tile(app):
         assert meta["width"] == meta["height"] == 256
 
         response = app.get(
-            f"/mosaicjson/tiles/{tile.z}/{tile.x}/{tile.y}@2x",
-            params={"url": MOSAICJSON_FILE},
+            f"/mosaicjson/tiles/WebMercatorQuad/{tile.z}/{tile.x}/{tile.y}",
+            params={"url": MOSAICJSON_FILE, "tilesize": 512},
         )
         assert response.status_code == 200
         assert response.headers["content-type"] == "image/png"
@@ -135,7 +127,7 @@ def test_tile(app):
         assert meta["width"] == meta["height"] == 512
 
         response = app.get(
-            f"/mosaicjson/tiles/{tile.z}/{tile.x}/{tile.y}.tif",
+            f"/mosaicjson/tiles/WebMercatorQuad/{tile.z}/{tile.x}/{tile.y}.tif",
             params={"url": MOSAICJSON_FILE},
         )
         assert response.status_code == 200
@@ -145,8 +137,8 @@ def test_tile(app):
         assert meta["crs"] == 3857
 
         response = app.get(
-            f"/mosaicjson/tiles/{tile.z}/{tile.x}/{tile.y}@2x.tif",
-            params={"url": MOSAICJSON_FILE, "nodata": 0, "bidx": 1},
+            f"/mosaicjson/tiles/WebMercatorQuad/{tile.z}/{tile.x}/{tile.y}.tif",
+            params={"url": MOSAICJSON_FILE, "nodata": 0, "bidx": 1, "tilesize": 512},
         )
         assert response.status_code == 200
         assert response.headers["content-type"] == "image/tiff; application=geotiff"
@@ -157,7 +149,7 @@ def test_tile(app):
         assert meta["height"] == 512
 
         response = app.get(
-            f"/mosaicjson/tiles/{tile.z}/{tile.x}/{tile.y}@2x.jpg",
+            f"/mosaicjson/tiles/WebMercatorQuad/{tile.z}/{tile.x}/{tile.y}.jpg",
             params={
                 "url": MOSAICJSON_FILE,
                 "rescale": "0,1000",
@@ -170,14 +162,14 @@ def test_tile(app):
 
         # partial tile
         response = app.get(
-            f"/mosaicjson/tiles/{partial_tile.z}/{partial_tile.x}/{partial_tile.y}",
+            f"/mosaicjson/tiles/WebMercatorQuad/{partial_tile.z}/{partial_tile.x}/{partial_tile.y}",
             params={"url": MOSAICJSON_FILE},
         )
         assert response.status_code == 200
         assert response.headers["content-type"] == "image/png"
 
         response = app.get(
-            f"/mosaicjson/tiles/{partial_tile.z}/{partial_tile.x}/{partial_tile.y}.tif",
+            f"/mosaicjson/tiles/WebMercatorQuad/{partial_tile.z}/{partial_tile.x}/{partial_tile.y}.tif",
             params={"url": MOSAICJSON_FILE, "resampling": "bilinear"},
         )
         assert response.status_code == 200
@@ -185,26 +177,16 @@ def test_tile(app):
 
 
 def test_wmts(app):
-    """test GET /mosaicjson/WMTSCapabilities.xml endpoint"""
+    """test GET /mosaicjson/WebMercatorQuad/WMTSCapabilities.xml endpoint"""
     with patch.object(FileBackend, "_read", mosaic_read_factory(MOSAICJSON_FILE)):
-        response = app.get(
-            "/mosaicjson/WMTSCapabilities.xml", params={"url": MOSAICJSON_FILE}
-        )
-        assert response.status_code == 200
-        assert response.headers["content-type"] == "application/xml"
-        assert (
-            "http://testserver/mosaicjson/tiles/WebMercatorQuad/{TileMatrix}/{TileCol}/{TileRow}@1x.png?url="
-            in response.content.decode()
-        )
-
         response = app.get(
             "/mosaicjson/WMTSCapabilities.xml",
-            params={"url": MOSAICJSON_FILE, "tile_scale": 2},
+            params={"url": MOSAICJSON_FILE},
         )
         assert response.status_code == 200
         assert response.headers["content-type"] == "application/xml"
         assert (
-            "http://testserver/mosaicjson/tiles/WebMercatorQuad/{TileMatrix}/{TileCol}/{TileRow}@2x.png?url="
+            "http://testserver/mosaicjson/tiles/WebMercatorQuad/{TileMatrix}/{TileCol}/{TileRow}.png?url="
             in response.content.decode()
         )
 
diff --git a/src/titiler/application/tests/routes/test_stac.py b/src/titiler/application/tests/routes/test_stac.py
index 2ced6f0dd..70adf9a2c 100644
--- a/src/titiler/application/tests/routes/test_stac.py
+++ b/src/titiler/application/tests/routes/test_stac.py
@@ -1,5 +1,4 @@
-"""test /COG endpoints."""
-
+"""test /stac endpoints."""
 
 from typing import Dict
 from unittest.mock import patch
@@ -9,17 +8,6 @@
 from ..conftest import mock_rasterio_open, mock_RequestGet
 
 
-@patch("rio_tiler.io.stac.httpx")
-def test_bounds(httpx, app):
-    """test /bounds endpoint."""
-    httpx.get = mock_RequestGet
-
-    response = app.get("/stac/bounds?url=https://myurl.com/item.json")
-    assert response.status_code == 200
-    body = response.json()
-    assert len(body["bounds"]) == 4
-
-
 @patch("rio_tiler.io.rasterio.rasterio")
 @patch("rio_tiler.io.stac.httpx")
 def test_info(httpx, rio, app):
@@ -37,7 +25,11 @@ def test_info(httpx, rio, app):
     body = response.json()
     assert body["B01"]
 
+    # no assets
     response = app.get("/stac/info?url=https://myurl.com/item.json")
+    assert response.status_code == 422
+
+    response = app.get("/stac/info?url=https://myurl.com/item.json&assets=:all:")
     assert response.status_code == 200
     body = response.json()
     assert body["B01"]
@@ -75,20 +67,13 @@ def test_tile(httpx, rio, app):
     rio.open = mock_rasterio_open
 
     # Missing assets
-    response = app.get("/stac/tiles/9/289/207?url=https://myurl.com/item.json")
-    assert response.status_code == 400
-
     response = app.get(
-        "/stac/tiles/9/289/207?url=https://myurl.com/item.json&assets=B01&rescale=0,1000"
+        "/stac/tiles/WebMercatorQuad/9/289/207?url=https://myurl.com/item.json"
     )
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "image/png"
-    meta = parse_img(response.content)
-    assert meta["width"] == 256
-    assert meta["height"] == 256
+    assert response.status_code == 422
 
     response = app.get(
-        "/stac/tiles/9/289/207?url=https://myurl.com/item.json&expression=B01_b1&rescale=0,1000"
+        "/stac/tiles/WebMercatorQuad/9/289/207?url=https://myurl.com/item.json&assets=B01&rescale=0,1000"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
@@ -104,20 +89,22 @@ def test_tilejson(httpx, rio, app):
     httpx.get = mock_RequestGet
     rio.open = mock_rasterio_open
 
-    response = app.get("/stac/tilejson.json?url=https://myurl.com/item.json")
-    assert response.status_code == 400
+    response = app.get(
+        "/stac/WebMercatorQuad/tilejson.json?url=https://myurl.com/item.json"
+    )
+    assert response.status_code == 422
 
     response = app.get(
-        "/stac/tilejson.json?url=https://myurl.com/item.json&assets=B01&minzoom=5&maxzoom=10"
+        "/stac/WebMercatorQuad/tilejson.json?url=https://myurl.com/item.json&assets=B01&minzoom=5&maxzoom=10"
     )
     assert response.status_code == 200
     body = response.json()
-    assert body["tilejson"] == "2.2.0"
+    assert body["tilejson"] == "3.0.0"
     assert body["version"] == "1.0.0"
     assert body["scheme"] == "xyz"
     assert len(body["tiles"]) == 1
     assert body["tiles"][0].startswith(
-        "http://testserver/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@1x?url="
+        "http://testserver/stac/tiles/WebMercatorQuad/{z}/{x}/{y}?url="
     )
     assert body["minzoom"] == 5
     assert body["maxzoom"] == 10
@@ -125,13 +112,14 @@ def test_tilejson(httpx, rio, app):
     assert body["center"]
 
     response = app.get(
-        "/stac/tilejson.json?url=https://myurl.com/item.json&assets=B01&tile_format=png&tile_scale=2"
+        "/stac/WebMercatorQuad/tilejson.json?url=https://myurl.com/item.json&assets=B01&tile_format=png&tilesize=512"
     )
     assert response.status_code == 200
     body = response.json()
     assert body["tiles"][0].startswith(
-        "http://testserver/stac/tiles/WebMercatorQuad/{z}/{x}/{y}@2x.png?url="
+        "http://testserver/stac/tiles/WebMercatorQuad/{z}/{x}/{y}.png?url="
     )
+    assert "tilesize=512" in body["tiles"][0]
 
 
 @patch("rio_tiler.io.rasterio.rasterio")
@@ -141,9 +129,9 @@ def test_preview(httpx, rio, app):
     httpx.get = mock_RequestGet
     rio.open = mock_rasterio_open
 
-    # Missing Assets or Expression
+    # Missing Assets
     response = app.get("/stac/preview?url=https://myurl.com/item.json")
-    assert response.status_code == 400
+    assert response.status_code == 422
 
     response = app.get(
         "/stac/preview?url=https://myurl.com/item.json&assets=B01&rescale=0,1000&max_size=64"
@@ -164,13 +152,25 @@ def test_preview(httpx, rio, app):
     assert meta["height"] == 128
 
     response = app.get(
-        "/stac/preview?url=https://myurl.com/item.json&expression=B01_b1&rescale=0,1000&max_size=64"
+        "/stac/preview.tiff?url=https://myurl.com/items_bands.json&assets=rgb&return_mask=False"
     )
     assert response.status_code == 200
-    assert response.headers["content-type"] == "image/png"
     meta = parse_img(response.content)
-    assert meta["width"] == 64
-    assert meta["height"] == 64
+    assert meta["count"] == 3
+
+    response = app.get(
+        "/stac/preview.tiff?url=https://myurl.com/items_bands.json&assets=rgb|bands=red&return_mask=False"
+    )
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["count"] == 1
+
+    response = app.get(
+        "/stac/preview.tiff?url=https://myurl.com/items_bands.json&assets=rgb|bidx=1&return_mask=False"
+    )
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["count"] == 1
 
 
 @patch("rio_tiler.io.rasterio.rasterio")
@@ -180,14 +180,14 @@ def test_part(httpx, rio, app):
     httpx.get = mock_RequestGet
     rio.open = mock_rasterio_open
 
-    # Missing Assets or Expression
+    # Missing Assets
     response = app.get(
-        "/stac/crop/23.878,32.063,23.966,32.145.png?url=https://myurl.com/item.json"
+        "/stac/bbox/23.878,32.063,23.966,32.145.png?url=https://myurl.com/item.json"
     )
-    assert response.status_code == 400
+    assert response.status_code == 422
 
     response = app.get(
-        "/stac/crop/23.878,32.063,23.966,32.145.png?url=https://myurl.com/item.json&assets=B01&rescale=0,1000&max_size=64"
+        "/stac/bbox/23.878,32.063,23.966,32.145.png?url=https://myurl.com/item.json&assets=B01&rescale=0,1000&max_size=64"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
@@ -196,7 +196,7 @@ def test_part(httpx, rio, app):
     assert meta["height"] == 14
 
     response = app.get(
-        "/stac/crop/23.878,32.063,23.966,32.145.png?url=https://myurl.com/item.json&assets=B01&rescale=0,1000&max_size=64&width=128&height=128"
+        "/stac/bbox/23.878,32.063,23.966,32.145.png?url=https://myurl.com/item.json&assets=B01&rescale=0,1000&max_size=64&width=128&height=128"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
@@ -205,7 +205,7 @@ def test_part(httpx, rio, app):
     assert meta["height"] == 128
 
     response = app.get(
-        "/stac/crop/23.878,32.063,23.966,32.145.png?url=https://myurl.com/item.json&expression=B01_b1&rescale=0,1000&max_size=64"
+        "/stac/bbox/23.878,32.063,23.966,32.145.png?url=https://myurl.com/item.json&assets=B01&rescale=0,1000&max_size=64"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
@@ -217,13 +217,13 @@ def test_part(httpx, rio, app):
 @patch("rio_tiler.io.rasterio.rasterio")
 @patch("rio_tiler.io.stac.httpx")
 def test_point(httpx, rio, app):
-    """test crop endpoints."""
+    """test point endpoints."""
     httpx.get = mock_RequestGet
     rio.open = mock_rasterio_open
 
-    # Missing Assets or Expression
+    # Missing Assets
     response = app.get("/stac/point/23.878,32.063?url=https://myurl.com/item.json")
-    assert response.status_code == 400
+    assert response.status_code == 422
 
     response = app.get(
         "/stac/point/23.878,32.063?url=https://myurl.com/item.json&assets=B01"
@@ -232,24 +232,46 @@ def test_point(httpx, rio, app):
     body = response.json()
     assert body["coordinates"] == [23.878, 32.063]
     assert body["values"] == [3565]
-    assert body["band_names"] == ["B01_b1"]
+    assert body["band_names"] == ["b1"]
+    assert body["band_descriptions"] == ["B01_b1"]
+
+    response = app.get(
+        "/stac/point/23.878,32.063?url=https://myurl.com/item.json&assets=B01&expression=b1*2"
+    )
+    assert response.status_code == 200
+    body = response.json()
+    assert body["coordinates"] == [23.878, 32.063]
+    assert body["values"] == [7130]
+    assert body["band_names"] == ["b1"]
+    assert body["band_descriptions"] == ["B01_b1*2"]
 
     response = app.get(
-        "/stac/point/23.878,32.063?url=https://myurl.com/item.json&expression=B01_b1*2"
+        "/stac/point/23.878,32.063?url=https://myurl.com/item.json&assets=B01&expression=b1*2&asset_as_band=true"
     )
     assert response.status_code == 200
     body = response.json()
     assert body["coordinates"] == [23.878, 32.063]
     assert body["values"] == [7130]
-    assert body["band_names"] == ["B01_b1*2"]
+    assert body["band_names"] == ["b1"]
+    assert body["band_descriptions"] == ["B01*2"]
+
+    response = app.get(
+        "/stac/point/23.878,32.063?url=https://myurl.com/item.json&assets=B01&assets=B09&expression=b1/b2"
+    )
+    assert response.status_code == 200
+    body = response.json()
+    assert body["coordinates"] == [23.878, 32.063]
+    assert round(body["values"][0], 2) == 0.49
+    assert body["band_descriptions"] == ["B01_b1/B09_b1"]
 
     response = app.get(
-        "/stac/point/23.878,32.063?url=https://myurl.com/item.json&expression=B01_b1/B09_b1"
+        "/stac/point/23.878,32.063?url=https://myurl.com/item.json&assets=B01&assets=B09&expression=b1/b2&asset_as_band=true"
     )
     assert response.status_code == 200
     body = response.json()
     assert body["coordinates"] == [23.878, 32.063]
     assert round(body["values"][0], 2) == 0.49
+    assert body["band_descriptions"] == ["B01/B09"]
 
 
 @patch("rio_tiler.io.rasterio.rasterio")
diff --git a/src/titiler/application/tests/routes/test_zarr.py b/src/titiler/application/tests/routes/test_zarr.py
new file mode 100644
index 000000000..6080a18ae
--- /dev/null
+++ b/src/titiler/application/tests/routes/test_zarr.py
@@ -0,0 +1,37 @@
+"""test /COG endpoints."""
+
+import os
+
+from ..conftest import DATA_DIR
+
+dataset_3d_zarr = os.path.join(DATA_DIR, "dataset_3d.zarr")
+
+
+def test_zarr_endpoints(app):
+    """test zarr endpoint."""
+    resp = app.get("/zarr/validate", params={"url": dataset_3d_zarr})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert list(resp.json()) == ["dataset"]
+    assert resp.json()["dataset"]["compatible_with_titiler"]
+
+    resp = app.get("/zarr/dataset/keys", params={"url": dataset_3d_zarr})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert resp.json() == ["dataset"]
+
+    resp = app.get("/zarr/info", params={"url": dataset_3d_zarr, "variable": "dataset"})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+
+    resp = app.get(
+        "/zarr/tiles/WebMercatorQuad/0/0/0",
+        params={
+            "url": dataset_3d_zarr,
+            "variable": "dataset",
+            "rescale": "0,500",
+            "bidx": 1,
+        },
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/png"
diff --git a/src/titiler/application/tests/test_main.py b/src/titiler/application/tests/test_main.py
index 81ddba727..038b40400 100644
--- a/src/titiler/application/tests/test_main.py
+++ b/src/titiler/application/tests/test_main.py
@@ -5,4 +5,19 @@ def test_health(app):
     """Test /healthz endpoint."""
     response = app.get("/healthz")
     assert response.status_code == 200
-    assert response.json() == {"ping": "pong!"}
+    resp = response.json()
+    assert set(resp["versions"].keys()) == {
+        "titiler",
+        "gdal",
+        "geos",
+        "proj",
+        "rasterio",
+        "zarr",
+        "xarray",
+    }
+
+    response = app.get("/api")
+    assert response.status_code == 200
+
+    response = app.get("/api.html")
+    assert response.status_code == 200
diff --git a/src/titiler/application/titiler/application/__init__.py b/src/titiler/application/titiler/application/__init__.py
index f59030372..0e41bf20a 100644
--- a/src/titiler/application/titiler/application/__init__.py
+++ b/src/titiler/application/titiler/application/__init__.py
@@ -1,3 +1,3 @@
 """titiler.application"""
 
-__version__ = "0.11.7"
+__version__ = "2.0.1"  # x-release-please-version
diff --git a/src/titiler/application/titiler/application/main.py b/src/titiler/application/titiler/application/main.py
index d6366d8bd..4f9b844eb 100644
--- a/src/titiler/application/titiler/application/main.py
+++ b/src/titiler/application/titiler/application/main.py
@@ -1,13 +1,20 @@
 """titiler app."""
 
+import json
 import logging
+from logging import config as log_config
+from typing import Annotated, Literal
 
 import jinja2
-from fastapi import FastAPI
-from rio_tiler.io import STACReader
+import rasterio
+from cogeo_mosaic.backends import MosaicBackend as MosaicJSONBackend
+from cogeo_mosaic.errors import MosaicAuthError, MosaicError, MosaicNotFoundError
+from fastapi import Depends, FastAPI, HTTPException, Query, Security
+from fastapi.security.api_key import APIKeyQuery
+from rio_tiler.io import Reader, STACReader
+from starlette import status
 from starlette.middleware.cors import CORSMiddleware
 from starlette.requests import Request
-from starlette.responses import HTMLResponse
 from starlette.templating import Jinja2Templates
 from starlette_cramjam.middleware import CompressionMiddleware
 
@@ -16,6 +23,7 @@
 from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
 from titiler.core.factory import (
     AlgorithmFactory,
+    ColorMapFactory,
     MultiBaseTilerFactory,
     TilerFactory,
     TMSFactory,
@@ -26,63 +34,116 @@
     LowerCaseQueryStringMiddleware,
     TotalTimeMiddleware,
 )
+from titiler.core.models.OGC import Conformance, Landing
+from titiler.core.resources.enums import MediaType
+from titiler.core.utils import accept_media_type, create_html_response, update_openapi
 from titiler.extensions import (
     cogValidateExtension,
     cogViewerExtension,
     stacExtension,
+    stacRenderExtension,
     stacViewerExtension,
+    wmtsExtension,
 )
-from titiler.mosaic.errors import MOSAIC_STATUS_CODES
-from titiler.mosaic.factory import MosaicTilerFactory
-
-try:
-    pass  # type: ignore
-except ImportError:
-    # Try backported to PY<39 `importlib_resources`.
-    pass  # type: ignore
 
 logging.getLogger("botocore.credentials").disabled = True
 logging.getLogger("botocore.utils").disabled = True
+logging.getLogger("rasterio.session").setLevel(logging.ERROR)
 logging.getLogger("rio-tiler").setLevel(logging.ERROR)
 
-templates = Jinja2Templates(
-    directory="",
-    loader=jinja2.ChoiceLoader([jinja2.PackageLoader(__package__, "templates")]),
-)  # type:ignore
+api_settings = ApiSettings()
 
+# custom template directory
+templates_location: list[jinja2.BaseLoader] = (
+    [jinja2.FileSystemLoader(api_settings.template_directory)]
+    if api_settings.template_directory
+    else []
+)
+# default template directory
+templates_location.extend(
+    [
+        jinja2.PackageLoader("titiler.application", "templates"),
+        jinja2.PackageLoader("titiler.core", "templates"),
+    ]
+)
 
-api_settings = ApiSettings()
+jinja2_env = jinja2.Environment(
+    autoescape=jinja2.select_autoescape(["html"]),
+    loader=jinja2.ChoiceLoader(templates_location),
+)
+titiler_templates = Jinja2Templates(env=jinja2_env)
 
-app = FastAPI(
-    title=api_settings.name,
-    description="""A modern dynamic tile server built on top of FastAPI and Rasterio/GDAL.
+app_dependencies = []
+if api_settings.global_access_token:
+    ###############################################################################
+    # Setup a global API access key, if configured
+    api_key_query = APIKeyQuery(name="access_token", auto_error=False)
+
+    def validate_access_token(access_token: str = Security(api_key_query)):
+        """Validates API key access token, set as the `api_settings.global_access_token` value.
+        Returns True if no access token is required, or if the access token is valid.
+        Raises an HTTPException (401) if the access token is required but invalid/missing.
+        """
+        if not access_token:
+            raise HTTPException(status_code=401, detail="Missing `access_token`")
+
+        # if access_token == `token` then OK
+        if access_token != api_settings.global_access_token:
+            raise HTTPException(status_code=401, detail="Invalid `access_token`")
 
----
+        return True
 
-**Documentation**: <a href="https://developmentseed.org/titiler/" target="_blank">https://developmentseed.org/titiler/</a>
+    app_dependencies.append(Depends(validate_access_token))
 
-**Source Code**: <a href="https://github.com/developmentseed/titiler" target="_blank">https://github.com/developmentseed/titiler</a>
 
----
-    """,
+###############################################################################
+
+app = FastAPI(
+    title=api_settings.name,
+    openapi_url="/api",
+    docs_url="/api.html",
+    description=api_settings.description,
     version=titiler_version,
     root_path=api_settings.root_path,
+    dependencies=app_dependencies,
 )
 
+# Fix OpenAPI response header for OGC Common compatibility
+update_openapi(app)
+
+TITILER_CONFORMS_TO = {
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/core",
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/landing-page",
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/oas30",
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/html",
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/json",
+}
+
+
 ###############################################################################
 # Simple Dataset endpoints (e.g Cloud Optimized GeoTIFF)
 if not api_settings.disable_cog:
     cog = TilerFactory(
+        reader=Reader,
         router_prefix="/cog",
+        add_ogc_maps=True,
         extensions=[
             cogValidateExtension(),
             cogViewerExtension(),
             stacExtension(),
+            wmtsExtension(),
         ],
+        enable_telemetry=api_settings.telemetry_enabled,
+        templates=titiler_templates,
     )
 
-    app.include_router(cog.router, prefix="/cog", tags=["Cloud Optimized GeoTIFF"])
+    app.include_router(
+        cog.router,
+        prefix="/cog",
+        tags=["Cloud Optimized GeoTIFF"],
+    )
 
+    TITILER_CONFORMS_TO.update(cog.conforms_to)
 
 ###############################################################################
 # STAC endpoints
@@ -90,33 +151,110 @@
     stac = MultiBaseTilerFactory(
         reader=STACReader,
         router_prefix="/stac",
-        extensions=[
-            stacViewerExtension(),
-        ],
+        add_ogc_maps=True,
+        extensions=[stacViewerExtension(), stacRenderExtension(), wmtsExtension()],
+        enable_telemetry=api_settings.telemetry_enabled,
+        templates=titiler_templates,
     )
 
     app.include_router(
-        stac.router, prefix="/stac", tags=["SpatioTemporal Asset Catalog"]
+        stac.router,
+        prefix="/stac",
+        tags=["SpatioTemporal Asset Catalog"],
     )
 
+    TITILER_CONFORMS_TO.update(stac.conforms_to)
+
 ###############################################################################
 # Mosaic endpoints
 if not api_settings.disable_mosaic:
-    mosaic = MosaicTilerFactory(router_prefix="/mosaicjson")
-    app.include_router(mosaic.router, prefix="/mosaicjson", tags=["MosaicJSON"])
+    from titiler.mosaic.errors import MOSAIC_STATUS_CODES
+    from titiler.mosaic.extensions.mosaicjson import MosaicJSONExtension
+    from titiler.mosaic.extensions.wmts import wmtsExtension as mosaic_wmtsExtension
+    from titiler.mosaic.factory import MosaicTilerFactory
+
+    mosaic = MosaicTilerFactory(
+        backend=MosaicJSONBackend,  # type: ignore
+        router_prefix="/mosaicjson",
+        extensions=[
+            MosaicJSONExtension(),
+            mosaic_wmtsExtension(),
+        ],
+        enable_telemetry=api_settings.telemetry_enabled,
+        templates=titiler_templates,
+    )
+    app.include_router(
+        mosaic.router,
+        prefix="/mosaicjson",
+        tags=["MosaicJSON"],
+    )
+
+    # Add Mosaic specific error handlers
+    MOSAIC_STATUS_CODES.update(
+        {
+            MosaicAuthError: status.HTTP_401_UNAUTHORIZED,
+            MosaicError: status.HTTP_424_FAILED_DEPENDENCY,
+            MosaicNotFoundError: status.HTTP_404_NOT_FOUND,
+        }
+    )
+    add_exception_handlers(app, MOSAIC_STATUS_CODES)
+
+    TITILER_CONFORMS_TO.update(mosaic.conforms_to)
+
+
+###############################################################################
+# Zarr endpoints
+if not api_settings.disable_zarr:
+    from titiler.xarray.extensions import DatasetMetadataExtension, ValidateExtension
+    from titiler.xarray.factory import TilerFactory as XarrayTilerFactory
+
+    md = XarrayTilerFactory(
+        router_prefix="/zarr",
+        extensions=[
+            DatasetMetadataExtension(),
+            ValidateExtension(),
+        ],
+        enable_telemetry=api_settings.telemetry_enabled,
+        templates=titiler_templates,
+    )
+    app.include_router(
+        md.router,
+        prefix="/zarr",
+        tags=["Zarr"],
+    )
+
+    TITILER_CONFORMS_TO.update(md.conforms_to)
+
 
 ###############################################################################
 # TileMatrixSets endpoints
-tms = TMSFactory()
-app.include_router(tms.router, tags=["Tiling Schemes"])
+tms = TMSFactory(templates=titiler_templates)
+app.include_router(
+    tms.router,
+    tags=["Tiling Schemes"],
+)
+TITILER_CONFORMS_TO.update(tms.conforms_to)
 
 ###############################################################################
 # Algorithms endpoints
-algorithms = AlgorithmFactory()
-app.include_router(algorithms.router, tags=["Algorithms"])
+algorithms = AlgorithmFactory(templates=titiler_templates)
+app.include_router(
+    algorithms.router,
+    tags=["Algorithms"],
+)
+TITILER_CONFORMS_TO.update(algorithms.conforms_to)
 
+###############################################################################
+# Colormaps endpoints
+cmaps = ColorMapFactory(templates=titiler_templates)
+app.include_router(
+    cmaps.router,
+    tags=["ColorMaps"],
+)
+TITILER_CONFORMS_TO.update(cmaps.conforms_to)
+
+###############################################################################
 add_exception_handlers(app, DEFAULT_STATUS_CODES)
-add_exception_handlers(app, MOSAIC_STATUS_CODES)
 
 # Set all CORS enabled origins
 if api_settings.cors_origins:
@@ -124,7 +262,7 @@
         CORSMiddleware,
         allow_origins=api_settings.cors_origins,
         allow_credentials=True,
-        allow_methods=["GET"],
+        allow_methods=api_settings.cors_allow_methods,
         allow_headers=["*"],
     )
 
@@ -138,6 +276,7 @@
         "image/jp2",
         "image/webp",
     },
+    compression_level=6,
 )
 
 app.add_middleware(
@@ -147,9 +286,70 @@
 )
 
 if api_settings.debug:
-    app.add_middleware(LoggerMiddleware, headers=True, querystrings=True)
+    app.add_middleware(LoggerMiddleware)
     app.add_middleware(TotalTimeMiddleware)
 
+    log_config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "detailed": {
+                    "format": "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+                },
+                "request": {
+                    "format": (
+                        "%(asctime)s - %(levelname)s - %(name)s - %(message)s "
+                        + json.dumps(
+                            {
+                                k: f"%({k})s"
+                                for k in [
+                                    "http.method",
+                                    "http.referer",
+                                    "http.request.header.origin",
+                                    "http.route",
+                                    "http.target",
+                                    "http.request.header.content-length",
+                                    "http.request.header.accept-encoding",
+                                    "http.request.header.origin",
+                                    "titiler.path_params",
+                                    "titiler.query_params",
+                                ]
+                            }
+                        )
+                    ),
+                },
+            },
+            "handlers": {
+                "console_detailed": {
+                    "class": "logging.StreamHandler",
+                    "level": "WARNING",
+                    "formatter": "detailed",
+                    "stream": "ext://sys.stdout",
+                },
+                "console_request": {
+                    "class": "logging.StreamHandler",
+                    "level": "DEBUG",
+                    "formatter": "request",
+                    "stream": "ext://sys.stdout",
+                },
+            },
+            "loggers": {
+                "titiler": {
+                    "level": "INFO",
+                    "handlers": ["console_detailed"],
+                    "propagate": False,
+                },
+                "titiler.requests": {
+                    "level": "INFO",
+                    "handlers": ["console_request"],
+                    "propagate": False,
+                },
+            },
+        }
+    )
+
+
 if api_settings.lower_case_query_parameters:
     app.add_middleware(LowerCaseQueryStringMiddleware)
 
@@ -161,16 +361,207 @@
     operation_id="healthCheck",
     tags=["Health Check"],
 )
-def ping():
+def application_health_check():
     """Health check."""
-    return {"ping": "pong!"}
+    versions = {
+        "titiler": titiler_version,
+        "rasterio": rasterio.__version__,
+        "gdal": rasterio.__gdal_version__,
+        "proj": rasterio.__proj_version__,
+        "geos": rasterio.__geos_version__,
+    }
+    if not api_settings.disable_zarr:
+        import xarray
+        import zarr
+
+        versions.update({"zarr": zarr.__version__, "xarray": xarray.__version__})
+
+    return {"versions": versions}
+
+
+@app.get(
+    "/",
+    response_model=Landing,
+    response_model_exclude_none=True,
+    responses={
+        200: {
+            "content": {
+                "text/html": {},
+                "application/json": {},
+            }
+        },
+    },
+    tags=["OGC Common"],
+)
+def landing(
+    request: Request,
+    f: Annotated[
+        Literal["html", "json"] | None,
+        Query(
+            description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+        ),
+    ] = None,
+):
+    """TiTiler landing page."""
+    data = {
+        "title": "TiTiler",
+        "description": "A modern dynamic tile server built on top of FastAPI and Rasterio/GDAL.",
+        "links": [
+            {
+                "title": "Landing page",
+                "href": str(request.url_for("landing")),
+                "type": "text/html",
+                "rel": "self",
+            },
+            {
+                "title": "The API definition (JSON)",
+                "href": str(request.url_for("openapi")),
+                "type": "application/vnd.oai.openapi+json;version=3.0",
+                "rel": "service-desc",
+            },
+            {
+                "title": "The API documentation",
+                "href": str(request.url_for("swagger_ui_html")),
+                "type": "text/html",
+                "rel": "service-doc",
+            },
+            {
+                "title": "Conformance Declaration",
+                "href": str(request.url_for("conformance")),
+                "type": "text/html",
+                "rel": "http://www.opengis.net/def/rel/ogc/1.0/conformance",
+            },
+            {
+                "title": "List of Available TileMatrixSets",
+                "href": str(request.url_for("tilematrixsets")),
+                "type": "application/json",
+                "rel": "http://www.opengis.net/def/rel/ogc/1.0/tiling-schemes",
+            },
+            {
+                "title": "List of Available Algorithms",
+                "href": str(request.url_for("available_algorithms")),
+                "type": "application/json",
+                "rel": "data",
+            },
+            {
+                "title": "List of Available ColorMaps",
+                "href": str(request.url_for("available_colormaps")),
+                "type": "application/json",
+                "rel": "data",
+            },
+            {
+                "title": "TiTiler Documentation (external link)",
+                "href": "https://developmentseed.org/titiler/",
+                "type": "text/html",
+                "rel": "doc",
+            },
+            {
+                "title": "TiTiler source code (external link)",
+                "href": "https://github.com/developmentseed/titiler",
+                "type": "text/html",
+                "rel": "doc",
+            },
+        ],
+    }
 
+    if f:
+        output_type = MediaType[f]
+    else:
+        accepted_media = [MediaType.html, MediaType.json]
+        output_type = (
+            accept_media_type(request.headers.get("accept", ""), accepted_media)
+            or MediaType.json
+        )
 
-@app.get("/", response_class=HTMLResponse, include_in_schema=False)
-def landing(request: Request):
-    """TiTiler Landing page"""
-    return templates.TemplateResponse(
-        name="index.html",
-        context={"request": request},
-        media_type="text/html",
+    if output_type == MediaType.html:
+        return create_html_response(
+            request,
+            data,
+            title="TiTiler",
+            template_name="landing",
+            templates=titiler_templates,
+        )
+
+    return data
+
+
+@app.get(
+    "/conformance",
+    response_model=Conformance,
+    response_model_exclude_none=True,
+    responses={
+        200: {
+            "content": {
+                "text/html": {},
+                "application/json": {},
+            }
+        },
+    },
+    tags=["OGC Common"],
+)
+def conformance(
+    request: Request,
+    f: Annotated[
+        Literal["html", "json"] | None,
+        Query(
+            description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+        ),
+    ] = None,
+):
+    """Conformance classes.
+
+    Called with `GET /conformance`.
+
+    Returns:
+        Conformance classes which the server conforms to.
+
+    """
+    data = {"conformsTo": sorted(TITILER_CONFORMS_TO)}
+
+    if f:
+        output_type = MediaType[f]
+    else:
+        accepted_media = [MediaType.html, MediaType.json]
+        output_type = (
+            accept_media_type(request.headers.get("accept", ""), accepted_media)
+            or MediaType.json
+        )
+
+    if output_type == MediaType.html:
+        return create_html_response(
+            request,
+            data,
+            title="Conformance",
+            template_name="conformance",
+            templates=titiler_templates,
+        )
+
+    return data
+
+
+if api_settings.telemetry_enabled:
+    from opentelemetry import trace
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+    from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+    from opentelemetry.instrumentation.logging import LoggingInstrumentor
+    from opentelemetry.sdk.resources import SERVICE_NAME, SERVICE_VERSION, Resource
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+    LoggingInstrumentor().instrument(set_logging_format=True)
+    FastAPIInstrumentor.instrument_app(app)
+
+    resource = Resource.create(
+        {
+            SERVICE_NAME: "titiler",
+            SERVICE_VERSION: titiler_version,
+        }
     )
+
+    provider = TracerProvider(resource=resource)
+
+    # uses the OTEL_EXPORTER_OTLP_ENDPOINT env var
+    processor = BatchSpanProcessor(OTLPSpanExporter())
+    provider.add_span_processor(processor)
+
+    trace.set_tracer_provider(provider)
diff --git a/src/titiler/application/titiler/application/py.typed b/src/titiler/application/titiler/application/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/titiler/application/titiler/application/settings.py b/src/titiler/application/titiler/application/settings.py
index 09fe63175..d4833656a 100644
--- a/src/titiler/application/titiler/application/settings.py
+++ b/src/titiler/application/titiler/application/settings.py
@@ -1,30 +1,54 @@
 """Titiler API settings."""
 
-import pydantic
+from pydantic import field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
-class ApiSettings(pydantic.BaseSettings):
+class ApiSettings(BaseSettings):
     """FASTAPI application settings."""
 
     name: str = "TiTiler"
+    description: str = """A modern dynamic tile server built on top of FastAPI and Rasterio/GDAL.
+
+---
+
+**Documentation**: <a href="https://developmentseed.org/titiler/" target="_blank">https://developmentseed.org/titiler/</a>
+
+**Source Code**: <a href="https://github.com/developmentseed/titiler" target="_blank">https://github.com/developmentseed/titiler</a>
+
+---
+    """
+
     cors_origins: str = "*"
+    cors_allow_methods: str = "GET"
     cachecontrol: str = "public, max-age=3600"
     root_path: str = ""
     debug: bool = False
 
+    template_directory: str | None = None
+
     disable_cog: bool = False
     disable_stac: bool = False
     disable_mosaic: bool = False
+    disable_zarr: bool = False
 
     lower_case_query_parameters: bool = False
 
-    @pydantic.validator("cors_origins")
+    telemetry_enabled: bool = False
+
+    # an API key required to access any endpoint, passed via the ?access_token= query parameter
+    global_access_token: str | None = None
+
+    model_config = SettingsConfigDict(
+        env_prefix="TITILER_API_", env_file=".env", extra="ignore"
+    )
+
+    @field_validator("cors_origins")
     def parse_cors_origin(cls, v):
         """Parse CORS origins."""
         return [origin.strip() for origin in v.split(",")]
 
-    class Config:
-        """model config"""
-
-        env_file = ".env"
-        env_prefix = "TITILER_API_"
+    @field_validator("cors_allow_methods")
+    def parse_cors_allow_methods(cls, v):
+        """Parse CORS allowed methods."""
+        return [method.strip().upper() for method in v.split(",")]
diff --git a/src/titiler/application/titiler/application/templates/conformance.html b/src/titiler/application/titiler/application/templates/conformance.html
new file mode 100644
index 000000000..0471b3683
--- /dev/null
+++ b/src/titiler/application/titiler/application/templates/conformance.html
@@ -0,0 +1,32 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ template.title }}</h1>
+
+<p>This API implements the conformance classes from standards and community specifications that are listed below.</p>
+
+<h2>Links</h2>
+<ul>
+{% for url in response.conformsTo %}
+  <li> <a target="_blank" href="{{ url }}">{{ url }}</a></li>
+{% endfor %}
+</ul>
+
+{% include "footer.html" %}
diff --git a/src/titiler/application/titiler/application/templates/header.html b/src/titiler/application/titiler/application/templates/header.html
new file mode 100644
index 000000000..a60001b62
--- /dev/null
+++ b/src/titiler/application/titiler/application/templates/header.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>{{ template.title }}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.3/css/bootstrap.min.css" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.css" />
+    <style>
+      html { position: relative; min-height: 100%; }
+      body { padding-top: 5rem; margin-bottom: 40px; }
+      #page { padding: 1.5rem 1.5rem; }
+      .navbar { border-bottom: 8px solid #3333A4; }
+      .navbar-brand { font-size: 2rem; color: #3333A4 !important; text-shadow: 2px 2px 4px #ccc; }
+      .json-link { font-weight: normal; }
+    </style>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
+    <script src="https://files.dnr.state.mn.us/lib/bootstrap4/javascripts/bootstrap.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.js"></script>
+  </head>
+  <body>
+    <nav class="navbar navbar-expand-md navbar-light fixed-top bg-light">
+      <a href="{{ template.api_root }}" style="width: 35px;height: auto;">
+        <img width=40 src="data:image/png;base64,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" alt="TiTiler">
+      </a>
+      <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbar" aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">
+        <span class="navbar-toggler-icon"></span>
+      </button>
+      <div class="collapse navbar-collapse" id="navbar">
+        <ul class="navbar-nav mr-auto">
+          <li class="nav-item dropdown">
+            <a class="nav-link dropdown-toggle" href="{{ template.api_root }}" id="links" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Links</a>
+            <div class="dropdown-menu" aria-labelledby="account">
+              <a class="dropdown-item" href="{{ template.api_root }}/">Home</a>
+              <a class="dropdown-item" href="{{ template.api_root }}/conformance">Conformance</a>
+              <a class="dropdown-item" href="{{ template.api_root }}/api.html">API Documentation</a>
+            </div>
+          </li>
+        </ul>
+      </div>
+    </nav>
+
+    <main role="main" class="container-fluid">
+      <div id="page">
diff --git a/src/titiler/application/titiler/application/templates/index.html b/src/titiler/application/titiler/application/templates/index.html
deleted file mode 100644
index 70f9c7ea3..000000000
--- a/src/titiler/application/titiler/application/templates/index.html
+++ /dev/null
@@ -1,56 +0,0 @@
-
-<!DOCTYPE html>
-<html>
-
-    <head>
-        <meta charset='utf-8' />
-        <title>TiTiler</title>
-        <meta name='viewport' content='initial-scale=1,maximum-scale=1,user-scalable=no' />
-    </head>
-        <style>
-            html {
-                font-family: sans-serif;
-                -ms-text-size-adjust: 100%;
-                -webkit-text-size-adjust:100%
-            }
-
-            body {
-                margin: 0;
-                padding: 0;
-                width: 100%;
-                height: 100%;
-            }
-
-            .devseed {
-                position: absolute;
-                right: 10px;
-                bottom: 0;
-                display: inline;
-            }
-        </style>
-    <body>
-        <div style="padding: 10px;">
-            <pre>
- ______   __     ______   __     __         ______     ______
-/\__  _\ /\ \   /\__  _\ /\ \   /\ \       /\  ___\   /\  == \
-\/_/\ \/ \ \ \  \/_/\ \/ \ \ \  \ \ \____  \ \  __\   \ \  __<
-   \ \_\  \ \_\    \ \_\  \ \_\  \ \_____\  \ \_____\  \ \_\ \_\
-    \/_/   \/_/     \/_/   \/_/   \/_____/   \/_____/   \/_/ /_/
-            </pre>
-
-            <p>API documentations: <a href="/docs">/docs</a>
-            <p>
-            <p>TiTiler Online documentations: <a href="https://developmentseed.org/titiler/"
-                    target="_blank">https://developmentseed.org/titiler/</a>
-            <p>
-        </div>
-
-        <div class="devseed">
-            <span>Created by </span>
-            <a href="https://www.developmentseed.org/" target="_blank">
-                <img src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" viewBox="0 0 188 32" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
    <rect id="hor--pos" x="0" y="0" width="188" height="32" style="fill:none;"/>
    <g id="hor--pos1" serif:id="hor--pos">
        <g id="text">
            <path d="M49,6L49,10.9C49,10.8 48.2,10.8 47.9,10.7C47.6,10.7 47.3,10.6 46.8,10.6C46,10.6 45.2,10.7 44.6,11C44,11.3 43.5,11.7 43.1,12.2C42.7,12.7 42.4,13.4 42.2,14.2C42.1,15 42,15.9 42,16.8C42,18.7 42.3,20.2 43,21.2C43.7,22.2 44.7,22.7 45.9,22.7C46.7,22.7 47.3,22.6 47.8,22.3C48.3,22 48.7,21.8 49.1,21.1L49.2,22.9L51,22.9L51,6L49,6ZM49,17.5C49,18 48.9,18.5 48.8,19C48.7,19.5 48.5,19.9 48.2,20.2C48,20.5 47.7,20.8 47.3,21C47,21.2 46.6,21.3 46.2,21.3C45.4,21.3 44.8,20.9 44.4,20.1C44,19.3 43.8,18.2 43.8,16.6C43.8,15.1 44,14 44.5,13.2C44.9,12.4 45.7,12.1 46.7,12.1C47.2,12.1 47.6,12.1 48,12.2C48.4,12.3 49,12.4 49,12.5L49,17.5ZM58.8,22.3C58.1,22.6 57.3,22.8 56.5,22.8C55,22.8 53.9,22.4 53.2,21.5C52.5,20.6 52.1,19.2 52.1,17.3C52.1,15.1 52.5,13.4 53.3,12.3C54.1,11.2 55.2,10.6 56.6,10.6C58,10.6 59,11.1 59.8,12.1C60.5,13.1 60.8,14.7 60.7,16.8L54,16.8L54,17C54,18.6 54.2,19.7 54.7,20.4C55.2,21.1 55.8,21.4 56.7,21.4C57.2,21.4 57.8,21.3 58.3,21.1C58.8,20.9 59.4,20.6 60.1,20.1L60.8,21.3C60.1,21.7 59.5,22 58.8,22.3ZM58.2,12.9C57.8,12.3 57.2,12 56.5,12C55.8,12 55.2,12.3 54.8,12.9C54.4,13.5 54.2,14.4 54.1,15.5L58.8,15.5C58.8,14.4 58.6,13.5 58.2,12.9ZM69.2,13.6C69,14.5 68.7,15.4 68.4,16.4C68.1,17.3 67.8,18.3 67.5,19.4C67.2,20.4 66.9,21.5 66.5,22.6L64.7,22.6C64.3,21.4 64,20.3 63.6,19.3L62.7,16.3C62.4,15.4 62.2,14.4 61.9,13.6C61.7,12.7 61.5,11.8 61.3,11L63,11L64.2,15.8C64.6,17.4 65.1,19 65.6,20.7L66.9,15.9C67.3,14.3 67.7,12.7 68.1,11L69.7,11C69.7,11.8 69.5,12.7 69.2,13.6ZM77.1,22.3C76.4,22.6 75.6,22.8 74.8,22.8C73.3,22.8 72.2,22.4 71.5,21.5C70.8,20.6 70.4,19.2 70.4,17.3C70.4,15.1 70.8,13.4 71.6,12.3C72.4,11.2 73.5,10.6 74.9,10.6C76.3,10.6 77.3,11.1 78.1,12.1C78.8,13.1 79.1,14.7 79,16.8L72.3,16.8L72.3,17C72.3,18.6 72.5,19.7 73,20.4C73.5,21.1 74.1,21.4 75,21.4C75.5,21.4 76.1,21.3 76.6,21.1C77.1,20.9 77.7,20.6 78.4,20.1L79.1,21.3C78.4,21.7 77.8,22 77.1,22.3ZM76.5,12.9C76.1,12.3 75.5,12 74.8,12C74.1,12 73.5,12.3 73.1,12.9C72.7,13.5 72.5,14.4 72.4,15.5L77,15.5C77.1,14.4 76.9,13.5 76.5,12.9ZM80.5,22.6L80.5,6.5L82.2,6.5L82.2,22.6L80.5,22.6ZM88.1,22.8C86.6,22.8 85.5,22.3 84.8,21.4C84.1,20.4 83.7,18.9 83.7,16.9C83.7,14.8 84.1,13.3 84.8,12.2C85.5,11.2 86.7,10.7 88.3,10.7C89.8,10.7 90.9,11.2 91.6,12.2C92.3,13.2 92.6,14.7 92.6,16.7C92.6,20.8 91.1,22.8 88.1,22.8ZM90.2,13.2C89.8,12.4 89.1,12 88.1,12C87.2,12 86.6,12.4 86.2,13.1C85.8,13.9 85.6,15 85.6,16.6C85.6,18.3 85.8,19.5 86.2,20.2C86.6,20.9 87.3,21.3 88.2,21.3C89.8,21.3 90.7,19.8 90.7,16.7C90.7,15.1 90.5,13.9 90.2,13.2ZM102.4,21.1C101.6,22.2 100.4,22.8 98.7,22.8C98.3,22.8 97.9,22.8 97.6,22.7C97.3,22.7 97,22.6 96.5,22.5L96.5,26.4L94.8,26.4L94.8,10.9L96.3,10.9L96.4,12.4C96.8,11.7 97.2,11.3 97.7,11C98.2,10.7 98.8,10.6 99.6,10.6C100.9,10.6 101.8,11.1 102.5,12.1C103.2,13.1 103.5,14.6 103.5,16.5C103.5,18.5 103.2,20 102.4,21.1ZM101.1,13.3C100.7,12.5 100.1,12.1 99.3,12.1C98.9,12.1 98.5,12.2 98.2,12.4C97.9,12.6 97.6,12.9 97.4,13.2C97.2,13.5 97,13.9 96.8,14.4C96.6,14.9 96.6,15.3 96.6,15.9L96.6,21C96.9,21.1 97.2,21.2 97.6,21.3C98,21.4 98.4,21.4 98.9,21.4C99.9,21.4 100.6,21 101.1,20.3C101.6,19.6 101.8,18.4 101.8,16.9C101.7,15.2 101.5,14 101.1,13.3ZM117.6,22.6L117.6,14.7C117.6,13.9 117.5,13.2 117.4,12.7C117.3,12.2 116.9,12 116.3,12C115.9,12 115.5,12.1 115.1,12.4C114.7,12.7 114.2,13.1 113.5,13.6L113.5,22.5L111.8,22.5L111.8,14.7C111.8,13.9 111.7,13.2 111.6,12.7C111.5,12.2 111.1,12 110.5,12C110.1,12 109.7,12.1 109.3,12.4C108.9,12.7 108.4,13.1 107.7,13.6L107.7,22.5L106,22.5L106,10.9L107.5,10.9L107.6,12.3L109.3,11.1C109.8,10.8 110.4,10.6 111,10.6C111.7,10.6 112.2,10.8 112.5,11.1C112.8,11.4 113.1,11.8 113.3,12.4C113.9,11.9 114.5,11.5 115.1,11.2C115.7,10.9 116.2,10.7 116.8,10.7C117.8,10.7 118.4,11 118.8,11.6C119.2,12.2 119.3,13.1 119.3,14.4L119.3,22.6L117.6,22.6ZM127.5,22.3C126.8,22.6 126,22.8 125.2,22.8C123.7,22.8 122.6,22.4 121.9,21.5C121.2,20.6 120.8,19.2 120.8,17.3C120.8,15.1 121.2,13.4 122,12.3C122.8,11.2 123.9,10.6 125.3,10.6C126.7,10.6 127.7,11.1 128.5,12.1C129.2,13.1 129.5,14.7 129.4,16.8L122.7,16.8L122.7,17C122.7,18.6 122.9,19.7 123.4,20.4C123.9,21.1 124.5,21.4 125.4,21.4C125.9,21.4 126.5,21.3 127,21.1C127.5,20.9 128.1,20.6 128.8,20.1L129.5,21.3C128.8,21.7 128.1,22 127.5,22.3ZM126.8,12.9C126.4,12.3 125.8,12 125.1,12C124.4,12 123.8,12.3 123.4,12.9C123,13.5 122.8,14.4 122.7,15.5L127.4,15.5C127.4,14.4 127.2,13.5 126.8,12.9ZM136.9,22.5L136.9,14.7C136.9,13.9 136.8,13.2 136.6,12.7C136.4,12.2 136,12 135.4,12C135,12 134.6,12.1 134.2,12.4C133.8,12.7 133.2,13.1 132.6,13.6L132.6,22.5L130.9,22.5L130.9,10.9L132.4,10.9L132.5,12.3C133.1,11.9 133.7,11.5 134.2,11.1C134.8,10.8 135.3,10.6 135.9,10.6C136.9,10.6 137.6,10.9 137.9,11.5C138.3,12.1 138.5,13 138.5,14.3L138.5,22.5L136.9,22.5ZM144.7,22.8C144.1,22.8 143.5,22.7 143.1,22.6C142.7,22.5 142.4,22.2 142.2,21.9C142,21.6 141.8,21.2 141.8,20.6C141.7,20.1 141.7,19.4 141.7,18.7L141.7,12.3L140,12.3L140,10.9L141.7,10.9L141.7,7.7L143.4,7.5L143.4,10.9L145.8,10.9L145.7,12.3L143.5,12.3L143.5,19.8C143.5,20.2 143.6,20.5 143.7,20.7C143.8,20.9 144,21.1 144.2,21.2C144.4,21.3 144.7,21.4 145.1,21.4L145.6,21.4L146.1,21.3L146.3,22.7C145.7,22.7 145.2,22.8 144.7,22.8Z" style="fill:rgb(68,63,63);fill-rule:nonzero;"/>
            <path d="M157.4,20.4C157.2,20.9 156.9,21.3 156.5,21.6C156.1,21.9 155.6,22.2 155.1,22.4C154.5,22.6 153.9,22.7 153.3,22.7C151.8,22.7 150.8,22.4 150.1,21.8C149.4,21.2 149.2,20.3 149.3,19.3L150.8,19.1C150.8,19.4 150.8,19.6 150.9,19.9C151,20.2 151.1,20.4 151.3,20.6C151.5,20.8 151.8,21 152.1,21.1C152.5,21.2 152.9,21.3 153.5,21.3C154.3,21.3 154.9,21.1 155.4,20.7C155.9,20.3 156.1,19.7 156.1,19C156.1,18.4 155.9,17.9 155.6,17.6C155.3,17.2 154.9,17 154.4,16.7C153.9,16.5 153.4,16.2 152.8,16C152.2,15.8 151.7,15.5 151.2,15.2C150.7,14.9 150.3,14.5 150,14C149.7,13.5 149.5,12.9 149.5,12.1C149.5,11.6 149.6,11.1 149.8,10.6C150,10.2 150.3,9.8 150.6,9.5C151,9.2 151.4,9 151.9,8.8C152.4,8.6 153,8.6 153.7,8.6C154.4,8.6 155,8.7 155.4,8.9C155.9,9.1 156.3,9.3 156.6,9.6C156.9,9.9 157.1,10.2 157.2,10.6C157.3,11 157.4,11.4 157.4,11.8L155.9,12C155.9,11.7 155.9,11.5 155.8,11.2C155.7,11 155.6,10.7 155.4,10.6C155.2,10.4 155,10.3 154.7,10.2C154.4,10.1 154,10 153.6,10C153.2,10 152.8,10.1 152.5,10.2C152.2,10.3 151.9,10.5 151.7,10.6C151.5,10.8 151.3,11 151.2,11.2C151.1,11.4 151,11.7 151,12C151,12.6 151.2,13.1 151.5,13.4C151.8,13.8 152.3,14 152.8,14.3L154.4,15C155,15.2 155.5,15.5 156,15.8C156.5,16.1 156.9,16.5 157.3,17C157.6,17.5 157.8,18.1 157.8,18.9C157.7,19.4 157.6,19.9 157.4,20.4ZM159.7,22.6L159.7,8.9L166.6,8.9L166.5,10.3L161.4,10.3L161.4,14.8L165.4,14.8L165.4,16.2L161.4,16.2L161.4,21.2L166.7,21.2L166.7,22.6L159.7,22.6ZM168.8,22.6L168.8,8.9L175.7,8.9L175.6,10.3L170.5,10.3L170.5,14.8L174.5,14.8L174.5,16.2L170.5,16.2L170.5,21.2L175.8,21.2L175.8,22.6L168.8,22.6ZM186.8,18.4C186.5,19.3 186.1,20 185.6,20.6C185.1,21.2 184.4,21.7 183.7,22C182.9,22.3 182.1,22.5 181.1,22.5L178.2,22.5L178.2,8.9L181.1,8.9C183.1,8.9 184.7,9.5 185.7,10.7C186.7,11.9 187.2,13.5 187.2,15.6C187.2,16.6 187.1,17.5 186.8,18.4ZM184.4,11.7C183.7,10.7 182.6,10.2 181,10.2L179.9,10.2L179.9,21.1L181.3,21.1C182.7,21.1 183.7,20.6 184.4,19.7C185.1,18.8 185.5,17.4 185.5,15.7C185.4,14 185.1,12.7 184.4,11.7Z" style="fill:rgb(208,66,0);fill-rule:nonzero;"/>
        </g>
        <g id="symbol">
            <path id="surface" d="M30,0L2,0C0.9,0 0,0.9 0,2L0,30C0,31.1 0.9,32 2,32L30,32C31.1,32 32,31.1 32,30L32,2C32,0.9 31.1,0 30,0Z" style="fill:rgb(208,66,0);fill-rule:nonzero;"/>
            <g id="shape" transform="matrix(0.925342,0,0,0.925342,1.19453,2.38906)">
                <path d="M18.1,27.2C18.1,26.6 18.3,26 18.5,25.4C17.9,25.9 17.7,26.5 17.5,27.3C17.6,26.4 18,20.4 18,20.1C19.5,15.7 18.8,2.7 20.8,1C18.6,1.4 17.8,3.7 17.1,5.5C16.4,3.4 17,2 14.6,1.2C16.5,2.8 16.1,4.2 16.5,6.4C15.4,4.9 15.7,3.1 14.4,1.6C14,1.2 12.8,0.3 12.8,0.3C12.8,0.4 13.8,2.3 14,3.4C14.2,4.4 14.6,6.5 14.6,7.3C14.8,11.5 15.8,15.6 16.6,19.8C16.7,20.5 17.1,22.6 17.1,22.6L17.2,23.5C17.1,22.9 16.9,22.4 16.9,22.2C16.7,21.6 16.2,20 16,19.3C14.2,15.6 11,8.5 6.6,7.4C9.1,9.6 11.7,12.5 12.3,15.3C11,13.4 5.8,9.5 3.6,8C7.6,12.1 10.8,16.4 14.3,21C15.3,22.3 16.6,25 16.7,25.6C16.8,26 16.8,27.7 16.9,28.7C15,24 13.9,21.6 10.3,19.5C9.7,19.2 7.8,18.5 7.8,18.5C8.7,19.5 9.7,19.5 10.5,20.8C8.9,19.7 7.2,19.5 5.3,19.5C11.3,22.6 14.5,23.5 16.5,29.4C16.7,30.4 16.4,31 16.4,32L17.7,32L17.7,30.6C17.8,30.2 17.8,28.9 18,28.6C18.6,27 19.6,26.3 21.1,25.3C19.7,25.8 19.1,25.6 18.1,27.2ZM24,13.2C23.5,13.7 22,15.5 22,15.5C22.1,12.9 22.7,10.1 24.4,8.1C22.1,9.6 20.8,13.4 20.1,15.7C19.9,16.6 17.1,22 18.4,24.9C18.6,23.8 19.2,22.8 19.9,21.9C20.2,21.5 21.5,19.4 22.8,16.5C23.9,13.6 25.8,11.8 28.4,10.4C26.5,10.7 25.4,11.8 24,13.2Z" style="fill:white;fill-rule:nonzero;"/>
            </g>
        </g>
    </g>
</svg>
"
-                    alt="Development Seed">
-            </a>
-        </div>
-    </body>
-</html>
diff --git a/src/titiler/application/titiler/application/templates/landing.html b/src/titiler/application/titiler/application/templates/landing.html
new file mode 100644
index 000000000..715d91d5b
--- /dev/null
+++ b/src/titiler/application/titiler/application/templates/landing.html
@@ -0,0 +1,42 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ response.title }}</h1>
+<p>
+  {{ response.description }}
+</p>
+
+<pre>
+  ______   __     ______   __     __         ______     ______
+/\__  _\ /\ \   /\__  _\ /\ \   /\ \       /\  ___\   /\  == \
+\/_/\ \/ \ \ \  \/_/\ \/ \ \ \  \ \ \____  \ \  __\   \ \  __<
+    \ \_\  \ \_\    \ \_\  \ \_\  \ \_____\  \ \_____\  \ \_\ \_\
+    \/_/   \/_/     \/_/   \/_/   \/_____/   \/_____/   \/_/ /_/
+
+  </pre>
+
+<h2>Links</h2>
+<ul>
+{% for link in response.links %}
+  <li> <a href="{{ link.href }}">{{ link.title or link.rel }}</a></li>
+{% endfor %}
+</ul>
+
+{% include "footer.html" %}
diff --git a/src/titiler/core/LICENSE b/src/titiler/core/LICENSE
new file mode 100644
index 000000000..eb4365951
--- /dev/null
+++ b/src/titiler/core/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Development Seed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/titiler/core/README.md b/src/titiler/core/README.md
index 4a8fa87c1..ae5804fa7 100644
--- a/src/titiler/core/README.md
+++ b/src/titiler/core/README.md
@@ -5,14 +5,14 @@ Core of Titiler's application. Contains blocks to create dynamic tile servers.
 ## Installation
 
 ```bash
-$ pip install -U pip
+python -m pip install -U pip
 
 # From Pypi
-$ pip install titiler.core
+python -m pip install titiler.core
 
 # Or from sources
-$ git clone https://github.com/developmentseed/titiler.git
-$ cd titiler && pip install -e titiler/core
+git clone https://github.com/developmentseed/titiler.git
+cd titiler && python -m pip install -e src/titiler/core
 ```
 
 ## How To
@@ -33,8 +33,6 @@ cog = TilerFactory()
 app.include_router(cog.router, tags=["Cloud Optimized GeoTIFF"])
 ```
 
-See [titiler.application](../application) for a full example.
-
 ## Package structure
 
 ```
@@ -42,6 +40,10 @@ titiler/
  └── core/
     ├── tests/                   - Tests suite
     └── titiler/core/            - `core` namespace package
+        ├── algorithm/
+        |   ├── base.py          - ABC Base Class for custom algorithms
+        |   ├── dem.py           - Elevation data related algorithms
+        |   └── index.py         - Simple band index algorithms
         ├── models/
         |   ├── response.py      - Titiler's response models
         |   ├── mapbox.py        - Mapbox TileJSON pydantic model
@@ -50,10 +52,13 @@ titiler/
         |   ├── enums.py         - Titiler's enumerations (e.g MediaType)
         |   └── responses.py     - Custom Starlette's responses
         ├── templates/
-        |   └── wmts.xml         - OGC WMTS template
+        |   ├── map.html         - Simple Map viewer (built with leaflet)
+        |   └── wmts.xml         - OGC WMTS document template
         ├── dependencies.py      - Titiler FastAPI's dependencies
         ├── errors.py            - Errors handler factory
+        ├── middleware.py        - Starlette middlewares
         ├── factory.py           - Dynamic tiler endpoints factories
         ├── routing.py           - Custom APIRoute class
+        ├── telemetry.py         - OpenTelemetry tracing functions
         └── utils.py             - Titiler utility functions
 ```
diff --git a/src/titiler/core/pyproject.toml b/src/titiler/core/pyproject.toml
index f964c014a..3827b6de9 100644
--- a/src/titiler/core/pyproject.toml
+++ b/src/titiler/core/pyproject.toml
@@ -1,8 +1,8 @@
 [project]
-name = "titiler.core"
+name = "titiler-core"
 description = "A modern dynamic tile server built on top of FastAPI and Rasterio/GDAL."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 authors = [
     {name = "Vincent Sarago", email = "vincent@developmentseed.com"},
 ]
@@ -21,26 +21,36 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: GIS",
 ]
 dynamic = ["version"]
 dependencies = [
-    "fastapi>=0.87.0,<0.95",
-    "geojson-pydantic",
+    "fastapi>=0.108.0",
+    "geojson-pydantic>=1.1.2,<3.0",
     "jinja2>=2.11.2,<4.0.0",
     "numpy",
-    "pydantic",
+    "pydantic~=2.0",
     "rasterio",
-    "rio-tiler>=4.1.6,<4.2",
+    "rio-tiler>=9.0,<10.0",
+    "morecantile",
     "simplejson",
-    "typing_extensions;python_version<'3.8'",
 ]
 
 [project.optional-dependencies]
+telemetry = [
+    "opentelemetry-api",
+    "opentelemetry-sdk",
+    "opentelemetry-instrumentation-fastapi",
+    "opentelemetry-instrumentation-logging",
+    "opentelemetry-exporter-otlp",
+]
+
+[dependency-groups]
 test = [
     "pytest",
     "pytest-cov",
@@ -55,14 +65,15 @@ Issues = "https://github.com/developmentseed/titiler/issues"
 Source = "https://github.com/developmentseed/titiler"
 Changelog = "https://developmentseed.org/titiler/release-notes/"
 
-[build-system]
-requires = ["pdm-pep517"]
-build-backend = "pdm.pep517.api"
-
-[tool.pdm.version]
-source = "file"
+[tool.hatch.version]
 path = "titiler/core/__init__.py"
 
-[tool.pdm.build]
-includes = ["titiler/core"]
-excludes = ["tests/", "**/.mypy_cache", "**/.DS_Store"]
+[tool.hatch.build.targets.sdist]
+only-include = ["titiler"]
+
+[tool.hatch.build.targets.wheel]
+only-include = ["titiler"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/src/titiler/core/tests/conftest.py b/src/titiler/core/tests/conftest.py
index d2d299b5b..194e1c085 100644
--- a/src/titiler/core/tests/conftest.py
+++ b/src/titiler/core/tests/conftest.py
@@ -1,7 +1,7 @@
 """``pytest`` configuration."""
 
 import os
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 import rasterio
@@ -21,7 +21,7 @@ def set_env(monkeypatch):
     monkeypatch.setenv("AWS_CONFIG_FILE", "/tmp/noconfigheere")
 
 
-def parse_img(content: bytes) -> Dict[Any, Any]:
+def parse_img(content: bytes) -> dict[Any, Any]:
     """Read tile image and return metadata."""
     with MemoryFile(content) as mem:
         with mem.open() as dst:
diff --git a/src/titiler/core/tests/fixtures/cog_dateline.tif b/src/titiler/core/tests/fixtures/cog_dateline.tif
new file mode 100644
index 000000000..279183018
Binary files /dev/null and b/src/titiler/core/tests/fixtures/cog_dateline.tif differ
diff --git a/src/titiler/core/tests/fixtures/item.json b/src/titiler/core/tests/fixtures/item.json
index f8e447265..8a20a9ed5 100644
--- a/src/titiler/core/tests/fixtures/item.json
+++ b/src/titiler/core/tests/fixtures/item.json
@@ -1,18 +1,10 @@
 {
     "type": "Feature",
-    "stac_version": "1.0.0-beta.1",
-    "stac_extensions": [
-        "eo",
-        "view",
-        "proj"
-    ],
+    "stac_version": "1.0.0",
     "id": "S2A_34SGA_20200318_0_L2A",
-    "bbox": [
-        23.293255090449595,
-        31.505183020453355,
-        24.296453548295318,
-        32.51147809805106
-    ],
+    "properties": {
+        "datetime": "2020-03-18T09:11:33Z"
+    },
     "geometry": {
         "type": "Polygon",
         "coordinates": [
@@ -40,91 +32,31 @@
             ]
         ]
     },
-    "properties": {
-        "datetime": "2020-03-18T09:11:33Z",
-        "platform": "sentinel-2a",
-        "constellation": "sentinel-2",
-        "instruments": [
-            "msi"
-        ],
-        "gsd": 10,
-        "data_coverage": 73.85,
-        "view:off_nadir": 0,
-        "eo:cloud_cover": 89.84,
-        "proj:epsg": 32634,
-        "sentinel:latitude_band": "S",
-        "sentinel:grid_square": "GA",
-        "sentinel:sequence": "0",
-        "sentinel:product_id": "S2A_MSIL2A_20200318T085701_N0214_R007_T34SGA_20200318T115254",
-        "created": "2020-05-12T21:03:26.671Z",
-        "updated": "2020-05-12T21:03:26.671Z"
-    },
-    "collection": "sentinel-s2-l2a-cogs",
+    "links": [
+        {
+            "rel": "self",
+            "href": "https://myurl.com/item.json",
+            "type": "application/json"
+        }
+    ],
     "assets": {
         "B01": {
-            "title": "Band 1 (coastal)",
-            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
             "href": "https://myurl.com/B01.tif",
-            "proj:shape": [
-                1830,
-                1830
-            ],
-            "proj:transform": [
-                60,
-                0,
-                699960,
-                0,
-                -60,
-                3600000,
-                0,
-                0,
-                1
-            ]
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "title": "Band 1 (coastal)"
         },
         "B09": {
-            "title": "Band 9",
-            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
             "href": "https://myurl.com/B09.tif",
-            "proj:shape": [
-                1830,
-                1830
-            ],
-            "proj:transform": [
-                60,
-                0,
-                699960,
-                0,
-                -60,
-                3600000,
-                0,
-                0,
-                1
-            ]
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "title": "Band 9"
         }
     },
-    "links": [
-        {
-            "rel": "self",
-            "href": "s3://sentinel-cogs/sentinel-s2-l2a-cogs/2020/S2A_34SGA_20200318_0_L2A/S2A_34SGA_20200318_0_L2A.json",
-            "type": "application/json"
-        },
-        {
-            "rel": "parent",
-            "href": "https://myurl.com/v0/collections/sentinel-s2-l2a"
-        },
-        {
-            "rel": "collection",
-            "href": "https://myurl.com/v0/collections/sentinel-s2-l2a"
-        },
-        {
-            "rel": "root",
-            "href": "https://myurl.com/v0/"
-        },
-        {
-            "title": "Source STAC Item",
-            "rel": "derived_from",
-            "href": "https://myurl.com/collections/sentinel-s2-l2a/items/S2A_34SGA_20200318_0_L2A",
-            "type": "application/json"
-        }
-    ]
+    "bbox": [
+        23.293255090449595,
+        31.505183020453355,
+        24.296453548295318,
+        32.51147809805106
+    ],
+    "stac_extensions": [],
+    "collection": "sentinel-s2-l2a-cogs"
 }
diff --git a/src/titiler/core/tests/test_CustomCmap.py b/src/titiler/core/tests/test_CustomCmap.py
index 0c189247a..8b396aaf7 100644
--- a/src/titiler/core/tests/test_CustomCmap.py
+++ b/src/titiler/core/tests/test_CustomCmap.py
@@ -1,14 +1,13 @@
 """Test TiTiler Custom Colormap Params."""
 
-from enum import Enum
 from io import BytesIO
-from typing import Dict, Optional
 
 import numpy
-from fastapi import FastAPI, Query
+from fastapi import FastAPI
 from rio_tiler.colormap import ColorMaps
 from starlette.testclient import TestClient
 
+from titiler.core.dependencies import create_colormap_dependency
 from titiler.core.factory import TilerFactory
 
 from .conftest import DATA_DIR
@@ -17,19 +16,8 @@
     "cmap1": {6: (4, 5, 6, 255)},
 }
 cmap = ColorMaps(data=cmap_values)
-ColorMapName = Enum(  # type: ignore
-    "ColorMapName", [(a, a) for a in sorted(cmap.list())]
-)
 
-
-def ColorMapParams(
-    colormap_name: ColorMapName = Query(None, description="Colormap name"),
-) -> Optional[Dict]:
-    """Colormap Dependency."""
-    if colormap_name:
-        return cmap.get(colormap_name.value)
-
-    return None
+ColorMapParams = create_colormap_dependency(cmap)
 
 
 def test_CustomCmap():
diff --git a/src/titiler/core/tests/test_CustomPath.py b/src/titiler/core/tests/test_CustomPath.py
index cb1bd3298..91589fc9e 100644
--- a/src/titiler/core/tests/test_CustomPath.py
+++ b/src/titiler/core/tests/test_CustomPath.py
@@ -2,6 +2,7 @@
 
 import os
 import re
+from typing import Annotated
 
 from fastapi import FastAPI, HTTPException, Query
 from starlette.testclient import TestClient
@@ -12,11 +13,13 @@
 
 
 def CustomPathParams(
-    name: str = Query(
-        ...,
-        alias="file",
-        description="Give me a url.",
-    )
+    name: Annotated[
+        str,
+        Query(
+            alias="file",
+            description="Give me a url.",
+        ),
+    ],
 ) -> str:
     """Custom path Dependency."""
     if not re.match(".+tif$", name):
diff --git a/src/titiler/core/tests/test_CustomRender.py b/src/titiler/core/tests/test_CustomRender.py
index 2d9661e2a..51b9e7e58 100644
--- a/src/titiler/core/tests/test_CustomRender.py
+++ b/src/titiler/core/tests/test_CustomRender.py
@@ -1,7 +1,6 @@
 """Test TiTiler Custom Render Params."""
 
 from dataclasses import dataclass
-from typing import Optional, Union
 
 import numpy
 from fastapi import FastAPI, Query
@@ -17,12 +16,12 @@
 class CustomRenderParams(ImageRenderingParams):
     """Custom renderparams class."""
 
-    nodata: Optional[Union[str, int, float]] = Query(
+    nodata: str | int | float | None = Query(
         None,
         title="Tiff Ouptut Nodata value",
         alias="output_nodata",
     )
-    compress: Optional[str] = Query(
+    compress: str | None = Query(
         None,
         title="Tiff compression schema",
         alias="output_compression",
@@ -30,6 +29,7 @@ class CustomRenderParams(ImageRenderingParams):
 
     def __post_init__(self):
         """post init."""
+        super().__post_init__()
         if self.nodata is not None:
             self.nodata = numpy.nan if self.nodata == "nan" else float(self.nodata)
 
@@ -41,7 +41,7 @@ def test_CustomRender():
     app.include_router(cog.router)
     client = TestClient(app)
 
-    response = client.get(f"/tiles/8/87/48.tif?url={DATA_DIR}/cog.tif")
+    response = client.get(f"/tiles/WebMercatorQuad/8/87/48.tif?url={DATA_DIR}/cog.tif")
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
     meta = parse_img(response.content)
@@ -51,7 +51,7 @@ def test_CustomRender():
     assert not meta.get("compress")
 
     response = client.get(
-        f"/tiles/8/87/48.tif?url={DATA_DIR}/cog.tif&return_mask=false&output_nodata=0&output_compression=deflate"
+        f"/tiles/WebMercatorQuad/8/87/48.tif?url={DATA_DIR}/cog.tif&return_mask=false&output_nodata=0&output_compression=deflate"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
@@ -62,7 +62,7 @@ def test_CustomRender():
     assert meta["compress"] == "deflate"
 
     response = client.get(
-        f"/tiles/9/289/207?url={DATA_DIR}/TCI.tif&rescale=0,1000&rescale=0,2000&rescale=0,3000"
+        f"/tiles/WebMercatorQuad/9/289/207?url={DATA_DIR}/TCI.tif&rescale=0,1000&rescale=0,2000&rescale=0,3000"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
diff --git a/src/titiler/core/tests/test_algorithms.py b/src/titiler/core/tests/test_algorithms.py
index ca4e95a59..fe2c90c97 100644
--- a/src/titiler/core/tests/test_algorithms.py
+++ b/src/titiler/core/tests/test_algorithms.py
@@ -3,6 +3,7 @@
 import json
 
 import numpy
+import pytest
 from fastapi import Depends, FastAPI
 from rasterio.io import MemoryFile
 from rio_tiler.models import ImageData
@@ -22,12 +23,11 @@ class Multiply(BaseAlgorithm):
     def __call__(self, img: ImageData) -> ImageData:
         """Apply Multiplication factor."""
         # Multiply image data bcy factor
-        data = img.data * self.factor
+        data = img.array * self.factor
 
         # Create output ImageData
         return ImageData(
             data,
-            img.mask,
             assets=img.assets,
             crs=img.crs,
             bounds=img.bounds,
@@ -88,7 +88,6 @@ def main(algorithm=Depends(default_algorithms.dependency)):
     # MAPBOX Terrain RGB
     response = client.get("/", params={"algorithm": "terrainrgb"})
     assert response.status_code == 200
-
     with MemoryFile(response.content) as mem:
         with mem.open() as dst:
             data = dst.read().astype(numpy.float64)
@@ -100,7 +99,6 @@ def main(algorithm=Depends(default_algorithms.dependency)):
     # TILEZEN Terrarium
     response = client.get("/", params={"algorithm": "terrarium"})
     assert response.status_code == 200
-
     with MemoryFile(response.content) as mem:
         with mem.open() as dst:
             data = dst.read().astype(numpy.float64)
@@ -108,3 +106,315 @@ def main(algorithm=Depends(default_algorithms.dependency)):
     # https://github.com/tilezen/joerd/blob/master/docs/formats.md#terrarium
     elevation = (data[0] * 256 + data[1] + data[2] / 256) - 32768
     numpy.testing.assert_array_equal(elevation, arr[0])
+
+
+def test_normalized_index():
+    """test ndi."""
+    algo = default_algorithms.get("normalizedIndex")()
+
+    arr = numpy.zeros((2, 256, 256), dtype="uint16")
+    arr[0, :, :] = 1
+    arr[1, :, :] = 2
+
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "float32"
+    assert len(numpy.unique(out.array).tolist()) == 1
+    numpy.testing.assert_almost_equal(out.array[0, 0, 0], 0.3333, decimal=3)
+
+    # with mixed 0 and masked
+    arr = numpy.ma.MaskedArray(
+        numpy.zeros((2, 256, 256), dtype="uint16"),
+        mask=numpy.zeros((2, 256, 256), dtype="bool"),
+    )
+    arr.data[0, :, :] = 1
+    arr.data[0, 0:10, 0:10] = 0
+    arr.mask[0, 0:5, 0:5] = True
+
+    arr.data[1, :, :] = 2
+    arr.data[1, 0:10, 0:10] = 0
+    arr.mask[1, 0:5, 0:5] = True
+
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "float32"
+    assert len(numpy.unique(out.array).tolist()) == 2  # 0.33 and None
+    assert out.array[0, 0, 0] is numpy.ma.masked
+    assert out.array[0, 6, 6] is numpy.ma.masked
+    numpy.testing.assert_almost_equal(out.array[0, 10, 10], 0.3333, decimal=3)
+
+
+def test_hillshade():
+    """test hillshade."""
+    algo = default_algorithms.get("hillshade")()
+
+    arr = numpy.random.randint(0, 5000, (1, 262, 262), dtype="uint16")
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "uint8"
+
+    arr = numpy.ma.MaskedArray(
+        numpy.random.randint(0, 5000, (1, 262, 262), dtype="uint16"),
+        mask=numpy.zeros((1, 262, 262), dtype="bool"),
+    )
+    arr.mask[0, 0:100, 0:100] = True
+
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 0, 0] is numpy.ma.masked
+
+
+def test_slope():
+    """test slope."""
+    algo = default_algorithms.get("slope")()
+
+    arr = numpy.random.randint(0, 5000, (1, 262, 262), dtype="uint16")
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "float32"
+
+    arr = numpy.ma.MaskedArray(
+        numpy.random.randint(0, 5000, (1, 262, 262), dtype="uint16"),
+        mask=numpy.zeros((1, 262, 262), dtype="bool"),
+    )
+    arr.mask[0, 0:100, 0:100] = True
+
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "float32"
+    assert out.array[0, 0, 0] is numpy.ma.masked
+
+
+def test_contours():
+    """test contours."""
+    algo = default_algorithms.get("contours")()
+
+    arr = numpy.random.randint(0, 5000, (1, 256, 256), dtype="uint16")
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (3, 256, 256)
+    assert out.array.dtype == "uint8"
+
+    arr = numpy.ma.MaskedArray(
+        numpy.random.randint(0, 5000, (1, 256, 256), dtype="uint16"),
+        mask=numpy.zeros((1, 256, 256), dtype="bool"),
+    )
+    arr.mask[0, 0:100, 0:100] = True
+
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (3, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 0, 0] is numpy.ma.masked
+
+
+def test_terrarium():
+    """test terrarium."""
+    algo = default_algorithms.get("terrarium")()
+
+    arr = numpy.random.randint(0, 5000, (1, 256, 256), dtype="uint16")
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (3, 256, 256)
+    assert out.array.dtype == "uint8"
+
+    arr = numpy.ma.MaskedArray(
+        numpy.random.randint(0, 5000, (1, 256, 256), dtype="uint16"),
+        mask=numpy.zeros((1, 256, 256), dtype="bool"),
+    )
+    arr.mask[0, 0:100, 0:100] = True
+
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (3, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 0, 0] is numpy.ma.masked
+
+    # works on the above masked array img, with algo which was passed nodata_height
+    nodata_height = 10.0
+    algo = default_algorithms.get("terrarium")(nodata_height=nodata_height)
+    out = algo(img)
+    masked = out.array[:, arr.mask[0, :, :]]
+    masked_height = (masked[0] * 256 + masked[1] + masked[2] / 256) - 32768
+    numpy.testing.assert_array_equal(
+        masked_height, nodata_height * numpy.ones((100 * 100), dtype="bool")
+    )
+
+
+def test_terrainrgb():
+    """test terrainrgb."""
+    algo = default_algorithms.get("terrainrgb")()
+
+    arr = numpy.random.randint(0, 5000, (1, 256, 256), dtype="uint16")
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (3, 256, 256)
+    assert out.array.dtype == "uint8"
+
+    arr = numpy.ma.MaskedArray(
+        numpy.random.randint(0, 5000, (1, 256, 256), dtype="uint16"),
+        mask=numpy.zeros((1, 256, 256), dtype="bool"),
+    )
+    arr.mask[0, 0:100, 0:100] = True
+
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (3, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 0, 0] is numpy.ma.masked
+
+    # works on the above masked array img, with algo which was passed nodata_height
+    nodata_height = 10.0
+    algo = default_algorithms.get("terrainrgb")(nodata_height=nodata_height)
+    out = algo(img)
+    masked = out.array[:, arr.mask[0, :, :]]
+    masked_height = -10000 + (
+        ((masked[0] * 256 * 256) + (masked[1] * 256) + masked[2]) * 0.1
+    )
+    numpy.testing.assert_array_equal(
+        masked_height, nodata_height * numpy.ones((100 * 100), dtype="bool")
+    )
+
+
+def test_ops():
+    """test ops: cast, ceil and floor."""
+    arr = numpy.ma.MaskedArray(
+        numpy.random.randint(0, 5000, (1, 256, 256)).astype("float32"),
+        mask=numpy.zeros((1, 256, 256), dtype="bool"),
+    )
+    arr.data[0, 0, 0] = 1.6
+    arr.mask[0, 1:100, 1:100] = True
+
+    img = ImageData(arr)
+    assert img.array.dtype == numpy.float32
+
+    algo = default_algorithms.get("cast")()
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 0, 0] == 1
+    assert out.array[0, 1, 1] is numpy.ma.masked
+
+    assert img.array.dtype == numpy.float32
+    algo = default_algorithms.get("floor")()
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 0, 0] == 1
+    assert out.array[0, 1, 1] is numpy.ma.masked
+
+    assert img.array.dtype == numpy.float32
+    algo = default_algorithms.get("ceil")()
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 0, 0] == 2
+    assert out.array[0, 1, 1] is numpy.ma.masked
+
+
+@pytest.mark.parametrize(
+    "name,numpy_method,options",
+    [
+        ("min", numpy.ma.min, {}),
+        ("max", numpy.ma.max, {}),
+        ("median", numpy.ma.median, {}),
+        ("mean", numpy.ma.mean, {}),
+        ("std", numpy.ma.std, {"ddof": 1}),
+        ("var", numpy.ma.var, {"ddof": 1}),
+        ("sum", numpy.ma.sum, {}),
+    ],
+)
+def test_math_algorithm(name, numpy_method, options):
+    """test math algos."""
+    arr = numpy.ma.MaskedArray(
+        numpy.random.randint(0, 5000, (1, 256, 256)).astype("float32"),
+        mask=numpy.zeros((1, 256, 256), dtype="bool"),
+    )
+    arr.data[0, 0, 0] = 1.6
+    arr.mask[0, 1:100, 1:100] = True
+
+    img = ImageData(arr)
+    assert img.array.dtype == numpy.float32
+
+    algo = default_algorithms.get(name)()
+    out = algo(img)
+
+    numpy.testing.assert_array_equal(
+        out.array, numpy_method(img.array, axis=0, keepdims=True, **options)
+    )
+    assert out.array[0, 1, 1] is numpy.ma.masked
+
+
+def test_bitonal_algorithm():
+    """Test bitonal algorithm."""
+    algo = default_algorithms.get("bitonal")()
+
+    arr = numpy.ma.MaskedArray(
+        numpy.zeros((1, 256, 256), dtype="uint8"),
+        mask=numpy.zeros((1, 256, 256), dtype="bool"),
+    )
+    arr.data[0, 100:200, 100:200] = 200
+    arr.mask[0, 120:130, 120:130] = True
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 125, 125] is numpy.ma.masked
+    assert out.array[0, 150, 150] == 255
+    assert out.array[0, 50, 50] == 0
+
+    arr = numpy.ma.MaskedArray(
+        numpy.zeros((3, 256, 256), dtype="uint8"),
+        mask=numpy.zeros((3, 256, 256), dtype="bool"),
+    )
+    arr.data[:, 100:200, 100:200] = 200
+    arr.mask[0, 120:130, 120:130] = True
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 125, 125] is numpy.ma.masked
+    assert out.array[0, 150, 150] == 255
+    assert out.array[0, 50, 50] == 0
+
+    arr = numpy.ma.MaskedArray(
+        numpy.zeros((4, 256, 256), dtype="uint8"),
+        mask=numpy.zeros((4, 256, 256), dtype="bool"),
+    )
+    img = ImageData(arr)
+    with pytest.raises(ValueError):
+        out = algo(img)
+
+
+def test_grayscale_algorithm():
+    """Test grayscale algorithm."""
+    algo = default_algorithms.get("grayscale")()
+
+    arr = numpy.ma.MaskedArray(
+        numpy.zeros((3, 256, 256), dtype="uint8"),
+        mask=numpy.zeros((3, 256, 256), dtype="bool"),
+    )
+    arr.data[:, 100:200, 100:200] = 200
+    arr.mask[0, 120:130, 120:130] = True
+    img = ImageData(arr)
+    out = algo(img)
+    assert out.array.shape == (1, 256, 256)
+    assert out.array.dtype == "uint8"
+    assert out.array[0, 125, 125] is numpy.ma.masked
+    assert out.array[0, 150, 150] != 0
+    assert out.array[0, 50, 50] == 0
+
+    arr = numpy.ma.MaskedArray(
+        numpy.zeros((2, 256, 256), dtype="uint8"),
+        mask=numpy.zeros((2, 256, 256), dtype="bool"),
+    )
+    img = ImageData(arr)
+    with pytest.raises(ValueError):
+        out = algo(img)
diff --git a/src/titiler/core/tests/test_cache_middleware.py b/src/titiler/core/tests/test_cache_middleware.py
index b1331edd9..1dfee53d8 100644
--- a/src/titiler/core/tests/test_cache_middleware.py
+++ b/src/titiler/core/tests/test_cache_middleware.py
@@ -1,5 +1,6 @@
 """Test titiler.core.CacheControlMiddleware."""
 
+from typing import Annotated
 
 from fastapi import FastAPI, Path
 from starlette.responses import Response
@@ -29,18 +30,18 @@ async def route3():
 
     @app.get("/tiles/{z}/{x}/{y}")
     async def tiles(
-        z: int = Path(..., ge=0, le=30, description="Mercator tiles's zoom level"),
-        x: int = Path(..., description="Mercator tiles's column"),
-        y: int = Path(..., description="Mercator tiles's row"),
+        z: Annotated[int, Path(ge=0, le=30, description="Mercator tiles's zoom level")],
+        x: Annotated[int, Path(description="Mercator tiles's column")],
+        y: Annotated[int, Path(description="Mercator tiles's row")],
     ):
         """tiles."""
         return "yeah"
 
     @app.get("/emptytiles/{z}/{x}/{y}")
     async def emptytiles(
-        z: int = Path(..., ge=0, le=30, description="Mercator tiles's zoom level"),
-        x: int = Path(..., description="Mercator tiles's column"),
-        y: int = Path(..., description="Mercator tiles's row"),
+        z: Annotated[int, Path(ge=0, le=30, description="Mercator tiles's zoom level")],
+        x: Annotated[int, Path(description="Mercator tiles's column")],
+        y: Annotated[int, Path(description="Mercator tiles's row")],
     ):
         """tiles."""
         return Response(status_code=404)
diff --git a/src/titiler/core/tests/test_case_middleware.py b/src/titiler/core/tests/test_case_middleware.py
index dc46ab5ae..b2f4b758b 100644
--- a/src/titiler/core/tests/test_case_middleware.py
+++ b/src/titiler/core/tests/test_case_middleware.py
@@ -1,6 +1,6 @@
 """Test titiler.core.middleware.LowerCaseQueryStringMiddleware."""
 
-from typing import List
+from typing import Annotated
 
 from fastapi import FastAPI, Query
 from starlette.testclient import TestClient
@@ -13,7 +13,7 @@ def test_lowercase_middleware():
     app = FastAPI()
 
     @app.get("/route1")
-    async def route1(value: str = Query(...)):
+    async def route1(value: Annotated[str, Query()]):
         """route1."""
         return {"value": value}
 
@@ -33,7 +33,7 @@ def test_lowercase_middleware_multiple_values():
     app = FastAPI()
 
     @app.get("/route1")
-    async def route1(value: List[str] = Query(...)):
+    async def route1(value: Annotated[list[str], Query()]):
         """route1."""
         return {"value": value}
 
@@ -46,3 +46,26 @@ async def route1(value: List[str] = Query(...)):
 
     response = client.get("/route1?VALUE=lorenzori&VALUE=dogs&value=trucks")
     assert response.json() == {"value": ["lorenzori", "dogs", "trucks"]}
+
+
+def test_lowercase_middleware_url_with_query_parameters():
+    """Make sure all query parameters return."""
+    app = FastAPI()
+
+    @app.get("/route1")
+    async def route1(url: list[str] = Query(...)):
+        """route1."""
+        return {"url": url}
+
+    app.add_middleware(LowerCaseQueryStringMiddleware)
+
+    client = TestClient(app)
+
+    url = "https://developmentseed.org?solutions=geospatial&planet=better"
+    url_encoded = (
+        "https%3A%2F%2Fdevelopmentseed.org%3Fsolutions%3Dgeospatial%26planet%3Dbetter"
+    )
+
+    response = client.get(f"/route1?url={url_encoded}")
+
+    assert response.json() == {"url": [url]}
diff --git a/src/titiler/core/tests/test_dependencies.py b/src/titiler/core/tests/test_dependencies.py
index 6254aa471..e61e078ba 100644
--- a/src/titiler/core/tests/test_dependencies.py
+++ b/src/titiler/core/tests/test_dependencies.py
@@ -2,15 +2,15 @@
 
 import json
 from dataclasses import dataclass
-from typing import Literal
+from typing import Annotated, Literal
 
-import pytest
-from fastapi import Depends, FastAPI, Query
+from fastapi import Depends, FastAPI, Path
 from morecantile import tms
+from rasterio.crs import CRS
 from rio_tiler.types import ColorMapType
 from starlette.testclient import TestClient
 
-from titiler.core import dependencies, errors
+from titiler.core import dependencies
 from titiler.core.resources.responses import JSONResponse
 
 
@@ -18,15 +18,20 @@ def test_tms():
     """Create App."""
     app = FastAPI()
 
-    @app.get("/web/{TileMatrixSetId}")
-    def web(TileMatrixSetId: Literal["WebMercatorQuad"] = Query(...)):
+    @app.get("/web/{tileMatrixSetId}")
+    def web(
+        tileMatrixSetId: Annotated[
+            Literal["WebMercatorQuad"],
+            Path(),
+        ],
+    ):
         """return tms id."""
-        return TileMatrixSetId
+        return tileMatrixSetId
 
-    @app.get("/all/{TileMatrixSetId}")
-    def all(TileMatrixSetId: Literal[tuple(tms.list())] = Query(...)):
+    @app.get("/all/{tileMatrixSetId}")
+    def all(tileMatrixSetId: Annotated[Literal[tuple(tms.list())], Path()]):
         """return tms id."""
-        return TileMatrixSetId
+        return tileMatrixSetId
 
     client = TestClient(app)
     response = client.get("/web/WebMercatorQuad")
@@ -34,7 +39,7 @@ def all(TileMatrixSetId: Literal[tuple(tms.list())] = Query(...)):
 
     response = client.get("/web/WorldCRS84Quad")
     assert response.status_code == 422
-    assert "permitted: 'WebMercatorQuad'" in response.json()["detail"][0]["msg"]
+    assert "Input should be 'WebMercatorQuad'" in response.json()["detail"][0]["msg"]
 
     response = client.get("/all/WebMercatorQuad")
     assert response.json() == "WebMercatorQuad"
@@ -60,7 +65,7 @@ def main(cm=Depends(dependencies.ColorMapParams)):
     assert response.json()["1"] == [68, 2, 85, 255]
 
     cmap = json.dumps({1: [68, 1, 84, 255]})
-    response = client.get(f"/?colormap={cmap}")
+    response = client.get("/", params={"colormap": cmap})
     assert response.json()["1"] == [68, 1, 84, 255]
 
     cmap = json.dumps({0: "#000000", 255: "#ffffff"})
@@ -75,7 +80,7 @@ def main(cm=Depends(dependencies.ColorMapParams)):
         ([3, 1000], [255, 0, 0, 255]),
     ]
     cmap = json.dumps(intervals)
-    response = client.get(f"/?colormap={cmap}")
+    response = client.get("/", params={"colormap": cmap})
     assert response.json()[0] == [[1, 2], [0, 0, 0, 255]]
     assert response.json()[1] == [[2, 3], [255, 255, 255, 255]]
     assert response.json()[2] == [[3, 1000], [255, 0, 0, 255]]
@@ -135,17 +140,20 @@ def main(cm=Depends(dependencies.ColorMapParams)):
     assert response.json()[0][0] == [0.0, 0.05263157894736842]
     assert response.json()[0][1] == [247, 252, 240, 255]
 
+    response = client.get("/", params={"colormap": "invalid json"})
+    assert response.status_code == 400  # this can only be validated via exception
+
 
 def test_default():
     """test default dep behavior."""
 
     @dataclass
     class dep(dependencies.DefaultDependency):
+        v: int | None = None
 
-        v: int
-
-    # make sure we can unpack the class
-    assert dict(**dep(v=1)) == {"v": 1}
+    assert dep(v=1).as_dict() == {"v": 1}
+    assert dep().as_dict() == {}
+    assert dep().as_dict(exclude_none=False) == {"v": None}
     assert dep(v=1).v == 1
 
 
@@ -204,131 +212,103 @@ def _assets(params=Depends(dependencies.AssetsParams)):
         return params.assets
 
     @app.get("/second")
-    def _assets_expr(params=Depends(dependencies.AssetsBidxExprParams)):
-        """return params."""
-        return params
-
-    @app.get("/third")
-    def _assets_bidx(params=Depends(dependencies.AssetsBidxParams)):
+    def _assets_expr(params=Depends(dependencies.AssetsExprParams)):
         """return params."""
         return params
 
     client = TestClient(app)
+    response = client.get("/first")
+    assert response.status_code == 422
+
     response = client.get("/first?assets=data&assets=image")
     assert response.json() == ["data", "image"]
 
-    response = client.get("/first")
-    assert not response.json()
+    response = client.get("/first?assets=data|bidx=1,2|expression=b1*b2")
+    assert response.json()[0]["name"] == "data"
+    assert response.json()[0]["indexes"] == [1, 2]
+    assert response.json()[0]["expression"] == "b1*b2"
 
     response = client.get("/second?assets=data&assets=image")
     assert response.json()["assets"] == ["data", "image"]
     assert not response.json()["expression"]
 
-    response = client.get("/second?expression=data*image")
-    assert response.json()["expression"] == "data*image"
-    assert not response.json()["assets"]
-
-    with pytest.raises(errors.MissingAssets):
-        response = client.get("/second")
-
-    response = client.get(
-        "/second?assets=data&assets=image&asset_bidx=data|1,2,3&asset_bidx=image|1"
-    )
+    response = client.get("/second?assets=data&assets=image&expression=b1*b2")
+    assert response.json()["expression"] == "b1*b2"
     assert response.json()["assets"] == ["data", "image"]
-    assert response.json()["asset_indexes"] == {"data": [1, 2, 3], "image": [1]}
 
-    response = client.get("/third?assets=data&assets=image")
-    assert response.json()["assets"] == ["data", "image"]
-
-    response = client.get("/third")
-    assert not response.json()["assets"]
-
-    response = client.get(
-        "/third?assets=data&assets=image&asset_bidx=data|1,2,3&asset_bidx=image|1"
-    )
-    assert response.json()["assets"] == ["data", "image"]
-    assert response.json()["asset_indexes"] == {"data": [1, 2, 3], "image": [1]}
+    response = client.get("/second?assets=data|bidx=1,2|expression=b1*b2")
+    assert response.json()["assets"][0]["name"] == "data"
+    assert response.json()["assets"][0]["indexes"] == [1, 2]
+    assert response.json()["assets"][0]["expression"] == "b1*b2"
 
-    response = client.get(
-        "/third?assets=data&assets=image&asset_expression=data|b1/b2&asset_expression=image|b1*b2"
-    )
-    assert response.json()["assets"] == ["data", "image"]
-    assert response.json()["asset_expression"] == {"data": "b1/b2", "image": "b1*b2"}
+    response = client.get("/second")
+    assert response.status_code == 422
 
 
-def test_bands():
-    """test bands deps."""
+def test_preview_part_params():
+    """test preview/part deps."""
 
     app = FastAPI()
 
-    @app.get("/first")
-    def _bands(params=Depends(dependencies.BandsParams)):
-        """return bands."""
-        return params.bands
-
-    @app.get("/second")
-    def _bands_expr(params=Depends(dependencies.BandsExprParams)):
+    @app.get("/preview")
+    @app.get("/preview/{width}x{height}")
+    def _endpoint(params=Depends(dependencies.PreviewParams)):
         """return params."""
         return params
 
-    @app.get("/third")
-    def _bands_expr_opt(params=Depends(dependencies.BandsExprParamsOptional)):
+    @app.get("/part")
+    @app.get("/part/{width}x{height}")
+    def _endpoint(params=Depends(dependencies.PartFeatureParams)):
         """return params."""
         return params
 
     client = TestClient(app)
-    response = client.get("/first?bands=b1&bands=b2")
-    assert response.json() == ["b1", "b2"]
-
-    response = client.get("/first")
-    assert not response.json()
-
-    response = client.get("/second?bands=b1&bands=b2")
-    assert response.json()["bands"] == ["b1", "b2"]
-
-    response = client.get("/second", params={"expression": "b1;b2"})
-    assert response.json()["expression"] == "b1;b2"
-
-    with pytest.raises(errors.MissingBands):
-        response = client.get("/second")
-
-    response = client.get("/third?bands=b1&bands=b2")
-    assert response.json()["bands"] == ["b1", "b2"]
-
-    response = client.get("/third", params={"expression": "b1;b2"})
-    assert response.json()["expression"] == "b1;b2"
-
-    response = client.get("/third")
-    assert not response.json()["bands"]
+    response = client.get("/preview")
+    assert response.json()["max_size"] == 1024
+    assert not response.json()["height"]
+    assert not response.json()["width"]
 
+    response = client.get("/preview?max_size=2048")
+    assert response.json()["max_size"] == 2048
+    assert not response.json()["height"]
+    assert not response.json()["width"]
 
-def test_image():
-    """test image deps."""
+    response = client.get("/preview?width=128")
+    assert not response.json()["max_size"]
+    assert not response.json()["height"]
+    assert response.json()["width"] == 128
 
-    app = FastAPI()
+    response = client.get("/preview/128x128")
+    assert not response.json()["max_size"]
+    assert response.json()["height"] == 128
+    assert response.json()["width"] == 128
 
-    @app.get("/")
-    def _endpoint(params=Depends(dependencies.ImageParams)):
-        """return params."""
-        return params
+    response = client.get("/preview?width=128&height=128")
+    assert not response.json()["max_size"]
+    assert response.json()["height"] == 128
+    assert response.json()["width"] == 128
 
-    client = TestClient(app)
-    response = client.get("/")
-    assert response.json()["max_size"] == 1024
+    response = client.get("/part")
+    assert not response.json()["max_size"]
     assert not response.json()["height"]
     assert not response.json()["width"]
 
-    response = client.get("/?max_size=2048")
+    response = client.get("/part?max_size=2048")
     assert response.json()["max_size"] == 2048
     assert not response.json()["height"]
     assert not response.json()["width"]
 
-    response = client.get("/?width=128")
-    assert response.json()["max_size"] == 1024
+    response = client.get("/part?width=128")
+    assert not response.json()["max_size"]
     assert not response.json()["height"]
     assert response.json()["width"] == 128
 
-    response = client.get("/?width=128&height=128")
+    response = client.get("/part?width=128&height=128")
+    assert not response.json()["max_size"]
+    assert response.json()["height"] == 128
+    assert response.json()["width"] == 128
+
+    response = client.get("/part/128x128")
     assert not response.json()["max_size"]
     assert response.json()["height"] == 128
     assert response.json()["width"] == 128
@@ -353,7 +333,7 @@ def is_nan(params=Depends(dependencies.DatasetParams)):
     response = client.get("/")
     assert not response.json()["nodata"]
     assert not response.json()["unscale"]
-    assert response.json()["resampling_method"] == "nearest"
+    assert not response.json()["resampling_method"]
 
     response = client.get("/?resampling=cubic")
     assert not response.json()["nodata"]
@@ -366,6 +346,9 @@ def is_nan(params=Depends(dependencies.DatasetParams)):
     response = client.get("/nan?nodata=nan")
     assert response.json() == "nan"
 
+    response = client.get("/?nodata=invalid-value")
+    assert response.status_code == 422
+
 
 def test_render():
     """test render deps."""
@@ -379,7 +362,7 @@ def _endpoint(params=Depends(dependencies.ImageRenderingParams)):
 
     client = TestClient(app)
     response = client.get("/")
-    assert response.json()["add_mask"] is True
+    assert not response.json()["add_mask"]
 
     response = client.get("/?return_mask=False")
     assert response.json()["add_mask"] is False
@@ -401,7 +384,7 @@ def test_algo():
     def _endpoint(algorithm=Depends(PostProcessParams)):
         """return params."""
         if algorithm:
-            return algorithm.dict()
+            return algorithm.model_dump()
         return {}
 
     client = TestClient(app)
@@ -412,7 +395,7 @@ def _endpoint(algorithm=Depends(PostProcessParams)):
     assert response.status_code == 422
 
     response = client.get("/?algorithm=hillshade")
-    assert response.json()["azimuth"] == 90
+    assert response.json()["azimuth"] == 45
     assert response.json()["buffer"] == 3
     assert response.json()["input_nbands"] == 1
 
@@ -426,3 +409,254 @@ def _endpoint(algorithm=Depends(PostProcessParams)):
     assert response.json()["azimuth"] == 30
     assert response.json()["buffer"] == 4
     assert response.json()["input_nbands"] == 1
+
+    response = client.get(
+        "/",
+        params={
+            "algorithm_params": "invalid json",
+        },
+    )
+    assert response.status_code == 422
+
+
+def test_rescale_params():
+    """test RescalingParams dependency."""
+    app = FastAPI()
+
+    @app.get("/")
+    def main(params=Depends(dependencies.ImageRenderingParams)):
+        """return rescale."""
+        return params.rescale
+
+    client = TestClient(app)
+
+    response = client.get("/", params={"rescale": "0,1"})
+    assert response.status_code == 200
+    assert response.json() == [[0, 1]]
+
+    response = client.get("/?rescale=0,1")
+    assert response.status_code == 200
+    assert response.json() == [[0, 1]]
+
+    response = client.get("/?rescale=0,1&rescale=2,3")
+    assert response.status_code == 200
+    assert response.json() == [[0, 1], [2, 3]]
+
+    response = client.get("/", params={"rescale": [0, 1]})
+    assert response.status_code == 422
+
+    response = client.get("/", params={"rescale": [[0, 1]]})
+    assert response.status_code == 200
+    assert response.json() == [[0, 1]]
+
+    response = client.get(
+        "/",
+        params=(
+            ("rescale", [0, 1]),
+            ("rescale", [0, 1]),
+        ),
+    )
+    assert response.status_code == 200
+    assert response.json() == [[0, 1], [0, 1]]
+
+    response = client.get(
+        "/",
+        params=(
+            ("rescale", "0,1"),
+            ("rescale", "0,1"),
+        ),
+    )
+    assert response.status_code == 200
+    assert response.json() == [[0, 1], [0, 1]]
+
+    response = client.get("/", params={"rescale": [[0, 1], [2, 3]]})
+    assert response.status_code == 200
+    assert response.json() == [[0, 1], [2, 3]]
+
+    response = client.get("/", params={"rescale": "not a number"})
+    assert response.status_code == 422
+
+    response = client.get(
+        "/", params={"rescale": ["not a number", "also not a number"]}
+    )
+    assert response.status_code == 422
+
+
+def test_histogram_params():
+    """Test HistogramParams dependency."""
+    app = FastAPI()
+
+    @app.get("/")
+    def main(params=Depends(dependencies.HistogramParams)):
+        """return rescale."""
+        return params
+
+    client = TestClient(app)
+
+    response = client.get(
+        "/",
+        params={"histogram_bins": "8"},
+    )
+    assert response.status_code == 200
+    assert response.json()["bins"] == 8
+
+    response = client.get(
+        "/",
+        params={"histogram_bins": "8,9"},
+    )
+    assert response.status_code == 200
+    assert response.json()["bins"] == [8.0, 9.0]
+
+    response = client.get(
+        "/",
+        params={"histogram_bins": "invalid value"},
+    )
+    assert response.status_code == 422
+
+    response = client.get(
+        "/",
+    )
+    assert response.status_code == 200
+    assert response.json()["bins"] == 10
+
+    response = client.get(
+        "/",
+        params={"histogram_range": "8,9"},
+    )
+    assert response.status_code == 200
+    assert response.json()["range"] == [8.0, 9.0]
+
+    response = client.get(
+        "/",
+        params={"histogram_range": "8"},
+    )
+    assert response.status_code == 422
+
+    response = client.get(
+        "/",
+        params={"histogram_range": "invalid value"},
+    )
+    assert response.status_code == 422
+
+
+def test_crs_params():
+    """Test various crs dependencies."""
+    for alias, dependency in {
+        "crs": dependencies.CRSParams,
+        "coord_crs": dependencies.CoordCRSParams,
+        "dst_crs": dependencies.DstCRSParams,
+    }.items():
+        app = FastAPI()
+
+        @app.get("/")
+        def main(params=Depends(dependency)):
+            """return crs params."""
+            # special handling required for CRS object as it cannot be JSON-serialized by default
+            return params.to_dict()
+
+        client = TestClient(app)
+
+        response = client.get(
+            "/",
+            params={
+                alias: """
+            GEOGCS["WGS 84",
+                DATUM["WGS_1984",
+                    SPHEROID["WGS 84",6378137,298.257223563,
+                        AUTHORITY["EPSG","7030"]],
+                    AUTHORITY["EPSG","6326"]],
+                PRIMEM["Greenwich",0,
+                    AUTHORITY["EPSG","8901"]],
+                UNIT["degree",0.0174532925199433,
+                    AUTHORITY["EPSG","9122"]],
+                AUTHORITY["EPSG","4326"]]
+        """
+            },
+        )
+        assert response.status_code == 200
+
+        response = client.get("/", params={alias: "epsg:4326"})
+        assert response.status_code == 200
+
+        response = client.get(
+            "/", params={alias: "+proj=longlat +datum=WGS84 +no_defs +type=crs"}
+        )
+        assert response.status_code == 200
+
+        response = client.get("/", params={alias: "invalid crs"})
+        assert response.status_code == 422
+
+
+def test_ogc_maps_params_crs():
+    """Test OGCMapsParams crs."""
+    app = FastAPI()
+
+    @app.get("/")
+    def main(params=Depends(dependencies.OGCMapsParams)):
+        """return crs params."""
+        # special handling required for CRS object as it cannot be JSON-serialized by default
+        # exclude request due to recursion during serialization
+        return {
+            key: value.to_dict() if isinstance(value, CRS) else value
+            for key, value in params.as_dict().items()
+            if key not in ["request"]
+        }
+
+    client = TestClient(app)
+
+    for field in ["crs", "bbox-crs"]:
+        response = client.get(
+            "/",
+            params={
+                field: """
+            GEOGCS["WGS 84",
+                DATUM["WGS_1984",
+                    SPHEROID["WGS 84",6378137,298.257223563,
+                        AUTHORITY["EPSG","7030"]],
+                    AUTHORITY["EPSG","6326"]],
+                PRIMEM["Greenwich",0,
+                    AUTHORITY["EPSG","8901"]],
+                UNIT["degree",0.0174532925199433,
+                    AUTHORITY["EPSG","9122"]],
+                AUTHORITY["EPSG","4326"]]
+        """
+            },
+        )
+        assert response.status_code == 200
+
+        response = client.get("/", params={field: "epsg:4326"})
+        assert response.status_code == 200
+
+        response = client.get(
+            "/", params={field: "+proj=longlat +datum=WGS84 +no_defs +type=crs"}
+        )
+        assert response.status_code == 200
+
+        response = client.get("/", params={field: "invalid crs"})
+        assert response.status_code == 422
+
+
+def test_ogc_maps_params_bbox():
+    """Test OGCMapsParams bbox."""
+    app = FastAPI()
+
+    @app.get("/")
+    def main(params=Depends(dependencies.OGCMapsParams)):
+        """return bbox params."""
+        return params.bbox
+
+    client = TestClient(app)
+
+    response = client.get("/", params={"bbox": "-2,-1,2,1"})
+    assert response.status_code == 200
+    assert response.json() == [-2, -1, 2, 1]
+
+    response = client.get("/", params={"bbox": "-2,-1,-5,2,1,5"})
+    assert response.status_code == 200
+    assert response.json() == [-2, -1, 2, 1]
+
+    response = client.get("/", params={"bbox": "0"})
+    assert response.status_code == 422
+
+    response = client.get("/", params={"bbox": "invalid bbox"})
+    assert response.status_code == 422
diff --git a/src/titiler/core/tests/test_factories.py b/src/titiler/core/tests/test_factories.py
index 408cf96a9..576ecf8e7 100644
--- a/src/titiler/core/tests/test_factories.py
+++ b/src/titiler/core/tests/test_factories.py
@@ -1,33 +1,39 @@
 """Test TiTiler Tiler Factories."""
 
 import json
+import math
 import os
 import pathlib
+import warnings
 from dataclasses import dataclass
 from enum import Enum
 from io import BytesIO
-from typing import Dict, Optional, Type
+from typing import Annotated, Dict, Optional, Sequence, Type
 from unittest.mock import patch
-from urllib.parse import urlencode
+from urllib.parse import quote, urlencode
 
 import attr
 import httpx
 import morecantile
 import numpy
+import pytest
+from attrs import define
 from fastapi import Depends, FastAPI, HTTPException, Path, Query, security, status
 from morecantile.defaults import TileMatrixSets
 from rasterio.crs import CRS
 from rasterio.io import MemoryFile
+from rio_tiler.colormap import cmap as default_cmap
+from rio_tiler.errors import InvalidDatatypeWarning, NoOverviewWarning
 from rio_tiler.io import BaseReader, MultiBandReader, Reader, STACReader
 from starlette.requests import Request
 from starlette.testclient import TestClient
 
-from titiler.core.dependencies import RescaleType
+from titiler.core import dependencies
 from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
 from titiler.core.factory import (
     AlgorithmFactory,
-    BaseTilerFactory,
-    MultiBandTilerFactory,
+    BaseFactory,
+    ColorMapFactory,
     MultiBaseTilerFactory,
     TilerFactory,
     TMSFactory,
@@ -43,7 +49,7 @@
 def test_TilerFactory():
     """Test TilerFactory class."""
     cog = TilerFactory()
-    assert len(cog.router.routes) == 27
+    assert len(cog.router.routes) == 19
     assert len(cog.supported_tms.list()) == NB_DEFAULT_TMS
 
     cog = TilerFactory(router_prefix="something", supported_tms=WEB_TMS)
@@ -53,7 +59,15 @@ def test_TilerFactory():
     app.include_router(cog.router, prefix="/something")
     client = TestClient(app)
 
-    response = client.get(f"/something/tilejson.json?url={DATA_DIR}/cog.tif")
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+
+    response = client.get("/docs")
+    assert response.status_code == 200
+
+    response = client.get(
+        f"/something/WebMercatorQuad/tilejson.json?url={DATA_DIR}/cog.tif"
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     assert response.json()["tilejson"]
@@ -62,7 +76,7 @@ def test_TilerFactory():
     assert response.status_code == 422
 
     cog = TilerFactory(add_preview=False, add_part=False, add_viewer=False)
-    assert len(cog.router.routes) == 18
+    assert len(cog.router.routes) == 10
 
     app = FastAPI()
     cog = TilerFactory()
@@ -72,17 +86,19 @@ def test_TilerFactory():
 
     client = TestClient(app)
 
-    response = client.get(f"/tiles/8/87/48?url={DATA_DIR}/cog.tif&rescale=0,1000")
+    response = client.get(
+        f"/tiles/WebMercatorQuad/8/87/48?url={DATA_DIR}/cog.tif&rescale=0,1000"
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpeg"
     response = client.get(
-        f"/tiles/8/87/48?url={DATA_DIR}/cog.tif&rescale=-3.4028235e+38,3.4028235e+38"
+        f"/tiles/WebMercatorQuad/8/87/48?url={DATA_DIR}/cog.tif&rescale={quote('-3.4028235e+38,3.4028235e+38')}"  # + symbols are interpreted as spaces without quoting
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpeg"
 
     response = client.get(
-        f"/tiles/8/87/48.tif?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&bidx=1&return_mask=false"
+        f"/tiles/WebMercatorQuad/8/87/48.tif?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&bidx=1&return_mask=false"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
@@ -93,7 +109,7 @@ def test_TilerFactory():
     assert meta["height"] == 256
 
     response = client.get(
-        "/tiles/8/87/48.tif",
+        "/tiles/WebMercatorQuad/8/87/48.tif",
         params={
             "url": f"{DATA_DIR}/cog.tif",
             "expression": "b1;b1;b1",
@@ -109,14 +125,17 @@ def test_TilerFactory():
     assert meta["height"] == 256
 
     response = client.get(
-        f"/tiles/8/84/47?url={DATA_DIR}/cog.tif&bidx=1&rescale=0,1000&colormap_name=viridis"
+        f"/tiles/WebMercatorQuad/8/84/47?url={DATA_DIR}/cog.tif&bidx=1&rescale=0,1000&colormap_name=viridis"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
 
     # Dict
-    cmap = urlencode(
-        {
+    response = client.get(
+        "/tiles/WebMercatorQuad/8/84/47.png",
+        params={
+            "url": f"{DATA_DIR}/cog.tif",
+            "bidx": 1,
             "colormap": json.dumps(
                 {
                     "1": [58, 102, 24, 255],
@@ -124,16 +143,18 @@ def test_TilerFactory():
                     "3": "#b1b129",
                     "4": "#ddcb9aFF",
                 }
-            )
-        }
+            ),
+        },
     )
-    response = client.get(f"/tiles/8/84/47.png?url={DATA_DIR}/cog.tif&bidx=1&{cmap}")
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
 
     # Intervals
-    cmap = urlencode(
-        {
+    response = client.get(
+        "/tiles/WebMercatorQuad/8/84/47.png",
+        params={
+            "url": f"{DATA_DIR}/cog.tif",
+            "bidx": 1,
             "colormap": json.dumps(
                 [
                     # ([min, max], [r, g, b, a])
@@ -141,37 +162,50 @@ def test_TilerFactory():
                     ([2, 3], [255, 255, 255, 255]),
                     ([3, 1000], [255, 0, 0, 255]),
                 ]
-            )
-        }
+            ),
+        },
     )
-    response = client.get(f"/tiles/8/84/47.png?url={DATA_DIR}/cog.tif&bidx=1&{cmap}")
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
 
     # Bad colormap format
     cmap = urlencode({"colormap": json.dumps({"1": [58, 102]})})
-    response = client.get(f"/tiles/8/84/47.png?url={DATA_DIR}/cog.tif&bidx=1&{cmap}")
+    response = client.get(
+        f"/tiles/WebMercatorQuad/8/84/47.png?url={DATA_DIR}/cog.tif&bidx=1&{cmap}"
+    )
     assert response.status_code == 400
 
     # no json encoding
     cmap = urlencode({"colormap": {"1": [58, 102]}})
-    response = client.get(f"/tiles/8/84/47.png?url={DATA_DIR}/cog.tif&bidx=1&{cmap}")
+    response = client.get(
+        f"/tiles/WebMercatorQuad/8/84/47.png?url={DATA_DIR}/cog.tif&bidx=1&{cmap}"
+    )
     assert response.status_code == 400
 
     # Test NumpyTile
-    response = client.get(f"/tiles/8/87/48.npy?url={DATA_DIR}/cog.tif")
+    response = client.get(f"/tiles/WebMercatorQuad/8/87/48.npy?url={DATA_DIR}/cog.tif")
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/x-binary"
     npy_tile = numpy.load(BytesIO(response.content))
     assert npy_tile.shape == (2, 256, 256)  # mask + data
 
     # Test Buffer
-    response = client.get(f"/tiles/8/87/48.npy?url={DATA_DIR}/cog.tif&buffer=10")
+    response = client.get(
+        f"/tiles/WebMercatorQuad/8/87/48.npy?url={DATA_DIR}/cog.tif&buffer=10"
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/x-binary"
     npy_tile = numpy.load(BytesIO(response.content))
     assert npy_tile.shape == (2, 276, 276)  # mask + data
 
+    response = client.get(
+        f"/tiles/WebMercatorQuad/8/87/48.png?url={DATA_DIR}/cog.tif&tilesize=512"
+    )
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["width"] == 512
+    assert meta["height"] == 512
+
     response = client.get(
         f"/preview?url={DATA_DIR}/cog.tif&rescale=0,1000&max_size=256"
     )
@@ -179,10 +213,21 @@ def test_TilerFactory():
     assert response.headers["content-type"] == "image/jpeg"
 
     response = client.get(
-        f"/crop/-56.228,72.715,-54.547,73.188.png?url={DATA_DIR}/cog.tif&rescale=0,1000&max_size=256"
+        f"/bbox/-56.228,72.715,-54.547,73.188.png?url={DATA_DIR}/cog.tif&rescale=0,1000&max_size=256"
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "image/png"
+
+    response = client.get(
+        f"/bbox/-56.228,72.715,-54.547,73.188/100x100.png?url={DATA_DIR}/cog.tif&rescale=0,1000"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
+    meta = parse_img(response.content)
+    assert meta["driver"] == "PNG"
+    assert meta["count"] == 2
+    assert meta["width"] == 100
+    assert meta["height"] == 100
 
     response = client.get(f"/point/-56.228,72.715?url={DATA_DIR}/cog.tif")
     assert response.status_code == 200
@@ -190,8 +235,15 @@ def test_TilerFactory():
     assert len(response.json()["values"]) == 1
     assert response.json()["band_names"] == ["b1"]
 
+    # Masked values
+    response = client.get(f"/point/-59.337,73.9898?url={DATA_DIR}/cog.tif&nodata=1")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    assert response.json()["values"] == [None]
+    assert response.json()["band_names"] == ["b1"]
+
     response = client.get(
-        f"/point/-6259272.328324187,12015838.020930404?url={DATA_DIR}/cog.tif&coord-crs=EPSG:3857"
+        f"/point/-6259272.328324187,12015838.020930404?url={DATA_DIR}/cog.tif&coord_crs=EPSG:3857"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
@@ -201,63 +253,51 @@ def test_TilerFactory():
     response = client.get(f"/point/-56.228,72.715?url={DATA_DIR}/cog.tif&bidx=1&bidx=1")
     assert len(response.json()["values"]) == 2
     assert response.json()["band_names"] == ["b1", "b1"]
+    assert response.json()["band_descriptions"] == ["b1", "b1"]
 
     response = client.get(
         f"/point/-56.228,72.715?url={DATA_DIR}/cog.tif&expression=b1*2"
     )
     assert len(response.json()["values"]) == 1
-    assert response.json()["band_names"] == ["b1*2"]
-
-    response = client.get(f"/tilejson.json?url={DATA_DIR}/cog.tif")
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "application/json"
-    assert response.json()["tilejson"]
+    assert response.json()["band_descriptions"] == ["b1*2"]
 
-    response = client.get(f"/WorldCRS84Quad/tilejson.json?url={DATA_DIR}/cog.tif")
+    # NOTE: tilejson tilesize default to 512x512
+    # because Mapbox and Maplibre expect tiles to be 512x512
+    response = client.get(f"/WebMercatorQuad/tilejson.json?url={DATA_DIR}/cog.tif")
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     assert response.json()["tilejson"]
+    assert "tilesize=512" in response.json()["tiles"][0]
 
-    response_qs = client.get(
-        f"/tilejson.json?url={DATA_DIR}/cog.tif&TileMatrixSetId=WorldCRS84Quad"
+    response = client.get(
+        f"/WebMercatorQuad/tilejson.json?url={DATA_DIR}/cog.tif&tilesize=256"
     )
-    assert response.json()["tiles"] == response_qs.json()["tiles"]
-
-    response = client.get(f"/tilejson.json?url={DATA_DIR}/cog.tif&tile_format=png")
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     assert response.json()["tilejson"]
-    assert "png" in response.json()["tiles"][0]
+    assert "tilesize=256" in response.json()["tiles"][0]
 
-    response = client.get(f"/tilejson.json?url={DATA_DIR}/cog.tif&minzoom=5&maxzoom=12")
+    response = client.get(f"/WorldCRS84Quad/tilejson.json?url={DATA_DIR}/cog.tif")
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     assert response.json()["tilejson"]
-    assert response.json()["minzoom"] == 5
-    assert response.json()["maxzoom"] == 12
 
     response = client.get(
-        f"/WMTSCapabilities.xml?url={DATA_DIR}/cog.tif&minzoom=5&maxzoom=12"
+        f"/WebMercatorQuad/tilejson.json?url={DATA_DIR}/cog.tif&tile_format=png"
     )
     assert response.status_code == 200
-    assert response.headers["content-type"] == "application/xml"
-    meta = parse_img(response.content)
-    assert meta["driver"] == "WMTS"
-    assert meta["crs"] == "EPSG:3857"
+    assert response.headers["content-type"] == "application/json"
+    assert response.json()["tilejson"]
+    assert "png" in response.json()["tiles"][0]
 
     response = client.get(
-        f"/WorldCRS84Quad/WMTSCapabilities.xml?url={DATA_DIR}/cog.tif&minzoom=5&maxzoom=12"
+        f"/WebMercatorQuad/tilejson.json?url={DATA_DIR}/cog.tif&minzoom=5&maxzoom=12"
     )
     assert response.status_code == 200
-    assert response.headers["content-type"] == "application/xml"
-    meta = parse_img(response.content)
-    assert meta["driver"] == "WMTS"
-    assert str(meta["crs"]) == "OGC:CRS84"
-
-    response = client.get(f"/bounds?url={DATA_DIR}/cog.tif")
-    assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
-    assert response.json()["bounds"]
+    assert response.json()["tilejson"]
+    assert response.json()["minzoom"] == 5
+    assert response.json()["maxzoom"] == 12
 
     response = client.get(f"/info?url={DATA_DIR}/cog.tif")
     assert response.status_code == 200
@@ -268,6 +308,17 @@ def test_TilerFactory():
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
     assert response.json()["type"] == "Feature"
+    assert "bbox" in response.json()
+    assert response.json()["geometry"]["type"] == "Polygon"
+
+    # BBOX crossing the Antimeridian
+    with pytest.warns(UserWarning):
+        response = client.get(f"/info.geojson?url={DATA_DIR}/cog_dateline.tif")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/geo+json"
+    assert response.json()["type"] == "Feature"
+    assert "bbox" in response.json()
+    assert response.json()["geometry"]["type"] == "MultiPolygon"
 
     response = client.get(
         f"/preview.png?url={DATA_DIR}/cog.tif&rescale=0,1000&max_size=256"
@@ -286,14 +337,12 @@ def test_TilerFactory():
     assert meta["width"] == 512
     assert meta["height"] == 512
 
-    response = client.get(
-        f"/preview.png?url={DATA_DIR}/cog.tif&rescale=0,1000&max_size=0&nodata=0"
-    )
+    response = client.get(f"/preview/512x512.png?url={DATA_DIR}/cog.tif&rescale=0,1000")
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
     meta = parse_img(response.content)
-    assert meta["width"] == 2658
-    assert meta["height"] == 2667
+    assert meta["width"] == 512
+    assert meta["height"] == 512
 
     response = client.get(
         f"/preview.png?url={DATA_DIR}/cog.tif&rescale=0,1000&max_size=0&nodata=0"
@@ -345,18 +394,31 @@ def test_TilerFactory():
 
     feature_collection = {"type": "FeatureCollection", "features": [feature]}
 
-    response = client.post(f"/crop?url={DATA_DIR}/cog.tif", json=feature)
+    response = client.post(f"/feature?url={DATA_DIR}/cog.tif", json=feature)
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "image/png"
+
+    response = client.post(
+        f"/feature/100x100.png?url={DATA_DIR}/cog.tif&rescale=0,1000", json=feature
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/png"
+    meta = parse_img(response.content)
+    assert meta["driver"] == "PNG"
+    assert meta["width"] == 100
+    assert meta["height"] == 100
 
-    response = client.post(f"/crop.tif?url={DATA_DIR}/cog.tif", json=feature)
+    response = client.post(f"/feature.tif?url={DATA_DIR}/cog.tif", json=feature)
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
     meta = parse_img(response.content)
     assert meta["dtype"] == "uint16"
     assert meta["count"] == 2
 
-    response = client.post(f"/crop/100x100.jpeg?url={DATA_DIR}/cog.tif", json=feature)
+    with pytest.warns(InvalidDatatypeWarning):
+        response = client.post(
+            f"/feature/100x100.jpeg?url={DATA_DIR}/cog.tif", json=feature
+        )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpeg"
     meta = parse_img(response.content)
@@ -364,12 +426,7 @@ def test_TilerFactory():
     assert meta["height"] == 100
 
     # GET - statistics
-    response = client.get(f"/statistics?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&bidx=1")
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "application/json"
-    resp = response.json()
-    assert len(resp) == 1
-    assert set(resp["b1"].keys()) == {
+    stats_keys = [
         "min",
         "max",
         "mean",
@@ -384,34 +441,33 @@ def test_TilerFactory():
         "valid_percent",
         "masked_pixels",
         "valid_pixels",
+        "description",
+    ]
+
+    response = client.get(f"/statistics?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&bidx=1")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    resp = response.json()
+    assert len(resp) == 1
+    assert set(resp["b1"].keys()) == {
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
     assert len(resp["b1"]["histogram"][0]) == 10
+    assert resp["b1"]["description"] == "b1"
 
     response = client.get(f"/statistics?url={DATA_DIR}/cog.tif&expression=b1*2")
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     resp = response.json()
     assert len(resp) == 1
-    assert set(resp["b1*2"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+    assert set(resp["b1"].keys()) == {
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
+    assert resp["b1"]["description"] == "b1*2"
 
     response = client.get(
         f"/statistics?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&bidx=1&p=4&p=5"
@@ -421,23 +477,11 @@ def test_TilerFactory():
     resp = response.json()
     assert len(resp) == 1
     assert set(resp["b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+        *stats_keys,
         "percentile_4",
         "percentile_5",
     }
+    assert resp["b1"]["description"] == "b1"
 
     response = client.get(f"/statistics?url={DATA_DIR}/cog.tif&categorical=true")
     assert response.status_code == 200
@@ -445,20 +489,7 @@ def test_TilerFactory():
     resp = response.json()
     assert len(resp) == 1
     assert set(resp["b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
@@ -473,20 +504,7 @@ def test_TilerFactory():
     resp = response.json()
     assert len(resp) == 1
     assert set(resp["b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
@@ -510,6 +528,16 @@ def test_TilerFactory():
     assert min(resp["b1"]["histogram"][1]) == 5.0
     assert max(resp["b1"]["histogram"][1]) == 10.0
 
+    # Stats with Algorithm
+    response = client.get(
+        f"/statistics?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&algorithm=normalizedIndex"
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    resp = response.json()
+    assert len(resp) == 1
+    assert resp["b1"]["description"] == "(b1 - b1) / (b1 + b1)"
+
     # POST - statistics
     response = client.post(
         f"/statistics?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&bidx=1", json=feature
@@ -520,23 +548,11 @@ def test_TilerFactory():
     assert resp["type"] == "Feature"
     assert len(resp["properties"]["statistics"]) == 1
     assert set(resp["properties"]["statistics"]["b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
+        *stats_keys,
         "percentile_2",
         "percentile_98",
-        "valid_pixels",
-        "masked_pixels",
-        "valid_percent",
     }
+    assert resp["properties"]["statistics"]["b1"]["description"] == "b1"
 
     response = client.post(
         f"/statistics?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&bidx=1",
@@ -548,26 +564,16 @@ def test_TilerFactory():
     assert resp["type"] == "FeatureCollection"
     assert len(resp["features"][0]["properties"]["statistics"]) == 1
     assert set(resp["features"][0]["properties"]["statistics"]["b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
+        *stats_keys,
         "percentile_2",
         "percentile_98",
-        "valid_pixels",
-        "masked_pixels",
-        "valid_percent",
     }
+    assert resp["features"][0]["properties"]["statistics"]["b1"]["description"] == "b1"
 
     response = client.post(
-        f"/statistics?url={DATA_DIR}/cog.tif&categorical=true", json=feature
+        "/statistics",
+        json=feature,
+        params={"categorical": True, "max_size": 1024, "url": f"{DATA_DIR}/cog.tif"},
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
@@ -575,28 +581,25 @@ def test_TilerFactory():
     assert resp["type"] == "Feature"
     assert len(resp["properties"]["statistics"]) == 1
     assert set(resp["properties"]["statistics"]["b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
+        *stats_keys,
         "percentile_2",
         "percentile_98",
-        "valid_pixels",
-        "masked_pixels",
-        "valid_percent",
     }
-    assert len(resp["properties"]["statistics"]["b1"]["histogram"][1]) == 12
+    assert len(resp["properties"]["statistics"]["b1"]["histogram"][1]) == 13
+    assert resp["properties"]["statistics"]["b1"]["description"] == "b1"
 
     response = client.post(
-        f"/statistics?url={DATA_DIR}/cog.tif&categorical=true&c=1&c=2&c=3&c=4",
+        "/statistics",
         json=feature,
+        params=(
+            ("categorical", True),
+            ("c", 1),
+            ("c", 2),
+            ("c", 3),
+            ("c", 4),
+            ("max_size", 1024),
+            ("url", f"{DATA_DIR}/cog.tif"),
+        ),
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
@@ -604,26 +607,27 @@ def test_TilerFactory():
     assert resp["type"] == "Feature"
     assert len(resp["properties"]["statistics"]) == 1
     assert set(resp["properties"]["statistics"]["b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
+        *stats_keys,
         "percentile_2",
         "percentile_98",
-        "valid_pixels",
-        "masked_pixels",
-        "valid_percent",
     }
     assert len(resp["properties"]["statistics"]["b1"]["histogram"][0]) == 4
     assert resp["properties"]["statistics"]["b1"]["histogram"][0][3] == 0
 
+    # Stats with Algorithm
+    response = client.post(
+        f"/statistics?url={DATA_DIR}/cog.tif&bidx=1&bidx=1&algorithm=normalizedIndex",
+        json=feature,
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/geo+json"
+    resp = response.json()
+    assert resp["type"] == "Feature"
+    assert len(resp["properties"]["statistics"]) == 1
+    assert (
+        resp["properties"]["statistics"]["b1"]["description"] == "(b1 - b1) / (b1 + b1)"
+    )
+
     # Test with Algorithm
     response = client.get(f"/preview.tif?url={DATA_DIR}/dem.tif&return_mask=False")
     assert response.status_code == 200
@@ -641,6 +645,25 @@ def test_TilerFactory():
     assert meta["dtype"] == "uint8"
     assert meta["count"] == 3
 
+    # OGC Tileset
+    response = client.get(f"/tiles?url={DATA_DIR}/cog.tif")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    resp = response.json()
+    assert len(resp["tilesets"]) == NB_DEFAULT_TMS
+
+    first_tms = resp["tilesets"][0]
+    first_id = DEFAULT_TMS.list()[0]
+    assert first_id in first_tms["title"]
+    assert len(first_tms["links"]) == 2  # no link to the tms definition
+
+    response = client.get(f"/tiles/WebMercatorQuad?url={DATA_DIR}/cog.tif")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    resp = response.json()
+    # covers only 5 zoom levels
+    assert len(resp["tileMatrixSetLimits"]) == 5
+
 
 @patch("rio_tiler.io.rasterio.rasterio")
 def test_MultiBaseTilerFactory(rio):
@@ -648,7 +671,7 @@ def test_MultiBaseTilerFactory(rio):
     rio.open = mock_rasterio_open
 
     stac = MultiBaseTilerFactory(reader=STACReader)
-    assert len(stac.router.routes) == 29
+    assert len(stac.router.routes) == 21
 
     app = FastAPI()
     app.include_router(stac.router)
@@ -657,15 +680,22 @@ def test_MultiBaseTilerFactory(rio):
 
     client = TestClient(app)
 
-    response = client.get(f"/assets?url={DATA_DIR}/item.json")
+    response = client.get("/openapi.json")
     assert response.status_code == 200
-    assert len(response.json()) == 2
 
-    response = client.get(f"/bounds?url={DATA_DIR}/item.json")
+    response = client.get("/docs")
     assert response.status_code == 200
-    assert len(response.json()["bounds"]) == 4
 
+    response = client.get(f"/assets?url={DATA_DIR}/item.json")
+    assert response.status_code == 200
+    assert len(response.json()) == 2
+
+    # no assets
     response = client.get(f"/info?url={DATA_DIR}/item.json")
+    assert response.status_code == 422
+
+    # :all: assets
+    response = client.get(f"/info?url={DATA_DIR}/item.json&assets=:all:")
     assert response.status_code == 200
     assert len(response.json()) == 2
 
@@ -679,8 +709,9 @@ def test_MultiBaseTilerFactory(rio):
     assert response.headers["content-type"] == "application/geo+json"
     assert response.json()["type"] == "Feature"
 
+    # missing assets
     response = client.get(f"/preview.tif?url={DATA_DIR}/item.json")
-    assert response.status_code == 400
+    assert response.status_code == 422
 
     response = client.get(
         f"/preview.tif?url={DATA_DIR}/item.json&assets=B01&assets=B09&return_mask=false"
@@ -695,30 +726,36 @@ def test_MultiBaseTilerFactory(rio):
         "/preview.tif",
         params={
             "url": f"{DATA_DIR}/item.json",
-            "expression": "B01_b1;B01_b1;B01_b1",
+            "assets": "B01|bidx=1,1,1",
             "return_mask": False,
         },
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
     meta = parse_img(response.content)
-    assert meta["dtype"] == "int32"
+    assert meta["dtype"] == "uint16"
     assert meta["count"] == 3
 
     response = client.get(
-        f"/preview.tif?url={DATA_DIR}/item.json&assets=B01&asset_bidx=B01|1,1,1&return_mask=false"
+        "/preview.tif",
+        params={
+            "url": f"{DATA_DIR}/item.json",
+            "assets": "B01",
+            "expression": "b1;b1;b1",
+            "return_mask": False,
+        },
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
     meta = parse_img(response.content)
-    assert meta["dtype"] == "uint16"
+    assert meta["dtype"] == "int32"
     assert meta["count"] == 3
 
     response = client.get(
         "/preview.tif",
         params={
             "url": f"{DATA_DIR}/item.json",
-            "expression": "B01_b1;B01_b1;B01_b1",
+            "assets": "B01|expression=b1;b1;b1",
             "return_mask": False,
         },
     )
@@ -733,7 +770,7 @@ def test_MultiBaseTilerFactory(rio):
         "/preview.tif",
         params={
             "url": f"{DATA_DIR}/item.json",
-            "expression": "B01;B01;B01",
+            "assets": "B01",
             "asset_as_band": True,
             "return_mask": False,
         },
@@ -741,18 +778,11 @@ def test_MultiBaseTilerFactory(rio):
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/tiff; application=geotiff"
     meta = parse_img(response.content)
-    assert meta["dtype"] == "int32"
-    assert meta["count"] == 3
+    assert meta["dtype"] == "uint16"
+    assert meta["count"] == 1
 
     # GET - statistics
-    response = client.get(
-        f"/asset_statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09"
-    )
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "application/json"
-    resp = response.json()
-    assert len(resp) == 2
-    assert set(resp["B01"]["b1"].keys()) == {
+    stats_keys = [
         "min",
         "max",
         "mean",
@@ -767,326 +797,85 @@ def test_MultiBaseTilerFactory(rio):
         "valid_percent",
         "masked_pixels",
         "valid_pixels",
-        "percentile_2",
-        "percentile_98",
-    }
+        "description",
+    ]
+
     response = client.get(
-        f"/asset_statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09&asset_bidx=B01|1&asset_bidx=B09|1"
+        f"/asset_statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     resp = response.json()
     assert len(resp) == 2
-    assert resp["B01"]["b1"]
-    assert resp["B09"]["b1"]
-
-    response = client.get(f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09")
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "application/json"
-    resp = response.json()
-    assert list(resp) == ["B01_b1", "B09_b1"]
-    assert set(resp["B01_b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+    assert set(resp["B01"]["b1"].keys()) == {
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
+    assert resp["B09"]["b1"]["description"] == "b1"
 
     response = client.get(
-        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09&asset_bidx=B01|1&asset_bidx=B09|1"
+        f"/asset_statistics?url={DATA_DIR}/item.json&assets=B09|bidx=1,1"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     resp = response.json()
-    assert len(resp) == 2
-    assert resp["B01_b1"]
-    assert resp["B09_b1"]
-
-    stac_feature = {
-        "type": "FeatureCollection",
-        "features": [
-            {
-                "type": "Feature",
-                "properties": {},
-                "geometry": {
-                    "type": "Polygon",
-                    "coordinates": [
-                        [
-                            [23.62060546875, 31.834399275715842],
-                            [23.838958740234375, 31.834399275715842],
-                            [23.838958740234375, 32.072101858328686],
-                            [23.62060546875, 32.072101858328686],
-                            [23.62060546875, 31.834399275715842],
-                        ]
-                    ],
-                },
-            }
-        ],
-    }
+    assert len(resp) == 1
+    assert resp["B09|indexes=[1,1]"]["b1"]
+    assert resp["B09|indexes=[1,1]"]["b1"]["description"] == "b1"
 
-    # POST - statistics
-    response = client.post(
-        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09",
-        json=stac_feature["features"][0],
-    )
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "application/geo+json"
-    resp = response.json()
-    props = resp["properties"]["statistics"]
-    assert len(props) == 2
-    assert set(props["B01_b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
-        "percentile_2",
-        "percentile_98",
-    }
-    assert props["B09_b1"]
+    # missing assets
+    response = client.get(f"/statistics?url={DATA_DIR}/item.json")
+    assert response.status_code == 422
 
-    response = client.post(
-        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09", json=stac_feature
-    )
+    # all assets
+    response = client.get(f"/statistics?url={DATA_DIR}/item.json&assets=:all:")
     assert response.status_code == 200
-    assert response.headers["content-type"] == "application/geo+json"
+    assert response.headers["content-type"] == "application/json"
     resp = response.json()
-    props = resp["features"][0]["properties"]["statistics"]
-    assert len(props) == 2
-    assert set(props["B01_b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
-        "percentile_2",
-        "percentile_98",
-    }
-    assert props["B09_b1"]
+    assert len(resp) == 2
 
-    response = client.post(
-        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09&asset_bidx=B01|1&asset_bidx=B09|1",
-        json=stac_feature["features"][0],
-    )
+    response = client.get(f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09")
     assert response.status_code == 200
-    assert response.headers["content-type"] == "application/geo+json"
+    assert response.headers["content-type"] == "application/json"
     resp = response.json()
-    props = resp["properties"]["statistics"]
-    assert len(props) == 2
-    assert set(props["B01_b1"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+    assert list(resp) == ["b1", "b2"]
+    assert set(resp["b1"].keys()) == {
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
-    assert props["B09_b1"]
-
-
-@attr.s
-class BandFileReader(MultiBandReader):
-    """Test MultiBand"""
-
-    input: str = attr.ib()
-    tms: morecantile.TileMatrixSet = attr.ib(
-        default=morecantile.tms.get("WebMercatorQuad")
-    )
-    reader_options: Dict = attr.ib(factory=dict)
-
-    reader: Type[BaseReader] = attr.ib(default=Reader)
+    assert resp["b1"]["description"] == "B01_b1"
+    assert resp["b2"]["description"] == "B09_b1"
 
-    minzoom: int = attr.ib()
-    maxzoom: int = attr.ib()
-
-    @minzoom.default
-    def _minzoom(self):
-        return self.tms.minzoom
-
-    @maxzoom.default
-    def _maxzoom(self):
-        return self.tms.maxzoom
-
-    def __attrs_post_init__(self):
-        """Parse Sceneid and get grid bounds."""
-        self.bands = sorted([p.stem for p in pathlib.Path(self.input).glob("B0*.tif")])
-        with self.reader(self._get_band_url(self.bands[0])) as cog:
-            self.bounds = cog.bounds
-            self.crs = cog.crs
-            self.minzoom = cog.minzoom
-            self.maxzoom = cog.maxzoom
-
-    def _get_band_url(self, band: str) -> str:
-        """Validate band's name and return band's url."""
-        return os.path.join(self.input, f"{band}.tif")
-
-
-def CustomPathParams(directory: str = Query(..., description="Give me a url.")) -> str:
-    """Custom path Dependency."""
-    return directory
-
-
-def test_MultiBandTilerFactory():
-    """test MultiBandTilerFactory."""
-
-    bands = MultiBandTilerFactory(
-        reader=BandFileReader, path_dependency=CustomPathParams
-    )
-    assert len(bands.router.routes) == 28
-
-    app = FastAPI()
-    app.include_router(bands.router)
-
-    add_exception_handlers(app, DEFAULT_STATUS_CODES)
-
-    client = TestClient(app)
-
-    response = client.get(f"/bands?directory={DATA_DIR}")
-    assert response.status_code == 200
-    assert response.json() == ["B01", "B09"]
-
-    # default bands
-    response = client.get(f"/info?directory={DATA_DIR}")
-    assert response.json()["band_metadata"] == [["B01", {}], ["B09", {}]]
-
-    response = client.get(f"/info?directory={DATA_DIR}&bands=B01")
-    assert response.status_code == 200
-    assert response.json()["band_metadata"] == [["B01", {}]]
-
-    response = client.get(f"/info.geojson?directory={DATA_DIR}&bands=B01")
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "application/geo+json"
-    assert response.json()["properties"]["band_metadata"] == [["B01", {}]]
-
-    # need bands or expression
-    response = client.get(f"/preview.tif?directory={DATA_DIR}&return_mask=false")
-    assert response.status_code == 400
-
-    response = client.get(
-        f"/preview.tif?directory={DATA_DIR}&bands=B01&bands=B09&bands=B01&return_mask=false"
-    )
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "image/tiff; application=geotiff"
-    meta = parse_img(response.content)
-    assert meta["dtype"] == "uint16"
-    assert meta["count"] == 3
-
-    response = client.get(
-        "/preview.tif",
-        params={
-            "directory": DATA_DIR,
-            "expression": "B01;B09;B01",
-            "return_mask": False,
-        },
-    )
-    assert response.status_code == 200
-    assert response.headers["content-type"] == "image/tiff; application=geotiff"
-    meta = parse_img(response.content)
-    assert (
-        meta["dtype"] == "int32"
-    )  # when using expression, numexpr will change the datatype
-    assert meta["count"] == 3
-
-    # GET - statistics
-    response = client.get(f"/statistics?directory={DATA_DIR}")
+    response = client.get(f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09")
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     resp = response.json()
     assert len(resp) == 2
-    assert resp["B01"]
-    assert resp["B09"]
+    assert resp["b1"]["description"] == "B01_b1"
+    assert resp["b2"]["description"] == "B09_b1"
 
-    response = client.get(f"/statistics?directory={DATA_DIR}&bands=B01&bands=B09")
+    response = client.get(
+        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09&asset_as_band=True"
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     resp = response.json()
     assert len(resp) == 2
-    assert set(resp["B01"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
-        "percentile_2",
-        "percentile_98",
-    }
-    assert resp["B09"]
+    assert resp["b1"]["description"] == "B01"
+    assert resp["b2"]["description"] == "B09"
 
-    response = client.get(f"/statistics?directory={DATA_DIR}&expression=B01/B09")
+    # with Algorithm
+    response = client.get(
+        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09&algorithm=normalizedIndex&asset_as_band=True"
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     resp = response.json()
-    assert len(resp) == 1
-    assert set(resp["B01/B09"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
-        "percentile_2",
-        "percentile_98",
-    }
+    assert resp["b1"]["description"] == "(B09 - B01) / (B09 + B01)"
 
-    # POST - statistics
-    band_feature = {
+    stac_feature = {
         "type": "FeatureCollection",
         "features": [
             {
@@ -1108,137 +897,154 @@ def test_MultiBandTilerFactory():
         ],
     }
 
+    # POST - statistics
     response = client.post(
-        f"/statistics?directory={DATA_DIR}&bands=B01&bands=B09",
-        json=band_feature["features"][0],
+        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09",
+        json=stac_feature["features"][0],
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
     resp = response.json()
     props = resp["properties"]["statistics"]
     assert len(props) == 2
-    assert set(props["B01"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+    assert set(props["b1"].keys()) == {
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
-    assert props["B09"]
+    assert props["b1"]["description"] == "B01_b1"
+    assert props["b2"]["description"] == "B09_b1"
 
+    # missing assets
     response = client.post(
-        f"/statistics?directory={DATA_DIR}&expression=B01/B09",
-        json=band_feature["features"][0],
+        f"/statistics?url={DATA_DIR}/item.json",
+        json=stac_feature["features"][0],
+    )
+    assert response.status_code == 422
+
+    # all assets
+    response = client.post(
+        f"/statistics?url={DATA_DIR}/item.json&assets=:all:",
+        json=stac_feature["features"][0],
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
     resp = response.json()
-    props = resp["properties"]["statistics"]
-    assert len(props) == 1
-    assert set(props["B01/B09"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
-        "percentile_2",
-        "percentile_98",
-    }
+    assert len(resp["properties"]["statistics"]) == 2
 
     response = client.post(
-        f"/statistics?directory={DATA_DIR}&bands=B01&bands=B09", json=band_feature
+        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09", json=stac_feature
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
     resp = response.json()
     props = resp["features"][0]["properties"]["statistics"]
     assert len(props) == 2
-    assert set(props["B01"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+    assert set(props["b1"].keys()) == {
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
-    assert props["B09"]
+    assert props["b1"]["description"] == "B01_b1"
 
     response = client.post(
-        f"/statistics?directory={DATA_DIR}&expression=B01/B09", json=band_feature
+        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09&asset_as_band=True",
+        json=stac_feature["features"][0],
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
     resp = response.json()
-    props = resp["features"][0]["properties"]["statistics"]
-    assert len(props) == 1
-    assert set(props["B01/B09"].keys()) == {
-        "min",
-        "max",
-        "mean",
-        "count",
-        "sum",
-        "std",
-        "median",
-        "majority",
-        "minority",
-        "unique",
-        "histogram",
-        "valid_percent",
-        "masked_pixels",
-        "valid_pixels",
+    props = resp["properties"]["statistics"]
+    assert len(props) == 2
+    assert set(props["b1"].keys()) == {
+        *stats_keys,
         "percentile_2",
         "percentile_98",
     }
+    assert props["b1"]["description"] == "B01"
+    assert props["b2"]["description"] == "B09"
 
-    # default bands
-    response = client.post(f"/statistics?directory={DATA_DIR}", json=band_feature)
+    response = client.post(
+        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09&expression=b1/b2&asset_as_band=True",
+        json=stac_feature["features"][0],
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
     resp = response.json()
-    props = resp["features"][0]["properties"]["statistics"]
-    assert props["B01"]
-    assert props["B09"]
+    props = resp["properties"]["statistics"]
+    assert len(props) == 1
+    assert set(props["b1"].keys()) == {
+        *stats_keys,
+        "percentile_2",
+        "percentile_98",
+    }
+    assert props["b1"]["description"] == "B01/B09"
 
+    # with Algorithm
     response = client.post(
-        f"/statistics?directory={DATA_DIR}",
-        json=band_feature["features"][0],
+        f"/statistics?url={DATA_DIR}/item.json&assets=B01&assets=B09&algorithm=normalizedIndex&asset_as_band=True",
+        json=stac_feature["features"][0],
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/geo+json"
     resp = response.json()
     props = resp["properties"]["statistics"]
-    assert props["B01"]
-    assert props["B09"]
+    assert len(props) == 1
+    assert props["b1"]["description"] == "(B09 - B01) / (B09 + B01)"
+
+    # OGC Tileset
+    response = client.get(f"/tiles?url={DATA_DIR}/item.json")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    resp = response.json()
+    assert len(resp["tilesets"]) == NB_DEFAULT_TMS
+
+    first_tms = resp["tilesets"][0]
+    first_id = DEFAULT_TMS.list()[0]
+    assert first_id in first_tms["title"]
+    assert len(first_tms["links"]) == 2  # no link to the tms definition
+
+    response = client.get(f"/tiles/WebMercatorQuad?url={DATA_DIR}/item.json")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    resp = response.json()
+    # default minzoom/maxzoom are 0->24
+    assert len(resp["tileMatrixSetLimits"]) == 25
+
+
+@attr.s
+class BandFileReader(MultiBandReader):
+    """Test MultiBand"""
+
+    input: str = attr.ib()
+    tms: morecantile.TileMatrixSet = attr.ib(
+        default=morecantile.tms.get("WebMercatorQuad")
+    )
+
+    reader: Type[BaseReader] = attr.ib(default=Reader)
+    reader_options: Dict = attr.ib(factory=dict)
+
+    bands: Sequence[str] = attr.ib(init=False)
+    default_bands: Optional[Sequence[str]] = attr.ib(init=False, default=None)
+
+    minzoom: int = attr.ib(init=False)
+    maxzoom: int = attr.ib(init=False)
+
+    def __attrs_post_init__(self):
+        """Parse Sceneid and get grid bounds."""
+        self.bands = sorted([p.stem for p in pathlib.Path(self.input).glob("B0*.tif")])
+        with self.reader(self._get_band_url(self.bands[0])) as cog:
+            self.bounds = cog.bounds
+            self.crs = cog.crs
+            self.minzoom = cog.minzoom
+            self.maxzoom = cog.maxzoom
+            self.width = cog.width
+            self.height = cog.height
+            self.transform = cog.transform
+
+    def _get_band_url(self, band: str) -> str:
+        """Validate band's name and return band's url."""
+        return os.path.join(self.input, f"{band}.tif")
 
 
 def test_TMSFactory():
@@ -1267,8 +1073,7 @@ def test_TMSFactory():
     response = client.get("/tms/tileMatrixSets/WebMercatorQuad")
     assert response.status_code == 200
     body = response.json()
-    assert body["type"] == "TileMatrixSetType"
-    assert body["identifier"] == "WebMercatorQuad"
+    assert body["id"] == "WebMercatorQuad"
 
     response = client.get("/tms/tileMatrixSets/WebMercatorQua")
     assert response.status_code == 422
@@ -1311,15 +1116,15 @@ def must_be_bob(credentials: security.HTTPBasicCredentials = Depends(http_basic)
         route_dependencies=[
             (
                 [
-                    {"path": "/bounds", "method": "GET"},
-                    {"path": "/tiles/{z}/{x}/{y}", "method": "GET"},
+                    {"path": "/info", "method": "GET"},
+                    {"path": "/tiles/{tileMatrixSetId}/{z}/{x}/{y}", "method": "GET"},
                 ],
                 [Depends(must_be_bob)],
             ),
         ],
         router_prefix="something",
     )
-    assert len(cog.router.routes) == 27
+    assert len(cog.router.routes) == 19
 
     app = FastAPI()
     app.include_router(cog.router, prefix="/something")
@@ -1328,44 +1133,43 @@ def must_be_bob(credentials: security.HTTPBasicCredentials = Depends(http_basic)
     auth_bob = httpx.BasicAuth(username="bob", password="ILoveSponge")
     auth_notbob = httpx.BasicAuth(username="notbob", password="IHateSponge")
 
-    response = client.get(f"/something/tilejson.json?url={DATA_DIR}/cog.tif")
+    response = client.get(
+        f"/something/WebMercatorQuad/tilejson.json?url={DATA_DIR}/cog.tif"
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     assert response.json()["tilejson"]
 
-    response = client.get(
-        f"/something/bounds?url={DATA_DIR}/cog.tif&rescale=0,1000", auth=auth_bob
-    )
+    response = client.get(f"/something/info?url={DATA_DIR}/cog.tif", auth=auth_bob)
     assert response.status_code == 200
 
-    response = client.get(
-        f"/something/bounds?url={DATA_DIR}/cog.tif&rescale=0,1000", auth=auth_notbob
-    )
+    response = client.get(f"/something/info?url={DATA_DIR}/cog.tif", auth=auth_notbob)
     assert response.status_code == 401
     assert response.json()["detail"] == "You're not Bob"
 
     response = client.get(
-        f"/something/tiles/8/87/48?url={DATA_DIR}/cog.tif&rescale=0,1000", auth=auth_bob
+        f"/something/tiles/WebMercatorQuad/8/87/48?url={DATA_DIR}/cog.tif&rescale=0,1000",
+        auth=auth_bob,
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpeg"
 
     response = client.get(
-        f"/something/tiles/8/87/48?url={DATA_DIR}/cog.tif&rescale=0,1000",
+        f"/something/tiles/WebMercatorQuad/8/87/48?url={DATA_DIR}/cog.tif&rescale=0,1000",
         auth=auth_notbob,
     )
     assert response.status_code == 401
     assert response.json()["detail"] == "You're not Bob"
 
     response = client.get(
-        f"/something/tiles/8/87/48.jpeg?url={DATA_DIR}/cog.tif&rescale=0,1000"
+        f"/something/tiles/WebMercatorQuad/8/87/48.jpeg?url={DATA_DIR}/cog.tif&rescale=0,1000"
     )
     assert response.status_code == 200
     assert response.headers["content-type"] == "image/jpeg"
 
     cog = TilerFactory(router_prefix="something")
     cog.add_route_dependencies(
-        scopes=[{"path": "/bounds", "method": "GET"}],
+        scopes=[{"path": "/info", "method": "GET"}],
         dependencies=[Depends(must_be_bob)],
     )
 
@@ -1373,19 +1177,17 @@ def must_be_bob(credentials: security.HTTPBasicCredentials = Depends(http_basic)
     app.include_router(cog.router, prefix="/something")
     client = TestClient(app)
 
-    response = client.get(f"/something/tilejson.json?url={DATA_DIR}/cog.tif")
+    response = client.get(
+        f"/something/WebMercatorQuad/tilejson.json?url={DATA_DIR}/cog.tif"
+    )
     assert response.status_code == 200
     assert response.headers["content-type"] == "application/json"
     assert response.json()["tilejson"]
 
-    response = client.get(
-        f"/something/bounds?url={DATA_DIR}/cog.tif&rescale=0,1000", auth=auth_bob
-    )
+    response = client.get(f"/something/info?url={DATA_DIR}/cog.tif", auth=auth_bob)
     assert response.status_code == 200
 
-    response = client.get(
-        f"/something/bounds?url={DATA_DIR}/cog.tif&rescale=0,1000", auth=auth_notbob
-    )
+    response = client.get(f"/something/info?url={DATA_DIR}/cog.tif", auth=auth_notbob)
     assert response.status_code == 401
     assert response.json()["detail"] == "You're not Bob"
 
@@ -1400,7 +1202,8 @@ def test_TilerFactory_WithGdalEnv():
     app.include_router(router)
     client = TestClient(app)
 
-    response = client.get(f"/info?url={DATA_DIR}/non_cog.tif")
+    with pytest.warns(NoOverviewWarning):
+        response = client.get(f"/info?url={DATA_DIR}/non_cog.tif")
     assert not response.json()["overviews"]
 
     router = TilerFactory(
@@ -1414,7 +1217,6 @@ def test_TilerFactory_WithGdalEnv():
     assert response.json()["overviews"]
 
     class ReaddirType(str, Enum):
-
         false = "false"
         true = "true"
         empty_dir = "empty_dir"
@@ -1427,14 +1229,21 @@ def gdal_env(disable_read: ReaddirType = Query(ReaddirType.false)):
     app.include_router(router)
     client = TestClient(app)
 
-    response = client.get(f"/info?url={DATA_DIR}/non_cog.tif")
-    assert response.json()["overviews"]
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        response = client.get(f"/info?url={DATA_DIR}/non_cog.tif")
+        assert response.json()["overviews"]
 
-    response = client.get(f"/info?url={DATA_DIR}/non_cog.tif&disable_read=false")
-    assert response.json()["overviews"]
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        response = client.get(f"/info?url={DATA_DIR}/non_cog.tif&disable_read=false")
+        assert response.json()["overviews"]
 
-    response = client.get(f"/info?url={DATA_DIR}/non_cog.tif&disable_read=empty_dir")
-    assert not response.json()["overviews"]
+    with pytest.warns(NoOverviewWarning):
+        response = client.get(
+            f"/info?url={DATA_DIR}/non_cog.tif&disable_read=empty_dir"
+        )
+        assert not response.json()["overviews"]
 
 
 def test_algorithm():
@@ -1447,17 +1256,34 @@ def test_algorithm():
 
     response = client.get("/algorithms")
     assert response.status_code == 200
-    assert "hillshade" in response.json()
+    algo_ids = [algo["id"] for algo in response.json()["algorithms"]]
+    assert "hillshade" in algo_ids
+
+    response = client.get("/algorithms", params={"f": "html"})
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
+
+    response = client.get("/algorithms", headers={"Accept": "text/html"})
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
 
     response = client.get("/algorithms/hillshade")
     assert response.status_code == 200
 
+    response = client.get("/algorithms/hillshade", params={"f": "html"})
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
+
+    response = client.get("/algorithms/hillshade", headers={"Accept": "text/html"})
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
+
 
 def test_path_param_in_prefix():
     """Test path params in prefix."""
 
-    @dataclass
-    class EndpointFactory(BaseTilerFactory):
+    @define
+    class EndpointFactory(BaseFactory):
         def register_routes(self):
             """register endpoints."""
 
@@ -1474,7 +1300,7 @@ def route1(param1: int = Path(...), param2: str = Path(...)):
                 return {"value": param2}
 
     app = FastAPI()
-    endpoints = EndpointFactory(reader=Reader, router_prefix="/prefixed/{param1}")
+    endpoints = EndpointFactory(router_prefix="/prefixed/{param1}")
     app.include_router(endpoints.router, prefix="/prefixed/{param1}")
     client = TestClient(app)
 
@@ -1495,9 +1321,11 @@ def test_AutoFormat_Colormap():
     app.include_router(cog.router)
 
     with TestClient(app) as client:
-
-        cmap = urlencode(
-            {
+        response = client.get(
+            "/preview",
+            params={
+                "url": f"{DATA_DIR}/cog.tif",
+                "bidx": 1,
                 "colormap": json.dumps(
                     [
                         # ([min, max], [r, g, b, a])
@@ -1505,14 +1333,11 @@ def test_AutoFormat_Colormap():
                         ([2, 6000], [255, 0, 0, 255]),
                         ([6001, 300000], [0, 255, 0, 255]),
                     ]
-                )
-            }
+                ),
+            },
         )
-
-        response = client.get(f"/preview?url={DATA_DIR}/cog.tif&bidx=1&{cmap}")
         assert response.status_code == 200
         assert response.headers["content-type"] == "image/png"
-
         with MemoryFile(response.content) as mem:
             with mem.open() as dst:
                 img = dst.read()
@@ -1528,11 +1353,34 @@ def test_AutoFormat_Colormap():
 def test_rescale_dependency():
     """Ensure that we can set default rescale values via the rescale_dependency"""
 
-    def custom_rescale_params() -> Optional[RescaleType]:
-        return [(0, 100)]
+    @dataclass
+    class ImageRenderingParams(dependencies.ImageRenderingParams):
+        """Custom ImageParams."""
+
+        def __post_init__(self):
+            if self.rescale:
+                rescale_array = []
+                for r in self.rescale:
+                    parsed = tuple(
+                        map(
+                            float,
+                            r.replace(" ", "")
+                            .replace("[", "")
+                            .replace("]", "")
+                            .split(","),
+                        )
+                    )
+                    assert (
+                        len(parsed) == 2
+                    ), f"Invalid rescale values: {self.rescale}, should be of form ['min,max', 'min,max'] or [[min,max], [min, max]]"
+                    rescale_array.append(parsed)
+
+                self.rescale = rescale_array  # Noqa
+            else:
+                self.rescale = [(0, 100)]
 
     cog = TilerFactory()
-    cog_custom_range = TilerFactory(rescale_dependency=custom_rescale_params)
+    cog_custom_range = TilerFactory(render_dependency=ImageRenderingParams)
 
     app = FastAPI()
     app.include_router(cog.router, prefix="/cog")
@@ -1540,7 +1388,7 @@ def custom_rescale_params() -> Optional[RescaleType]:
 
     with TestClient(app) as client:
         response = client.get(
-            f"/cog/tiles/8/87/48.npy?url={DATA_DIR}/cog.tif&rescale=0,1000"
+            f"/cog/tiles/WebMercatorQuad/8/87/48.npy?url={DATA_DIR}/cog.tif&rescale=0,1000"
         )
         assert response.status_code == 200
         assert response.headers["content-type"] == "application/x-binary"
@@ -1548,7 +1396,7 @@ def custom_rescale_params() -> Optional[RescaleType]:
         assert npy_tile.shape == (2, 256, 256)  # mask + data
 
         response = client.get(
-            f"/cog_custom/tiles/8/87/48.npy?url={DATA_DIR}/cog.tif&rescale=0,1000"
+            f"/cog_custom/tiles/WebMercatorQuad/8/87/48.npy?url={DATA_DIR}/cog.tif&rescale=0,1000"
         )
         assert response.status_code == 200
         assert response.headers["content-type"] == "application/x-binary"
@@ -1557,7 +1405,7 @@ def custom_rescale_params() -> Optional[RescaleType]:
 
 
 def test_dst_crs_option():
-    """test dst-crs parameter."""
+    """test dst_crs parameter."""
     app = FastAPI()
     app.include_router(TilerFactory().router)
 
@@ -1571,14 +1419,14 @@ def test_dst_crs_option():
             32621
         )  # return the image in the original CRS
 
-        response = client.get(f"/preview.tif?url={DATA_DIR}/cog.tif&dst-crs=epsg:4326")
+        response = client.get(f"/preview.tif?url={DATA_DIR}/cog.tif&dst_crs=epsg:4326")
         meta = parse_img(response.content)
         assert meta["crs"] == CRS.from_epsg(4326)
         assert not meta["crs"] == CRS.from_epsg(32621)
 
-        # /crop endpoints
+        # /bbox endpoints
         response = client.get(
-            f"/crop/-56.228,72.715,-54.547,73.188.tif?url={DATA_DIR}/cog.tif"
+            f"/bbox/-56.228,72.715,-54.547,73.188.tif?url={DATA_DIR}/cog.tif"
         )
         meta = parse_img(response.content)
         assert meta["crs"] == CRS.from_epsg(
@@ -1588,20 +1436,402 @@ def test_dst_crs_option():
 
         # Force output in epsg:32621
         response = client.get(
-            f"/crop/-56.228,72.715,-54.547,73.188.tif?url={DATA_DIR}/cog.tif&dst-crs=epsg:32621"
+            f"/bbox/-56.228,72.715,-54.547,73.188.tif?url={DATA_DIR}/cog.tif&dst_crs=epsg:32621"
         )
         meta = parse_img(response.content)
         assert meta["crs"] == CRS.from_epsg(32621)
 
-        # coord-crs + dst-crs
+        # coord_crs + dst_crs
         response = client.get(
-            f"/crop/-6259272.328324187,12015838.020930404,-6072144.264300693,12195445.265479913.tif?url={DATA_DIR}/cog.tif&coord-crs=epsg:3857"
+            f"/bbox/-6259272.328324187,12015838.020930404,-6072144.264300693,12195445.265479913.tif?url={DATA_DIR}/cog.tif&coord_crs=epsg:3857"
         )
         meta = parse_img(response.content)
         assert meta["crs"] == CRS.from_epsg(3857)
 
         response = client.get(
-            f"/crop/-6259272.328324187,12015838.020930404,-6072144.264300693,12195445.265479913.tif?url={DATA_DIR}/cog.tif&coord-crs=epsg:3857&dst-crs=epsg:32621"
+            f"/bbox/-6259272.328324187,12015838.020930404,-6072144.264300693,12195445.265479913.tif?url={DATA_DIR}/cog.tif&coord_crs=epsg:3857&dst_crs=epsg:32621"
         )
         meta = parse_img(response.content)
         assert meta["crs"] == CRS.from_epsg(32621)
+
+
+def test_color_formula_dependency():
+    """Ensure that we can set default color formulae via the color_formula_dependency"""
+
+    @dataclass
+    class ImageRenderingParams(dependencies.ImageRenderingParams):
+        """Custom ImageParams."""
+
+        color_formula: Annotated[
+            Optional[str],
+            Query(
+                title="Color Formula",
+                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
+            ),
+        ] = "sigmoidal R 7 0.4"
+
+    cog = TilerFactory()
+    cog_custom_color_formula = TilerFactory(render_dependency=ImageRenderingParams)
+
+    app = FastAPI()
+    app.include_router(cog.router, prefix="/cog")
+    app.include_router(cog_custom_color_formula.router, prefix="/cog_custom")
+
+    with TestClient(app) as client:
+        response = client.get(
+            f"/cog/tiles/WebMercatorQuad/8/87/48.npy?url={DATA_DIR}/cog.tif&color_formula=sigmoidal R 10 0.1"
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "application/x-binary"
+        npy_tile = numpy.load(BytesIO(response.content))
+        assert npy_tile.shape == (2, 256, 256)  # mask + data
+
+        response = client.get(
+            f"/cog_custom/tiles/WebMercatorQuad/8/87/48.npy?url={DATA_DIR}/cog.tif"
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "application/x-binary"
+        numpy.load(BytesIO(response.content))
+        assert npy_tile.shape == (2, 256, 256)  # mask + data
+
+
+def test_colormap_factory():
+    """Test ColorMapFactory endpoint."""
+    # Register custom colormaps
+    cmaps = default_cmap.register(
+        {
+            "cust": {0: (0, 0, 0, 255), 1: (255, 0, 0, 255), 255: (255, 255, 0, 255)},
+            "negative": {
+                -100: (0, 0, 0, 255),
+                1: (255, 0, 0, 255),
+                255: (255, 255, 0, 255),
+            },
+            "seq": [
+                ((1, 2), (255, 0, 0, 255)),
+                ((2, 3), (255, 240, 255, 255)),
+            ],
+        }
+    )
+
+    cmaps = ColorMapFactory(supported_colormaps=cmaps)
+
+    app = FastAPI()
+    app.include_router(cmaps.router)
+    client = TestClient(app)
+
+    response = client.get("/colorMaps")
+    assert response.status_code == 200
+    cmap_ids = [cm["id"] for cm in response.json()["colormaps"]]
+    assert "cust" in cmap_ids
+    assert "negative" in cmap_ids
+    assert "seq" in cmap_ids
+    assert "viridis" in cmap_ids
+
+    response = client.get("/colorMaps", headers={"Accept": "text/html"})
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
+
+    response = client.get("/colorMaps/viridis")
+    assert response.status_code == 200
+
+    response = client.get("/colorMaps/viridis", headers={"Accept": "text/html"})
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
+
+    response = client.get("/colorMaps/cust")
+    assert response.status_code == 200
+
+    response = client.get("/colorMaps/negative")
+    assert response.status_code == 200
+
+    response = client.get("/colorMaps/seq")
+    assert response.status_code == 200
+
+    response = client.get("/colorMaps/yo")
+    assert response.status_code == 422
+
+    response = client.get("/colorMaps/viridis", params={"f": "png"})
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 256
+    assert meta["height"] == 20
+
+    response = client.get(
+        "/colorMaps/viridis", params={"f": "png", "orientation": "vertical"}
+    )
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 20
+    assert meta["height"] == 256
+
+    response = client.get(
+        "/colorMaps/viridis", params={"f": "png", "width": 1000, "height": 100}
+    )
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 1000
+    assert meta["height"] == 100
+
+    response = client.get("/colorMaps/cust", params={"f": "png"})
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 256
+    assert meta["height"] == 20
+
+    response = client.get(
+        "/colorMaps/cust", params={"f": "png", "orientation": "vertical"}
+    )
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 20
+    assert meta["height"] == 256
+
+    response = client.get("/colorMaps/negative", params={"f": "png"})
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 256
+    assert meta["height"] == 20
+
+    response = client.get(
+        "/colorMaps/negative", params={"f": "png", "orientation": "vertical"}
+    )
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 20
+    assert meta["height"] == 256
+
+    response = client.get("/colorMaps/seq", params={"f": "png"})
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 256
+    assert meta["height"] == 20
+
+    response = client.get(
+        "/colorMaps/seq", params={"f": "png", "orientation": "vertical"}
+    )
+    assert response.status_code == 200
+    meta = parse_img(response.content)
+    assert meta["dtype"] == "uint8"
+    assert meta["count"] == 4
+    assert meta["width"] == 20
+    assert meta["height"] == 256
+
+
+def test_ogc_maps_cog():
+    """Test TilerFactory class."""
+    cog_path = f"{DATA_DIR}/cog.tif"
+
+    cog = TilerFactory(add_ogc_maps=True)
+    assert len(cog.router.routes) == 20
+
+    assert "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/core" in cog.conforms_to
+
+    app = FastAPI()
+    app.include_router(cog.router)
+    with TestClient(app) as client:
+        # Conformance Class “Core”
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+            },
+        )
+        assert response.status_code == 200
+        headers = response.headers
+        assert (
+            headers["Content-Bbox"]
+            == "373185.0,8019284.949381611,639014.9492102272,8286015.0"
+        )
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/32621>"
+        assert headers["content-type"] == "image/png"
+        meta = parse_img(response.content)
+        assert meta["width"] == 1021
+        assert meta["height"] == 1024  # default max size
+
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+            },
+            headers={"Accept": "image/jpeg"},
+        )
+        assert response.status_code == 200
+        headers = response.headers
+        assert "Content-Bbox" in headers
+        assert "Content-Crs" in headers
+        assert headers["content-type"] == "image/jpeg"
+        meta = parse_img(response.content)
+        assert not meta["crs"]
+
+        response = client.get("/map", params={"url": cog_path, "f": "tif"})
+        assert response.status_code == 200
+        headers = response.headers
+        assert "Content-Bbox" in headers
+        assert "Content-Crs" in headers
+        assert headers["content-type"] == "image/tiff; application=geotiff"
+        meta = parse_img(response.content)
+        assert meta["crs"]
+
+        response = client.get("/map", params={"url": cog_path, "f": "tiff"})
+        assert response.status_code == 200
+        headers = response.headers
+        assert "Content-Bbox" in headers
+        assert "Content-Crs" in headers
+        assert headers["content-type"] == "image/tiff; application=geotiff"
+        meta = parse_img(response.content)
+        assert meta["crs"]
+
+        # Conformance Class “Scaling”
+        # /req/scaling/width-definition
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+                "width": 256,
+            },
+        )
+        assert response.status_code == 200
+        meta = parse_img(response.content)
+        assert meta["width"] == 256
+        assert meta["height"] == 257
+
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+                "width": -256,
+            },
+        )
+        assert response.status_code == 422
+
+        # /req/scaling/height-definition
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+                "height": 256,
+            },
+        )
+        assert response.status_code == 200
+        meta = parse_img(response.content)
+        assert meta["height"] == 256
+
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+                "height": -256,
+            },
+        )
+        assert response.status_code == 422
+
+        # Conformance Class “Spatial Subsetting”
+        # /conf/spatial-subsetting/bbox-crs
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+                "bbox": "-56.228,72.715,-54.547,73.188",
+            },
+        )
+        headers = response.headers
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/32621>"
+        bbox = list(map(float, headers["Content-Bbox"].split(",")))
+        assert all(
+            math.isclose(a, b, rel_tol=1e-5)
+            for a, b in zip(
+                bbox,
+                [
+                    524922.2217886819,
+                    8068852.367048624,
+                    581330.6416587981,
+                    8123074.564952523,
+                ],
+            )
+        )
+
+        assert headers["content-type"] == "image/png"
+        meta = parse_img(response.content)
+
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+                "bbox": "-56.228,72.715,-54.547,73.188",
+                "bbox-crs": "http://www.opengis.net/def/crs/OGC/0/CRS84",
+            },
+        )
+        headers = response.headers
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/32621>"
+        bbox = list(map(float, headers["Content-Bbox"].split(",")))
+        assert all(
+            math.isclose(a, b, rel_tol=1e-5)
+            for a, b in zip(
+                bbox,
+                [
+                    524922.2217886819,
+                    8068852.367048624,
+                    581330.6416587981,
+                    8123074.564952523,
+                ],
+            )
+        )
+        assert headers["content-type"] == "image/png"
+
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+                "bbox": "-6259272.328324187,12015838.020930404,-6072144.264300693,12195445.265479913",
+                "bbox-crs": "[EPSG:3857]",
+            },
+        )
+        assert response.status_code == 200
+        headers = response.headers
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/32621>"
+        bbox = list(map(float, headers["Content-Bbox"].split(",")))
+        assert all(
+            math.isclose(a, b, rel_tol=1e-5)
+            for a, b in zip(
+                bbox,
+                [
+                    524922.2217886819,
+                    8068852.367048624,
+                    581330.6416587981,
+                    8123074.564952523,
+                ],
+            )
+        )
+        assert headers["content-type"] == "image/png"
+
+        # Abstract Test for Requirement crs parameter definition
+        response = client.get(
+            "/map",
+            params={
+                "url": cog_path,
+                "bbox": "-6259272.328324187,12015838.020930404,-6072144.264300693,12195445.265479913",
+                "bbox-crs": "[EPSG:3857]",
+                "crs": "[EPSG:4326]",
+            },
+        )
+        assert response.status_code == 200
+        headers = response.headers
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/4326>"
+        assert headers["Content-Bbox"] == "-56.228,72.715,-54.54699999999999,73.188"
+        assert headers["content-type"] == "image/png"
diff --git a/src/titiler/core/tests/test_logger_middleware.py b/src/titiler/core/tests/test_logger_middleware.py
index 9c298f5c5..7987d6f0b 100644
--- a/src/titiler/core/tests/test_logger_middleware.py
+++ b/src/titiler/core/tests/test_logger_middleware.py
@@ -1,12 +1,17 @@
-"""Test titiler.core.middleware.TotalTimeMiddleware."""
+"""Test titiler.core.middleware.LoggerMiddleware."""
 
-from fastapi import FastAPI
+import json
+import logging
+from logging import config
+
+import pytest
+from fastapi import FastAPI, Path
 from starlette.testclient import TestClient
 
 from titiler.core.middleware import LoggerMiddleware
 
 
-def test_timing_middleware_exclude(caplog):
+def test_logger_middleware(caplog):
     """Create App."""
     app = FastAPI()
 
@@ -15,18 +20,103 @@ async def route1():
         """route1."""
         return "Yo"
 
-    app.add_middleware(LoggerMiddleware, querystrings=True, headers=True)
+    @app.get("/route2/{value}")
+    async def route2(value: str = Path()):
+        """route2."""
+        return value
+
+    @app.get("/route3/{value}")
+    async def route3(value: str = Path()):
+        """route3."""
+        raise Exception("something went wrong")
+
+    app.add_middleware(LoggerMiddleware)
+
+    config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "request": {
+                    "format": (
+                        "%(asctime)s - %(levelname)s - %(name)s - %(message)s "
+                        + json.dumps(
+                            {
+                                k: f"%({k})s"
+                                for k in [
+                                    "http.method",
+                                    "http.referer",
+                                    "http.origin",
+                                    "http.route",
+                                    "http.path",
+                                    "titiler.path_params",
+                                    "titiler.query_params",
+                                    "http.request.header.",
+                                ]
+                            }
+                        )
+                    ),
+                },
+            },
+            "handlers": {
+                "console_request": {
+                    "class": "logging.StreamHandler",
+                    "level": "DEBUG",
+                    "formatter": "request",
+                    "stream": "ext://sys.stdout",
+                },
+            },
+            "loggers": {
+                "titiler.requests": {
+                    "level": "INFO",
+                    "handlers": ["console_request"],
+                    "propagate": True,
+                },
+            },
+        }
+    )
 
     with TestClient(app) as client:
-        caplog.clear()
-        client.get("/route1")
-        assert len([rec.message for rec in caplog.records]) == 2
-
-        caplog.clear()
-        client.get("/route1", params={"hey": "yo"})
-        assert len([rec.message for rec in caplog.records]) == 3
-
-        caplog.clear()
-        client.get("/route1", params={"hey": "yo"}, headers={"accept-encoding": "gzip"})
-        h = caplog.records[2].message
-        assert "'accept-encoding': 'gzip'" in h
+        with caplog.at_level(logging.INFO, logger="titiler.requests"):
+            caplog.clear()
+            client.get("/route1")
+            log = caplog.records[0]
+            assert log.name == "titiler.requests"
+            assert log.levelname == "INFO"
+            assert log.message == "Request received: /route1 GET"
+            assert hasattr(log, "titiler.query_params")
+            assert getattr(log, "http.route") == "/route1"
+
+            caplog.clear()
+            client.get("/route1", params={"hey": "yo"})
+            log = caplog.records[0]
+            assert log.message == "Request received: /route1 GET"
+            assert getattr(log, "titiler.query_params") == {"hey": "yo"}
+
+            caplog.clear()
+            client.get(
+                "/route1", params={"hey": "yo"}, headers={"accept-encoding": "gzip"}
+            )
+            log = caplog.records[0]
+            assert log.message == "Request received: /route1 GET"
+            assert getattr(log, "titiler.query_params") == {"hey": "yo"}
+            assert getattr(log, "http.request.header.accept-encoding") == "gzip"
+
+            caplog.clear()
+            client.get("/route2/val")
+            log = caplog.records[0]
+            assert log.name == "titiler.requests"
+            assert log.levelname == "INFO"
+            assert log.message == "Request received: /route2/val GET"
+            assert hasattr(log, "titiler.query_params")
+            assert getattr(log, "http.route") == "/route2/{value}"
+
+            caplog.clear()
+            with pytest.raises(Exception):  # noqa: B017
+                client.get("/route3/val")
+                log = caplog.records[0]
+                assert log.name == "titiler.requests"
+                assert log.levelname == "INFO"
+                assert log.message == "Request received: /route3/val GET"
+                assert hasattr(log, "titiler.query_params")
+                assert log.route == "/route3/{value}"
diff --git a/src/titiler/core/tests/test_models.py b/src/titiler/core/tests/test_models.py
index 10c5511a5..42766ca59 100644
--- a/src/titiler/core/tests/test_models.py
+++ b/src/titiler/core/tests/test_models.py
@@ -9,8 +9,8 @@
 def test_tilejson_model():
     """Make sure TileJSON model validates input and return default."""
     tj = TileJSON(tiles=["https://something.xyz/{x}/{y}/{z}"])
-    assert tj.center == (0.0, 0.0, 0)
-    assert tj.bounds == [-180, -90, 180, 90]
+    assert list(map(round, tj.center)) == [0.0, 0.0, 0]
+    assert tj.bounds == [-180, -85.0511287798066, 180, 85.0511287798066]
     assert tj.minzoom == 0
     assert tj.maxzoom == 30
     assert tj.scheme == "xyz"
@@ -19,8 +19,12 @@ def test_tilejson_model():
         tiles=["https://something.xyz/{x}/{y}/{z}"], center=(10, 10, 4), scheme="tms"
     )
     assert tj.center == (10.0, 10.0, 4)
-    assert tj.bounds == [-180, -90, 180, 90]
+    assert tj.bounds == [-180, -85.0511287798066, 180, 85.0511287798066]
     assert tj.scheme == "tms"
 
     with pytest.raises(ValidationError):
         TileJSON(tiles=["https://something.xyz/{x}/{y}/{z}"], scheme="abc")
+
+    # Check extra fields are allowed
+    tj = TileJSON(tiles=["https://something.xyz/{x}/{y}/{z}"], dtype="uint8")
+    assert tj.dtype == "uint8"
diff --git a/src/titiler/core/tests/test_rendering.py b/src/titiler/core/tests/test_rendering.py
new file mode 100644
index 000000000..d5c56aa5f
--- /dev/null
+++ b/src/titiler/core/tests/test_rendering.py
@@ -0,0 +1,160 @@
+"""test titiler rendering function."""
+
+import warnings
+
+import numpy
+import pytest
+from rasterio.io import MemoryFile
+from rio_tiler.errors import InvalidDatatypeWarning
+from rio_tiler.models import ImageData
+
+from titiler.core.resources.enums import ImageType
+from titiler.core.utils import render_image
+
+
+def test_rendering():
+    """test rendering."""
+    im = ImageData(numpy.zeros((1, 256, 256), dtype="uint8"))
+
+    # Should render as JPEG
+    content, media = render_image(im)
+    assert media == "image/jpeg"
+    with MemoryFile(content) as mem:
+        with mem.open() as dst:
+            assert dst.profile["driver"] == "JPEG"
+            assert dst.count == 1
+            assert dst.width == 256
+            assert dst.height == 256
+            arr = dst.read()
+            assert numpy.unique(arr).tolist() == [0]
+
+    # Should render as PNG
+    content, media = render_image(im, output_format=ImageType.png)
+    assert media == "image/png"
+    with MemoryFile(content) as mem:
+        with mem.open() as dst:
+            assert dst.profile["driver"] == "PNG"
+            assert dst.count == 2
+            arr = dst.read()
+            assert numpy.unique(arr[0]).tolist() == [0]
+
+    with pytest.warns(InvalidDatatypeWarning):
+        _, media = render_image(
+            ImageData(numpy.zeros((1, 256, 256), dtype="uint16")),
+            output_format=ImageType.jpeg,
+        )
+        assert media == "image/jpeg"
+
+    with pytest.warns(InvalidDatatypeWarning):
+        _, media = render_image(
+            ImageData(numpy.zeros((1, 256, 256), dtype="float32")),
+            output_format=ImageType.png,
+        )
+        assert media == "image/png"
+
+    with pytest.warns(InvalidDatatypeWarning):
+        _, media = render_image(
+            ImageData(numpy.zeros((1, 256, 256), dtype="float32")),
+            output_format=ImageType.jp2,
+        )
+        assert media == "image/jp2"
+
+    # Make sure that we do not rescale uint16 data when there is a colormap
+    # Because the colormap will result in data between 0 and 255 it should be of type uint8
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        cm = {1: (0, 0, 0, 255), 1000: (255, 255, 255, 255)}
+        d = numpy.zeros((1, 256, 256), dtype="float32") + 1
+        d[0, 0:10, 0:10] = 1000
+        content, media = render_image(
+            ImageData(d),
+            output_format=ImageType.jpeg,
+            colormap=cm,
+        )
+        assert media == "image/jpeg"
+
+    with MemoryFile(content) as mem:
+        with mem.open() as dst:
+            assert dst.count == 3
+            assert dst.dtypes == ("uint8", "uint8", "uint8")
+            assert dst.read()[:, 0, 0].tolist() == [255, 255, 255]
+            assert dst.read()[:, 11, 11].tolist() == [0, 0, 0]
+
+    # Partial alpha values
+    cm = {
+        1: (0, 0, 0, 0),
+        500: (100, 100, 100, 50),
+        1000: (255, 255, 255, 255),
+    }
+    data = numpy.ma.zeros((1, 256, 256), dtype="float32") + 1
+    data.mask = False
+
+    data[0, 0, 0] = 0
+    data.mask[0, 0, 0] = True
+    data[0, 1:, 1:] = 1
+    data[0, 2:, 2:] = 500
+    data[0, 3:, 3:] = 1000
+
+    content, media = render_image(
+        ImageData(data),
+        output_format=ImageType.png,
+        colormap=cm,
+    )
+    assert media == "image/png"
+
+    with MemoryFile(content) as mem:
+        with mem.open() as dst:
+            data_converted = dst.read()
+            assert dst.count == 4
+            assert dst.dtypes == ("uint8", "uint8", "uint8", "uint8")
+            # Masked from Original Mask | set to UINT8 (0)
+            assert data_converted[:, 0, 0].tolist() == [0, 0, 0, 0]
+            # masked from CMAP
+            assert data_converted[:, 1, 1].tolist() == [0, 0, 0, 0]
+            # Partially masked from CMAP
+            assert data_converted[:, 2, 2].tolist() == [100, 100, 100, 50]
+            # Non-masked from CMAP
+            assert data_converted[:, 3, 3].tolist() == [255, 255, 255, 255]
+
+
+def test_rendering_auto_dtype():
+    """Test Automatic format selection and dtype"""
+    data = numpy.ma.zeros((1, 5, 5), dtype="uint16") + 1
+    data.mask = False
+    # add a masked value
+    data.mask[0, 0, 0] = True
+    im = ImageData(data)
+    with pytest.warns(InvalidDatatypeWarning):
+        content, media = render_image(im)
+        assert media == "image/png"
+
+        with MemoryFile(content) as mem:
+            with mem.open() as dst:
+                assert dst.count == 2
+                assert dst.dtypes == ("uint8", "uint8")
+
+    # Not Masked
+    data = numpy.ma.zeros((1, 5, 5), dtype="uint16") + 1
+    data.mask = False
+    im = ImageData(data)
+    with pytest.warns(InvalidDatatypeWarning):
+        content, media = render_image(im)
+        assert media == "image/jpeg"
+
+        with MemoryFile(content) as mem:
+            with mem.open() as dst:
+                assert dst.count == 1
+                assert dst.dtypes == ("uint8",)
+
+    # Full Masked
+    data = numpy.ma.zeros((1, 5, 5), dtype="uint16") + 1
+    data.mask = True
+    im = ImageData(data)
+    with pytest.warns(InvalidDatatypeWarning):
+        content, media = render_image(im)
+        assert media == "image/png"
+
+        with MemoryFile(content) as mem:
+            with mem.open() as dst:
+                assert dst.count == 2
+                assert dst.dtypes == ("uint8", "uint8")
diff --git a/src/titiler/core/tests/test_routing.py b/src/titiler/core/tests/test_routing.py
index 32c5789e4..20eb133ec 100644
--- a/src/titiler/core/tests/test_routing.py
+++ b/src/titiler/core/tests/test_routing.py
@@ -1,131 +1,10 @@
-"""Test Custom APIRoute factory."""
-
-from concurrent import futures
+"""Test route dependencies."""
 
 import httpx
-import pytest
-import rasterio
-from fastapi import APIRouter, Depends, FastAPI, HTTPException, security, status
-from rasterio._env import get_gdal_config
+from fastapi import Depends, FastAPI, HTTPException, security, status
 from starlette.testclient import TestClient
 
-from titiler.core.routing import add_route_dependencies, apiroute_factory
-
-
-@pytest.mark.xfail
-def test_withoutCustomRoute(monkeypatch):
-    """Create App."""
-    monkeypatch.setenv("GDAL_DISABLE_READDIR_ON_OPEN", "something")
-
-    app = FastAPI()
-    router = APIRouter()
-
-    def f(r):
-        return get_gdal_config("GDAL_DISABLE_READDIR_ON_OPEN")
-
-    @router.get("/simple")
-    def home():
-        """Works and should return FALSE."""
-        with rasterio.Env(GDAL_DISABLE_READDIR_ON_OPEN="FALSE"):
-            res = get_gdal_config("GDAL_DISABLE_READDIR_ON_OPEN")
-        return {"env": res}
-
-    @router.get("/asimple")
-    async def home1():
-        """Works and should return FALSE."""
-        with rasterio.Env(GDAL_DISABLE_READDIR_ON_OPEN="FALSE"):
-            res = get_gdal_config("GDAL_DISABLE_READDIR_ON_OPEN")
-        return {"env": res}
-
-    @router.get("/future")
-    def home2():
-        """Doesn't work and should return the value from env."""
-        with rasterio.Env(GDAL_DISABLE_READDIR_ON_OPEN="FALSE"):
-            with futures.ThreadPoolExecutor() as executor:
-                res = list(executor.map(f, range(1)))[0]
-        return {"env": res}
-
-    @router.get("/afuture")
-    async def home3():
-        """Works and should return FALSE."""
-        with rasterio.Env(GDAL_DISABLE_READDIR_ON_OPEN="FALSE"):
-            with futures.ThreadPoolExecutor() as executor:
-                res = list(executor.map(f, range(1)))[0]
-        return {"env": res}
-
-    app.include_router(router)
-    client = TestClient(app)
-
-    response = client.get("/simple")
-    assert response.json()["env"] == "FALSE"
-
-    response = client.get("/asimple")
-    assert response.json()["env"] == "FALSE"
-
-    # confirm the multi threads case doesn't work
-    response = client.get("/future")
-    assert not response.json()["env"] == "FALSE"
-
-    response = client.get("/afuture")
-    assert response.json()["env"] == "FALSE"
-
-
-@pytest.mark.xfail
-def test_withCustomRoute(monkeypatch):
-    """Create App."""
-    monkeypatch.setenv("GDAL_DISABLE_READDIR_ON_OPEN", "something")
-
-    app = FastAPI()
-
-    env = {"GDAL_DISABLE_READDIR_ON_OPEN": "FALSE"}
-    with pytest.warns(DeprecationWarning):
-        route_class = apiroute_factory(env)
-    router = APIRouter(route_class=route_class)
-
-    def f(r):
-        return get_gdal_config("GDAL_DISABLE_READDIR_ON_OPEN")
-
-    @router.get("/simple")
-    def home():
-        """Works and should return FALSE."""
-        res = get_gdal_config("GDAL_DISABLE_READDIR_ON_OPEN")
-        return {"env": res}
-
-    @router.get("/asimple")
-    async def home1():
-        """Works and should return FALSE."""
-        res = get_gdal_config("GDAL_DISABLE_READDIR_ON_OPEN")
-        return {"env": res}
-
-    @router.get("/future")
-    def home2():
-        """Doesn't work and should return the value from env."""
-        with futures.ThreadPoolExecutor() as executor:
-            res = list(executor.map(f, range(1)))[0]
-        return {"env": res}
-
-    @router.get("/afuture")
-    async def home3():
-        """Works and should return FALSE."""
-        with futures.ThreadPoolExecutor() as executor:
-            res = list(executor.map(f, range(1)))[0]
-        return {"env": res}
-
-    app.include_router(router)
-    client = TestClient(app)
-
-    response = client.get("/simple")
-    assert response.json()["env"] == "FALSE"
-
-    response = client.get("/asimple")
-    assert response.json()["env"] == "FALSE"
-
-    # confirm the Custom APIRoute class fix
-    response = client.get("/future")
-    assert response.json()["env"] == "FALSE"
-
-    response = client.get("/afuture")
-    assert response.json()["env"] == "FALSE"
+from titiler.core.routing import add_route_dependencies
 
 
 def test_register_deps():
diff --git a/src/titiler/core/tests/test_telemetry.py b/src/titiler/core/tests/test_telemetry.py
new file mode 100644
index 000000000..8b3574a59
--- /dev/null
+++ b/src/titiler/core/tests/test_telemetry.py
@@ -0,0 +1,96 @@
+"""telemetry tests"""
+
+import os
+
+import pytest
+from fastapi import FastAPI
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+from opentelemetry.trace import StatusCode
+from starlette.testclient import TestClient
+
+from titiler.core import telemetry
+from titiler.core.factory import TilerFactory
+
+TEST_URL = f"file://{os.path.join(os.path.dirname(__file__), 'fixtures', 'cog.tif')}"
+TEST_Z, TEST_X, TEST_Y = 8, 84, 47
+
+
+@pytest.fixture
+def telemetry_disabled(monkeypatch):
+    """Fixture to simulate OTel being disabled by monkeypatching the tracer."""
+    monkeypatch.setattr("titiler.core.telemetry.tracer", None)
+    monkeypatch.setattr("titiler.core.telemetry.factory_trace.decorator_enabled", False)
+
+
+@pytest.fixture
+def memory_exporter():
+    """Fixture to configure an in-memory exporter for capturing spans."""
+    tracer_provider = TracerProvider()
+    exporter = InMemorySpanExporter()
+    processor = SimpleSpanProcessor(exporter)
+    tracer_provider.add_span_processor(processor)
+
+    original_provider = trace.get_tracer_provider()
+    trace.set_tracer_provider(tracer_provider)
+
+    yield exporter
+
+    exporter.shutdown()
+    trace.set_tracer_provider(original_provider)
+
+
+def test_tracing_disabled_noop(telemetry_disabled):
+    """Test that the application works correctly when OTel is not installed."""
+    assert not telemetry.tracer
+    assert not telemetry.factory_trace.decorator_enabled
+
+    app = FastAPI()
+    tiler = TilerFactory(router_prefix="cog")
+    app.include_router(tiler.router, prefix="/cog")
+    client = TestClient(app)
+
+    response = client.get(
+        f"/cog/tiles/WebMercatorQuad/{TEST_Z}/{TEST_X}/{TEST_Y}.png",
+        params={
+            "url": TEST_URL,
+        },
+    )
+    assert response.status_code == 200
+
+
+def test_tracing_enabled_but_not_available_warning(telemetry_disabled):
+    """Test that enabling telemetry without the decorator enabled emits a warning."""
+    assert not telemetry.tracer
+    assert not telemetry.factory_trace.decorator_enabled
+
+    with pytest.warns(match="tracing is not available"):
+        _ = TilerFactory(router_prefix="cog", enable_telemetry=True)
+
+
+def test_tracing_enabled_success_path(memory_exporter):
+    """Test that spans are correctly created on a successful request."""
+    assert telemetry.tracer
+    assert telemetry.factory_trace.decorator_enabled
+
+    app = FastAPI()
+    tiler = TilerFactory(router_prefix="cog", enable_telemetry=True)
+    app.include_router(tiler.router, prefix="/cog")
+    client = TestClient(app)
+
+    response = client.get(
+        f"/cog/tiles/WebMercatorQuad/{TEST_Z}/{TEST_X}/{TEST_Y}.png",
+        params={
+            "url": TEST_URL,
+        },
+    )
+    assert response.status_code == 200
+
+    finished_spans = memory_exporter.get_finished_spans()
+    assert len(finished_spans) == 1
+
+    span = next(filter(lambda x: x.name == "TilerFactory.tile", finished_spans), None)
+    assert span
+    assert span.status.status_code == StatusCode.OK
diff --git a/src/titiler/core/tests/test_utils.py b/src/titiler/core/tests/test_utils.py
new file mode 100644
index 000000000..33108ea31
--- /dev/null
+++ b/src/titiler/core/tests/test_utils.py
@@ -0,0 +1,219 @@
+"""Test utils."""
+
+from typing import Annotated
+
+import pytest
+from fastapi import Query
+
+from titiler.core.dependencies import AssetsExprParams, BidxParams
+from titiler.core.resources.enums import MediaType
+from titiler.core.utils import (
+    accept_media_type,
+    check_query_params,
+    dependencies_to_openapi_params,
+    deserialize_query_params,
+    extract_query_params,
+    get_dependency_query_params,
+)
+
+
+def test_get_dependency_params():
+    """Test dependency filtering from query params."""
+
+    # invalid
+    values, err = get_dependency_query_params(
+        dependency=BidxParams, params={"bidx": ["invalid type"]}
+    )
+    assert values == {}
+    assert err
+    assert err == [
+        {
+            "input": "invalid type",
+            "loc": (
+                "query",
+                "bidx",
+                0,
+            ),
+            "msg": "Input should be a valid integer, unable to parse string as an integer",
+            "type": "int_parsing",
+        },
+    ]
+
+    # not in dep
+    values, err = get_dependency_query_params(
+        dependency=BidxParams, params={"not_in_dep": "no error, no value"}
+    )
+    assert values == {"indexes": None}
+    assert not err
+
+    # valid
+    values, err = get_dependency_query_params(
+        dependency=BidxParams, params={"bidx": [1, 2, 3]}
+    )
+    assert values == {"indexes": [1, 2, 3]}
+    assert not err
+
+    # valid and not in dep
+    values, err = get_dependency_query_params(
+        dependency=BidxParams,
+        params={"bidx": [1, 2, 3], "other param": "to be filtered out"},
+    )
+    assert values == {"indexes": [1, 2, 3]}
+    assert not err
+
+
+def test_deserialize_query_params():
+    """Test deserialize_query_params."""
+    # invalid
+    res, err = deserialize_query_params(
+        dependency=BidxParams, params={"bidx": ["invalid type"]}
+    )
+    assert res == BidxParams(indexes=None)
+    assert err
+
+    # valid
+    res, err = deserialize_query_params(
+        dependency=BidxParams, params={"not_in_dep": "no error, no value", "bidx": [1]}
+    )
+    assert res == BidxParams(indexes=[1])
+    assert not err
+
+
+def test_extract_query_params():
+    """Test extract_query_params."""
+    # invalid
+    qs, err = extract_query_params(
+        dependencies=[BidxParams],
+        params={"bidx": ["invalid type"]},
+    )
+    assert qs == {}
+    assert len(err)
+
+    qs, err = extract_query_params(
+        dependencies=[BidxParams],
+        params={"bidx": [1]},
+    )
+    assert qs == {"indexes": [1]}
+    assert len(err) == 0
+
+    qs, err = extract_query_params(
+        dependencies=[BidxParams],
+        params={"bidx": 1},
+    )
+    assert qs == {"indexes": [1]}
+    assert len(err) == 0
+
+    qs, err = extract_query_params(
+        dependencies=[BidxParams],
+        params={"not_in_dep": "no error, no value", "bidx": [1]},
+    )
+    assert qs == {"indexes": [1]}
+    assert len(err) == 0
+
+
+def test_dependencies_to_openapi_params():
+    """Test dependencies_to_openapi_params.
+
+    This Code was generated with help of Claude 2.0. See plans/openapi-params-from-dependencies.prompt.md.
+    """
+
+    # empty list → no params
+    assert dependencies_to_openapi_params([]) == []
+
+    # single dependency
+    params = dependencies_to_openapi_params([BidxParams])
+    names = [p["name"] for p in params]
+    assert names == ["bidx"]
+    assert all(p["in"] == "query" for p in params)
+    assert params[0]["required"] is False
+
+    # multiple dependencies are merged
+    params = dependencies_to_openapi_params([BidxParams, AssetsExprParams])
+    names = [p["name"] for p in params]
+    assert "bidx" in names
+    assert "assets" in names
+    assert "expression" in names
+
+    # required flag is respected
+    assets_param = next(p for p in params if p["name"] == "assets")
+    assert assets_param["required"] is True
+
+    # duplicate params across dependencies are deduplicated
+    def dep_a(scale: Annotated[float | None, Query()] = None): ...
+    def dep_b(scale: Annotated[float | None, Query()] = None): ...
+
+    params = dependencies_to_openapi_params([dep_a, dep_b])
+    assert len([p for p in params if p["name"] == "scale"]) == 1
+
+
+def test_check_query_params():
+    """Test check_query_params."""
+    # invalid bidx value
+    assert (
+        check_query_params(
+            dependencies=[BidxParams],
+            params={"bidx": ["invalid type"]},
+        )
+        is False
+    )
+
+    # assets is required
+    assert (
+        check_query_params(
+            dependencies=[AssetsExprParams],
+            params={},
+        )
+        is False
+    )
+
+    assert (
+        check_query_params(
+            dependencies=[AssetsExprParams, BidxParams],
+            params={"assets": "yo"},
+        )
+        is True
+    )
+
+
+@pytest.mark.parametrize(
+    "media,accept,expected",
+    [
+        ([MediaType.html], "text/html, application/json;q=0.8", MediaType.html),
+        (
+            [MediaType.html, MediaType.json],
+            "application/json, text/html;q=0.8",
+            MediaType.json,
+        ),
+        ([MediaType.xml], "application/json, text/html;q=0.8", None),
+        ([MediaType.json], "", None),
+        (
+            [MediaType.json, MediaType.html],
+            "application/json;q=1.0, text/html;q=0.8",
+            MediaType.json,
+        ),
+        (
+            [MediaType.json, MediaType.html],
+            "application/json;q=1.0, text/html;q=1.0",
+            MediaType.json,
+        ),
+        (
+            [MediaType.html, MediaType.json],
+            "application/json;q=1.0, text/html;q=1.0",
+            MediaType.html,
+        ),
+        ([MediaType.html, MediaType.json], "*;q=1.0", MediaType.html),
+        (
+            [MediaType.json, MediaType.html],
+            "application/json;q=aaa, text/html",
+            MediaType.html,
+        ),
+        (
+            [MediaType.json, MediaType.html],
+            "application/json;q=0.0, text/html",
+            MediaType.html,
+        ),
+    ],
+)
+def test_accept_media_type(media, accept, expected):
+    """test MetadataOutputType dependency."""
+    assert accept_media_type(accept, media) == expected
diff --git a/src/titiler/core/titiler/core/__init__.py b/src/titiler/core/titiler/core/__init__.py
index f26d8963f..36bb00412 100644
--- a/src/titiler/core/titiler/core/__init__.py
+++ b/src/titiler/core/titiler/core/__init__.py
@@ -1,11 +1,13 @@
 """titiler.core"""
 
-__version__ = "0.11.7"
+__version__ = "2.0.1"  # x-release-please-version
 
 from . import dependencies, errors, factory, routing  # noqa
 from .factory import (  # noqa
-    BaseTilerFactory,
-    MultiBandTilerFactory,
+    AlgorithmFactory,
+    BaseFactory,
+    ColorMapFactory,
     MultiBaseTilerFactory,
     TilerFactory,
+    TMSFactory,
 )
diff --git a/src/titiler/core/titiler/core/algorithm/__init__.py b/src/titiler/core/titiler/core/algorithm/__init__.py
index b77327384..26fd153cf 100644
--- a/src/titiler/core/titiler/core/algorithm/__init__.py
+++ b/src/titiler/core/titiler/core/algorithm/__init__.py
@@ -2,22 +2,43 @@
 
 import json
 from copy import copy
-from typing import Dict, List, Literal, Optional, Type
+from typing import Annotated, Literal
 
 import attr
 from fastapi import HTTPException, Query
-from pydantic import ValidationError
-
-from titiler.core.algorithm.base import AlgorithmMetadata, BaseAlgorithm  # noqa
-from titiler.core.algorithm.dem import Contours, HillShade, TerrainRGB, Terrarium
+from pydantic import BeforeValidator, ValidationError
+
+from titiler.core.algorithm.base import (  # noqa
+    AlgorithmMetadata,
+    AlgorithmtList,
+    BaseAlgorithm,
+)
+from titiler.core.algorithm.dem import Contours, HillShade, Slope, TerrainRGB, Terrarium
+from titiler.core.algorithm.image import ToBitonal, ToGrayScale
 from titiler.core.algorithm.index import NormalizedIndex
+from titiler.core.algorithm.math import _Max, _Mean, _Median, _Min, _Std, _Sum, _Var
+from titiler.core.algorithm.ops import CastToInt, Ceil, Floor
+from titiler.core.validation import validate_json
 
-default_algorithms: Dict[str, Type[BaseAlgorithm]] = {
+default_algorithms: dict[str, type[BaseAlgorithm]] = {
     "hillshade": HillShade,
+    "slope": Slope,
     "contours": Contours,
     "normalizedIndex": NormalizedIndex,
     "terrarium": Terrarium,
     "terrainrgb": TerrainRGB,
+    "cast": CastToInt,
+    "ceil": Ceil,
+    "floor": Floor,
+    "min": _Min,
+    "max": _Max,
+    "median": _Median,
+    "mean": _Mean,
+    "std": _Std,
+    "var": _Var,
+    "sum": _Sum,
+    "grayscale": ToGrayScale,
+    "bitonal": ToBitonal,
 }
 
 
@@ -25,22 +46,22 @@
 class Algorithms:
     """Algorithms."""
 
-    data: Dict[str, Type[BaseAlgorithm]] = attr.ib()
+    data: dict[str, type[BaseAlgorithm]] = attr.ib(factory=dict)
 
-    def get(self, name: str) -> BaseAlgorithm:
+    def get(self, name: str) -> type[BaseAlgorithm]:
         """Fetch a TMS."""
         if name not in self.data:
             raise KeyError(f"Invalid name: {name}")
 
         return self.data[name]
 
-    def list(self) -> List[str]:
+    def list(self) -> list[str]:
         """List registered Algorithm."""
         return list(self.data.keys())
 
     def register(
         self,
-        algorithms: Dict[str, BaseAlgorithm],
+        algorithms: dict[str, BaseAlgorithm],
         overwrite: bool = False,
     ) -> "Algorithms":
         """Register Algorithm(s)."""
@@ -48,18 +69,23 @@ def register(
             if name in self.data and not overwrite:
                 raise Exception(f"{name} is already a registered. Use overwrite=True.")
 
-        return Algorithms({**self.data, **algorithms})
+        return Algorithms({**self.data, **algorithms})  # type: ignore [dict-item]
 
     @property
     def dependency(self):
         """FastAPI PostProcess dependency."""
 
         def post_process(
-            algorithm: Literal[tuple(self.data.keys())] = Query(
-                None, description="Algorithm name"
-            ),
-            algorithm_params: str = Query(None, description="Algorithm parameter"),
-        ) -> Optional[BaseAlgorithm]:
+            algorithm: Annotated[
+                Literal[tuple(self.data.keys())],
+                Query(description="Algorithm name"),
+            ] = None,
+            algorithm_params: Annotated[
+                str | None,
+                BeforeValidator(validate_json),
+                Query(description="Algorithm parameter"),
+            ] = None,
+        ) -> BaseAlgorithm | None:
             """Data Post-Processing options."""
             kwargs = json.loads(algorithm_params) if algorithm_params else {}
             if algorithm:
diff --git a/src/titiler/core/titiler/core/algorithm/base.py b/src/titiler/core/titiler/core/algorithm/base.py
index 5eb6bdf3b..79924a7dc 100644
--- a/src/titiler/core/titiler/core/algorithm/base.py
+++ b/src/titiler/core/titiler/core/algorithm/base.py
@@ -1,11 +1,13 @@
 """Algorithm base class."""
 
 import abc
-from typing import Dict, Optional, Sequence
+from collections.abc import Sequence
 
 from pydantic import BaseModel
 from rio_tiler.models import ImageData
 
+from titiler.core.models.common import Link
+
 
 class BaseAlgorithm(BaseModel, metaclass=abc.ABCMeta):
     """Algorithm baseclass.
@@ -15,26 +17,40 @@ class BaseAlgorithm(BaseModel, metaclass=abc.ABCMeta):
     """
 
     # metadata
-    input_nbands: Optional[int]
-    output_nbands: Optional[int]
-    output_dtype: Optional[str]
-    output_min: Optional[Sequence]
-    output_max: Optional[Sequence]
+    input_nbands: int | None = None
+    output_nbands: int | None = None
+    output_dtype: str | None = None
+    output_min: Sequence | None = None
+    output_max: Sequence | None = None
+
+    model_config = {"extra": "allow"}
 
     @abc.abstractmethod
     def __call__(self, img: ImageData) -> ImageData:
         """Apply algorithm"""
         ...
 
-    class Config:
-        """Config for model."""
-
-        extra = "allow"
-
 
 class AlgorithmMetadata(BaseModel):
     """Algorithm metadata."""
 
-    inputs: Dict
-    outputs: Dict
-    parameters: Dict
+    title: str | None = None
+    description: str | None = None
+
+    inputs: dict
+    outputs: dict
+    parameters: dict
+
+
+class AlgorithmRef(BaseModel):
+    """AlgorithmRef model."""
+
+    id: str
+    title: str | None = None
+    links: list[Link]
+
+
+class AlgorithmtList(BaseModel):
+    """AlgorithmList model."""
+
+    algorithms: list[AlgorithmRef]
diff --git a/src/titiler/core/titiler/core/algorithm/dem.py b/src/titiler/core/titiler/core/algorithm/dem.py
index 858d538d2..ce58c8d6c 100644
--- a/src/titiler/core/titiler/core/algorithm/dem.py
+++ b/src/titiler/core/titiler/core/algorithm/dem.py
@@ -1,6 +1,7 @@
 """titiler.core.algorithm DEM."""
 
 import numpy
+from pydantic import Field
 from rasterio import windows
 from rio_tiler.colormap import apply_cmap, cmap
 from rio_tiler.models import ImageData
@@ -8,14 +9,20 @@
 
 from titiler.core.algorithm.base import BaseAlgorithm
 
+__all__ = ["HillShade", "Slope", "Contours", "Terrarium", "TerrainRGB"]
+
 
 class HillShade(BaseAlgorithm):
     """Hillshade."""
 
+    title: str = "Hillshade"
+    description: str = "Create hillshade from DEM dataset."
+
     # parameters
-    azimuth: int = 90
-    angle_altitude: float = 90
-    buffer: int = 3
+    azimuth: int = Field(45, ge=0, le=360)
+    angle_altitude: float = Field(45.0, ge=-90.0, le=90.0)
+    buffer: int = Field(3, ge=0, le=99)
+    z_exaggeration: float = Field(1.0, ge=1e-6, le=1e6)
 
     # metadata
     input_nbands: int = 1
@@ -24,41 +31,90 @@ class HillShade(BaseAlgorithm):
 
     def __call__(self, img: ImageData) -> ImageData:
         """Create hillshade from DEM dataset."""
-        data = img.data[0]
-        mask = img.mask
-        bounds = img.bounds
-
-        x, y = numpy.gradient(data)
-
+        x, y = numpy.gradient(img.array[0])
+        x *= self.z_exaggeration
+        y *= self.z_exaggeration
         slope = numpy.pi / 2.0 - numpy.arctan(numpy.sqrt(x * x + y * y))
         aspect = numpy.arctan2(-x, y)
-        azimuthrad = self.azimuth * numpy.pi / 180.0
-        altituderad = self.angle_altitude * numpy.pi / 180.0
+        azimuth = 360.0 - self.azimuth
+        azimuthrad = numpy.deg2rad(azimuth)
+        altituderad = numpy.deg2rad(self.angle_altitude)
         shaded = numpy.sin(altituderad) * numpy.sin(slope) + numpy.cos(
             altituderad
         ) * numpy.cos(slope) * numpy.cos(azimuthrad - aspect)
-        hillshade_array = 255 * (shaded + 1) / 2
+        data = 255 * (shaded + 1) / 2
+        data[data < 0] = 0  # set hillshade values to min of 0.
+
+        bounds = img.bounds
+        if self.buffer:
+            data = data[self.buffer : -self.buffer, self.buffer : -self.buffer]
+
+            window = windows.Window(
+                col_off=self.buffer,
+                row_off=self.buffer,
+                width=data.shape[1],
+                height=data.shape[0],
+            )
+            bounds = windows.bounds(window, img.transform)
+
+        return ImageData(
+            data.astype(self.output_dtype),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=bounds,
+            band_descriptions=["hillshade"],
+        )
+
+
+class Slope(BaseAlgorithm):
+    """Slope calculation."""
 
-        data = numpy.expand_dims(hillshade_array, axis=0).astype(dtype=numpy.uint8)
+    title: str = "Slope"
+    description: str = "Calculate degrees of slope from DEM dataset."
 
+    # parameters
+    buffer: int = Field(3, ge=0, le=99, description="Buffer size for edge effects")
+    z_exaggeration: float = Field(1.0, ge=1e-6, le=1e6)
+
+    # metadata
+    input_nbands: int = 1
+    output_nbands: int = 1
+    output_dtype: str = "float32"
+    output_min: list[float] = [0.0]
+    output_max: list[float] = [90.0]
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Calculate degrees slope from DEM dataset."""
+        # Get the pixel size from the transform
+        pixel_size_x = abs(img.transform[0])
+        pixel_size_y = abs(img.transform[4])
+
+        x, y = numpy.gradient(img.array[0])
+        x *= self.z_exaggeration
+        y *= self.z_exaggeration
+        dx = x / pixel_size_x
+        dy = y / pixel_size_y
+
+        slope = numpy.rad2deg(numpy.arctan(numpy.sqrt(dx * dx + dy * dy)))
+
+        bounds = img.bounds
         if self.buffer:
-            data = data[:, self.buffer : -self.buffer, self.buffer : -self.buffer]
-            mask = mask[self.buffer : -self.buffer, self.buffer : -self.buffer]
-            # image bounds without buffer
+            slope = slope[self.buffer : -self.buffer, self.buffer : -self.buffer]
+
             window = windows.Window(
                 col_off=self.buffer,
                 row_off=self.buffer,
-                width=mask.shape[1],
-                height=mask.shape[0],
+                width=slope.shape[1],
+                height=slope.shape[0],
             )
             bounds = windows.bounds(window, img.transform)
 
         return ImageData(
-            data,
-            mask,
+            slope.astype(self.output_dtype),
             assets=img.assets,
             crs=img.crs,
             bounds=bounds,
+            band_descriptions=["slope"],
         )
 
 
@@ -68,11 +124,14 @@ class Contours(BaseAlgorithm):
     Original idea from https://custom-scripts.sentinel-hub.com/dem/contour-lines/
     """
 
+    title: str = "Contours"
+    description: str = "Create contours from DEM dataset."
+
     # parameters
-    increment: int = 35
-    thickness: int = 1
-    minz: int = -12000
-    maxz: int = 8000
+    increment: int = Field(35, ge=0, le=999)
+    thickness: int = Field(1, ge=0, le=10)
+    minz: int = Field(-12000, ge=-99999, le=99999)
+    maxz: int = Field(8000, ge=-99999, le=99999)
 
     # metadata
     input_nbands: int = 1
@@ -81,27 +140,36 @@ class Contours(BaseAlgorithm):
 
     def __call__(self, img: ImageData) -> ImageData:
         """Add contours."""
-        data = img.data
+        data = img.data.astype("float64")
 
         # Apply rescaling for minz,maxz to 1->255 and apply Terrain colormap
-        arr = linear_rescale(data, (self.minz, self.maxz), (1, 255)).astype("uint8")
+        arr = linear_rescale(data, (self.minz, self.maxz), (1, 255)).astype(
+            self.output_dtype
+        )
         arr, _ = apply_cmap(arr, cmap.get("terrain"))
 
         # set black (0) for contour lines
         arr = numpy.where(data % self.increment < self.thickness, 0, arr)
 
+        data = numpy.ma.MaskedArray(arr)
+        data.mask = img.array.mask
+
         return ImageData(
-            arr,
-            img.mask,
+            data,
             assets=img.assets,
             crs=img.crs,
             bounds=img.bounds,
+            band_descriptions=["contours_r", "contours_g", "contours_b"],
         )
 
 
 class Terrarium(BaseAlgorithm):
     """Encode DEM into RGB (Mapzen Terrarium)."""
 
+    title: str = "Terrarium"
+    description: str = "Encode DEM into RGB (Mapzen Terrarium)."
+    nodata_height: float | None = Field(None, ge=-99999.0, le=99999.0)
+
     # metadata
     input_nbands: int = 1
     output_nbands: int = 3
@@ -109,27 +177,34 @@ class Terrarium(BaseAlgorithm):
 
     def __call__(self, img: ImageData) -> ImageData:
         """Encode DEM into RGB."""
-        data = numpy.clip(img.data[0] + 32768.0, 0.0, 65535.0)
+        data = numpy.clip(img.array[0] + 32768.0, 0.0, 65535.0)
+        if self.nodata_height is not None:
+            data[img.array.mask[0]] = numpy.clip(  # type: ignore [index]
+                self.nodata_height + 32768.0, 0.0, 65535.0
+            )
         r = data / 256
         g = data % 256
         b = (data * 256) % 256
-        arr = numpy.stack([r, g, b]).astype(numpy.uint8)
 
         return ImageData(
-            arr,
-            img.mask,
+            numpy.ma.stack([r, g, b]).astype(self.output_dtype),
             assets=img.assets,
             crs=img.crs,
             bounds=img.bounds,
+            band_descriptions=["terranium_r", "terranium_g", "terranium_b"],
         )
 
 
 class TerrainRGB(BaseAlgorithm):
     """Encode DEM into RGB (Mapbox Terrain RGB)."""
 
+    title: str = "TerrainRGB"
+    description: str = "Encode DEM into RGB (Mapbox Terrain RGB)."
+
     # parameters
-    interval: float = 0.1
-    baseval: float = -10000.0
+    interval: float = Field(0.1, ge=0.0, le=1.0)
+    baseval: float = Field(-10000.0, ge=-99999.0, le=99999.0)
+    nodata_height: float | None = Field(None, ge=-99999.0, le=99999.0)
 
     # metadata
     input_nbands: int = 1
@@ -153,28 +228,30 @@ def _range_check(datarange):
 
         round_digits = 0
 
-        data = img.data[0].astype(numpy.float64)
+        data = img.array[0].astype(numpy.float64)
         data -= self.baseval
         data /= self.interval
 
         data = numpy.around(data / 2**round_digits) * 2**round_digits
 
-        rows, cols = data.shape
         datarange = data.max() - data.min()
         if _range_check(datarange):
-            raise ValueError("Data of {} larger than 256 ** 3".format(datarange))
+            raise ValueError(f"Data of {datarange} larger than 256 ** 3")
+
+        if self.nodata_height is not None:
+            data[img.array.mask[0]] = (  # type: ignore [index]
+                self.nodata_height - self.baseval
+            ) / self.interval
 
-        rgb = numpy.zeros((3, rows, cols), dtype=numpy.uint8)
-        rgb[2] = ((data / 256) - (data // 256)) * 256
-        rgb[1] = (((data // 256) / 256) - ((data // 256) // 256)) * 256
-        rgb[0] = (
-            (((data // 256) // 256) / 256) - (((data // 256) // 256) // 256)
-        ) * 256
+        data_int32 = data.astype(numpy.int32)
+        b = (data_int32) & 0xFF
+        g = (data_int32 >> 8) & 0xFF
+        r = (data_int32 >> 16) & 0xFF
 
         return ImageData(
-            rgb,
-            img.mask,
+            numpy.ma.stack([r, g, b]).astype(self.output_dtype),
             assets=img.assets,
             crs=img.crs,
             bounds=img.bounds,
+            band_descriptions=["terrain_r", "terrain_g", "terrain_b"],
         )
diff --git a/src/titiler/core/titiler/core/algorithm/image.py b/src/titiler/core/titiler/core/algorithm/image.py
new file mode 100644
index 000000000..a0e061ccf
--- /dev/null
+++ b/src/titiler/core/titiler/core/algorithm/image.py
@@ -0,0 +1,73 @@
+"""titiler.core.algorithm Images"""
+
+import numpy
+from rio_tiler.models import ImageData
+
+from titiler.core.algorithm.base import BaseAlgorithm
+
+
+class ToGrayScale(BaseAlgorithm):
+    """Transform a RGB Image to Grayscale."""
+
+    title: str = "Transform a RGB Image to Grayscale"
+    description: str = "Transform a RGB Image to Grayscale using the ITU-R 601-2 luma."
+
+    # metadata
+    output_nbands: int = 1
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """RGB to L."""
+        if img.count < 3:
+            raise ValueError(
+                f"Cannot apply `grayscale` algorithm on image with {img.count} bands."
+            )
+
+        arr = (
+            img.array[0] * 299 / 1000
+            + img.array[1] * 587 / 1000
+            + img.array[2] * 114 / 1000
+        )
+        return ImageData(
+            arr.astype(img.array.dtype),
+            assets=img.assets,
+            crs=img.crs,
+            band_descriptions=["grayscale"],
+            bounds=img.bounds,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class ToBitonal(BaseAlgorithm):
+    """Transform an Image to Bitonal."""
+
+    title: str = "Transform an Image to Bitonal"
+    description: str = "All values larger than 127 are set to 255 (white), all other values to 0 (black)."
+
+    # metadata
+    output_nbands: int = 1
+    output_dtype: str = "uint8"
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Image to Bitonal"""
+        if img.count == 3:
+            # Convert to Grayscale
+            arr = (
+                img.array[0] * 299 / 1000
+                + img.array[1] * 587 / 1000
+                + img.array[2] * 114 / 1000
+            )
+        elif img.count == 1:
+            arr = img.array
+        else:
+            raise ValueError(
+                f"Cannot apply `bitonal` algorithm on image with {img.count} bands."
+            )
+
+        return ImageData(
+            numpy.ma.where(arr > 127, 255, 0).astype("uint8"),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=["bitonal"],
+            cutline_mask=img.cutline_mask,
+        )
diff --git a/src/titiler/core/titiler/core/algorithm/index.py b/src/titiler/core/titiler/core/algorithm/index.py
index 1e28e0f45..7ab85a425 100644
--- a/src/titiler/core/titiler/core/algorithm/index.py
+++ b/src/titiler/core/titiler/core/algorithm/index.py
@@ -1,16 +1,21 @@
 """titiler.core.algorithm Normalized Index."""
 
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy
 from rio_tiler.models import ImageData
 
 from titiler.core.algorithm.base import BaseAlgorithm
 
+__all__ = ["NormalizedIndex"]
+
 
 class NormalizedIndex(BaseAlgorithm):
     """Normalized Difference Index."""
 
+    title: str = "Normalized Difference Index"
+    description: str = "Compute normalized difference index from two bands."
+
     # metadata
     input_nbands: int = 2
     output_nbands: int = 1
@@ -20,18 +25,16 @@ class NormalizedIndex(BaseAlgorithm):
 
     def __call__(self, img: ImageData) -> ImageData:
         """Normalized difference."""
-        b1 = img.data[0].astype("float32")
-        b2 = img.data[1].astype("float32")
-
-        arr = numpy.where(img.mask, (b2 - b1) / (b2 + b1), 0)
-
-        # ImageData only accept image in form of (count, height, width)
-        arr = numpy.expand_dims(arr, axis=0).astype(self.output_dtype)
-
+        b1 = img.array[0].astype("float32")
+        b2 = img.array[1].astype("float32")
+        arr = numpy.ma.MaskedArray((b2 - b1) / (b2 + b1), dtype=self.output_dtype)
+        bnames = img.band_descriptions
         return ImageData(
             arr,
-            img.mask,
             assets=img.assets,
             crs=img.crs,
             bounds=img.bounds,
+            band_descriptions=[
+                f"({bnames[1]} - {bnames[0]}) / ({bnames[1]} + {bnames[0]})"
+            ],
         )
diff --git a/src/titiler/core/titiler/core/algorithm/math.py b/src/titiler/core/titiler/core/algorithm/math.py
new file mode 100644
index 000000000..3c4b4353c
--- /dev/null
+++ b/src/titiler/core/titiler/core/algorithm/math.py
@@ -0,0 +1,159 @@
+"""titiler.core.algorithm Math."""
+
+import numpy
+from rio_tiler.models import ImageData
+
+from titiler.core.algorithm.base import BaseAlgorithm
+
+__all__ = ["_Min", "_Max", "_Median", "_Mean", "_Std", "_Var", "_Sum"]
+
+
+class _Min(BaseAlgorithm):
+    """Return Min values along the `bands` axis."""
+
+    title: str = "Min"
+    description: str = "Return Min values along the `bands` axis."
+
+    output_nbands: int = 1
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Return Min."""
+        return ImageData(
+            numpy.ma.min(img.array, axis=0, keepdims=True),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=["min"],
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class _Max(BaseAlgorithm):
+    """Return Max values along the `bands` axis."""
+
+    title: str = "Max"
+    description: str = "Return Max values along the `bands` axis."
+
+    output_nbands: int = 1
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Return Max."""
+        return ImageData(
+            numpy.ma.max(img.array, axis=0, keepdims=True),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=["max"],
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class _Median(BaseAlgorithm):
+    """Return Median values along the `bands` axis."""
+
+    title: str = "Median"
+    description: str = "Return Median values along the `bands` axis."
+
+    output_nbands: int = 1
+    output_dtype: str = "float64"
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Return Median."""
+        return ImageData(
+            numpy.ma.median(img.array, axis=0, keepdims=True),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=["median"],
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class _Mean(BaseAlgorithm):
+    """Return Mean values along the `bands` axis."""
+
+    title: str = "Mean"
+    description: str = "Return Mean values."
+
+    output_nbands: int = 1
+    output_dtype: str = "float64"
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Return Mean."""
+        return ImageData(
+            numpy.ma.mean(img.array, axis=0, keepdims=True),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=["mean"],
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class _Std(BaseAlgorithm):
+    """Return the standard deviation along the `bands` axis."""
+
+    title: str = "Standard deviation"
+    description: str = "Return the Standard Deviation along the `bands` axis."
+
+    output_nbands: int = 1
+    output_dtype: str = "float64"
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Return Stddev."""
+        return ImageData(
+            numpy.ma.std(img.array, axis=0, keepdims=True, ddof=1),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=["std"],
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class _Var(BaseAlgorithm):
+    """Return Variance values along the `bands` axis."""
+
+    title: str = "Variance"
+    description: str = "Return Variance along the `bands` axis."
+
+    output_nbands: int = 1
+    output_dtype: str = "float64"
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Return Variance."""
+        return ImageData(
+            numpy.ma.var(img.array, axis=0, keepdims=True, ddof=1),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=["var"],
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class _Sum(BaseAlgorithm):
+    """Return Sum values along the `bands` axis."""
+
+    title: str = "Sum"
+    description: str = "Return Sum values along the `bands` axis."
+
+    output_nbands: int = 1
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Return Min."""
+        return ImageData(
+            numpy.ma.sum(img.array, axis=0, keepdims=True),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=["sum"],
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
diff --git a/src/titiler/core/titiler/core/algorithm/ops.py b/src/titiler/core/titiler/core/algorithm/ops.py
new file mode 100644
index 000000000..a6ace6493
--- /dev/null
+++ b/src/titiler/core/titiler/core/algorithm/ops.py
@@ -0,0 +1,82 @@
+"""titiler.core.algorithm Ops."""
+
+from collections.abc import Sequence
+
+import numpy
+from rio_tiler.models import ImageData
+
+from titiler.core.algorithm.base import BaseAlgorithm
+
+__all__ = ["CastToInt", "Ceil", "Floor"]
+
+
+class CastToInt(BaseAlgorithm):
+    """Cast data to Integer."""
+
+    title: str = "Cast data to Integer"
+    description: str = "Cast data to Integer."
+
+    # metadata
+    output_dtype: str = "uint8"
+    output_min: Sequence[int] = [0]
+    output_max: Sequence[int] = [255]
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Cast Data."""
+        return ImageData(
+            img.array.astype("uint8"),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=img.band_descriptions,
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class Ceil(BaseAlgorithm):
+    """Round data to the smallest integer."""
+
+    title: str = "Round data to the smallest integer"
+    description: str = "Round data to the smallest integer."
+
+    # metadata
+    output_dtype: str = "uint8"
+    output_min: Sequence[int] = [0]
+    output_max: Sequence[int] = [255]
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Cast Data."""
+        return ImageData(
+            numpy.ceil(img.array).astype("uint8"),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=img.band_descriptions,
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
+
+
+class Floor(BaseAlgorithm):
+    """Round data to the largest integer."""
+
+    title: str = "Round data to the largest integer"
+    description: str = "Round data to the largest integer."
+
+    # metadata
+    output_dtype: str = "uint8"
+    output_min: Sequence[int] = [0]
+    output_max: Sequence[int] = [255]
+
+    def __call__(self, img: ImageData) -> ImageData:
+        """Cast Data."""
+        return ImageData(
+            numpy.floor(img.array).astype("uint8"),
+            assets=img.assets,
+            crs=img.crs,
+            bounds=img.bounds,
+            band_descriptions=img.band_descriptions,
+            metadata=img.metadata,
+            cutline_mask=img.cutline_mask,
+        )
diff --git a/src/titiler/core/titiler/core/dependencies.py b/src/titiler/core/titiler/core/dependencies.py
index efc19260c..eec4f2723 100644
--- a/src/titiler/core/titiler/core/dependencies.py
+++ b/src/titiler/core/titiler/core/dependencies.py
@@ -1,55 +1,74 @@
 """Common dependency."""
 
 import json
-from dataclasses import dataclass
-from enum import Enum
-from typing import Dict, List, Optional, Sequence, Tuple, Union
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from typing import Annotated, Any, Literal, cast
 
 import numpy
 from fastapi import HTTPException, Query
+from pydantic import AfterValidator, BeforeValidator, Field
 from rasterio.crs import CRS
-from rasterio.enums import Resampling
-from rio_tiler.colormap import cmap, parse_color
-from rio_tiler.errors import MissingAssets, MissingBands
-from rio_tiler.types import ColorMapType
-
-ColorMapName = Enum(  # type: ignore
-    "ColorMapName", [(a, a) for a in sorted(cmap.list())]
-)
-ResamplingName = Enum(  # type: ignore
-    "ResamplingName", [(r.name, r.name) for r in Resampling]
+from rio_tiler.colormap import ColorMaps
+from rio_tiler.colormap import cmap as default_cmap
+from rio_tiler.colormap import parse_color
+from rio_tiler.types import AssetType, AssetWithOptions, RIOResampling, WarpResampling
+from starlette.requests import Request
+
+from titiler.core.resources.enums import ImageType, MediaType
+from titiler.core.utils import accept_media_type
+from titiler.core.validation import (
+    separated_parseable_floats_regex,
+    validate_bbox,
+    validate_color_formula,
+    validate_crs,
+    validate_rescale,
 )
 
 
-def ColorMapParams(
-    colormap_name: ColorMapName = Query(None, description="Colormap name"),
-    colormap: str = Query(None, description="JSON encoded custom Colormap"),
-) -> Optional[ColorMapType]:
-    """Colormap Dependency."""
-    if colormap_name:
-        return cmap.get(colormap_name.value)
+def create_colormap_dependency(cmap: ColorMaps) -> Callable:
+    """Create Colormap Dependency."""
 
-    if colormap:
-        try:
-            c = json.loads(
-                colormap,
-                object_hook=lambda x: {int(k): parse_color(v) for k, v in x.items()},
-            )
+    def deps(
+        colormap_name: Annotated[  # type: ignore
+            Literal[tuple(cmap.list())],
+            Query(description="Colormap name"),
+        ] = None,
+        colormap: Annotated[
+            str | None, Query(description="JSON encoded custom Colormap")
+        ] = None,
+    ):
+        if colormap_name:
+            return cmap.get(colormap_name)
 
-            # Make sure to match colormap type
-            if isinstance(c, Sequence):
-                c = [(tuple(inter), parse_color(v)) for (inter, v) in c]
+        if colormap:
+            try:
+                c = json.loads(
+                    colormap,
+                    object_hook=lambda x: {
+                        int(k): parse_color(v) for k, v in x.items()
+                    },
+                )
 
-            return c
-        except json.JSONDecodeError as e:
-            raise HTTPException(
-                status_code=400, detail="Could not parse the colormap value."
-            ) from e
+                # Make sure to match colormap type
+                if isinstance(c, Sequence):
+                    c = [(tuple(inter), parse_color(v)) for (inter, v) in c]
 
-    return None
+                return c
+            except json.JSONDecodeError as e:
+                raise HTTPException(
+                    status_code=400, detail="Could not parse the colormap value."
+                ) from e
+
+        return None
+
+    return deps
+
+
+ColorMapParams = create_colormap_dependency(default_cmap)
 
 
-def DatasetPathParams(url: str = Query(..., description="Dataset URL")) -> str:
+def DatasetPathParams(url: Annotated[str, Query(description="Dataset URL")]) -> str:
     """Create dataset path from args"""
     return url
 
@@ -58,13 +77,12 @@ def DatasetPathParams(url: str = Query(..., description="Dataset URL")) -> str:
 class DefaultDependency:
     """Dataclass with dict unpacking"""
 
-    def keys(self):
-        """Return Keys."""
-        return self.__dict__.keys()
+    def as_dict(self, exclude_none: bool = True) -> dict:
+        """Transform dataclass to dict."""
+        if exclude_none:
+            return {k: v for k, v in self.__dict__.items() if v is not None}
 
-    def __getitem__(self, key):
-        """Return value."""
-        return self.__dict__[key]
+        return dict(self.__dict__.items())
 
 
 # Dependencies for simple BaseReader (e.g COGReader)
@@ -72,31 +90,40 @@ def __getitem__(self, key):
 class BidxParams(DefaultDependency):
     """Band Indexes parameters."""
 
-    indexes: Optional[List[int]] = Query(
-        None,
-        title="Band indexes",
-        alias="bidx",
-        description="Dataset band indexes",
-        examples={"one-band": {"value": [1]}, "multi-bands": {"value": [1, 2, 3]}},
-    )
+    indexes: Annotated[
+        list[int] | None,
+        Query(
+            title="Band indexes",
+            alias="bidx",
+            description="Dataset band indexes",
+            openapi_examples={
+                "user-provided": {"value": None},
+                "one-band": {"value": [1]},
+                "multi-bands": {"value": [1, 2, 3]},
+            },
+        ),
+    ] = None
 
 
 @dataclass
 class ExpressionParams(DefaultDependency):
     """Expression parameters."""
 
-    expression: Optional[str] = Query(
-        None,
-        title="Band Math expression",
-        description="rio-tiler's band math expression",
-        examples={
-            "simple": {"description": "Simple band math.", "value": "b1/b2"},
-            "multi-bands": {
-                "description": "Semicolon (;) delimited expressions (band1: b1/b2, band2: b2+b3).",
-                "value": "b1/b2;b2+b3",
+    expression: Annotated[
+        str | None,
+        Query(
+            title="Band Math expression",
+            description="rio-tiler's band math expression",
+            openapi_examples={
+                "user-provided": {"value": None},
+                "simple": {"description": "Simple band math.", "value": "b1/b2"},
+                "multi-bands": {
+                    "description": "Semicolon (;) delimited expressions (band1: b1/b2, band2: b2+b3).",
+                    "value": "b1/b2;b2+b3",
+                },
             },
-        },
-    )
+        ),
+    ] = None
 
 
 @dataclass
@@ -107,213 +134,107 @@ class BidxExprParams(ExpressionParams, BidxParams):
 
 
 # Dependencies for  MultiBaseReader (e.g STACReader)
-@dataclass
-class AssetsParams(DefaultDependency):
-    """Assets parameters."""
+def _parse_asset(values: list[str]) -> list[AssetType]:
+    """Parse assets with optional parameter."""
+    assets: list[AssetType] = []
+    for v in values:
+        if "|" in v:
+            asset_name, params = v.split("|", 1)
+            opts: dict[str, Any] = {"name": asset_name}
+            for option in params.split("|"):
+                key, value = option.split("=", 1)
+                if key == "bidx":
+                    opts["indexes"] = list(map(int, value.split(",")))
+                elif key == "expression":
+                    opts["expression"] = value
+                elif key == "bands":
+                    opts["bands"] = value.split(",")
+
+            asset = cast(AssetWithOptions, opts)
+            assets.append(asset)
+        else:
+            assets.append(v)
 
-    assets: List[str] = Query(
-        None,
-        title="Asset names",
-        description="Asset's names.",
-        examples={
-            "one-asset": {
-                "description": "Return results for asset `data`.",
-                "value": ["data"],
-            },
-            "multi-assets": {
-                "description": "Return results for assets `data` and `cog`.",
-                "value": ["data", "cog"],
-            },
-        },
-    )
+    return assets
 
 
 @dataclass
-class AssetsBidxExprParams(DefaultDependency):
-    """Assets, Expression and Asset's band Indexes parameters."""
-
-    assets: Optional[List[str]] = Query(
-        None,
-        title="Asset names",
-        description="Asset's names.",
-        examples={
-            "one-asset": {
-                "description": "Return results for asset `data`.",
-                "value": ["data"],
-            },
-            "multi-assets": {
-                "description": "Return results for assets `data` and `cog`.",
-                "value": ["data", "cog"],
-            },
-        },
-    )
-    expression: Optional[str] = Query(
-        None,
-        title="Band Math expression",
-        description="Band math expression between assets",
-        examples={
-            "simple": {
-                "description": "Return results of expression between assets.",
-                "value": "asset1_b1 + asset2_b1 / asset3_b1",
-            },
-        },
-    )
+class AssetsParams(DefaultDependency):
+    """Assets parameters."""
 
-    asset_indexes: Optional[Sequence[str]] = Query(
-        None,
-        title="Per asset band indexes",
-        description="Per asset band indexes (coma separated indexes)",
-        alias="asset_bidx",
-        examples={
-            "one-asset": {
-                "description": "Return indexes 1,2,3 of asset `data`.",
-                "value": ["data|1,2,3"],
-            },
-            "multi-assets": {
-                "description": "Return indexes 1,2,3 of asset `data` and indexes 1 of asset `cog`",
-                "value": ["data|1,2,3", "cog|1"],
+    assets: Annotated[
+        list[str],
+        AfterValidator(_parse_asset),
+        Query(
+            title="Asset names",
+            description="Asset's names.",
+            openapi_examples={
+                "user-provided": {"value": None},
+                "one-asset": {
+                    "description": "Return results for asset `data`.",
+                    "value": ["data"],
+                },
+                "multi-assets": {
+                    "description": "Return results for assets `data` and `cog`.",
+                    "value": ["data", "cog"],
+                },
+                "multi-assets-with-options": {
+                    "description": "Return results for assets `data` and `cog`.",
+                    "value": ["data|bidx=1", "cog|bidx=1,2"],
+                },
             },
-        },
-    )
-
-    asset_as_band: Optional[bool] = Query(
-        None,
-        title="Consider asset as a 1 band dataset",
-        description="Asset as Band",
-    )
-
-    def __post_init__(self):
-        """Post Init."""
-        if not self.assets and not self.expression:
-            raise MissingAssets(
-                "assets must be defined either via expression or assets options."
-            )
-
-        if self.asset_indexes:
-            self.asset_indexes: Dict[str, Sequence[int]] = {  # type: ignore
-                idx.split("|")[0]: list(map(int, idx.split("|")[1].split(",")))
-                for idx in self.asset_indexes
-            }
+        ),
+    ]
 
 
 @dataclass
-class AssetsBidxExprParamsOptional(AssetsBidxExprParams):
-    """Assets, Expression and Asset's band Indexes parameters but with no requirement."""
+class AssetsExprParams(ExpressionParams, AssetsParams):
+    """Assets and Expression parameters."""
 
-    def __post_init__(self):
-        """Post Init."""
-        if self.asset_indexes:
-            self.asset_indexes: Dict[str, Sequence[int]] = {  # type: ignore
-                idx.split("|")[0]: list(map(int, idx.split("|")[1].split(",")))
-                for idx in self.asset_indexes
-            }
+    asset_as_band: Annotated[
+        bool | None,
+        Query(
+            title="Consider asset as a 1 band dataset",
+            description="Asset as Band",
+        ),
+    ] = None
 
 
 @dataclass
-class AssetsBidxParams(AssetsParams):
-    """Assets, Asset's band Indexes and Asset's band Expression parameters."""
-
-    asset_indexes: Optional[Sequence[str]] = Query(
-        None,
-        title="Per asset band indexes",
-        description="Per asset band indexes",
-        alias="asset_bidx",
-        examples={
-            "one-asset": {
-                "description": "Return indexes 1,2,3 of asset `data`.",
-                "value": ["data|1;2;3"],
-            },
-            "multi-assets": {
-                "description": "Return indexes 1,2,3 of asset `data` and indexes 1 of asset `cog`",
-                "value": ["data|1;2;3", "cog|1"],
-            },
-        },
-    )
+class PreviewParams(DefaultDependency):
+    """Common Preview parameters."""
 
-    asset_expression: Optional[Sequence[str]] = Query(
-        None,
-        title="Per asset band expression",
-        description="Per asset band expression",
-        examples={
-            "one-asset": {
-                "description": "Return results for expression `b1*b2+b3` of asset `data`.",
-                "value": ["data|b1*b2+b3"],
-            },
-            "multi-assets": {
-                "description": "Return results for expressions `b1*b2+b3` for asset `data` and `b1+b3` for asset `cog`.",
-                "value": ["data|b1*b2+b3", "cog|b1+b3"],
-            },
-        },
+    # NOTE: sizes dependency can either be a Query or a Path Parameter
+    max_size: Annotated[int, Field(description="Maximum image size to read onto.")] = (
+        1024
     )
-
-    def __post_init__(self):
-        """Post Init."""
-        if self.asset_indexes:
-            self.asset_indexes: Dict[str, Sequence[int]] = {  # type: ignore
-                idx.split("|")[0]: list(map(int, idx.split("|")[1].split(",")))
-                for idx in self.asset_indexes
-            }
-
-        if self.asset_expression:
-            self.asset_expression: Dict[str, str] = {  # type: ignore
-                idx.split("|")[0]: idx.split("|")[1] for idx in self.asset_expression
-            }
-
-
-# Dependencies for  MultiBandReader
-@dataclass
-class BandsParams(DefaultDependency):
-    """Band names parameters."""
-
-    bands: List[str] = Query(
-        None,
-        title="Band names",
-        description="Band's names.",
-        examples={
-            "one-band": {
-                "description": "Return results for band `B01`.",
-                "value": ["B01"],
-            },
-            "multi-bands": {
-                "description": "Return results for bands `B01` and `B02`.",
-                "value": ["B01", "B02"],
-            },
-        },
+    height: Annotated[int | None, Field(description="Force output image height.")] = (
+        None
     )
-
-
-@dataclass
-class BandsExprParamsOptional(ExpressionParams, BandsParams):
-    """Optional Band names and Expression parameters."""
-
-    pass
-
-
-@dataclass
-class BandsExprParams(ExpressionParams, BandsParams):
-    """Band names and Expression parameters (Band or Expression required)."""
+    width: Annotated[int | None, Field(description="Force output image width.")] = None
 
     def __post_init__(self):
         """Post Init."""
-        if not self.bands and not self.expression:
-            raise MissingBands(
-                "bands must be defined either via expression or bands options."
-            )
+        if self.width or self.height:
+            self.max_size = None
 
 
 @dataclass
-class ImageParams(DefaultDependency):
-    """Common Preview/Crop parameters."""
-
-    max_size: Optional[int] = Query(
-        1024, description="Maximum image size to read onto."
+class PartFeatureParams(DefaultDependency):
+    """Common parameters for bbox and feature."""
+
+    # NOTE: the part sizes dependency can either be a Query or a Path Parameter
+    max_size: Annotated[
+        int | None, Field(description="Maximum image size to read onto.")
+    ] = None
+    height: Annotated[int | None, Field(description="Force output image height.")] = (
+        None
     )
-    height: Optional[int] = Query(None, description="Force output image height.")
-    width: Optional[int] = Query(None, description="Force output image width.")
+    width: Annotated[int | None, Field(description="Force output image width.")] = None
 
     def __post_init__(self):
         """Post Init."""
-        if self.width and self.height:
+        if self.width or self.height:
             self.max_size = None
 
 
@@ -321,109 +242,174 @@ def __post_init__(self):
 class DatasetParams(DefaultDependency):
     """Low level WarpedVRT Optional parameters."""
 
-    nodata: Optional[Union[str, int, float]] = Query(
-        None, title="Nodata value", description="Overwrite internal Nodata value"
-    )
-    unscale: Optional[bool] = Query(
-        False,
-        title="Apply internal Scale/Offset",
-        description="Apply internal Scale/Offset",
-    )
-    resampling_method: ResamplingName = Query(
-        ResamplingName.nearest,  # type: ignore
-        alias="resampling",
-        description="Resampling method.",
-    )
+    nodata: Annotated[
+        Literal["nan", "inf", "-inf"] | int | float | None,
+        Query(
+            title="Nodata value",
+            description="Overwrite internal Nodata value; nan or valid float values only.",
+        ),
+    ] = None
+    unscale: Annotated[
+        bool | None,
+        Query(
+            title="Apply internal Scale/Offset",
+            description="Apply internal Scale/Offset. Defaults to `False`.",
+        ),
+    ] = None
+    resampling_method: Annotated[
+        RIOResampling | None,
+        Query(
+            alias="resampling",
+            description="RasterIO resampling algorithm. Defaults to `nearest`.",
+        ),
+    ] = None
+    reproject_method: Annotated[
+        WarpResampling | None,
+        Query(
+            alias="reproject",
+            description="WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.",
+        ),
+    ] = None
 
     def __post_init__(self):
         """Post Init."""
         if self.nodata is not None:
             self.nodata = numpy.nan if self.nodata == "nan" else float(self.nodata)
-        self.resampling_method = self.resampling_method.value  # type: ignore
 
+        if self.unscale is not None:
+            self.unscale = bool(self.unscale)
 
-@dataclass
-class ImageRenderingParams(DefaultDependency):
-    """Image Rendering options."""
 
-    add_mask: bool = Query(
-        True, alias="return_mask", description="Add mask to the output data."
-    )
+RescaleType = list[tuple[float, float]]
 
 
-RescaleType = List[Tuple[float, ...]]
+@dataclass
+class RenderingParams(DefaultDependency):
+    """Image Rendering options."""
 
+    rescale: Annotated[
+        list[str] | None,
+        BeforeValidator(validate_rescale),
+        Query(
+            title="Min/Max data Rescaling",
+            description="comma (',') delimited Min,Max range. Can set multiple time for multiple bands.",
+            examples=["0,2000", "0,1000", "0,10000"],  # band 1  # band 2  # band 3
+        ),
+    ] = None
+
+    color_formula: Annotated[
+        str | None,
+        BeforeValidator(validate_color_formula),
+        Query(
+            title="Color Formula",
+            description="rio-color formula (info: https://github.com/mapbox/rio-color)",
+        ),
+    ] = None
+
+    def __post_init__(self) -> None:
+        """Post Init."""
+        if self.rescale:
+            rescale_array = []
+            for r in self.rescale:
+                parsed = tuple(
+                    map(
+                        float,
+                        r.split(","),
+                    )
+                )
+                assert (
+                    len(parsed) == 2
+                ), f"Invalid rescale values: {self.rescale}, should be of form ['min,max', 'min,max'] or [[min,max], [min, max]]"
+                rescale_array.append(parsed)
+
+            self.rescale: RescaleType = rescale_array  # type: ignore
 
-def RescalingParams(
-    rescale: Optional[List[str]] = Query(
-        None,
-        title="Min/Max data Rescaling",
-        description="comma (',') delimited Min,Max range. Can set multiple time for multiple bands.",
-        example=["0,2000", "0,1000", "0,10000"],  # band 1  # band 2  # band 3
-    )
-) -> Optional[RescaleType]:
-    """Min/Max data Rescaling"""
-    if rescale:
-        return [tuple(map(float, r.replace(" ", "").split(","))) for r in rescale]
 
-    return None
+@dataclass
+class ImageRenderingParams(RenderingParams):
+    """Image Rendering options."""
+
+    add_mask: Annotated[
+        bool | None,
+        Query(
+            alias="return_mask",
+            description="Add mask to the output data. Defaults to `True`",
+        ),
+    ] = None
 
 
 @dataclass
 class StatisticsParams(DefaultDependency):
     """Statistics options."""
 
-    categorical: bool = Query(
-        False, description="Return statistics for categorical dataset."
-    )
-    categories: List[Union[float, int]] = Query(
-        None,
-        alias="c",
-        title="Pixels values for categories.",
-        description="List of values for which to report counts.",
-        example=[1, 2, 3],
-    )
-    percentiles: List[int] = Query(
-        [2, 98],
-        alias="p",
-        title="Percentile values",
-        description="List of percentile values.",
-        example=[2, 5, 95, 98],
-    )
+    categorical: Annotated[
+        bool | None,
+        Query(
+            description="Return statistics for categorical dataset. Defaults to `False`"
+        ),
+    ] = None
+    categories: Annotated[
+        list[float | int] | None,
+        Query(
+            alias="c",
+            title="Pixels values for categories.",
+            description="List of values for which to report counts.",
+            examples=[1, 2, 3],
+        ),
+    ] = None
+    percentiles: Annotated[
+        list[int] | None,
+        Query(
+            alias="p",
+            title="Percentile values",
+            description="List of percentile values (default to [2, 98]).",
+            examples=[2, 5, 95, 98],
+        ),
+    ] = None
+
+    def __post_init__(self):
+        """Set percentiles default."""
+        if not self.percentiles:
+            self.percentiles = [2, 98]
 
 
 @dataclass
 class HistogramParams(DefaultDependency):
     """Numpy Histogram options."""
 
-    bins: Optional[str] = Query(
-        None,
-        alias="histogram_bins",
-        title="Histogram bins.",
-        description="""
+    bins: Annotated[
+        str | None,
+        Query(
+            alias="histogram_bins",
+            title="Histogram bins.",
+            description="""
 Defines the number of equal-width bins in the given range (10, by default).
 
 If bins is a sequence (comma `,` delimited values), it defines a monotonically increasing array of bin edges, including the rightmost edge, allowing for non-uniform bin widths.
 
 link: https://numpy.org/doc/stable/reference/generated/numpy.histogram.html
-        """,
-        examples={
-            "simple": {
-                "description": "Defines the number of equal-width bins",
-                "value": 8,
+            """,
+            openapi_examples={
+                "user-provided": {"value": None},
+                "simple": {
+                    "description": "Defines the number of equal-width bins",
+                    "value": 8,
+                },
+                "array": {
+                    "description": "Defines custom bin edges (comma `,` delimited values)",
+                    "value": "0,100,200,300",
+                },
             },
-            "array": {
-                "description": "Defines custom bin edges (comma `,` delimited values)",
-                "value": "0,100,200,300",
-            },
-        },
-    )
-
-    range: Optional[str] = Query(
-        None,
-        alias="histogram_range",
-        title="Histogram range",
-        description="""
+            pattern=r"^\d+(,\d+)*$",
+        ),
+    ] = None
+
+    range: Annotated[
+        str | None,
+        Query(
+            alias="histogram_range",
+            title="Histogram range",
+            description="""
 Comma `,` delimited range of the bins.
 
 The lower and upper range of the bins. If not provided, range is simply (a.min(), a.max()).
@@ -432,9 +418,17 @@ class HistogramParams(DefaultDependency):
 range affects the automatic bin computation as well.
 
 link: https://numpy.org/doc/stable/reference/generated/numpy.histogram.html
-        """,
-        example="0,1000",
-    )
+            """,
+            openapi_examples={
+                "user-provided": {"value": None},
+                "array": {
+                    "description": "Defines custom histogram range (comma `,` delimited values)",
+                    "value": "0,1000",
+                },
+            },
+            pattern=separated_parseable_floats_regex(count=2),
+        ),
+    ] = None
 
     def __post_init__(self):
         """Post Init."""
@@ -448,16 +442,24 @@ def __post_init__(self):
             self.bins = 10
 
         if self.range:
-            self.range = list(map(float, self.range.split(",")))  # type: ignore
+            parsed = list(map(float, self.range.split(",")))
+            assert (
+                len(parsed) == 2
+            ), f"Invalid histogram_range values: {self.range}, should be of form 'min,max'"
+
+            self.range = parsed  # type: ignore
 
 
 def CoordCRSParams(
-    crs: str = Query(
-        None,
-        alias="coord-crs",
-        description="Coordinate Reference System of the input coords. Default to `epsg:4326`.",
-    )
-) -> Optional[CRS]:
+    crs: Annotated[
+        str | None,
+        BeforeValidator(validate_crs),
+        Query(
+            alias="coord_crs",
+            description="Coordinate Reference System of the input coords. Default to `epsg:4326`.",
+        ),
+    ] = None,
+) -> CRS | None:
     """Coordinate Reference System Coordinates Param."""
     if crs:
         return CRS.from_user_input(crs)
@@ -466,14 +468,155 @@ def CoordCRSParams(
 
 
 def DstCRSParams(
-    crs: str = Query(
-        None,
-        alias="dst-crs",
-        description="Output Coordinate Reference System.",
-    )
-) -> Optional[CRS]:
+    crs: Annotated[
+        str | None,
+        BeforeValidator(validate_crs),
+        Query(
+            alias="dst_crs",
+            description="Output Coordinate Reference System.",
+        ),
+    ] = None,
+) -> CRS | None:
     """Coordinate Reference System Coordinates Param."""
     if crs:
         return CRS.from_user_input(crs)
 
     return None
+
+
+def CRSParams(
+    crs: Annotated[
+        str | None,
+        BeforeValidator(validate_crs),
+        Query(
+            description="Coordinate Reference System.",
+        ),
+    ] = None,
+) -> CRS | None:
+    """Coordinate Reference System Coordinates Param."""
+    if crs:
+        return CRS.from_user_input(crs)
+
+    return None
+
+
+def BufferParams(
+    buffer: Annotated[
+        float | None,
+        Query(
+            gt=0,
+            title="Tile buffer.",
+            description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
+        ),
+    ] = None,
+) -> float | None:
+    """Tile buffer Parameter."""
+    return buffer
+
+
+@dataclass
+class TileParams(DefaultDependency):
+    """Tile options."""
+
+    buffer: Annotated[
+        float | None,
+        Query(
+            gt=0,
+            title="Tile buffer.",
+            description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
+        ),
+    ] = None
+
+    padding: Annotated[
+        int | None,
+        Query(
+            gt=0,
+            title="Tile padding.",
+            description="Padding to apply to each tile edge. Helps reduce resampling artefacts along edges. Defaults to `0`.",
+        ),
+    ] = None
+
+
+@dataclass
+class OGCMapsParams(DefaultDependency):
+    """OGC Maps options."""
+
+    request: Request
+
+    bbox: Annotated[
+        str | None,
+        BeforeValidator(validate_bbox),
+        Query(
+            description="Bounding box of the rendered map. The bounding box is provided as four or six coordinates.",
+        ),
+    ] = None
+
+    crs: Annotated[
+        str | None,
+        BeforeValidator(validate_crs),
+        Query(
+            description="Reproject the output to the given crs.",
+        ),
+    ] = None
+
+    bbox_crs: Annotated[
+        str | None,
+        BeforeValidator(validate_crs),
+        Query(
+            description="crs for the specified bbox.",
+            alias="bbox-crs",
+        ),
+    ] = None
+
+    height: Annotated[
+        int | None,
+        Query(
+            description="Height of the map in pixels. If omitted and `width` is specified, defaults to the `height` maintaining a 1:1 aspect ratio. If both `width` and `height` are omitted, the server will select default dimensions.",
+            gt=0,
+        ),
+    ] = None
+
+    width: Annotated[
+        int | None,
+        Query(
+            description="Width of the map in pixels. If omitted and `height` is specified, defaults to the `width` maintaining a 1:1 aspect ratio. If both `width` and `height` are omitted, the server will select default dimensions.",
+            gt=0,
+        ),
+    ] = None
+
+    f: Annotated[
+        ImageType | None,
+        Query(description="The format of the map response (e.g. png)."),
+    ] = None
+
+    max_size: int | None = field(init=False, default=None)
+
+    format: ImageType | None = field(init=False, default=ImageType.png)
+
+    def __post_init__(self):  # noqa: C901
+        """Parse and validate."""
+        if self.crs:
+            self.crs = CRS.from_user_input(self.crs)  # type: ignore
+
+        if self.bbox_crs:
+            self.bbox_crs = CRS.from_user_input(self.bbox_crs)  # type: ignore
+
+        if not self.height and not self.width:
+            self.max_size = 1024
+
+        if self.bbox:
+            bounds = list(map(float, self.bbox.split(",")))
+            if len(bounds) == 6:
+                bounds = [bounds[0], bounds[1], bounds[3], bounds[4]]
+
+            self.bbox = bounds  # type: ignore
+
+        if self.f:
+            self.format = ImageType[self.f]
+
+        else:
+            if media := accept_media_type(
+                self.request.headers.get("accept", ""),
+                [MediaType[e] for e in ImageType],
+            ):
+                self.format = ImageType[media.name]
diff --git a/src/titiler/core/titiler/core/errors.py b/src/titiler/core/titiler/core/errors.py
index 141aadcc7..cd9ee4a71 100644
--- a/src/titiler/core/titiler/core/errors.py
+++ b/src/titiler/core/titiler/core/errors.py
@@ -1,6 +1,6 @@
 """Titiler error classes."""
 
-from typing import Callable, Dict, Type
+from collections.abc import Callable
 
 from fastapi import FastAPI
 from rasterio.errors import RasterioError, RasterioIOError
@@ -8,6 +8,7 @@
     InvalidAssetName,
     InvalidBandName,
     InvalidColorFormat,
+    InvalidExpression,
     MissingAssets,
     MissingBands,
     RioTilerError,
@@ -15,7 +16,7 @@
 )
 from starlette import status
 from starlette.requests import Request
-from starlette.responses import JSONResponse
+from starlette.responses import JSONResponse, Response
 
 
 class TilerError(Exception):
@@ -43,6 +44,7 @@ class BadRequestError(TilerError):
     RasterioError: status.HTTP_500_INTERNAL_SERVER_ERROR,
     RioTilerError: status.HTTP_500_INTERNAL_SERVER_ERROR,
     Exception: status.HTTP_500_INTERNAL_SERVER_ERROR,
+    InvalidExpression: status.HTTP_400_BAD_REQUEST,
 }
 
 
@@ -52,16 +54,19 @@ def exception_handler_factory(status_code: int) -> Callable:
     """
 
     def handler(request: Request, exc: Exception):
+        if status_code == status.HTTP_204_NO_CONTENT:
+            return Response(content=None, status_code=204)
+
         return JSONResponse(content={"detail": str(exc)}, status_code=status_code)
 
     return handler
 
 
 def add_exception_handlers(
-    app: FastAPI, status_codes: Dict[Type[Exception], int]
+    app: FastAPI, status_codes: dict[type[Exception], int]
 ) -> None:
     """
     Add exception handlers to the FastAPI app.
     """
-    for (exc, code) in status_codes.items():
+    for exc, code in status_codes.items():
         app.add_exception_handler(exc, exception_handler_factory(code))
diff --git a/src/titiler/core/titiler/core/factory.py b/src/titiler/core/titiler/core/factory.py
index 52e16a3d6..7ba655889 100644
--- a/src/titiler/core/titiler/core/factory.py
+++ b/src/titiler/core/titiler/core/factory.py
@@ -1,58 +1,70 @@
 """TiTiler Router factories."""
 
 import abc
-from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Type, Union
+import base64
+import logging
+import os
+import warnings
+from collections.abc import Callable, Sequence
+from typing import Annotated, Any, Literal
 from urllib.parse import urlencode
 
 import jinja2
+import numpy
 import rasterio
+from attrs import define, field
 from fastapi import APIRouter, Body, Depends, Path, Query
 from fastapi.dependencies.utils import get_parameterless_sub_dependant
 from fastapi.params import Depends as DependsFunc
 from geojson_pydantic.features import Feature, FeatureCollection
-from geojson_pydantic.geometries import Polygon
 from morecantile import TileMatrixSet
 from morecantile import tms as morecantile_tms
 from morecantile.defaults import TileMatrixSets
-from rasterio.crs import CRS
+from pydantic import Field
+from rio_tiler.colormap import ColorMaps
+from rio_tiler.colormap import cmap as default_cmap
 from rio_tiler.constants import WGS84_CRS
-from rio_tiler.io import BaseReader, MultiBandReader, MultiBaseReader, Reader
-from rio_tiler.models import BandStatistics, Bounds, Info
+from rio_tiler.io import BaseReader, MultiBaseReader, Reader
+from rio_tiler.models import ImageData, Info
 from rio_tiler.types import ColorMapType
-from rio_tiler.utils import get_array_statistics
+from rio_tiler.utils import CRS_to_uri
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, Response
-from starlette.routing import Match, compile_path, replace_params
+from starlette.routing import Match, NoMatchFound
+from starlette.routing import Route as APIRoute
+from starlette.routing import compile_path, replace_params
 from starlette.templating import Jinja2Templates
 
-from titiler.core.algorithm import AlgorithmMetadata, Algorithms, BaseAlgorithm
+from titiler.core.algorithm import (
+    AlgorithmMetadata,
+    Algorithms,
+    AlgorithmtList,
+    BaseAlgorithm,
+)
 from titiler.core.algorithm import algorithms as available_algorithms
 from titiler.core.dependencies import (
-    AssetsBidxExprParams,
-    AssetsBidxExprParamsOptional,
-    AssetsBidxParams,
+    AssetsExprParams,
     AssetsParams,
-    BandsExprParams,
-    BandsExprParamsOptional,
-    BandsParams,
     BidxExprParams,
     ColorMapParams,
     CoordCRSParams,
+    CRSParams,
     DatasetParams,
     DatasetPathParams,
     DefaultDependency,
     DstCRSParams,
     HistogramParams,
-    ImageParams,
     ImageRenderingParams,
-    RescaleType,
-    RescalingParams,
+    OGCMapsParams,
+    PartFeatureParams,
+    PreviewParams,
     StatisticsParams,
+    TileParams,
 )
 from titiler.core.models.mapbox import TileJSON
-from titiler.core.models.OGC import TileMatrixSetList
+from titiler.core.models.OGC import TileMatrixSetList, TileSet, TileSetList
 from titiler.core.models.responses import (
+    ColorMapList,
     InfoGeoJSON,
     MultiBaseInfo,
     MultiBaseInfoGeoJSON,
@@ -62,17 +74,25 @@
     Statistics,
     StatisticsGeoJSON,
 )
-from titiler.core.resources.enums import ImageType, MediaType, OptionalHeader
-from titiler.core.resources.responses import GeoJSONResponse, JSONResponse, XMLResponse
+from titiler.core.resources.enums import ImageType, MediaType
+from titiler.core.resources.responses import GeoJSONResponse, JSONResponse
 from titiler.core.routing import EndpointScope
+from titiler.core.telemetry import factory_trace
+from titiler.core.utils import (
+    accept_media_type,
+    bounds_to_geometry,
+    create_html_response,
+    render_image,
+    tms_limits,
+)
 
-DEFAULT_TEMPLATES = Jinja2Templates(
-    directory="",
+jinja2_env = jinja2.Environment(
+    autoescape=jinja2.select_autoescape(["html"]),
     loader=jinja2.ChoiceLoader([jinja2.PackageLoader(__package__, "templates")]),
-)  # type:ignore
-
+)
+DEFAULT_TEMPLATES = Jinja2Templates(env=jinja2_env)
 
-img_endpoint_params: Dict[str, Any] = {
+img_endpoint_params: dict[str, Any] = {
     "responses": {
         200: {
             "content": {
@@ -90,95 +110,62 @@
     "response_class": Response,
 }
 
+logger = logging.getLogger(__name__)
 
-@dataclass  # type: ignore
+
+@define
 class FactoryExtension(metaclass=abc.ABCMeta):
     """Factory Extension."""
 
     @abc.abstractmethod
-    def register(self, factory: "BaseTilerFactory"):
+    def register(self, factory: "BaseFactory"):
         """Register extension to the factory."""
         ...
 
 
-# ref: https://github.com/python/mypy/issues/5374
-@dataclass  # type: ignore
-class BaseTilerFactory(metaclass=abc.ABCMeta):
-    """BaseTiler Factory.
+@define(kw_only=True)
+class BaseFactory(metaclass=abc.ABCMeta):
+    """Base Factory.
 
     Abstract Base Class which defines most inputs used by dynamic tiler.
 
     Attributes:
-        reader (rio_tiler.io.base.BaseReader): A rio-tiler reader (e.g Reader).
         router (fastapi.APIRouter): Application router to register endpoints to.
-        path_dependency (Callable): Endpoint dependency defining `path` to pass to the reader init.
-        dataset_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining dataset overwriting options (e.g nodata).
-        layer_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining dataset indexes/bands/assets options.
-        render_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining image rendering options (e.g add_mask).
-        colormap_dependency (Callable): Endpoint dependency defining ColorMap options (e.g colormap_name).
-        process_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining image post-processing options (e.g rescaling, color-formula).
-        tms_dependency (Callable): Endpoint dependency defining TileMatrixSet to use.
-        reader_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining BaseReader options.
-        environment_dependency (Callable): Endpoint dependency to define GDAL environment at runtime.
         router_prefix (str): prefix where the router will be mounted in the application.
-        optional_headers(sequence of titiler.core.resources.enums.OptionalHeader): additional headers to return with the response.
+        route_dependencies (list): Additional routes dependencies to add after routes creations.
 
     """
 
-    reader: Type[BaseReader]
-
     # FastAPI router
-    router: APIRouter = field(default_factory=APIRouter)
-
-    # Path Dependency
-    path_dependency: Callable[..., Any] = DatasetPathParams
-
-    # Rasterio Dataset Options (nodata, unscale, resampling)
-    dataset_dependency: Type[DefaultDependency] = DatasetParams
-
-    # Indexes/Expression Dependencies
-    layer_dependency: Type[DefaultDependency] = BidxExprParams
-
-    # Image rendering Dependencies
-    render_dependency: Type[DefaultDependency] = ImageRenderingParams
-    colormap_dependency: Callable[..., Optional[ColorMapType]] = ColorMapParams
-
-    rescale_dependency: Callable[..., Optional[RescaleType]] = RescalingParams
-
-    # Post Processing Dependencies (algorithm)
-    process_dependency: Callable[
-        ..., Optional[BaseAlgorithm]
-    ] = available_algorithms.dependency
-
-    # Reader dependency
-    reader_dependency: Type[DefaultDependency] = DefaultDependency
-
-    # GDAL ENV dependency
-    environment_dependency: Callable[..., Dict] = field(default=lambda: {})
-
-    # TileMatrixSet dependency
-    supported_tms: TileMatrixSets = morecantile_tms
-    default_tms: str = "WebMercatorQuad"
+    router: APIRouter = field(factory=APIRouter)
 
     # Router Prefix is needed to find the path for /tile if the TilerFactory.router is mounted
     # with other router (multiple `.../tile` routes).
     # e.g if you mount the route with `/cog` prefix, set router_prefix to cog and
     router_prefix: str = ""
 
-    # add additional headers in response
-    optional_headers: List[OptionalHeader] = field(default_factory=list)
-
     # add dependencies to specific routes
-    route_dependencies: List[Tuple[List[EndpointScope], List[DependsFunc]]] = field(
-        default_factory=list
+    route_dependencies: list[tuple[list[EndpointScope], list[DependsFunc]]] = field(
+        factory=list
     )
 
-    extensions: List[FactoryExtension] = field(default_factory=list)
+    extensions: list[FactoryExtension] = field(factory=list)
+
+    name: str | None = field(default=None)
+    operation_prefix: str = field(init=False, default="")
+
+    conforms_to: set[str] = field(factory=set)
+
+    enable_telemetry: bool = field(default=False)
 
     templates: Jinja2Templates = DEFAULT_TEMPLATES
 
-    def __post_init__(self):
+    def __attrs_post_init__(self):
         """Post Init: register route and configure specific options."""
+        # prefix for endpoint's operationId
+        name = self.name or self.router_prefix.replace("/", ".")
+        self.operation_prefix = f"{name}." if name else ""
+
         # Register endpoints
         self.register_routes()
 
@@ -190,9 +177,12 @@ def __post_init__(self):
         for scopes, dependencies in self.route_dependencies:
             self.add_route_dependencies(scopes=scopes, dependencies=dependencies)
 
+        if self.enable_telemetry:
+            self.add_telemetry()
+
     @abc.abstractmethod
     def register_routes(self):
-        """Register Tiler Routes."""
+        """Register Routes."""
         ...
 
     def url_for(self, request: Request, name: str, **path_params: Any) -> str:
@@ -206,7 +196,7 @@ def url_for(self, request: Request, name: str, **path_params: Any) -> str:
             if "{" in prefix:
                 _, path_format, param_convertors = compile_path(prefix)
                 prefix, _ = replace_params(
-                    path_format, param_convertors, request.path_params
+                    path_format, param_convertors, request.path_params.copy()
                 )
             base_url += prefix
 
@@ -215,8 +205,8 @@ def url_for(self, request: Request, name: str, **path_params: Any) -> str:
     def add_route_dependencies(
         self,
         *,
-        scopes: List[EndpointScope],
-        dependencies=List[DependsFunc],
+        scopes: list[EndpointScope],
+        dependencies=list[DependsFunc],
     ):
         """Add dependencies to routes.
 
@@ -235,7 +225,8 @@ def add_route_dependencies(
                     route.dependant.dependencies.insert(  # type: ignore
                         0,
                         get_parameterless_sub_dependant(
-                            depends=depends, path=route.path_format  # type: ignore
+                            depends=depends,
+                            path=route.path_format,  # type: ignore
                         ),
                     )
 
@@ -245,36 +236,117 @@ def add_route_dependencies(
                 # https://github.com/tiangolo/fastapi/blob/58ab733f19846b4875c5b79bfb1f4d1cb7f4823f/fastapi/routing.py#L677-L678
                 route.dependencies.extend(dependencies)  # type: ignore
 
+    def add_telemetry(self):
+        """
+        Applies the factory_trace decorator to all registered API routes.
+
+        This method iterates through the router's routes and wraps the endpoint
+        of each APIRoute to ensure consistent OpenTelemetry tracing.
+        """
+        if not factory_trace.decorator_enabled:
+            warnings.warn(
+                "telemetry enabled for the factory class but tracing is not available",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+            return
+
+        for route in self.router.routes:
+            if isinstance(route, APIRoute):
+                route.endpoint = factory_trace(route.endpoint, factory_instance=self)
 
-@dataclass
-class TilerFactory(BaseTilerFactory):
+
+@define(kw_only=True)
+class TilerFactory(BaseFactory):
     """Tiler Factory.
 
     Attributes:
         reader (rio_tiler.io.base.BaseReader): A rio-tiler reader. Defaults to `rio_tiler.io.Reader`.
+        reader_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining BaseReader options.
+        path_dependency (Callable): Endpoint dependency defining `path` to pass to the reader init.
+        layer_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining dataset indexes/bands/assets options.
+        dataset_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining dataset overwriting options (e.g nodata).
+        tile_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining tile options (e.g buffer, padding).
         stats_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining options for rio-tiler's statistics method.
         histogram_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining options for numpy's histogram method.
-        img_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining options for rio-tiler's preview/crop method.
+        img_preview_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining options for rio-tiler's preview method.
+        img_part_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining options for rio-tiler's part/feature methods.
+        process_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining image post-processing options (e.g rescaling, color-formula).
+        rescale_dependency (Callable[..., Optional[RescaleType]]):
+        color_formula_dependency (Callable[..., Optional[str]]):
+        colormap_dependency (Callable): Endpoint dependency defining ColorMap options (e.g colormap_name).
+        render_dependency (titiler.core.dependencies.DefaultDependency): Endpoint dependency defining image rendering options (e.g add_mask).
+        environment_dependency (Callable): Endpoint dependency to define GDAL environment at runtime.
+        supported_tms (morecantile.defaults.TileMatrixSets): TileMatrixSets object holding the supported TileMatrixSets.
+        templates (Jinja2Templates): Jinja2 templates.
         add_preview (bool): add `/preview` endpoints. Defaults to True.
-        add_part (bool): add `/crop` endpoints. Defaults to True.
-        add_viewer (bool): add `/map` endpoints. Defaults to True.
+        add_part (bool): add `/bbox` and `/feature` endpoints. Defaults to True.
+        add_viewer (bool): add `/map.html` endpoints. Defaults to True.
 
     """
 
     # Default reader is set to rio_tiler.io.Reader
-    reader: Type[BaseReader] = Reader
+    reader: type[BaseReader] = Reader
+
+    # Reader dependency
+    reader_dependency: type[DefaultDependency] = DefaultDependency
+
+    # Path Dependency
+    path_dependency: Callable[..., Any] = DatasetPathParams
+
+    # Indexes/Expression Dependencies
+    layer_dependency: type[DefaultDependency] = BidxExprParams
+
+    # Rasterio Dataset Options (nodata, unscale, resampling, reproject)
+    dataset_dependency: type[DefaultDependency] = DatasetParams
+
+    # Tile/Tilejson/WMTS Dependencies
+    tile_dependency: type[DefaultDependency] = TileParams
 
     # Statistics/Histogram Dependencies
-    stats_dependency: Type[DefaultDependency] = StatisticsParams
-    histogram_dependency: Type[DefaultDependency] = HistogramParams
+    stats_dependency: type[DefaultDependency] = StatisticsParams
+    histogram_dependency: type[DefaultDependency] = HistogramParams
 
     # Crop/Preview endpoints Dependencies
-    img_dependency: Type[DefaultDependency] = ImageParams
+    img_preview_dependency: type[DefaultDependency] = PreviewParams
+    img_part_dependency: type[DefaultDependency] = PartFeatureParams
+
+    # Post Processing Dependencies (algorithm)
+    process_dependency: Callable[..., BaseAlgorithm | None] = (
+        available_algorithms.dependency
+    )
+
+    # Image rendering Dependencies
+    colormap_dependency: Callable[..., ColorMapType | None] = ColorMapParams
+    render_dependency: type[DefaultDependency] = ImageRenderingParams
+
+    # GDAL ENV dependency
+    environment_dependency: Callable[..., dict] = field(default=lambda: {})
+
+    # TileMatrixSet dependency
+    supported_tms: TileMatrixSets = morecantile_tms
+
+    render_func: Callable[..., tuple[bytes, str]] = render_image
 
     # Add/Remove some endpoints
     add_preview: bool = True
     add_part: bool = True
     add_viewer: bool = True
+    add_ogc_maps: bool = False
+
+    conforms_to: set[str] = field(
+        factory=lambda: {
+            # https://docs.ogc.org/is/20-057/20-057.html#toc30
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/tileset",
+            # https://docs.ogc.org/is/20-057/20-057.html#toc34
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/tilesets-list",
+            # https://docs.ogc.org/is/20-057/20-057.html#toc65
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/core",
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/png",
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/jpeg",
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/tiff",
+        }
+    )
 
     def register_routes(self):
         """
@@ -286,13 +358,14 @@ def register_routes(self):
 
         """
         # Default Routes
-        # (/bounds, /info, /statistics, /tile, /tilejson.json, /WMTSCapabilities.xml and /point)
-        self.bounds()
+        # (/info, /statistics, /tiles, /tilejson.json, and /point)
         self.info()
         self.statistics()
+        self.tilesets()
         self.tile()
+        if self.add_viewer:
+            self.map_viewer()
         self.tilejson()
-        self.wmts()
         self.point()
 
         # Optional Routes
@@ -302,29 +375,8 @@ def register_routes(self):
         if self.add_part:
             self.part()
 
-        if self.add_viewer:
-            self.map_viewer()
-
-    ############################################################################
-    # /bounds
-    ############################################################################
-    def bounds(self):
-        """Register /bounds endpoint."""
-
-        @self.router.get(
-            "/bounds",
-            response_model=Bounds,
-            responses={200: {"description": "Return dataset's bounds."}},
-        )
-        def bounds(
-            src_path=Depends(self.path_dependency),
-            reader_params=Depends(self.reader_dependency),
-            env=Depends(self.environment_dependency),
-        ):
-            """Return the bounds of the COG."""
-            with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    return {"bounds": src_dst.geographic_bounds}
+        if self.add_ogc_maps:
+            self.ogc_maps()
 
     ############################################################################
     # /info
@@ -338,6 +390,7 @@ def info(self):
             response_model_exclude_none=True,
             response_class=JSONResponse,
             responses={200: {"description": "Return dataset's basic info."}},
+            operation_id=f"{self.operation_prefix}getInfo",
         )
         def info(
             src_path=Depends(self.path_dependency),
@@ -346,7 +399,7 @@ def info(
         ):
             """Return dataset's basic info."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
                     return src_dst.info()
 
         @self.router.get(
@@ -360,18 +413,24 @@ def info(
                     "description": "Return dataset's basic info as a GeoJSON feature.",
                 }
             },
+            operation_id=f"{self.operation_prefix}getInfoGeoJSON",
         )
         def info_geojson(
             src_path=Depends(self.path_dependency),
             reader_params=Depends(self.reader_dependency),
+            crs=Depends(CRSParams),
             env=Depends(self.environment_dependency),
         ):
             """Return dataset's basic info as a GeoJSON feature."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    bounds = src_dst.get_geographic_bounds(crs or WGS84_CRS)
+                    geometry = bounds_to_geometry(bounds)
+
                     return Feature(
                         type="Feature",
-                        geometry=Polygon.from_bounds(*src_dst.geographic_bounds),
+                        bbox=bounds,
+                        geometry=geometry,
                         properties=src_dst.info(),
                     )
 
@@ -392,26 +451,34 @@ def statistics(self):
                     "description": "Return dataset's statistics.",
                 }
             },
+            operation_id=f"{self.operation_prefix}getStatistics",
         )
         def statistics(
             src_path=Depends(self.path_dependency),
+            reader_params=Depends(self.reader_dependency),
             layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
+            image_params=Depends(self.img_preview_dependency),
+            post_process=Depends(self.process_dependency),
             stats_params=Depends(self.stats_dependency),
             histogram_params=Depends(self.histogram_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Get Dataset statistics."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    return src_dst.statistics(
-                        **layer_params,
-                        **image_params,
-                        **dataset_params,
-                        **stats_params,
-                        hist_options={**histogram_params},
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    image = src_dst.preview(
+                        **layer_params.as_dict(),
+                        **image_params.as_dict(),
+                        **dataset_params.as_dict(),
+                    )
+
+                    if post_process:
+                        image = post_process(image)
+
+                    return image.statistics(
+                        **stats_params.as_dict(),
+                        hist_options=histogram_params.as_dict(),
                     )
 
         # POST endpoint
@@ -422,23 +489,27 @@ def statistics(
             response_class=GeoJSONResponse,
             responses={
                 200: {
-                    "content": {"application/json": {}},
-                    "description": "Return dataset's statistics.",
+                    "content": {"application/geo+json": {}},
+                    "description": "Return dataset's statistics from feature or featureCollection.",
                 }
             },
+            operation_id=f"{self.operation_prefix}postStatisticsForGeoJSON",
         )
         def geojson_statistics(
-            geojson: Union[FeatureCollection, Feature] = Body(
-                ..., description="GeoJSON Feature or FeatureCollection."
-            ),
+            geojson: Annotated[
+                FeatureCollection | Feature,
+                Body(description="GeoJSON Feature or FeatureCollection."),
+            ],
             src_path=Depends(self.path_dependency),
-            coord_crs: Optional[CRS] = Depends(CoordCRSParams),
+            reader_params=Depends(self.reader_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            dst_crs=Depends(DstCRSParams),
             layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
+            image_params=Depends(self.img_part_dependency),
+            post_process=Depends(self.process_dependency),
             stats_params=Depends(self.stats_dependency),
             histogram_params=Depends(self.histogram_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Get Statistics from a geojson feature or featureCollection."""
@@ -447,181 +518,458 @@ def geojson_statistics(
                 fc = FeatureCollection(type="FeatureCollection", features=[geojson])
 
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    for feature in fc:
-                        data = src_dst.feature(
-                            feature.dict(exclude_none=True),
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    for feature in fc.features:
+                        shape = feature.model_dump(exclude_none=True)
+                        image = src_dst.feature(
+                            shape,
                             shape_crs=coord_crs or WGS84_CRS,
-                            **layer_params,
-                            **image_params,
-                            **dataset_params,
+                            dst_crs=dst_crs,
+                            align_bounds_with_dataset=True,
+                            **layer_params.as_dict(),
+                            **image_params.as_dict(),
+                            **dataset_params.as_dict(),
                         )
-                        stats = get_array_statistics(
-                            data.as_masked(),
-                            **stats_params,
-                            **histogram_params,
+
+                        # Get the coverage % array
+                        coverage_array = image.get_coverage_array(
+                            shape,
+                            shape_crs=coord_crs or WGS84_CRS,
                         )
 
-                        feature.properties = feature.properties or {}
-                        feature.properties.update(
-                            {
-                                "statistics": {
-                                    f"{data.band_names[ix]}": BandStatistics(
-                                        **stats[ix]
-                                    )
-                                    for ix in range(len(stats))
-                                }
-                            }
+                        if post_process:
+                            image = post_process(image)
+
+                        stats = image.statistics(
+                            **stats_params.as_dict(),
+                            hist_options=histogram_params.as_dict(),
+                            coverage=coverage_array,
                         )
 
+                        feature.properties = feature.properties or {}
+                        feature.properties.update({"statistics": stats})
+
             return fc.features[0] if isinstance(geojson, Feature) else fc
 
+    ############################################################################
+    # /tileset
+    ############################################################################
+    def tilesets(self):  # noqa: C901
+        """Register OGC tilesets endpoints."""
+
+        @self.router.get(
+            "/tiles",
+            response_model=TileSetList,
+            response_class=JSONResponse,
+            response_model_exclude_none=True,
+            responses={
+                200: {
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    }
+                }
+            },
+            summary="Retrieve a list of available raster tilesets for the specified dataset.",
+            operation_id=f"{self.operation_prefix}getTileSetList",
+        )
+        async def tileset_list(
+            request: Request,
+            src_path=Depends(self.path_dependency),
+            reader_params=Depends(self.reader_dependency),
+            crs=Depends(CRSParams),
+            env=Depends(self.environment_dependency),
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
+        ):
+            """Retrieve a list of available raster tilesets for the specified dataset."""
+            with rasterio.Env(**env):
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    bounds = src_dst.get_geographic_bounds(crs or WGS84_CRS)
+
+            collection_bbox = {
+                "lowerLeft": [bounds[0], bounds[1]],
+                "upperRight": [bounds[2], bounds[3]],
+                "crs": CRS_to_uri(crs or WGS84_CRS),
+            }
+
+            qs = [
+                (key, value)
+                for (key, value) in request.query_params._list
+                if key.lower() not in ["crs"]
+            ]
+            query_string = f"?{urlencode(qs)}" if qs else ""
+
+            attribution = os.environ.get("TITILER_DEFAULT_ATTRIBUTION")
+
+            tilesets: list[dict[str, Any]] = []
+            for tms in self.supported_tms.list():
+                tileset: dict[str, Any] = {
+                    "title": f"tileset tiled using {tms} TileMatrixSet",
+                    "attribution": attribution,
+                    "dataType": "map",
+                    "crs": self.supported_tms.get(tms).crs,
+                    "boundingBox": collection_bbox,
+                    "links": [
+                        {
+                            "href": self.url_for(
+                                request, "tileset", tileMatrixSetId=tms
+                            )
+                            + query_string,
+                            "rel": "self",
+                            "type": "application/json",
+                            "title": f"Tileset tiled using {tms} TileMatrixSet",
+                        },
+                        {
+                            "href": self.url_for(
+                                request,
+                                "tile",
+                                tileMatrixSetId=tms,
+                                z="{z}",
+                                x="{x}",
+                                y="{y}",
+                            )
+                            + query_string,
+                            "rel": "tile",
+                            "title": "Templated link for retrieving Raster tiles",
+                        },
+                    ],
+                }
+
+                try:
+                    tileset["links"].append(
+                        {
+                            "href": str(
+                                request.url_for("tilematrixset", tileMatrixSetId=tms)
+                            ),
+                            "rel": "http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme",
+                            "type": "application/json",
+                            "title": f"Definition of '{tms}' tileMatrixSet",
+                        }
+                    )
+                except NoMatchFound:
+                    pass
+
+                tilesets.append(tileset)
+
+            data = TileSetList.model_validate({"tilesets": tilesets})
+
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
+
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    data.model_dump(exclude_none=True, mode="json"),
+                    title="Tilesets",
+                    template_name="tilesets",
+                    templates=self.templates,
+                )
+
+            return data
+
+        @self.router.get(
+            "/tiles/{tileMatrixSetId}",
+            response_model=TileSet,
+            response_class=JSONResponse,
+            response_model_exclude_none=True,
+            responses={
+                200: {
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    }
+                }
+            },
+            summary="Retrieve the raster tileset metadata for the specified dataset and tiling scheme (tile matrix set).",
+            operation_id=f"{self.operation_prefix}getTileSet",
+        )
+        async def tileset(
+            request: Request,
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
+            src_path=Depends(self.path_dependency),
+            reader_params=Depends(self.reader_dependency),
+            env=Depends(self.environment_dependency),
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
+        ):
+            """Retrieve the raster tileset metadata for the specified dataset and tiling scheme (tile matrix set)."""
+            tms = self.supported_tms.get(tileMatrixSetId)
+            with rasterio.Env(**env):
+                with self.reader(
+                    src_path, tms=tms, **reader_params.as_dict()
+                ) as src_dst:
+                    bounds = src_dst.get_geographic_bounds(tms.rasterio_geographic_crs)
+                    minzoom = src_dst.minzoom
+                    maxzoom = src_dst.maxzoom
+
+                    collection_bbox = {
+                        "lowerLeft": [bounds[0], bounds[1]],
+                        "upperRight": [bounds[2], bounds[3]],
+                        "crs": CRS_to_uri(tms.rasterio_geographic_crs),
+                    }
+
+                    tilematrix_limits = tms_limits(
+                        tms,
+                        bounds,
+                        zooms=(minzoom, maxzoom),
+                    )
+
+            query_string = (
+                f"?{urlencode(request.query_params._list)}"
+                if request.query_params._list
+                else ""
+            )
+
+            links = [
+                {
+                    "href": self.url_for(
+                        request,
+                        "tileset",
+                        tileMatrixSetId=tileMatrixSetId,
+                    ),
+                    "rel": "self",
+                    "type": "application/json",
+                    "title": f"Tileset tiled using {tileMatrixSetId} TileMatrixSet",
+                },
+                {
+                    "href": self.url_for(
+                        request,
+                        "tile",
+                        tileMatrixSetId=tileMatrixSetId,
+                        z="{z}",
+                        x="{x}",
+                        y="{y}",
+                    )
+                    + query_string,
+                    "rel": "tile",
+                    "title": "Templated link for retrieving Raster tiles",
+                    "templated": True,
+                },
+            ]
+            try:
+                links.append(
+                    {
+                        "href": str(
+                            request.url_for(
+                                "tilematrixset", tileMatrixSetId=tileMatrixSetId
+                            )
+                        ),
+                        "rel": "http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme",
+                        "type": "application/json",
+                        "title": f"Definition of '{tileMatrixSetId}' tileMatrixSet",
+                    }
+                )
+            except NoMatchFound:
+                pass
+
+            if self.add_viewer:
+                links.append(
+                    {
+                        "href": self.url_for(
+                            request,
+                            "map_viewer",
+                            tileMatrixSetId=tileMatrixSetId,
+                        )
+                        + query_string,
+                        "type": "text/html",
+                        "rel": "data",
+                        "title": f"Map viewer for '{tileMatrixSetId}' tileMatrixSet",
+                    }
+                )
+
+            data = TileSet.model_validate(
+                {
+                    "title": f"tileset tiled using {tileMatrixSetId} TileMatrixSet",
+                    "dataType": "map",
+                    "crs": tms.crs,
+                    "boundingBox": collection_bbox,
+                    "links": links,
+                    "tileMatrixSetLimits": tilematrix_limits,
+                    "attribution": os.environ.get("TITILER_DEFAULT_ATTRIBUTION"),
+                }
+            )
+
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
+
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    data,
+                    title=tileMatrixSetId,
+                    template_name="tileset",
+                    templates=self.templates,
+                )
+
+            return data
+
     ############################################################################
     # /tiles
     ############################################################################
     def tile(self):  # noqa: C901
         """Register /tiles endpoint."""
 
-        @self.router.get(r"/tiles/{z}/{x}/{y}", **img_endpoint_params)
-        @self.router.get(r"/tiles/{z}/{x}/{y}.{format}", **img_endpoint_params)
-        @self.router.get(r"/tiles/{z}/{x}/{y}@{scale}x", **img_endpoint_params)
-        @self.router.get(r"/tiles/{z}/{x}/{y}@{scale}x.{format}", **img_endpoint_params)
-        @self.router.get(r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}", **img_endpoint_params)
-        @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}.{format}", **img_endpoint_params
-        )
         @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}@{scale}x", **img_endpoint_params
+            "/tiles/{tileMatrixSetId}/{z}/{x}/{y}",
+            operation_id=f"{self.operation_prefix}getTile",
+            **img_endpoint_params,
         )
         @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}@{scale}x.{format}",
+            "/tiles/{tileMatrixSetId}/{z}/{x}/{y}.{format}",
+            operation_id=f"{self.operation_prefix}getTileWithFormat",
             **img_endpoint_params,
         )
         def tile(
-            z: int = Path(..., ge=0, le=30, description="TMS tiles's zoom level"),
-            x: int = Path(..., description="TMS tiles's column"),
-            y: int = Path(..., description="TMS tiles's row"),
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
-                self.default_tms,
-                description=f"TileMatrixSet Name (default: '{self.default_tms}')",
-            ),
-            scale: int = Query(
-                1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."
-            ),
-            format: ImageType = Query(
-                None, description="Output image type. Default is auto."
-            ),
+            z: Annotated[
+                int,
+                Path(
+                    description="Identifier (Z) selecting one of the scales defined in the TileMatrixSet and representing the scaleDenominator the tile.",
+                ),
+            ],
+            x: Annotated[
+                int,
+                Path(
+                    description="Column (X) index of the tile on the selected TileMatrix. It cannot exceed the MatrixHeight-1 for the selected TileMatrix.",
+                ),
+            ],
+            y: Annotated[
+                int,
+                Path(
+                    description="Row (Y) index of the tile on the selected TileMatrix. It cannot exceed the MatrixWidth-1 for the selected TileMatrix.",
+                ),
+            ],
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
+            format: Annotated[
+                ImageType | None,
+                Field(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg)."
+                ),
+            ] = None,
+            tilesize: Annotated[
+                int | None,
+                Query(gt=0, description="Tilesize in pixels."),
+            ] = None,
             src_path=Depends(self.path_dependency),
+            reader_params=Depends(self.reader_dependency),
+            tile_params=Depends(self.tile_dependency),
             layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
-            buffer: Optional[float] = Query(
-                None,
-                gt=0,
-                title="Tile buffer.",
-                description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
-            ),
             post_process=Depends(self.process_dependency),
-            rescale=Depends(self.rescale_dependency),
-            color_formula: Optional[str] = Query(
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
             colormap=Depends(self.colormap_dependency),
             render_params=Depends(self.render_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Create map tile from a dataset."""
-            tms = self.supported_tms.get(TileMatrixSetId)
+            tms = self.supported_tms.get(tileMatrixSetId)
             with rasterio.Env(**env):
-                with self.reader(src_path, tms=tms, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(
+                    src_path, tms=tms, **reader_params.as_dict()
+                ) as src_dst:
                     image = src_dst.tile(
                         x,
                         y,
                         z,
-                        tilesize=scale * 256,
-                        buffer=buffer,
-                        **layer_params,
-                        **dataset_params,
+                        tilesize=tilesize,
+                        **tile_params.as_dict(),
+                        **layer_params.as_dict(),
+                        **dataset_params.as_dict(),
                     )
                     dst_colormap = getattr(src_dst, "colormap", None)
 
             if post_process:
                 image = post_process(image)
 
-            if rescale:
-                image.rescale(rescale)
-
-            if color_formula:
-                image.apply_color_formula(color_formula)
-
-            if cmap := colormap or dst_colormap:
-                image = image.apply_colormap(cmap)
-
-            if not format:
-                format = ImageType.jpeg if image.mask.all() else ImageType.png
-
-            content = image.render(
-                img_format=format.driver,
-                **format.profile,
-                **render_params,
+            content, media_type = self.render_func(
+                image,
+                output_format=format,
+                colormap=colormap or dst_colormap,
+                **render_params.as_dict(),
             )
 
-            return Response(content, media_type=format.mediatype)
+            headers: dict[str, str] = {}
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
+
+            return Response(content, media_type=media_type, headers=headers)
 
     def tilejson(self):  # noqa: C901
         """Register /tilejson.json endpoint."""
 
         @self.router.get(
-            "/tilejson.json",
-            response_model=TileJSON,
-            responses={200: {"description": "Return a tilejson"}},
-            response_model_exclude_none=True,
-        )
-        @self.router.get(
-            "/{TileMatrixSetId}/tilejson.json",
+            "/{tileMatrixSetId}/tilejson.json",
             response_model=TileJSON,
             responses={200: {"description": "Return a tilejson"}},
             response_model_exclude_none=True,
+            operation_id=f"{self.operation_prefix}getTileJSON",
         )
         def tilejson(
             request: Request,
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
-                self.default_tms,
-                description=f"TileMatrixSet Name (default: '{self.default_tms}')",
-            ),
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
+            tilesize: Annotated[
+                int | None,
+                Query(gt=0, description="Tilesize in pixels. Default to 512."),
+            ] = 512,
+            tile_format: Annotated[
+                ImageType | None,
+                Query(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg).",
+                ),
+            ] = None,
+            minzoom: Annotated[
+                int | None,
+                Query(description="Overwrite default minzoom."),
+            ] = None,
+            maxzoom: Annotated[
+                int | None,
+                Query(description="Overwrite default maxzoom."),
+            ] = None,
             src_path=Depends(self.path_dependency),
-            tile_format: Optional[ImageType] = Query(
-                None, description="Output image type. Default is auto."
-            ),
-            tile_scale: int = Query(
-                1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."
-            ),
-            minzoom: Optional[int] = Query(
-                None, description="Overwrite default minzoom."
-            ),
-            maxzoom: Optional[int] = Query(
-                None, description="Overwrite default maxzoom."
-            ),
-            layer_params=Depends(self.layer_dependency),  # noqa
-            dataset_params=Depends(self.dataset_dependency),  # noqa
-            buffer: Optional[float] = Query(  # noqa
-                None,
-                gt=0,
-                title="Tile buffer.",
-                description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
-            ),
-            post_process=Depends(self.process_dependency),  # noqa
-            rescale=Depends(self.rescale_dependency),  # noqa
-            color_formula: Optional[str] = Query(  # noqa
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
-            colormap=Depends(self.colormap_dependency),  # noqa
-            render_params=Depends(self.render_dependency),  # noqa
             reader_params=Depends(self.reader_dependency),
+            tile_params=Depends(self.tile_dependency),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            post_process=Depends(self.process_dependency),
+            colormap=Depends(self.colormap_dependency),
+            render_params=Depends(self.render_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Return TileJSON document for a dataset."""
@@ -629,8 +977,7 @@ def tilejson(
                 "z": "{z}",
                 "x": "{x}",
                 "y": "{y}",
-                "scale": tile_scale,
-                "TileMatrixSetId": TileMatrixSetId,
+                "tileMatrixSetId": tileMatrixSetId,
             }
             if tile_format:
                 route_params["format"] = tile_format.value
@@ -639,240 +986,160 @@ def tilejson(
             qs_key_to_remove = [
                 "tilematrixsetid",
                 "tile_format",
-                "tile_scale",
                 "minzoom",
                 "maxzoom",
             ]
-            qs = [
+            qs: list[tuple[str, Any]] = [
                 (key, value)
                 for (key, value) in request.query_params._list
                 if key.lower() not in qs_key_to_remove
             ]
-            if qs:
-                tiles_url += f"?{urlencode(qs)}"
+            if "tilesize" not in request.query_params:
+                qs.append(("tilesize", str(tilesize)))
+            tiles_url += f"?{urlencode(qs)}"
 
-            tms = self.supported_tms.get(TileMatrixSetId)
+            tms = self.supported_tms.get(tileMatrixSetId)
             with rasterio.Env(**env):
-                with self.reader(src_path, tms=tms, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(
+                    src_path, tms=tms, **reader_params.as_dict()
+                ) as src_dst:
                     return {
-                        "bounds": src_dst.geographic_bounds,
+                        "bounds": src_dst.get_geographic_bounds(
+                            tms.rasterio_geographic_crs
+                        ),
                         "minzoom": minzoom if minzoom is not None else src_dst.minzoom,
                         "maxzoom": maxzoom if maxzoom is not None else src_dst.maxzoom,
                         "tiles": [tiles_url],
+                        "attribution": os.environ.get("TITILER_DEFAULT_ATTRIBUTION"),
                     }
 
     def map_viewer(self):  # noqa: C901
-        """Register /map endpoint."""
+        """Register /map.html endpoint."""
 
-        @self.router.get("/map", response_class=HTMLResponse)
-        @self.router.get("/{TileMatrixSetId}/map", response_class=HTMLResponse)
+        @self.router.get(
+            "/{tileMatrixSetId}/map.html",
+            response_class=HTMLResponse,
+            operation_id=f"{self.operation_prefix}getMapViewer",
+        )
         def map_viewer(
             request: Request,
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
+            tile_format: Annotated[
+                ImageType | None,
+                Query(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg).",
+                ),
+            ] = None,
+            tilesize: Annotated[
+                int,
+                Query(gt=0, description="Tilesize in pixels. Default to 256."),
+            ] = 256,
+            minzoom: Annotated[
+                int | None,
+                Query(description="Overwrite default minzoom."),
+            ] = None,
+            maxzoom: Annotated[
+                int | None,
+                Query(description="Overwrite default maxzoom."),
+            ] = None,
             src_path=Depends(self.path_dependency),
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
-                self.default_tms,
-                description=f"TileMatrixSet Name (default: '{self.default_tms}')",
-            ),  # noqa
-            tile_format: Optional[ImageType] = Query(
-                None, description="Output image type. Default is auto."
-            ),  # noqa
-            tile_scale: int = Query(
-                1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."
-            ),  # noqa
-            minzoom: Optional[int] = Query(
-                None, description="Overwrite default minzoom."
-            ),  # noqa
-            maxzoom: Optional[int] = Query(
-                None, description="Overwrite default maxzoom."
-            ),  # noqa
-            layer_params=Depends(self.layer_dependency),  # noqa
-            dataset_params=Depends(self.dataset_dependency),  # noqa
-            buffer: Optional[float] = Query(  # noqa
-                None,
-                gt=0,
-                title="Tile buffer.",
-                description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
-            ),
-            post_process=Depends(self.process_dependency),  # noqa
-            rescale=Depends(self.rescale_dependency),  # noqa
-            color_formula: Optional[str] = Query(  # noqa
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
-            colormap=Depends(self.colormap_dependency),  # noqa
-            render_params=Depends(self.render_dependency),  # noqa
-            reader_params=Depends(self.reader_dependency),  # noqa
-            env=Depends(self.environment_dependency),  # noqa
+            reader_params=Depends(self.reader_dependency),
+            tile_params=Depends(self.tile_dependency),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            post_process=Depends(self.process_dependency),
+            colormap=Depends(self.colormap_dependency),
+            render_params=Depends(self.render_dependency),
+            env=Depends(self.environment_dependency),
         ):
             """Return TileJSON document for a dataset."""
             tilejson_url = self.url_for(
-                request, "tilejson", TileMatrixSetId=TileMatrixSetId
+                request, "tilejson", tileMatrixSetId=tileMatrixSetId
             )
+
+            qs = list(request.query_params._list)
+            if "tilesize" not in request.query_params:
+                qs.append(("tilesize", tilesize))
+            tilejson_url += f"?{urlencode(qs)}"
+
+            point_url = self.url_for(request, "point", lon="{lon}", lat="{lat}")
             if request.query_params._list:
-                tilejson_url += f"?{urlencode(request.query_params._list)}"
+                qs_key_to_remove = [
+                    "tilesize",
+                    "tile_format",
+                    "minzoom",
+                    "maxzoom",
+                    "buffer",
+                    "padding",
+                    "colormap",
+                    "colormap_name",
+                ]
+                qs = [
+                    (key, value)
+                    for (key, value) in request.query_params._list
+                    if key.lower() not in qs_key_to_remove
+                ]
+                point_url += f"?{urlencode(qs)}"
 
-            tms = self.supported_tms.get(TileMatrixSetId)
+            tms = self.supported_tms.get(tileMatrixSetId)
             return self.templates.TemplateResponse(
+                request,
                 name="map.html",
                 context={
-                    "request": request,
                     "tilejson_endpoint": tilejson_url,
+                    "point_endpoint": point_url,
                     "tms": tms,
-                    "resolutions": [tms._resolution(matrix) for matrix in tms],
+                    "resolutions": [matrix.cellSize for matrix in tms],
                 },
                 media_type="text/html",
             )
 
-    def wmts(self):  # noqa: C901
-        """Register /wmts endpoint."""
+    ############################################################################
+    # /point
+    ############################################################################
+    def point(self):
+        """Register /point endpoints."""
 
-        @self.router.get("/WMTSCapabilities.xml", response_class=XMLResponse)
         @self.router.get(
-            "/{TileMatrixSetId}/WMTSCapabilities.xml", response_class=XMLResponse
+            "/point/{lon},{lat}",
+            response_model=Point,
+            response_class=JSONResponse,
+            responses={200: {"description": "Return a value for a point"}},
+            operation_id=f"{self.operation_prefix}getDataForPoint",
         )
-        def wmts(
-            request: Request,
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
-                self.default_tms,
-                description=f"TileMatrixSet Name (default: '{self.default_tms}')",
-            ),
+        def point(
+            lon: Annotated[float, Path(description="Longitude")],
+            lat: Annotated[float, Path(description="Latitude")],
             src_path=Depends(self.path_dependency),
-            tile_format: ImageType = Query(
-                ImageType.png, description="Output image type. Default is png."
-            ),
-            tile_scale: int = Query(
-                1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."
-            ),
-            minzoom: Optional[int] = Query(
-                None, description="Overwrite default minzoom."
-            ),
-            maxzoom: Optional[int] = Query(
-                None, description="Overwrite default maxzoom."
-            ),
-            layer_params=Depends(self.layer_dependency),  # noqa
-            dataset_params=Depends(self.dataset_dependency),  # noqa
-            buffer: Optional[float] = Query(  # noqa
-                None,
-                gt=0,
-                title="Tile buffer.",
-                description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
-            ),
-            post_process=Depends(self.process_dependency),  # noqa
-            rescale=Depends(self.rescale_dependency),  # noqa
-            color_formula: Optional[str] = Query(  # noqa
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
-            colormap=Depends(self.colormap_dependency),  # noqa
-            render_params=Depends(self.render_dependency),  # noqa
-            reader_params=Depends(self.reader_dependency),
-            env=Depends(self.environment_dependency),
-        ):
-            """OGC WMTS endpoint."""
-            route_params = {
-                "z": "{TileMatrix}",
-                "x": "{TileCol}",
-                "y": "{TileRow}",
-                "scale": tile_scale,
-                "format": tile_format.value,
-                "TileMatrixSetId": TileMatrixSetId,
-            }
-            tiles_url = self.url_for(request, "tile", **route_params)
-
-            qs_key_to_remove = [
-                "tilematrixsetid",
-                "tile_format",
-                "tile_scale",
-                "minzoom",
-                "maxzoom",
-                "service",
-                "request",
-            ]
-            qs = [
-                (key, value)
-                for (key, value) in request.query_params._list
-                if key.lower() not in qs_key_to_remove
-            ]
-            if qs:
-                tiles_url += f"?{urlencode(qs)}"
-
-            tms = self.supported_tms.get(TileMatrixSetId)
-            with rasterio.Env(**env):
-                with self.reader(src_path, tms=tms, **reader_params) as src_dst:
-                    bounds = src_dst.geographic_bounds
-                    minzoom = minzoom if minzoom is not None else src_dst.minzoom
-                    maxzoom = maxzoom if maxzoom is not None else src_dst.maxzoom
-
-            tileMatrix = []
-            for zoom in range(minzoom, maxzoom + 1):
-                matrix = tms.matrix(zoom)
-                tm = f"""
-                        <TileMatrix>
-                            <ows:Identifier>{matrix.identifier}</ows:Identifier>
-                            <ScaleDenominator>{matrix.scaleDenominator}</ScaleDenominator>
-                            <TopLeftCorner>{matrix.topLeftCorner[0]} {matrix.topLeftCorner[1]}</TopLeftCorner>
-                            <TileWidth>{matrix.tileWidth}</TileWidth>
-                            <TileHeight>{matrix.tileHeight}</TileHeight>
-                            <MatrixWidth>{matrix.matrixWidth}</MatrixWidth>
-                            <MatrixHeight>{matrix.matrixHeight}</MatrixHeight>
-                        </TileMatrix>"""
-                tileMatrix.append(tm)
-
-            return self.templates.TemplateResponse(
-                "wmts.xml",
-                {
-                    "request": request,
-                    "tiles_endpoint": tiles_url,
-                    "bounds": bounds,
-                    "tileMatrix": tileMatrix,
-                    "tms": tms,
-                    "title": "Cloud Optimized GeoTIFF",
-                    "layer_name": "cogeo",
-                    "media_type": tile_format.mediatype,
-                },
-                media_type=MediaType.xml.value,
-            )
-
-    ############################################################################
-    # /point
-    ############################################################################
-    def point(self):
-        """Register /point endpoints."""
-
-        @self.router.get(
-            r"/point/{lon},{lat}",
-            response_model=Point,
-            response_class=JSONResponse,
-            responses={200: {"description": "Return a value for a point"}},
-        )
-        def point(
-            lon: float = Path(..., description="Longitude"),
-            lat: float = Path(..., description="Latitude"),
-            src_path=Depends(self.path_dependency),
-            coord_crs: Optional[CRS] = Depends(CoordCRSParams),
-            layer_params=Depends(self.layer_dependency),
-            dataset_params=Depends(self.dataset_dependency),
             reader_params=Depends(self.reader_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Get Point value for a dataset."""
-
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
                     pts = src_dst.point(
                         lon,
                         lat,
                         coord_crs=coord_crs or WGS84_CRS,
-                        **layer_params,
-                        **dataset_params,
+                        **layer_params.as_dict(),
+                        **dataset_params.as_dict(),
                     )
 
             return {
                 "coordinates": [lon, lat],
-                "values": pts.data.tolist(),
+                "values": pts.array.tolist(),
                 "band_names": pts.band_names,
+                "band_descriptions": pts.band_descriptions,
             }
 
     ############################################################################
@@ -881,36 +1148,47 @@ def point(
     def preview(self):
         """Register /preview endpoint."""
 
-        @self.router.get(r"/preview", **img_endpoint_params)
-        @self.router.get(r"/preview.{format}", **img_endpoint_params)
+        @self.router.get(
+            "/preview",
+            operation_id=f"{self.operation_prefix}getPreview",
+            **img_endpoint_params,
+        )
+        @self.router.get(
+            "/preview.{format}",
+            operation_id=f"{self.operation_prefix}getPreviewWithFormat",
+            **img_endpoint_params,
+        )
+        @self.router.get(
+            "/preview/{width}x{height}.{format}",
+            operation_id=f"{self.operation_prefix}getPreviewWithSizeAndFormat",
+            **img_endpoint_params,
+        )
         def preview(
-            format: ImageType = Query(
-                None, description="Output image type. Default is auto."
-            ),
+            format: Annotated[
+                ImageType | None,
+                Field(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg)."
+                ),
+            ] = None,
             src_path=Depends(self.path_dependency),
+            reader_params=Depends(self.reader_dependency),
             layer_params=Depends(self.layer_dependency),
-            dst_crs: Optional[CRS] = Depends(DstCRSParams),
             dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
+            image_params=Depends(self.img_preview_dependency),
+            dst_crs=Depends(DstCRSParams),
             post_process=Depends(self.process_dependency),
-            rescale=Depends(self.rescale_dependency),  # noqa
-            color_formula: Optional[str] = Query(
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
             colormap=Depends(self.colormap_dependency),
             render_params=Depends(self.render_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Create preview of a dataset."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
                     image = src_dst.preview(
-                        **layer_params,
-                        **image_params,
-                        **dataset_params,
+                        **layer_params.as_dict(),
+                        **image_params.as_dict(exclude_none=False),
+                        **dataset_params.as_dict(),
                         dst_crs=dst_crs,
                     )
                     dst_colormap = getattr(src_dst, "colormap", None)
@@ -918,170 +1196,249 @@ def preview(
             if post_process:
                 image = post_process(image)
 
-            if rescale:
-                image.rescale(rescale)
-
-            if color_formula:
-                image.apply_color_formula(color_formula)
-
-            if cmap := colormap or dst_colormap:
-                image = image.apply_colormap(cmap)
-
-            if not format:
-                format = ImageType.jpeg if image.mask.all() else ImageType.png
-
-            content = image.render(
-                img_format=format.driver,
-                **format.profile,
-                **render_params,
+            content, media_type = self.render_func(
+                image,
+                output_format=format,
+                colormap=colormap or dst_colormap,
+                **render_params.as_dict(),
             )
 
-            return Response(content, media_type=format.mediatype)
+            headers: dict[str, str] = {}
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
+
+            return Response(content, media_type=media_type, headers=headers)
 
     ############################################################################
-    # /crop (Optional)
+    # /bbox and /feature (Optional)
     ############################################################################
     def part(self):  # noqa: C901
-        """Register /crop endpoint."""
+        """Register /bbox and `/feature` endpoints."""
 
         # GET endpoints
         @self.router.get(
-            r"/crop/{minx},{miny},{maxx},{maxy}.{format}",
+            "/bbox/{minx},{miny},{maxx},{maxy}.{format}",
+            operation_id=f"{self.operation_prefix}getDataForBoundingBoxWithFormat",
             **img_endpoint_params,
         )
         @self.router.get(
-            r"/crop/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}",
+            "/bbox/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}",
+            operation_id=f"{self.operation_prefix}getDataForBoundingBoxWithSizesAndFormat",
             **img_endpoint_params,
         )
-        def part(
-            minx: float = Path(..., description="Bounding box min X"),
-            miny: float = Path(..., description="Bounding box min Y"),
-            maxx: float = Path(..., description="Bounding box max X"),
-            maxy: float = Path(..., description="Bounding box max Y"),
-            format: ImageType = Query(..., description="Output image type."),
+        def bbox_image(
+            minx: Annotated[float, Path(description="Bounding box min X")],
+            miny: Annotated[float, Path(description="Bounding box min Y")],
+            maxx: Annotated[float, Path(description="Bounding box max X")],
+            maxy: Annotated[float, Path(description="Bounding box max Y")],
+            format: Annotated[
+                ImageType | None,
+                Field(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg).",
+                ),
+            ] = None,
             src_path=Depends(self.path_dependency),
-            dst_crs: Optional[CRS] = Depends(DstCRSParams),
-            coord_crs: Optional[CRS] = Depends(CoordCRSParams),
+            reader_params=Depends(self.reader_dependency),
             layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
+            image_params=Depends(self.img_part_dependency),
+            dst_crs=Depends(DstCRSParams),
+            coord_crs=Depends(CoordCRSParams),
             post_process=Depends(self.process_dependency),
-            rescale=Depends(self.rescale_dependency),
-            color_formula: Optional[str] = Query(
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
             colormap=Depends(self.colormap_dependency),
             render_params=Depends(self.render_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
-            """Create image from part of a dataset."""
+            """Create image from a bbox."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
                     image = src_dst.part(
                         [minx, miny, maxx, maxy],
                         dst_crs=dst_crs,
                         bounds_crs=coord_crs or WGS84_CRS,
-                        **layer_params,
-                        **image_params,
-                        **dataset_params,
+                        **layer_params.as_dict(),
+                        **image_params.as_dict(),
+                        **dataset_params.as_dict(),
                     )
                     dst_colormap = getattr(src_dst, "colormap", None)
 
             if post_process:
                 image = post_process(image)
 
-            if rescale:
-                image.rescale(rescale)
-
-            if color_formula:
-                image.apply_color_formula(color_formula)
-
-            if cmap := colormap or dst_colormap:
-                image = image.apply_colormap(cmap)
-
-            content = image.render(
-                img_format=format.driver,
-                **format.profile,
-                **render_params,
+            content, media_type = self.render_func(
+                image,
+                output_format=format,
+                colormap=colormap or dst_colormap,
+                **render_params.as_dict(),
             )
 
-            return Response(content, media_type=format.mediatype)
+            headers: dict[str, str] = {}
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
+
+            return Response(content, media_type=media_type, headers=headers)
 
         # POST endpoints
         @self.router.post(
-            r"/crop",
+            "/feature",
+            operation_id=f"{self.operation_prefix}postDataForGeoJSON",
             **img_endpoint_params,
         )
         @self.router.post(
-            r"/crop.{format}",
+            "/feature.{format}",
+            operation_id=f"{self.operation_prefix}postDataForGeoJSONWithFormat",
             **img_endpoint_params,
         )
         @self.router.post(
-            r"/crop/{width}x{height}.{format}",
+            "/feature/{width}x{height}.{format}",
+            operation_id=f"{self.operation_prefix}postDataForGeoJSONWithSizesAndFormat",
             **img_endpoint_params,
         )
-        def geojson_crop(
-            geojson: Feature = Body(..., description="GeoJSON Feature."),
-            format: ImageType = Query(
-                None, description="Output image type. Default is auto."
-            ),
+        def feature_image(
+            geojson: Annotated[Feature, Body(description="GeoJSON Feature.")],
+            format: Annotated[
+                ImageType | None,
+                Field(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg)."
+                ),
+            ] = None,
             src_path=Depends(self.path_dependency),
-            coord_crs: Optional[CRS] = Depends(CoordCRSParams),
+            reader_params=Depends(self.reader_dependency),
             layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
+            image_params=Depends(self.img_part_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            dst_crs=Depends(DstCRSParams),
             post_process=Depends(self.process_dependency),
-            rescale=Depends(self.rescale_dependency),
-            color_formula: Optional[str] = Query(
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
             colormap=Depends(self.colormap_dependency),
             render_params=Depends(self.render_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Create image from a geojson feature."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
                     image = src_dst.feature(
-                        geojson.dict(exclude_none=True),
+                        geojson.model_dump(exclude_none=True),
                         shape_crs=coord_crs or WGS84_CRS,
-                        **layer_params,
-                        **image_params,
-                        **dataset_params,
+                        dst_crs=dst_crs,
+                        **layer_params.as_dict(),
+                        **image_params.as_dict(),
+                        **dataset_params.as_dict(),
                     )
                     dst_colormap = getattr(src_dst, "colormap", None)
 
             if post_process:
                 image = post_process(image)
 
-            if rescale:
-                image.rescale(rescale)
+            content, media_type = self.render_func(
+                image,
+                output_format=format,
+                colormap=colormap or dst_colormap,
+                **render_params.as_dict(),
+            )
+
+            headers: dict[str, str] = {}
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
+
+            return Response(content, media_type=media_type, headers=headers)
+
+    ############################################################################
+    # OGC Maps (Optional)
+    ############################################################################
+    def ogc_maps(self):  # noqa: C901
+        """Register OGC Maps /map` endpoint."""
+
+        self.conforms_to.update(
+            {
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/core",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/crs",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/scaling",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/scaling/width-definition",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/scaling/height-definition",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/spatial-subsetting",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/spatial-subsetting/bbox-definition",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/spatial-subsetting/bbox-crs",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/spatial-subsetting/crs-curie",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/png",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/jpeg",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/tiff",
+            }
+        )
+
+        # GET endpoints
+        @self.router.get(
+            "/map",
+            operation_id=f"{self.operation_prefix}getMap",
+            **img_endpoint_params,
+        )
+        def get_map(
+            src_path=Depends(self.path_dependency),
+            ogc_params=Depends(OGCMapsParams),
+            reader_params=Depends(self.reader_dependency),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            post_process=Depends(self.process_dependency),
+            colormap=Depends(self.colormap_dependency),
+            render_params=Depends(self.render_dependency),
+            env=Depends(self.environment_dependency),
+        ) -> Response:
+            """OGC Maps API."""
+            with rasterio.Env(**env):
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    if ogc_params.bbox is not None:
+                        image = src_dst.part(
+                            ogc_params.bbox,
+                            dst_crs=ogc_params.crs or src_dst.crs,
+                            bounds_crs=ogc_params.bbox_crs or WGS84_CRS,
+                            width=ogc_params.width,
+                            height=ogc_params.height,
+                            max_size=ogc_params.max_size,
+                            **layer_params.as_dict(),
+                            **dataset_params.as_dict(),
+                        )
 
-            if color_formula:
-                image.apply_color_formula(color_formula)
+                    else:
+                        image = src_dst.preview(
+                            width=ogc_params.width,
+                            height=ogc_params.height,
+                            max_size=ogc_params.max_size,
+                            dst_crs=ogc_params.crs or src_dst.crs,
+                            **layer_params.as_dict(),
+                            **dataset_params.as_dict(),
+                        )
 
-            if cmap := colormap or dst_colormap:
-                image = image.apply_colormap(cmap)
+                    dst_colormap = getattr(src_dst, "colormap", None)
 
-            if not format:
-                format = ImageType.jpeg if image.mask.all() else ImageType.png
+            if post_process:
+                image = post_process(image)
 
-            content = image.render(
-                img_format=format.driver,
-                **format.profile,
-                **render_params,
+            content, media_type = self.render_func(
+                image,
+                output_format=ogc_params.format,
+                colormap=colormap or dst_colormap,
+                **render_params.as_dict(),
             )
 
-            return Response(content, media_type=format.mediatype)
+            headers: dict[str, str] = {}
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
 
+            return Response(content, media_type=media_type, headers=headers)
 
-@dataclass
+
+@define(kw_only=True)
 class MultiBaseTilerFactory(TilerFactory):
     """Custom Tiler Factory for MultiBaseReader classes.
 
@@ -1096,13 +1453,13 @@ class MultiBaseTilerFactory(TilerFactory):
 
     """
 
-    reader: Type[MultiBaseReader]
+    reader: type[MultiBaseReader]  # type: ignore
 
-    # Assets/Indexes/Expression dependency
-    layer_dependency: Type[DefaultDependency] = AssetsBidxExprParams
+    # Assets/Expression dependency
+    layer_dependency: type[DefaultDependency] = AssetsExprParams
 
     # Assets dependency
-    assets_dependency: Type[DefaultDependency] = AssetsParams
+    assets_dependency: type[DefaultDependency] = AssetsParams
 
     # Overwrite the `/info` endpoint to return the list of assets when no assets is passed.
     def info(self):
@@ -1118,17 +1475,22 @@ def info(self):
                     "description": "Return dataset's basic info or the list of available assets."
                 }
             },
+            operation_id=f"{self.operation_prefix}getInfo",
         )
         def info(
             src_path=Depends(self.path_dependency),
-            asset_params=Depends(self.assets_dependency),
             reader_params=Depends(self.reader_dependency),
+            asset_params=Depends(self.assets_dependency),
             env=Depends(self.environment_dependency),
-        ):
+        ) -> MultiBaseInfo:
             """Return dataset's basic info or the list of available assets."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    return src_dst.info(**asset_params)
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    if asset_params.assets == [":all:"]:
+                        asset_params.assets = src_dst.assets
+
+                    return src_dst.info(**asset_params.as_dict())
 
         @self.router.get(
             "/info.geojson",
@@ -1141,31 +1503,37 @@ def info(
                     "description": "Return dataset's basic info as a GeoJSON feature.",
                 }
             },
+            operation_id=f"{self.operation_prefix}getInfoGeoJSON",
         )
         def info_geojson(
             src_path=Depends(self.path_dependency),
-            asset_params=Depends(self.assets_dependency),
             reader_params=Depends(self.reader_dependency),
+            asset_params=Depends(self.assets_dependency),
+            crs=Depends(CRSParams),
             env=Depends(self.environment_dependency),
-        ):
+        ) -> MultiBaseInfoGeoJSON:
             """Return dataset's basic info as a GeoJSON feature."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    if asset_params.assets == [":all:"]:
+                        asset_params.assets = src_dst.assets
+
+                    bounds = src_dst.get_geographic_bounds(crs or WGS84_CRS)
+                    geometry = bounds_to_geometry(bounds)
+
                     return Feature(
                         type="Feature",
-                        geometry=Polygon.from_bounds(*src_dst.geographic_bounds),
-                        properties={
-                            asset: asset_info
-                            for asset, asset_info in src_dst.info(
-                                **asset_params
-                            ).items()
-                        },
+                        bbox=bounds,
+                        geometry=geometry,
+                        properties=src_dst.info(**asset_params.as_dict()),
                     )
 
         @self.router.get(
             "/assets",
-            response_model=List[str],
+            response_model=list[str],
             responses={200: {"description": "Return a list of supported assets."}},
+            operation_id=f"{self.operation_prefix}getAssets",
         )
         def available_assets(
             src_path=Depends(self.path_dependency),
@@ -1174,7 +1542,8 @@ def available_assets(
         ):
             """Return a list of supported assets."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
                     return src_dst.assets
 
     # Overwrite the `/statistics` endpoint because the MultiBaseReader output model is different (Dict[str, Dict[str, BandStatistics]])
@@ -1193,26 +1562,31 @@ def statistics(self):  # noqa: C901
                     "description": "Return dataset's statistics.",
                 }
             },
+            operation_id=f"{self.operation_prefix}getAssetsStatistics",
         )
         def asset_statistics(
             src_path=Depends(self.path_dependency),
-            asset_params=Depends(AssetsBidxParams),
+            reader_params=Depends(self.reader_dependency),
+            asset_params=Depends(self.assets_dependency),
             dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
+            image_params=Depends(self.img_preview_dependency),
             stats_params=Depends(self.stats_dependency),
             histogram_params=Depends(self.histogram_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Per Asset statistics"""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    if asset_params.assets == [":all:"]:
+                        asset_params.assets = src_dst.assets
+
                     return src_dst.statistics(
-                        **asset_params,
-                        **image_params,
-                        **dataset_params,
-                        **stats_params,
-                        hist_options={**histogram_params},
+                        **asset_params.as_dict(),
+                        **image_params.as_dict(exclude_none=False),
+                        **dataset_params.as_dict(),
+                        **stats_params.as_dict(),
+                        hist_options=histogram_params.as_dict(),
                     )
 
         # MultiBaseReader merged statistics
@@ -1228,30 +1602,38 @@ def asset_statistics(
                     "description": "Return dataset's statistics.",
                 }
             },
+            operation_id=f"{self.operation_prefix}getStatistics",
         )
         def statistics(
             src_path=Depends(self.path_dependency),
-            layer_params=Depends(AssetsBidxExprParamsOptional),
+            reader_params=Depends(self.reader_dependency),
+            layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
+            image_params=Depends(self.img_preview_dependency),
+            post_process=Depends(self.process_dependency),
             stats_params=Depends(self.stats_dependency),
             histogram_params=Depends(self.histogram_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Merged assets statistics."""
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    # Default to all available assets
-                    if not layer_params.assets and not layer_params.expression:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    if layer_params.assets == [":all:"]:
                         layer_params.assets = src_dst.assets
 
-                    return src_dst.merged_statistics(
-                        **layer_params,
-                        **image_params,
-                        **dataset_params,
-                        **stats_params,
-                        hist_options={**histogram_params},
+                    image = src_dst.preview(
+                        **layer_params.as_dict(),
+                        **image_params.as_dict(),
+                        **dataset_params.as_dict(),
+                    )
+
+                    if post_process:
+                        image = post_process(image)
+
+                    return image.statistics(
+                        **stats_params.as_dict(),
+                        hist_options=histogram_params.as_dict(),
                     )
 
         # POST endpoint
@@ -1262,23 +1644,27 @@ def statistics(
             response_class=GeoJSONResponse,
             responses={
                 200: {
-                    "content": {"application/json": {}},
-                    "description": "Return dataset's statistics.",
+                    "content": {"application/geo+json": {}},
+                    "description": "Return dataset's statistics from feature or featureCollection.",
                 }
             },
+            operation_id=f"{self.operation_prefix}postStatisticsForGeoJSON",
         )
         def geojson_statistics(
-            geojson: Union[FeatureCollection, Feature] = Body(
-                ..., description="GeoJSON Feature or FeatureCollection."
-            ),
+            geojson: Annotated[
+                FeatureCollection | Feature,
+                Body(description="GeoJSON Feature or FeatureCollection."),
+            ],
             src_path=Depends(self.path_dependency),
-            coord_crs: Optional[CRS] = Depends(CoordCRSParams),
-            layer_params=Depends(AssetsBidxExprParamsOptional),
+            reader_params=Depends(self.reader_dependency),
+            layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            dst_crs=Depends(DstCRSParams),
+            post_process=Depends(self.process_dependency),
+            image_params=Depends(self.img_part_dependency),
             stats_params=Depends(self.stats_dependency),
             histogram_params=Depends(self.histogram_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Get Statistics from a geojson feature or featureCollection."""
@@ -1287,372 +1673,580 @@ def geojson_statistics(
                 fc = FeatureCollection(type="FeatureCollection", features=[geojson])
 
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    # Default to all available assets
-                    if not layer_params.assets and not layer_params.expression:
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    if layer_params.assets == [":all:"]:
                         layer_params.assets = src_dst.assets
 
-                    for feature in fc:
-                        data = src_dst.feature(
-                            feature.dict(exclude_none=True),
+                    for feature in fc.features:
+                        image = src_dst.feature(
+                            feature.model_dump(exclude_none=True),
                             shape_crs=coord_crs or WGS84_CRS,
-                            **layer_params,
-                            **image_params,
-                            **dataset_params,
+                            dst_crs=dst_crs,
+                            align_bounds_with_dataset=True,
+                            **layer_params.as_dict(),
+                            **image_params.as_dict(),
+                            **dataset_params.as_dict(),
                         )
 
-                        stats = get_array_statistics(
-                            data.as_masked(),
-                            **stats_params,
-                            **histogram_params,
+                        if post_process:
+                            image = post_process(image)
+
+                        stats = image.statistics(
+                            **stats_params.as_dict(),
+                            hist_options=histogram_params.as_dict(),
                         )
 
-                    feature.properties = feature.properties or {}
-                    feature.properties.update(
-                        {
-                            # NOTE: because we use `src_dst.feature` the statistics will be in form of
-                            # `Dict[str, BandStatistics]` and not `Dict[str, Dict[str, BandStatistics]]`
-                            "statistics": {
-                                f"{data.band_names[ix]}": BandStatistics(**stats[ix])
-                                for ix in range(len(stats))
-                            }
-                        }
-                    )
+                        feature.properties = feature.properties or {}
+                        # NOTE: because we use `src_dst.feature` the statistics will be in form of
+                        # `Dict[str, BandStatistics]` and not `Dict[str, Dict[str, BandStatistics]]`
+                        feature.properties.update({"statistics": stats})
 
             return fc.features[0] if isinstance(geojson, Feature) else fc
 
 
-@dataclass
-class MultiBandTilerFactory(TilerFactory):
-    """Custom Tiler Factory for MultiBandReader classes.
-
-    Note:
-        To be able to use the rio_tiler.io.MultiBandReader we need to be able to pass a `bands`
-        argument to most of its methods. By using the `BandsExprParams` for the `layer_dependency`, the
-        .tile(), .point(), .preview() and the .part() methods will receive bands or expression arguments.
-
-        The rio_tiler.io.MultiBandReader  `.info()` and `.metadata()` have `bands` as
-        a requirement arguments (https://github.com/cogeotiff/rio-tiler/blob/main/rio_tiler/io/base.py#L775).
-        This means we have to update the /info and /metadata endpoints in order to add the `bands` dependency.
-
-        For implementation example see https://github.com/developmentseed/titiler-pds
-
-    """
-
-    reader: Type[MultiBandReader]
-
-    # Assets/Expression dependency
-    layer_dependency: Type[DefaultDependency] = BandsExprParams
+@define(kw_only=True)
+class TMSFactory(BaseFactory):
+    """TileMatrixSet endpoints Factory."""
 
-    # Bands dependency
-    bands_dependency: Type[DefaultDependency] = BandsParams
+    supported_tms: TileMatrixSets = morecantile_tms
 
-    def info(self):
-        """Register /info endpoint."""
+    def register_routes(self):
+        """Register TMS endpoint routes."""
 
         @self.router.get(
-            "/info",
-            response_model=Info,
+            "/tileMatrixSets",
+            response_model=TileMatrixSetList,
             response_model_exclude_none=True,
-            response_class=JSONResponse,
-            responses={200: {"description": "Return dataset's basic info."}},
+            summary="Retrieve the list of available tiling schemes (tile matrix sets).",
+            operation_id=f"{self.operation_prefix}getTileMatrixSetsList",
+            responses={
+                200: {
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    },
+                },
+            },
         )
-        def info(
-            src_path=Depends(self.path_dependency),
-            bands_params=Depends(self.bands_dependency),
-            reader_params=Depends(self.reader_dependency),
-            env=Depends(self.environment_dependency),
+        async def tilematrixsets(
+            request: Request,
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
         ):
-            """Return dataset's basic info."""
-            with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    return src_dst.info(**bands_params)
+            """
+            OGC Specification: http://docs.opengeospatial.org/per/19-069.html#_tilematrixsets
+            """
+
+            data = TileMatrixSetList(
+                tileMatrixSets=[
+                    {  # type: ignore
+                        "id": tms_id,
+                        "links": [
+                            {
+                                "href": self.url_for(
+                                    request,
+                                    "tilematrixset",
+                                    tileMatrixSetId=tms_id,
+                                ),
+                                "rel": "http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme",
+                                "type": "application/json",
+                                "title": f"Definition of {tms_id} tileMatrixSet",
+                            }
+                        ],
+                    }
+                    for tms_id in self.supported_tms.list()
+                ]
+            )
+
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
+
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    data.model_dump(exclude_none=True, mode="json"),
+                    title="TileMatrixSets",
+                    template_name="tilematrixsets",
+                    templates=self.templates,
+                )
+
+            return data
 
         @self.router.get(
-            "/info.geojson",
-            response_model=InfoGeoJSON,
+            "/tileMatrixSets/{tileMatrixSetId}",
+            response_model=TileMatrixSet,
             response_model_exclude_none=True,
-            response_class=GeoJSONResponse,
+            summary="Retrieve the definition of the specified tiling scheme (tile matrix set).",
+            operation_id=f"{self.operation_prefix}getTileMatrixSet",
             responses={
                 200: {
-                    "content": {"application/geo+json": {}},
-                    "description": "Return dataset's basic info as a GeoJSON feature.",
-                }
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    },
+                },
             },
         )
-        def info_geojson(
-            src_path=Depends(self.path_dependency),
-            bands_params=Depends(self.bands_dependency),
-            reader_params=Depends(self.reader_dependency),
-            env=Depends(self.environment_dependency),
+        async def tilematrixset(
+            request: Request,
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(description="Identifier for a supported TileMatrixSet."),
+            ],
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
         ):
-            """Return dataset's basic info as a GeoJSON feature."""
-            with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    return Feature(
-                        type="Feature",
-                        geometry=Polygon.from_bounds(*src_dst.geographic_bounds),
-                        properties=src_dst.info(**bands_params),
-                    )
+            """
+            OGC Specification: http://docs.opengeospatial.org/per/19-069.html#_tilematrixset
+            """
+            tms = self.supported_tms.get(tileMatrixSetId)
+
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
 
-        @self.router.get(
-            "/bands",
-            response_model=List[str],
-            responses={200: {"description": "Return a list of supported bands."}},
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    {
+                        **tms.model_dump(exclude_none=True, mode="json"),
+                        # For visualization purpose we add the tms bbox
+                        "bbox": list(tms.bbox),
+                    },
+                    title=f"{tileMatrixSetId} TileMatrixSet",
+                    template_name="tilematrixset",
+                    templates=self.templates,
+                )
+
+            return tms
+
+
+@define(kw_only=True)
+class AlgorithmFactory(BaseFactory):
+    """Algorithm endpoints Factory."""
+
+    # Supported algorithm
+    supported_algorithm: Algorithms = available_algorithms
+
+    def _get_algo_metadata(self, algorithm: type[BaseAlgorithm]) -> AlgorithmMetadata:
+        """Algorithm Metadata"""
+        props = algorithm.model_json_schema()["properties"]
+
+        # title and description
+        info = {
+            k: v["default"]
+            for k, v in props.items()
+            if k == "title" or k == "description"
+        }
+        title = info.get("title", None)
+        description = info.get("description", None)
+
+        # Inputs Metadata
+        ins = {
+            k.replace("input_", ""): v["default"]
+            for k, v in props.items()
+            if k.startswith("input_") and "default" in v
+        }
+
+        # Output Metadata
+        outs = {
+            k.replace("output_", ""): v["default"]
+            for k, v in props.items()
+            if k.startswith("output_") and "default" in v
+        }
+
+        # Algorithm Parameters
+        params = {
+            k: v
+            for k, v in props.items()
+            if not k.startswith("input_")
+            and not k.startswith("output_")
+            and k != "title"
+            and k != "description"
+        }
+        return AlgorithmMetadata(
+            title=title,
+            description=description,
+            inputs=ins,
+            outputs=outs,
+            parameters=params,
         )
-        def available_bands(
-            src_path=Depends(self.path_dependency),
-            reader_params=Depends(self.reader_dependency),
-            env=Depends(self.environment_dependency),
-        ):
-            """Return a list of supported bands."""
-            with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    return src_dst.bands
 
-    # Overwrite the `/statistics` endpoint because we need bands to default to the list of bands.
-    def statistics(self):  # noqa: C901
-        """add statistics endpoints."""
+    def register_routes(self):
+        """Register Algorithm routes."""
 
-        # GET endpoint
         @self.router.get(
-            "/statistics",
-            response_class=JSONResponse,
-            response_model=Statistics,
+            "/algorithms",
+            response_model=AlgorithmtList,
+            summary="Retrieve the list of available Algorithms.",
+            operation_id=f"{self.operation_prefix}getAlgorithmList",
             responses={
                 200: {
-                    "content": {"application/json": {}},
-                    "description": "Return dataset's statistics.",
-                }
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    },
+                },
             },
         )
-        def statistics(
-            src_path=Depends(self.path_dependency),
-            bands_params=Depends(BandsExprParamsOptional),
-            dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
-            stats_params=Depends(self.stats_dependency),
-            histogram_params=Depends(self.histogram_dependency),
-            reader_params=Depends(self.reader_dependency),
-            env=Depends(self.environment_dependency),
+        def available_algorithms(
+            request: Request,
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
         ):
-            """Get Dataset statistics."""
-            with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    return src_dst.statistics(
-                        **bands_params,
-                        **image_params,
-                        **dataset_params,
-                        **stats_params,
-                        hist_options={**histogram_params},
-                    )
+            """Retrieve the list of available Algorithms."""
+            data = AlgorithmtList(
+                algorithms=[
+                    {  # type: ignore
+                        "id": algo_id,
+                        "links": [
+                            {
+                                "href": self.url_for(
+                                    request,
+                                    "algorithm_metadata",
+                                    algorithmId=algo_id,
+                                ),
+                                "rel": "item",
+                                "type": "application/json",
+                                "title": f"Definition of {algo_id} Algorithm",
+                            }
+                        ],
+                    }
+                    for algo_id, _ in self.supported_algorithm.data.items()
+                ],
+            )
 
-        # POST endpoint
-        @self.router.post(
-            "/statistics",
-            response_model=StatisticsGeoJSON,
-            response_model_exclude_none=True,
-            response_class=GeoJSONResponse,
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
+
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    data.model_dump(exclude_none=True, mode="json"),
+                    title="Algorithms",
+                    template_name="algorithms",
+                    templates=self.templates,
+                )
+
+            return data
+
+        @self.router.get(
+            "/algorithms/{algorithmId}",
+            response_model=AlgorithmMetadata,
+            summary="Retrieve the metadata of the specified algorithm.",
+            operation_id=f"{self.operation_prefix}getAlgorithm",
             responses={
                 200: {
-                    "content": {"application/json": {}},
-                    "description": "Return dataset's statistics.",
-                }
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    },
+                },
             },
         )
-        def geojson_statistics(
-            geojson: Union[FeatureCollection, Feature] = Body(
-                ..., description="GeoJSON Feature or FeatureCollection."
-            ),
-            src_path=Depends(self.path_dependency),
-            coord_crs: Optional[CRS] = Depends(CoordCRSParams),
-            bands_params=Depends(BandsExprParamsOptional),
-            dataset_params=Depends(self.dataset_dependency),
-            image_params=Depends(self.img_dependency),
-            stats_params=Depends(self.stats_dependency),
-            histogram_params=Depends(self.histogram_dependency),
-            reader_params=Depends(self.reader_dependency),
-            env=Depends(self.environment_dependency),
+        def algorithm_metadata(
+            request: Request,
+            algorithmId: Annotated[
+                Literal[tuple(self.supported_algorithm.list())],
+                Path(description="Algorithm name"),
+            ],
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
         ):
-            """Get Statistics from a geojson feature or featureCollection."""
-            fc = geojson
-            if isinstance(fc, Feature):
-                fc = FeatureCollection(type="FeatureCollection", features=[geojson])
-
-            with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                    # Default to all available bands
-                    if not bands_params.bands and not bands_params.expression:
-                        bands_params.bands = src_dst.bands
-
-                    for feature in fc:
-                        data = src_dst.feature(
-                            feature.dict(exclude_none=True),
-                            shape_crs=coord_crs or WGS84_CRS,
-                            **bands_params,
-                            **image_params,
-                            **dataset_params,
-                        )
-                        stats = get_array_statistics(
-                            data.as_masked(),
-                            **stats_params,
-                            **histogram_params,
-                        )
+            """Retrieve the metadata of the specified algorithm."""
+            data = self._get_algo_metadata(self.supported_algorithm.get(algorithmId))
+
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
 
-                        feature.properties = feature.properties or {}
-                        feature.properties.update(
-                            {
-                                "statistics": {
-                                    f"{data.band_names[ix]}": BandStatistics(
-                                        **stats[ix]
-                                    )
-                                    for ix in range(len(stats))
-                                }
-                            }
-                        )
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    data.model_dump(exclude_none=True, mode="json"),
+                    title=f"{algorithmId} Algorithm",
+                    template_name="algorithm",
+                    templates=self.templates,
+                )
 
-            return fc.features[0] if isinstance(geojson, Feature) else fc
+            return data
 
 
-@dataclass
-class TMSFactory:
-    """TileMatrixSet endpoints Factory."""
+@define(kw_only=True)
+class ColorMapFactory(BaseFactory):
+    """Colormap endpoints Factory."""
 
-    supported_tms: TileMatrixSets = morecantile_tms
+    # Supported colormaps
+    supported_colormaps: ColorMaps = default_cmap
 
-    # FastAPI router
-    router: APIRouter = field(default_factory=APIRouter)
+    def _image_from_colormap(
+        self,
+        cmap,
+        orientation: Literal["vertical", "horizontal"] | None = None,
+        width: int | None = None,
+        height: int | None = None,
+    ) -> ImageData:
+        """Create an image from a colormap."""
+        orientation = orientation or "horizontal"
+
+        if isinstance(cmap, Sequence):
+            values = [minv for ((minv, _), _) in cmap]
+            arr = numpy.array([values] * 20)
+
+            if orientation == "vertical":
+                height = height or 256 if len(values) < 256 else len(values)
+            else:
+                width = width or 256 if len(values) < 256 else len(values)
+
+        ###############################################################
+        # DISCRETE CMAP
+        elif len(cmap) != 256 or max(cmap) >= 256 or min(cmap) < 0:
+            values = list(cmap)
+            arr = numpy.array([values] * 20)
+
+            if orientation == "vertical":
+                height = height or 256 if len(values) < 256 else len(values)
+            else:
+                width = width or 256 if len(values) < 256 else len(values)
+
+        ###############################################################
+        # LINEAR CMAP
+        else:
+            cmin, cmax = min(cmap), max(cmap)
+            arr = numpy.array(
+                [numpy.round(numpy.linspace(cmin, cmax, num=256)).astype(numpy.uint8)]
+                * 20
+            )
 
-    # Router Prefix is needed to find the path for /tile if the TilerFactory.router is mounted
-    # with other router (multiple `.../tile` routes).
-    # e.g if you mount the route with `/cog` prefix, set router_prefix to cog and
-    router_prefix: str = ""
+        if orientation == "vertical":
+            arr = arr.transpose([1, 0])
 
-    def __post_init__(self):
-        """Post Init: register route and configure specific options."""
-        self.register_routes()
+        img = ImageData(arr)
 
-    def url_for(self, request: Request, name: str, **path_params: Any) -> str:
-        """Return full url (with prefix) for a specific endpoint."""
-        url_path = self.router.url_path_for(name, **path_params)
-        base_url = str(request.base_url)
-        if self.router_prefix:
-            base_url += self.router_prefix.lstrip("/")
+        width = width or img.width
+        height = height or img.height
+        if width != img.width or height != img.height:
+            img = img.resize(height, width)
 
-        return str(url_path.make_absolute_url(base_url=base_url))
+        return img
 
-    def register_routes(self):
-        """Register TMS endpoint routes."""
+    def register_routes(self):  # noqa: C901
+        """Register ColorMap routes."""
 
         @self.router.get(
-            r"/tileMatrixSets",
-            response_model=TileMatrixSetList,
+            "/colorMaps",
+            response_model=ColorMapList,
             response_model_exclude_none=True,
-            summary="Retrieve the list of available tiling schemes (tile matrix sets).",
-            operation_id="getTileMatrixSetsList",
+            summary="Retrieve the list of available colormaps.",
+            operation_id=f"{self.operation_prefix}getColorMapList",
+            responses={
+                200: {
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    },
+                },
+            },
         )
-        async def TileMatrixSet_list(request: Request):
-            """
-            OGC Specification: http://docs.opengeospatial.org/per/19-069.html#_tilematrixsets
-            """
-            return {
-                "tileMatrixSets": [
-                    {
-                        "id": tms,
-                        "title": tms,
+        def available_colormaps(
+            request: Request,
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
+        ):
+            """Retrieve the list of available colormaps."""
+            data = ColorMapList(
+                colormaps=[
+                    {  # type: ignore
+                        "id": cmap_name,
                         "links": [
                             {
                                 "href": self.url_for(
                                     request,
-                                    "TileMatrixSet_info",
-                                    TileMatrixSetId=tms,
+                                    "colormap_metadata",
+                                    colorMapId=cmap_name,
                                 ),
                                 "rel": "item",
                                 "type": "application/json",
+                                "title": f"Definition of {cmap_name} ColorMap",
                             }
                         ],
                     }
-                    for tms in self.supported_tms.list()
-                ]
-            }
-
-        @self.router.get(
-            r"/tileMatrixSets/{TileMatrixSetId}",
-            response_model=TileMatrixSet,
-            response_model_exclude_none=True,
-            summary="Retrieve the definition of the specified tiling scheme (tile matrix set).",
-            operation_id="getTileMatrixSet",
-        )
-        async def TileMatrixSet_info(
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Path(
-                ..., description="TileMatrixSet Name."
+                    for cmap_name in self.supported_colormaps.list()
+                ],
             )
-        ):
-            """
-            OGC Specification: http://docs.opengeospatial.org/per/19-069.html#_tilematrixset
-            """
-            return self.supported_tms.get(TileMatrixSetId)
 
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
 
-@dataclass
-class AlgorithmFactory:
-    """Algorithm endpoints Factory."""
-
-    # Supported algorithm
-    supported_algorithm: Algorithms = available_algorithms
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    data.model_dump(exclude_none=True, mode="json"),
+                    title="ColorMaps",
+                    template_name="colormaps",
+                    templates=self.templates,
+                )
 
-    # FastAPI router
-    router: APIRouter = field(default_factory=APIRouter)
+            return data
 
-    def __post_init__(self):
-        """Post Init: register routes"""
+        @self.router.get(
+            "/colorMaps/{colorMapId}",
+            response_model=ColorMapType,
+            summary="Retrieve the colorMap metadata or image.",
+            operation_id=f"{self.operation_prefix}getColorMap",
+            responses={
+                200: {
+                    "content": {
+                        "application/json": {},
+                        "image/png": {},
+                        "image/jpeg": {},
+                        "image/jpg": {},
+                        "image/webp": {},
+                        "image/jp2": {},
+                        "image/tiff; application=geotiff": {},
+                        "application/x-binary": {},
+                        "text/html": {},
+                    }
+                },
+            },
+        )
+        def colormap_metadata(  # noqa: C901
+            request: Request,
+            colorMapId: Annotated[
+                Literal[tuple(self.supported_colormaps.list())],
+                Path(description="ColorMap name"),
+            ],
+            f: Annotated[
+                (
+                    Literal[
+                        "html",
+                        "json",
+                        "png",
+                        "npy",
+                        "tif",
+                        "tiff",
+                        "jpeg",
+                        "jpg",
+                        "jp2",
+                        "webp",
+                        "pngraw",
+                    ]
+                    | None
+                ),
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
+            orientation: Annotated[
+                Literal["vertical", "horizontal"] | None,
+                Query(
+                    description="Image Orientation.",
+                ),
+            ] = None,
+            height: Annotated[
+                int | None,
+                Query(
+                    description="Image Height (default to 20px for horizontal or 256px for vertical).",
+                ),
+            ] = None,
+            width: Annotated[
+                int | None,
+                Query(
+                    description="Image Width (default to 256px for horizontal or 20px for vertical).",
+                ),
+            ] = None,
+        ):
+            """Retrieve the metadata of the specified colormap."""
+            cmap = self.supported_colormaps.get(colorMapId)
+
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
 
-        def metadata(algorithm: BaseAlgorithm) -> AlgorithmMetadata:
-            """Algorithm Metadata"""
-            props = algorithm.schema()["properties"]
+            if output_type.name in [im.name for im in ImageType]:
+                img = self._image_from_colormap(
+                    cmap,
+                    orientation,
+                    width=width,
+                    height=height,
+                )
 
-            # Inputs Metadata
-            ins = {
-                k.replace("input_", ""): v["default"]
-                for k, v in props.items()
-                if k.startswith("input_") and "default" in v
-            }
+                format = ImageType[output_type.name]
+                return Response(
+                    img.render(img_format=format.driver, colormap=cmap),
+                    media_type=format.mediatype,
+                )
 
-            # Output Metadata
-            outs = {
-                k.replace("output_", ""): v["default"]
-                for k, v in props.items()
-                if k.startswith("output_") and "default" in v
-            }
+            elif output_type == MediaType.html:
+                img = self._image_from_colormap(cmap, orientation="vertical")
+                content = img.render(img_format="PNG", colormap=cmap)
 
-            # Algorithm Parameters
-            params = {
-                k: v
-                for k, v in props.items()
-                if not k.startswith("input_") and not k.startswith("output_")
-            }
-            return AlgorithmMetadata(inputs=ins, outputs=outs, parameters=params)
+                return create_html_response(
+                    request,
+                    base64.b64encode(content).decode(),
+                    title=colorMapId,
+                    template_name="colormap",
+                    templates=self.templates,
+                )
 
-        @self.router.get(
-            "/algorithms",
-            response_model=Dict[str, AlgorithmMetadata],
-            summary="Retrieve the list of available Algorithms.",
-            operation_id="getAlgorithms",
-        )
-        def available_algorithms(request: Request):
-            """Retrieve the list of available Algorithms."""
-            return {k: metadata(v) for k, v in self.supported_algorithm.data.items()}
+            data: ColorMapType
+            if isinstance(cmap, Sequence):
+                data = [(k, numpy.array(v).tolist()) for (k, v) in cmap]
+            else:
+                data = {k: numpy.array(v).tolist() for k, v in cmap.items()}
 
-        @self.router.get(
-            "/algorithms/{algorithmId}",
-            response_model=AlgorithmMetadata,
-            summary="Retrieve the metadata of the specified algorithm.",
-            operation_id="getAlgorithm",
-        )
-        def algorithm_metadata(
-            algorithm: Literal[tuple(self.supported_algorithm.list())] = Path(
-                ..., description="Algorithm name", alias="algorithmId"
-            ),
-        ):
-            """Retrieve the metadata of the specified algorithm."""
-            return metadata(self.supported_algorithm.get(algorithm))
+            return data
diff --git a/src/titiler/core/titiler/core/middleware.py b/src/titiler/core/titiler/core/middleware.py
index f592c962d..46ca2e7c4 100644
--- a/src/titiler/core/titiler/core/middleware.py
+++ b/src/titiler/core/titiler/core/middleware.py
@@ -1,38 +1,35 @@
 """Titiler middlewares."""
 
+from __future__ import annotations
+
 import logging
 import re
 import time
-from typing import Optional, Set
+from dataclasses import dataclass, field
+from urllib.parse import urlencode
 
-from fastapi.logger import logger
 from starlette.datastructures import MutableHeaders
 from starlette.requests import Request
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
+from titiler.core import telemetry
+
 
+@dataclass(frozen=True)
 class CacheControlMiddleware:
-    """MiddleWare to add CacheControl in response headers."""
-
-    def __init__(
-        self,
-        app: ASGIApp,
-        cachecontrol: Optional[str] = None,
-        cachecontrol_max_http_code: Optional[int] = 500,
-        exclude_path: Optional[Set[str]] = None,
-    ) -> None:
-        """Init Middleware.
-
-        Args:
-            app (ASGIApp): starlette/FastAPI application.
-            cachecontrol (str): Cache-Control string to add to the response.
-            exclude_path (set): Set of regex expression to use to filter the path.
-
-        """
-        self.app = app
-        self.cachecontrol = cachecontrol
-        self.cachecontrol_max_http_code = cachecontrol_max_http_code
-        self.exclude_path = exclude_path or set()
+    """MiddleWare to add CacheControl in response headers.
+
+    Args:
+        app (ASGIApp): starlette/FastAPI application.
+        cachecontrol (str): Cache-Control string to add to the response.
+        exclude_path (set): Set of regex expression to use to filter the path.
+
+    """
+
+    app: ASGIApp
+    cachecontrol: str | None = None
+    cachecontrol_max_http_code: int = 500
+    exclude_path: set[str] = field(default_factory=set)
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send):
         """Handle call."""
@@ -49,10 +46,7 @@ async def send_wrapper(message: Message):
                         scope["method"] in ["HEAD", "GET"]
                         and message["status"] < self.cachecontrol_max_http_code
                         and not any(
-                            [
-                                re.match(path, scope["path"])
-                                for path in self.exclude_path
-                            ]
+                            re.match(path, scope["path"]) for path in self.exclude_path
                         )
                     ):
                         response_headers["Cache-Control"] = self.cachecontrol
@@ -62,17 +56,16 @@ async def send_wrapper(message: Message):
         await self.app(scope, receive, send_wrapper)
 
 
+@dataclass(frozen=True)
 class TotalTimeMiddleware:
-    """MiddleWare to add Total process time in response headers."""
+    """MiddleWare to add Total process time in response headers.
 
-    def __init__(self, app: ASGIApp) -> None:
-        """Init Middleware.
+    Args:
+        app (ASGIApp): starlette/FastAPI application.
 
-        Args:
-            app (ASGIApp): starlette/FastAPI application.
+    """
 
-        """
-        self.app = app
+    app: ASGIApp
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send):
         """Handle call."""
@@ -84,6 +77,8 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send):
 
         async def send_wrapper(message: Message):
             """Send Message."""
+            nonlocal start_time
+
             if message["type"] == "http.response.start":
                 response_headers = MutableHeaders(scope=message)
                 process_time = time.time() - start_time
@@ -99,70 +94,82 @@ async def send_wrapper(message: Message):
         await self.app(scope, receive, send_wrapper)
 
 
+@dataclass(frozen=True)
 class LoggerMiddleware:
     """MiddleWare to add logging."""
 
-    def __init__(
-        self,
-        app: ASGIApp,
-        querystrings: bool = False,
-        headers: bool = False,
-    ) -> None:
-        """Init Middleware.
-
-        Args:
-            app (ASGIApp): starlette/FastAPI application.
-
-        """
-        self.app = app
-        self.querystrings = querystrings
-        self.headers = headers
-        self.logger = logger
-        logger.setLevel(logging.DEBUG)
+    app: ASGIApp
+    logger: logging.Logger = field(
+        default_factory=lambda: logging.getLogger("titiler.requests")
+    )
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send):
         """Handle call."""
-        if scope["type"] == "http":
-            request = Request(scope)
-
-            self.logger.debug(str(request.url))
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        request = Request(scope, receive=receive)
+        data = {
+            "http.method": request.method,
+            "http.url": str(request.url),
+            "http.scheme": request.url.scheme,
+            "http.host": request.headers.get("host", request.url.hostname or "unknown"),
+            "http.target": request.url.path
+            + (f"?{request.url.query}" if request.url.query else ""),
+            "http.user_agent": request.headers.get("user-agent"),
+            "http.referer": next(
+                (request.headers.get(attr) for attr in ["referer", "referrer"]),
+                None,
+            ),
+            "http.request.header.content-length": request.headers.get("content-length"),
+            "http.request.header.accept-encoding": request.headers.get(
+                "accept-encoding"
+            ),
+            "http.request.header.origin": request.headers.get("origin"),
+            "net.host.name": request.url.hostname,
+            "net.host.port": request.url.port,
+            "titiler.query_params": dict(request.query_params),
+        }
+
+        telemetry.add_span_attributes(telemetry.flatten_dict(data))
+
+        exception: Exception | None = None
+        try:
+            await self.app(scope, receive, send)
+        except Exception as e:
+            exception = e
 
-            qs = dict(request.query_params)
-            if qs and self.querystrings:
-                self.logger.debug(qs)
+        if route := scope.get("route"):
+            data["http.route"] = route.path
 
-            if self.headers:
-                self.logger.debug(dict(request.headers))
+        data["titiler.path_params"] = request.path_params
 
-        await self.app(scope, receive, send)
+        self.logger.info(
+            f"Request received: {request.url.path} {request.method}",
+            extra=data,
+        )
+        if exception:
+            raise exception
 
 
+@dataclass(frozen=True)
 class LowerCaseQueryStringMiddleware:
     """Middleware to make URL parameters case-insensitive.
     taken from: https://github.com/tiangolo/fastapi/issues/826
-    """
 
-    def __init__(self, app: ASGIApp) -> None:
-        """Init Middleware.
-
-        Args:
-            app (ASGIApp): starlette/FastAPI application.
+    """
 
-        """
-        self.app = app
+    app: ASGIApp
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send):
         """Handle call."""
         if scope["type"] == "http":
             request = Request(scope)
-
             DECODE_FORMAT = "latin-1"
-
-            query_string = ""
-            for k, v in request.query_params.multi_items():
-                query_string += k.lower() + "=" + v + "&"
-
-            query_string = query_string[:-1]
+            query_items = [
+                (k.lower(), v) for k, v in request.query_params.multi_items()
+            ]
+            query_string = urlencode(query_items, doseq=True)
             request.scope["query_string"] = query_string.encode(DECODE_FORMAT)
 
         await self.app(scope, receive, send)
diff --git a/src/titiler/core/titiler/core/models/OGC.py b/src/titiler/core/titiler/core/models/OGC.py
index 6b735dff2..c09be7779 100644
--- a/src/titiler/core/titiler/core/models/OGC.py
+++ b/src/titiler/core/titiler/core/models/OGC.py
@@ -1,48 +1,663 @@
 """OGC models."""
 
+from datetime import datetime
+from typing import Annotated, Literal
 
-from typing import List
+from morecantile.models import CRSType
+from pydantic import AnyUrl, BaseModel, Field, RootModel
 
-from pydantic import AnyHttpUrl, BaseModel
+from titiler.core.models.common import Link
 
 
-class TileMatrixSetLink(BaseModel):
+class TileMatrixSetRef(BaseModel):
     """
-    TileMatrixSetLink model.
+    TileMatrixSetRef model.
 
     Based on http://docs.opengeospatial.org/per/19-069.html#_tilematrixsets
+    """
+
+    id: str
+    title: str | None = None
+    links: list[Link]
+
+
+class TileMatrixSetList(BaseModel):
+    """
+    TileMatrixSetList model.
 
+    Based on http://docs.opengeospatial.org/per/19-069.html#_tilematrixsets
     """
 
-    href: AnyHttpUrl
-    rel: str = "item"
-    type: str = "application/json"
+    tileMatrixSets: list[TileMatrixSetRef]
 
-    class Config:
-        """Config for model."""
 
-        use_enum_values = True
+class TimeStamp(RootModel):
+    """TimeStamp model.
 
+    Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/common-geodata/timeStamp.yaml
 
-class TileMatrixSetRef(BaseModel):
+    Code generated using https://github.com/koxudaxi/datamodel-code-generator/
     """
-    TileMatrixSetRef model.
 
-    Based on http://docs.opengeospatial.org/per/19-069.html#_tilematrixsets
+    root: Annotated[
+        datetime,
+        Field(
+            json_schema_extra={
+                "description": "This property indicates the time and date when the response was generated using RFC 3339 notation.",
+                "examples": ["2017-08-17T08:05:32Z"],
+            }
+        ),
+    ]
+
 
+class BoundingBox(BaseModel):
+    """BoundingBox model.
+
+    Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/2DBoundingBox.yaml
+
+    Code generated using https://github.com/koxudaxi/datamodel-code-generator/
     """
 
-    id: str
-    title: str
-    links: List[TileMatrixSetLink]
+    lowerLeft: Annotated[
+        list[float],
+        Field(
+            max_length=2,
+            min_length=2,
+            json_schema_extra={
+                "description": "A 2D Point in the CRS indicated elsewhere",
+            },
+        ),
+    ]
+    upperRight: Annotated[
+        list[float],
+        Field(
+            max_length=2,
+            min_length=2,
+            json_schema_extra={
+                "description": "A 2D Point in the CRS indicated elsewhere",
+            },
+        ),
+    ]
+    crs: Annotated[CRSType | None, Field(json_schema_extra={"title": "CRS"})] = None
+    orderedAxes: Annotated[list[str] | None, Field(max_length=2, min_length=2)] = None
 
 
-class TileMatrixSetList(BaseModel):
+# Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/propertiesSchema.yaml
+Type = Literal["array", "boolean", "integer", "null", "number", "object", "string"]
+
+# Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/propertiesSchema.yaml
+AccessConstraints = Literal[
+    "unclassified", "restricted", "confidential", "secret", "topSecret"
+]
+
+
+class Properties(BaseModel):
+    """Properties model.
+
+    Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/propertiesSchema.yaml
+
+    Code generated using https://github.com/koxudaxi/datamodel-code-generator/
     """
-    TileMatrixSetList model.
 
-    Based on http://docs.opengeospatial.org/per/19-069.html#_tilematrixsets
+    title: str | None = None
+    description: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Implements 'description'",
+            }
+        ),
+    ] = None
+    type: Type | None = None
+    enum: Annotated[
+        set | None,
+        Field(
+            min_length=1,
+            json_schema_extra={
+                "description": "Implements 'acceptedValues'",
+            },
+        ),
+    ] = None
+    format: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Complements implementation of 'type'",
+            }
+        ),
+    ] = None
+    contentMediaType: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Implements 'mediaType'",
+            }
+        ),
+    ] = None
+    maximum: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Implements 'range'",
+            }
+        ),
+    ] = None
+    exclusiveMaximum: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Implements 'range'",
+            }
+        ),
+    ] = None
+    minimum: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Implements 'range'",
+            }
+        ),
+    ] = None
+    exclusiveMinimum: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Implements 'range'",
+            }
+        ),
+    ] = None
+    pattern: str | None = None
+    maxItems: Annotated[
+        int | None,
+        Field(
+            ge=0,
+            json_schema_extra={
+                "description": "Implements 'upperMultiplicity'",
+            },
+        ),
+    ] = None
+    minItems: Annotated[
+        int | None,
+        Field(
+            ge=0,
+            json_schema_extra={
+                "description": "Implements 'lowerMultiplicity'",
+            },
+        ),
+    ] = 0
+    observedProperty: str | None = None
+    observedPropertyURI: AnyUrl | None = None
+    uom: str | None = None
+    uomURI: AnyUrl | None = None
+
+
+class PropertiesSchema(BaseModel):
+    """PropertiesSchema model.
+
+    Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/propertiesSchema.yaml
+
+    Code generated using https://github.com/koxudaxi/datamodel-code-generator/
+    """
+
+    type: Literal["object"]
+    required: Annotated[
+        list[str] | None,
+        Field(
+            min_length=1,
+            json_schema_extra={
+                "description": "Implements 'multiplicity' by citing property 'name' defined as 'additionalProperties'",
+            },
+        ),
+    ] = None
+    properties: dict[str, Properties]
+
+
+class Style(BaseModel):
+    """Style model.
+
+    Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/style.yaml
+
+    Code generated using https://github.com/koxudaxi/datamodel-code-generator/
+    """
+
+    id: Annotated[
+        str,
+        Field(
+            json_schema_extra={
+                "description": "An identifier for this style. Implementation of 'identifier'",
+            }
+        ),
+    ]
+    title: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "A title for this style",
+            }
+        ),
+    ] = None
+    description: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Brief narrative description of this style",
+            }
+        ),
+    ] = None
+    keywords: Annotated[
+        list[str] | None,
+        Field(
+            json_schema_extra={
+                "description": "keywords about this style",
+            }
+        ),
+    ] = None
+    links: Annotated[
+        list[Link] | None,
+        Field(
+            min_length=1,
+            json_schema_extra={
+                "description": "Links to style related resources. Possible link 'rel' values are: 'style' for a URL pointing to the style description, 'styleSpec' for a URL pointing to the specification or standard used to define the style.",
+            },
+        ),
+    ] = None
+
+
+class GeospatialData(BaseModel):
+    """Geospatial model.
+
+    Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/geospatialData.yaml
+
+    Code generated using https://github.com/koxudaxi/datamodel-code-generator/
+    """
+
+    title: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Title of this tile matrix set, normally used for display to a human",
+            }
+        ),
+    ] = None
+    description: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Brief narrative description of this tile matrix set, normally available for display to a human",
+            }
+        ),
+    ] = None
+    keywords: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Unordered list of one or more commonly used or formalized word(s) or phrase(s) used to describe this layer",
+            }
+        ),
+    ] = None
+    id: Annotated[
+        str,
+        Field(
+            json_schema_extra={
+                "description": "Unique identifier of the Layer. Implementation of 'identifier'",
+            }
+        ),
+    ]
+    dataType: Annotated[
+        Literal["map", "vector", "coverage"],
+        Field(
+            json_schema_extra={
+                "description": "Type of data represented in the tileset",
+            }
+        ),
+    ]
+    geometryDimension: Annotated[
+        int | None,
+        Field(  # type: ignore
+            ge=0,
+            le=3,
+            json_schema_extra={
+                "description": "The geometry dimension of the features shown in this layer (0: points, 1: curves, 2: surfaces, 3: solids), unspecified: mixed or unknown",
+            },
+        ),
+    ] = None
+    featureType: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Feature type identifier. Only applicable to layers of datatype 'geometries'",
+            }
+        ),
+    ] = None
+    attribution: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Short reference to recognize the author or provider",
+            }
+        ),
+    ] = None
+    license: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "License applicable to the tiles",
+            }
+        ),
+    ] = None
+    pointOfContact: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Useful information to contact the authors or custodians for the layer (e.g. e-mail address, a physical address,  phone numbers, etc)",
+            }
+        ),
+    ] = None
+    publisher: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Organization or individual responsible for making the layer available",
+            }
+        ),
+    ] = None
+    theme: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Category where the layer can be grouped",
+            }
+        ),
+    ] = None
+    crs: Annotated[CRSType | None, Field(json_schema_extra={"title": "CRS"})] = None
+    epoch: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Epoch of the Coordinate Reference System (CRS)",
+            }
+        ),
+    ] = None
+    minScaleDenominator: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Minimum scale denominator for usage of the layer",
+            }
+        ),
+    ] = None
+    maxScaleDenominator: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Maximum scale denominator for usage of the layer",
+            }
+        ),
+    ] = None
+    minCellSize: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Minimum cell size for usage of the layer",
+            }
+        ),
+    ] = None
+    maxCellSize: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Maximum cell size for usage of the layer",
+            }
+        ),
+    ] = None
+    maxTileMatrix: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "TileMatrix identifier associated with the minScaleDenominator",
+            }
+        ),
+    ] = None
+    minTileMatrix: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "TileMatrix identifier associated with the maxScaleDenominator",
+            }
+        ),
+    ] = None
+    boundingBox: BoundingBox | None = None
+    created: TimeStamp | None = None
+    updated: TimeStamp | None = None
+    style: Style | None = None
+    geoDataClasses: Annotated[
+        list[str] | None,
+        Field(
+            json_schema_extra={
+                "description": "URI identifying a class of data contained in this layer (useful to determine compatibility with styles or processes)",
+            }
+        ),
+    ] = None
+    propertiesSchema: PropertiesSchema | None = None
+    links: Annotated[
+        list[Link] | None,
+        Field(
+            min_length=1,
+            json_schema_extra={
+                "description": "Links related to this layer. Possible link 'rel' values are: 'geodata' for a URL pointing to the collection of geospatial data.",
+            },
+        ),
+    ] = None
+
+
+class TilePoint(BaseModel):
+    """TilePoint model.
+
+    Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/tilePoint.yaml
+
+    Code generated using https://github.com/koxudaxi/datamodel-code-generator/
+    """
+
+    coordinates: Annotated[list[float], Field(max_length=2, min_length=2)]
+    crs: Annotated[CRSType | None, Field(json_schema_extra={"title": "CRS"})]
+    tileMatrix: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "TileMatrix identifier associated with the scaleDenominator",
+            }
+        ),
+    ] = None
+    scaleDenominator: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Scale denominator of the tile matrix selected",
+            }
+        ),
+    ] = None
+    cellSize: Annotated[
+        float | None,
+        Field(
+            json_schema_extra={
+                "description": "Cell size of the tile matrix selected",
+            }
+        ),
+    ] = None
+
+
+class TileMatrixLimits(BaseModel):
+    """
+    The limits for an individual tile matrix of a TileSet's TileMatrixSet, as defined in the OGC 2D TileMatrixSet and TileSet Metadata Standard
+
+    Based on https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/tileMatrixLimits.yaml
+    """
+
+    tileMatrix: str
+    minTileRow: Annotated[int, Field(ge=0)]
+    maxTileRow: Annotated[int, Field(ge=0)]
+    minTileCol: Annotated[int, Field(ge=0)]
+    maxTileCol: Annotated[int, Field(ge=0)]
+
+
+class TileSet(BaseModel):
+    """
+    TileSet model.
+
+    Based on https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/tms/tileSet.yaml
+    """
+
+    title: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "A title for this tileset",
+            }
+        ),
+    ] = None
+    description: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Brief narrative description of this tile set",
+            }
+        ),
+    ] = None
+    dataType: Annotated[
+        Literal["map", "vector", "coverage"],
+        Field(
+            json_schema_extra={
+                "description": "Type of data represented in the tileset",
+            }
+        ),
+    ]
+    crs: Annotated[CRSType, Field(json_schema_extra={"title": "CRS"})]
+    tileMatrixSetURI: Annotated[
+        AnyUrl | None,
+        Field(
+            json_schema_extra={
+                "description": "Reference to a Tile Matrix Set on an official source for Tile Matrix Sets",
+            }
+        ),
+    ] = None
+    links: Annotated[
+        list[Link],
+        Field(
+            json_schema_extra={
+                "description": "Links to related resources",
+            }
+        ),
+    ]
+    tileMatrixSetLimits: Annotated[
+        list[TileMatrixLimits] | None,
+        Field(
+            json_schema_extra={
+                "description": "Limits for the TileRow and TileCol values for each TileMatrix in the tileMatrixSet. If missing, there are no limits other that the ones imposed by the TileMatrixSet. If present the TileMatrices listed are limited and the rest not available at all",
+            }
+        ),
+    ] = None
+    epoch: Annotated[
+        float | int | None,
+        Field(
+            json_schema_extra={
+                "description": "Epoch of the Coordinate Reference System (CRS)",
+            }
+        ),
+    ] = None
+    layers: Annotated[
+        list[GeospatialData] | None,
+        Field(min_length=1),
+    ] = None
+    boundingBox: BoundingBox | None = None
+    centerPoint: TilePoint | None = None
+    style: Style | None = None
+    attribution: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Short reference to recognize the author or provider",
+            }
+        ),
+    ] = None
+    license: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "License applicable to the tiles",
+            }
+        ),
+    ] = None
+    accessConstraints: Annotated[
+        AccessConstraints | None,
+        Field(
+            json_schema_extra={
+                "description": "Restrictions on the availability of the Tile Set that the user needs to be aware of before using or redistributing the Tile Set",
+            }
+        ),
+    ] = "unclassified"
+    keywords: Annotated[
+        list[str] | None,
+        Field(
+            json_schema_extra={
+                "description": "keywords about this tileset",
+            }
+        ),
+    ] = None
+    version: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Version of the Tile Set. Changes if the data behind the tiles has been changed",
+            }
+        ),
+    ] = None
+    created: TimeStamp | None = None
+    updated: TimeStamp | None = None
+    pointOfContact: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Useful information to contact the authors or custodians for the Tile Set",
+            }
+        ),
+    ] = None
+    mediaTypes: Annotated[
+        list[str] | None,
+        Field(
+            json_schema_extra={
+                "description": "Media types available for the tiles",
+            }
+        ),
+    ] = None
+
+
+class TileSetList(BaseModel):
+    """
+    TileSetList model.
+
+    Based on https://docs.ogc.org/is/20-057/20-057.html#toc34
+    """
+
+    tilesets: list[TileSet]
+
+
+class Conformance(BaseModel):
+    """Conformance model.
+
+    Ref: http://schemas.opengis.net/ogcapi/features/part1/1.0/openapi/schemas/confClasses.yaml
+
+    """
+
+    conformsTo: list[str]
+
+
+class Landing(BaseModel):
+    """Landing page model.
+
+    Ref: http://schemas.opengis.net/ogcapi/features/part1/1.0/openapi/schemas/landingPage.yaml
 
     """
 
-    tileMatrixSets: List[TileMatrixSetRef]
+    title: str | None = None
+    description: str | None = None
+    links: list[Link]
diff --git a/src/titiler/core/titiler/core/models/common.py b/src/titiler/core/titiler/core/models/common.py
new file mode 100644
index 000000000..56477e14c
--- /dev/null
+++ b/src/titiler/core/titiler/core/models/common.py
@@ -0,0 +1,80 @@
+"""titiler.core.models.common"""
+
+from typing import Annotated
+
+from pydantic import AnyUrl, BaseModel, Field
+
+
+class Link(BaseModel):
+    """Link model.
+
+    Ref: https://github.com/opengeospatial/ogcapi-tiles/blob/master/openapi/schemas/common-core/link.yaml
+
+    Code generated using https://github.com/koxudaxi/datamodel-code-generator/
+    """
+
+    href: Annotated[
+        AnyUrl,
+        Field(
+            json_schema_extra={
+                "description": "Supplies the URI to a remote resource (or resource fragment).",
+                "examples": ["http://data.example.com/buildings/123"],
+            }
+        ),
+    ]
+    rel: Annotated[
+        str,
+        Field(
+            json_schema_extra={
+                "description": "The type or semantics of the relation.",
+                "examples": ["alternate"],
+            }
+        ),
+    ]
+    type: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "A hint indicating what the media type of the result of dereferencing the link should be.",
+                "examples": ["application/geo+json"],
+            }
+        ),
+    ] = None
+    templated: Annotated[
+        bool | None,
+        Field(
+            json_schema_extra={
+                "description": "This flag set to true if the link is a URL template.",
+            }
+        ),
+    ] = None
+    varBase: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "A base path to retrieve semantic information about the variables used in URL template.",
+                "examples": ["/ogcapi/vars/"],
+            }
+        ),
+    ] = None
+    hreflang: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "A hint indicating what the language of the result of dereferencing the link should be.",
+                "examples": ["en"],
+            }
+        ),
+    ] = None
+    title: Annotated[
+        str | None,
+        Field(
+            json_schema_extra={
+                "description": "Used to label the destination of a link such that it can be used as a human-readable identifier.",
+                "examples": ["Trierer Strasse 70, 53115 Bonn"],
+            }
+        ),
+    ] = None
+    length: int | None = None
+
+    model_config = {"use_enum_values": True}
diff --git a/src/titiler/core/titiler/core/models/mapbox.py b/src/titiler/core/titiler/core/models/mapbox.py
index 755ce6901..1cdf3d2e7 100644
--- a/src/titiler/core/titiler/core/models/mapbox.py
+++ b/src/titiler/core/titiler/core/models/mapbox.py
@@ -1,55 +1,56 @@
 """Common response models."""
 
-from enum import Enum
-from typing import List, Optional, Tuple
+from typing import Annotated, Literal
 
-from pydantic import BaseModel, Field, root_validator
+from pydantic import BaseModel, Field, model_validator
 
 
-class SchemeEnum(str, Enum):
-    """TileJSON scheme choice."""
+class LayerJSON(BaseModel):
+    """
+    https://github.com/mapbox/tilejson-spec/tree/master/3.0.0#33-vector_layers
+    """
 
-    xyz = "xyz"
-    tms = "tms"
+    id: str
+    fields: Annotated[dict, Field(default_factory=dict)]
+    description: str | None = None
+    minzoom: int | None = None
+    maxzoom: int | None = None
 
 
-class TileJSON(BaseModel):
+class TileJSON(BaseModel, extra="allow"):
     """
     TileJSON model.
 
-    Based on https://github.com/mapbox/tilejson-spec/tree/master/2.2.0
+    Based on https://github.com/mapbox/tilejson-spec/tree/master/3.0.0
 
     """
 
-    tilejson: str = "2.2.0"
-    name: Optional[str]
-    description: Optional[str]
+    tilejson: str = "3.0.0"
+    name: str | None = None
+    description: str | None = None
     version: str = "1.0.0"
-    attribution: Optional[str]
-    template: Optional[str]
-    legend: Optional[str]
-    scheme: SchemeEnum = SchemeEnum.xyz
-    tiles: List[str]
-    grids: Optional[List[str]]
-    data: Optional[List[str]]
-    minzoom: int = Field(0, ge=0, le=30)
-    maxzoom: int = Field(30, ge=0, le=30)
-    bounds: List[float] = [-180, -90, 180, 90]
-    center: Optional[Tuple[float, float, int]]
-
-    @root_validator
-    def compute_center(cls, values):
+    attribution: str | None = None
+    template: str | None = None
+    legend: str | None = None
+    scheme: Literal["xyz", "tms"] = "xyz"
+    tiles: list[str]
+    vector_layers: list[LayerJSON] | None = None
+    grids: list[str] | None = None
+    data: list[str] | None = None
+    minzoom: int = Field(0)
+    maxzoom: int = Field(30)
+    fillzoom: int | None = None
+    bounds: list[float] = [-180, -85.0511287798066, 180, 85.0511287798066]
+    center: tuple[float, float, int] | None = None
+
+    @model_validator(mode="after")
+    def compute_center(self):
         """Compute center if it does not exist."""
-        bounds = values["bounds"]
-        if not values.get("center"):
-            values["center"] = (
+        bounds = self.bounds
+        if not self.center:
+            self.center = (
                 (bounds[0] + bounds[2]) / 2,
                 (bounds[1] + bounds[3]) / 2,
-                values["minzoom"],
+                self.minzoom,
             )
-        return values
-
-    class Config:
-        """TileJSON model configuration."""
-
-        use_enum_values = True
+        return self
diff --git a/src/titiler/core/titiler/core/models/responses.py b/src/titiler/core/titiler/core/models/responses.py
index 7932c02e8..cbf818f55 100644
--- a/src/titiler/core/titiler/core/models/responses.py
+++ b/src/titiler/core/titiler/core/models/responses.py
@@ -1,12 +1,12 @@
 """TiTiler response models."""
 
-from typing import Dict, List, Union
-
 from geojson_pydantic.features import Feature, FeatureCollection
-from geojson_pydantic.geometries import Geometry, Polygon
+from geojson_pydantic.geometries import Geometry, MultiPolygon, Polygon
 from pydantic import BaseModel
 from rio_tiler.models import BandStatistics, Info
 
+from titiler.core.models.common import Link
+
 
 class Point(BaseModel):
     """
@@ -16,13 +16,14 @@ class Point(BaseModel):
 
     """
 
-    coordinates: List[float]
-    values: List[float]
-    band_names: List[str]
+    coordinates: list[float]
+    values: list[float | None]
+    band_names: list[str]
+    band_descriptions: list[str] | None = None
 
 
-InfoGeoJSON = Feature[Polygon, Info]
-Statistics = Dict[str, BandStatistics]
+InfoGeoJSON = Feature[Polygon | MultiPolygon, Info]
+Statistics = dict[str, BandStatistics]
 
 
 class StatisticsInGeoJSON(BaseModel):
@@ -30,23 +31,31 @@ class StatisticsInGeoJSON(BaseModel):
 
     statistics: Statistics
 
-    class Config:
-        """Config for model."""
-
-        extra = "allow"
+    model_config = {"extra": "allow"}
 
 
-StatisticsGeoJSON = Union[
-    FeatureCollection[Geometry, StatisticsInGeoJSON],
-    Feature[Geometry, StatisticsInGeoJSON],
-]
+StatisticsGeoJSON = (
+    FeatureCollection[Feature[Geometry, StatisticsInGeoJSON]]
+    | Feature[Geometry, StatisticsInGeoJSON]
+)
 
 # MultiBase Models
-MultiBaseInfo = Dict[str, Info]
-MultiBaseInfoGeoJSON = Feature[Polygon, MultiBaseInfo]
-
-MultiBaseStatistics = Dict[str, Statistics]
-MultiBaseStatisticsGeoJSON = Union[
-    FeatureCollection[Geometry, StatisticsInGeoJSON],
-    Feature[Geometry, StatisticsInGeoJSON],
-]
+MultiBaseInfo = dict[str, Info]
+MultiBaseInfoGeoJSON = Feature[Polygon | MultiPolygon, MultiBaseInfo]
+
+MultiBaseStatistics = dict[str, Statistics]
+MultiBaseStatisticsGeoJSON = StatisticsGeoJSON
+
+
+class ColorMapRef(BaseModel):
+    """ColorMapRef model."""
+
+    id: str
+    title: str | None = None
+    links: list[Link]
+
+
+class ColorMapList(BaseModel):
+    """Model for colormap list."""
+
+    colormaps: list[ColorMapRef]
diff --git a/src/titiler/core/titiler/core/py.typed b/src/titiler/core/titiler/core/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/titiler/core/titiler/core/resources/enums.py b/src/titiler/core/titiler/core/resources/enums.py
index 1f0fbfa32..11915cbc5 100644
--- a/src/titiler/core/titiler/core/resources/enums.py
+++ b/src/titiler/core/titiler/core/resources/enums.py
@@ -10,6 +10,7 @@ class MediaType(str, Enum):
     """Responses Media types formerly known as MIME types."""
 
     tif = "image/tiff; application=geotiff"
+    tiff = "image/tiff; application=geotiff"
     jp2 = "image/jp2"
     png = "image/png"
     pngraw = "image/png"
@@ -23,7 +24,14 @@ class MediaType(str, Enum):
     html = "text/html"
     text = "text/plain"
     pbf = "application/x-protobuf"
-    mvt = "application/x-protobuf"
+    mvt = "application/vnd.mapbox-vector-tile"
+    ndjson = "application/ndjson"
+    geojsonseq = "application/geo+json-seq"
+    schemajson = "application/schema+json"
+    csv = "text/csv"
+    openapi30_json = "application/vnd.oai.openapi+json;version=3.0"
+    openapi30_yaml = "application/vnd.oai.openapi;version=3.0"
+    gif = "image/gif"
 
 
 class ImageDriver(str, Enum):
@@ -34,9 +42,11 @@ class ImageDriver(str, Enum):
     png = "PNG"
     pngraw = "PNG"
     tif = "GTiff"
+    tiff = "GTiff"
     webp = "WEBP"
     jp2 = "JP2OpenJPEG"
     npy = "NPY"
+    gif = "GIF"
 
 
 class ImageType(str, Enum):
@@ -45,6 +55,7 @@ class ImageType(str, Enum):
     png = "png"
     npy = "npy"
     tif = "tif"
+    tiff = "tiff"
     jpeg = "jpeg"
     jpg = "jpg"
     jp2 = "jp2"
diff --git a/src/titiler/core/titiler/core/resources/responses.py b/src/titiler/core/titiler/core/resources/responses.py
index cd37a6a85..3a99d6be5 100644
--- a/src/titiler/core/titiler/core/resources/responses.py
+++ b/src/titiler/core/titiler/core/resources/responses.py
@@ -2,6 +2,7 @@
 
 from typing import Any
 
+import numpy
 import simplejson as json
 from starlette import responses
 
@@ -12,6 +13,16 @@ class XMLResponse(responses.Response):
     media_type = "application/xml"
 
 
+class NumpyEncoder(json.JSONEncoder):
+    """Custom JSON Encoder."""
+
+    def default(self, obj):
+        """Catch numpy types and convert them."""
+        if isinstance(obj, (numpy.ndarray, numpy.generic)):
+            return obj.tolist()
+        return super().default(obj)
+
+
 class JSONResponse(responses.JSONResponse):
     """Custom JSON Response."""
 
@@ -27,6 +38,7 @@ def render(self, content: Any) -> bytes:
             indent=None,
             ignore_nan=True,
             separators=(",", ":"),
+            cls=NumpyEncoder,
         ).encode("utf-8")
 
 
diff --git a/src/titiler/core/titiler/core/routing.py b/src/titiler/core/titiler/core/routing.py
index 28b66d6ec..f6a443c38 100644
--- a/src/titiler/core/titiler/core/routing.py
+++ b/src/titiler/core/titiler/core/routing.py
@@ -1,58 +1,11 @@
 """Custom routing classes."""
 
-import sys
-import warnings
-from typing import Callable, Dict, List, Optional, Type
+from typing import TypedDict
 
-import rasterio
 from fastapi import params
 from fastapi.dependencies.utils import get_parameterless_sub_dependant
-from fastapi.routing import APIRoute
-from starlette.requests import Request
-from starlette.responses import Response
 from starlette.routing import BaseRoute, Match
 
-if sys.version_info >= (3, 8):
-    from typing import TypedDict  # pylint: disable=no-name-in-module
-else:
-    from typing_extensions import TypedDict
-
-
-def apiroute_factory(env: Optional[Dict] = None) -> Type[APIRoute]:
-    """
-    Create Custom API Route class with custom Env.
-
-    Because we cannot create middleware for specific router we need to create
-    a custom APIRoute which add the `rasterio.Env(` block before the endpoint is
-    actually called. This way we set the env outside the threads and we make sure
-    that event multithreaded Reader will get the environment set.
-
-    Note: This has been tested in python 3.6 and 3.7 only.
-
-    """
-    warnings.warn(
-        "'apiroute_factory' has been deprecated and will be removed"
-        "in titiler 0.1.0. Please see `environment_dependency` option in endpoint factories.",
-        DeprecationWarning,
-    )
-
-    class EnvAPIRoute(APIRoute):
-        """Custom API route with env."""
-
-        config = env or {}
-
-        def get_route_handler(self) -> Callable:
-            original_route_handler = super().get_route_handler()
-
-            async def custom_route_handler(request: Request) -> Response:
-                with rasterio.Env(**self.config):
-                    response: Response = await original_route_handler(request)
-                return response
-
-            return custom_route_handler
-
-    return EnvAPIRoute
-
 
 class EndpointScope(TypedDict, total=False):
     """Define endpoint."""
@@ -61,14 +14,14 @@ class EndpointScope(TypedDict, total=False):
     # https://github.com/encode/starlette/blob/6af5c515e0a896cbf3f86ee043b88f6c24200bcf/starlette/types.py#L3
     path: str
     method: str
-    type: Optional[str]  # http or websocket
+    type: str | None  # http or websocket
 
 
 def add_route_dependencies(
-    routes: List[BaseRoute],
+    routes: list[BaseRoute],
     *,
-    scopes: List[EndpointScope],
-    dependencies=List[params.Depends],
+    scopes: list[EndpointScope],
+    dependencies=list[params.Depends],
 ):
     """Add dependencies to routes.
 
@@ -87,7 +40,8 @@ def add_route_dependencies(
                 route.dependant.dependencies.insert(  # type: ignore
                     0,
                     get_parameterless_sub_dependant(
-                        depends=depends, path=route.path_format  # type: ignore
+                        depends=depends,
+                        path=route.path_format,  # type: ignore
                     ),
                 )
 
diff --git a/src/titiler/core/titiler/core/telemetry.py b/src/titiler/core/titiler/core/telemetry.py
new file mode 100644
index 000000000..6446edb81
--- /dev/null
+++ b/src/titiler/core/titiler/core/telemetry.py
@@ -0,0 +1,142 @@
+"""OpenTelemetry instrumentation for titiler.core."""
+
+from __future__ import annotations
+
+import functools
+import inspect
+from collections.abc import Callable
+from contextlib import contextmanager
+from typing import Any, Iterator, ParamSpec, TypeVar
+
+from titiler.core import __version__
+
+try:
+    from opentelemetry import trace
+    from opentelemetry.trace import Span, Status, StatusCode
+
+    tracer = trace.get_tracer("titiler.core", __version__)
+except ImportError:
+    trace = None  # type: ignore
+    Span = None  # type: ignore
+    Status = None  # type: ignore
+    StatusCode = None  # type: ignore
+    tracer = None  # type: ignore
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def add_span_attributes(attributes: dict[str, Any]) -> None:
+    """Adds attributes to the current active span."""
+    if not tracer:
+        return
+    span = trace.get_current_span()
+    if span and span.is_recording():
+        span.set_attributes(attributes)
+
+
+def flatten_dict(d: dict, parent_key: str = "", sep: str = ".") -> dict:
+    """Flattens a nested dictionary for adding span attributes."""
+    items = {}
+    for k, v in d.items():
+        new_key = parent_key + sep + k if parent_key else k
+        if isinstance(v, dict):
+            items.update(flatten_dict(v, new_key, sep=sep))
+        else:
+            if not isinstance(v, (str, bool, int, float)):
+                v = str(v)
+            items[new_key] = v
+    return items
+
+
+class SpanWrapper:
+    """A wrapper class to safely handle an optional OpenTelemetry Span."""
+
+    def __init__(self, span: Span | None):
+        """Set the span"""
+        self._span = span
+
+    def set_attributes(self, attributes: dict[str, Any]) -> None:
+        """Safely set attributes on the wrapped span if it exists."""
+        if self._span:
+            self._span.set_attributes(attributes)
+
+    def record_exception(self, exception: Exception) -> None:
+        """Safely record an exception on the wrapped span if it exists."""
+        if self._span:
+            self._span.record_exception(exception)
+
+
+@contextmanager
+def operation_tracer(
+    operation_name: str,
+    attributes: dict[str, Any] | None = None,
+) -> Iterator[SpanWrapper]:
+    """Context manager for creating granular child spans."""
+    if not tracer:
+        yield SpanWrapper(None)
+        return
+
+    with tracer.start_as_current_span(operation_name) as span:
+        wrapped_span = SpanWrapper(span)
+        if attributes:
+            wrapped_span.set_attributes(attributes)
+        try:
+            yield wrapped_span
+            span.set_status(Status(StatusCode.OK))
+        except Exception as e:
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            raise
+
+
+def _get_span_name(op_name: str, factory_instance: Any) -> str:
+    """Determine the span name using the factory class name."""
+    if not factory_instance:
+        return op_name
+    class_name = factory_instance.__class__.__name__
+    return f"{class_name}.{op_name}"
+
+
+def factory_trace(
+    _func: Callable[P, Any] | None = None,
+    *,
+    factory_instance: Any | None = None,
+) -> Any:
+    """A decorator for Factory methods that automatically handles tracing for factory methods"""
+
+    def decorator(func: Callable[P, Any]) -> Callable[P, Any]:
+        if not tracer:
+            return func
+
+        op_name = func.__name__
+
+        attributes = {}
+        if factory_instance:
+            if hasattr(factory_instance, "reader"):
+                attributes["reader"] = str(factory_instance.reader)
+            if hasattr(factory_instance, "backend"):
+                attributes["backend"] = str(factory_instance.backend)
+
+        if inspect.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
+                span_name = _get_span_name(op_name, factory_instance)
+                with operation_tracer(span_name, attributes=attributes):
+                    return await func(*args, **kwargs)
+
+            return async_wrapper
+        else:
+
+            @functools.wraps(func)
+            def sync_wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
+                span_name = _get_span_name(op_name, factory_instance)
+                with operation_tracer(span_name, attributes=attributes):
+                    return func(*args, **kwargs)
+
+            return sync_wrapper
+
+    return decorator if _func is None else decorator(_func)
+
+
+factory_trace.decorator_enabled = bool(tracer)  # type: ignore [attr-defined]
diff --git a/src/titiler/core/titiler/core/templates/algorithm.html b/src/titiler/core/titiler/core/templates/algorithm.html
new file mode 100644
index 000000000..6bb9c8c06
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/algorithm.html
@@ -0,0 +1,66 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<style>
+  table, th, td {
+    border: 1px solid black;
+    border-collapse: collapse;
+  }
+  th, td {
+    padding: 5px;
+  }
+</style>  
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ response.title}}</h1>
+<p>{{ response.description}}</p>
+
+<div class="row" style="margin-top: 30px;">
+  <div class="col-sm">
+    <h2>Inputs</h2>
+    {% for k, v in response.inputs.items() %}
+    <li><strong>{{ k }}:</strong> {{ v }}</li>
+    {% endfor %}
+    
+    <h2>Outputs</h2>
+    {% for k, v in response.outputs.items() %}
+    <li><strong>{{ k }}:</strong> {{ v }}</li>
+    {% endfor %}
+
+    <h2>Parameters</h2>
+    {% for k, v in response.parameters.items() %}
+    <li><strong>{{ k }}:</strong></li>
+    <table>
+      <tr>
+        <th style="padding: 5px;">Type</th>
+        <th style="padding: 5px;">Default</th>
+        <th style="padding: 5px;">Min</th>
+        <th style="padding: 5px;">Max</th>
+      </tr>
+      <tr>
+          <td style="text-align: right;">{{ v.type }}</td>
+          <td style="text-align: right;">{{ v.default }}</td>
+          <td style="text-align: right;">{{ v.minimum }}</td>
+          <td style="text-align: right;">{{ v.maximum }}</td>
+      </tr>
+    </table>
+    {% endfor %}
+  </div>
+</div>
+{% include "footer.html" %}
diff --git a/src/titiler/core/titiler/core/templates/algorithms.html b/src/titiler/core/titiler/core/templates/algorithms.html
new file mode 100644
index 000000000..14a93e4f8
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/algorithms.html
@@ -0,0 +1,31 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ template.title }}</h1>
+
+<p>This API implements algorithms that are listed below.</p>
+
+<ul>
+{% for algo in response.algorithms %}
+  <li> <a href="{{ algo.links[0].href }}">{{ algo.id }}</a></li>
+{% endfor %}
+</ul>
+
+{% include "footer.html" %}
diff --git a/src/titiler/core/titiler/core/templates/base.html b/src/titiler/core/titiler/core/templates/base.html
new file mode 100644
index 000000000..49764d1b2
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/base.html
@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>{{ template.title }}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.3/css/bootstrap.min.css" />
+    <style>
+      html { position: relative; min-height: 100%; }
+      body { padding-top: 5rem; margin-bottom: 40px; }
+      #page { padding: 1.5rem 1.5rem; }
+      .navbar { border-bottom: 8px solid #3333A4; }
+      .navbar-brand { font-size: 2rem; color: #3333A4 !important; text-shadow: 2px 2px 4px #ccc; }
+      .json-link { font-weight: normal; }
+    </style>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
+    <script src="https://files.dnr.state.mn.us/lib/bootstrap4/javascripts/bootstrap.min.js"></script>
+  </head>
+  <body>
+    <nav class="navbar navbar-expand-md navbar-light fixed-top bg-light">
+      <a href="{{ template.api_root }}" style="width: 35px;height: auto;">
+        <img width=40 src="data:image/png;base64,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" alt="TiTiler">
+      </a>
+      <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbar" aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">
+        <span class="navbar-toggler-icon"></span>
+      </button>
+      <div class="collapse navbar-collapse" id="navbar">
+        <ul class="navbar-nav mr-auto">
+          <li class="nav-item dropdown">
+            <a class="nav-link dropdown-toggle" href="{{ template.api_root }}" id="links" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Links</a>
+            <div class="dropdown-menu" aria-labelledby="account">
+              <a class="dropdown-item" href="{{ template.api_root }}/">Home</a>
+              <a class="dropdown-item" href="{{ template.api_root }}/conformance">Conformance</a>
+              <a class="dropdown-item" href="{{ template.api_root }}/api.html">API Documentation</a>
+            </div>
+          </li>
+        </ul>
+      </div>
+    </nav>
+
+    <main role="main" class="container-fluid">
+      <div id="page">
+        {% block content %}{% endblock %}
+        {% include "debug.html" %}
+      </div>
+    </main>
+  </body>
+</html>
diff --git a/src/titiler/core/titiler/core/templates/colormap.html b/src/titiler/core/titiler/core/templates/colormap.html
new file mode 100644
index 000000000..2bf2b0e95
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/colormap.html
@@ -0,0 +1,37 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<style>
+  table, th, td {
+    border: 1px solid black;
+    border-collapse: collapse;
+  }
+  th, td {
+    padding: 5px;
+  }
+</style>  
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ template.title }}</h1>
+
+<img height=600 src="data:image/png;base64,{{ response }}" alt="{{ template.title }}">
+<div class="row" style="margin-top: 30px;">
+</div>
+
+{% include "footer.html" %}
diff --git a/src/titiler/core/titiler/core/templates/colormaps.html b/src/titiler/core/titiler/core/templates/colormaps.html
new file mode 100644
index 000000000..778c45717
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/colormaps.html
@@ -0,0 +1,31 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ template.title }}</h1>
+
+<p>This API implements ColorMaps that are listed below.</p>
+
+<ul>
+{% for cmap in response.colormaps %}
+  <li> <a href="{{ cmap.links[0].href }}">{{ cmap.id }}</a></li>
+{% endfor %}
+</ul>
+
+{% include "footer.html" %}
diff --git a/src/titiler/core/titiler/core/templates/debug.html b/src/titiler/core/titiler/core/templates/debug.html
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/titiler/core/titiler/core/templates/footer.html b/src/titiler/core/titiler/core/templates/footer.html
new file mode 100644
index 000000000..0519bcd8d
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/footer.html
@@ -0,0 +1,16 @@
+        {% include "debug.html" %}
+      </div>
+    </main>
+
+    <div class="fixed-bottom">
+      <div style="padding: 10px;"">
+        <span>Created by </span>
+        </br>
+        <a href="https://www.developmentseed.org/" target="_blank">
+          <img width=200 src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" viewBox="0 0 188 32" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
    <rect id="hor--pos" x="0" y="0" width="188" height="32" style="fill:none;"/>
    <g id="hor--pos1" serif:id="hor--pos">
        <g id="text">
            <path d="M49,6L49,10.9C49,10.8 48.2,10.8 47.9,10.7C47.6,10.7 47.3,10.6 46.8,10.6C46,10.6 45.2,10.7 44.6,11C44,11.3 43.5,11.7 43.1,12.2C42.7,12.7 42.4,13.4 42.2,14.2C42.1,15 42,15.9 42,16.8C42,18.7 42.3,20.2 43,21.2C43.7,22.2 44.7,22.7 45.9,22.7C46.7,22.7 47.3,22.6 47.8,22.3C48.3,22 48.7,21.8 49.1,21.1L49.2,22.9L51,22.9L51,6L49,6ZM49,17.5C49,18 48.9,18.5 48.8,19C48.7,19.5 48.5,19.9 48.2,20.2C48,20.5 47.7,20.8 47.3,21C47,21.2 46.6,21.3 46.2,21.3C45.4,21.3 44.8,20.9 44.4,20.1C44,19.3 43.8,18.2 43.8,16.6C43.8,15.1 44,14 44.5,13.2C44.9,12.4 45.7,12.1 46.7,12.1C47.2,12.1 47.6,12.1 48,12.2C48.4,12.3 49,12.4 49,12.5L49,17.5ZM58.8,22.3C58.1,22.6 57.3,22.8 56.5,22.8C55,22.8 53.9,22.4 53.2,21.5C52.5,20.6 52.1,19.2 52.1,17.3C52.1,15.1 52.5,13.4 53.3,12.3C54.1,11.2 55.2,10.6 56.6,10.6C58,10.6 59,11.1 59.8,12.1C60.5,13.1 60.8,14.7 60.7,16.8L54,16.8L54,17C54,18.6 54.2,19.7 54.7,20.4C55.2,21.1 55.8,21.4 56.7,21.4C57.2,21.4 57.8,21.3 58.3,21.1C58.8,20.9 59.4,20.6 60.1,20.1L60.8,21.3C60.1,21.7 59.5,22 58.8,22.3ZM58.2,12.9C57.8,12.3 57.2,12 56.5,12C55.8,12 55.2,12.3 54.8,12.9C54.4,13.5 54.2,14.4 54.1,15.5L58.8,15.5C58.8,14.4 58.6,13.5 58.2,12.9ZM69.2,13.6C69,14.5 68.7,15.4 68.4,16.4C68.1,17.3 67.8,18.3 67.5,19.4C67.2,20.4 66.9,21.5 66.5,22.6L64.7,22.6C64.3,21.4 64,20.3 63.6,19.3L62.7,16.3C62.4,15.4 62.2,14.4 61.9,13.6C61.7,12.7 61.5,11.8 61.3,11L63,11L64.2,15.8C64.6,17.4 65.1,19 65.6,20.7L66.9,15.9C67.3,14.3 67.7,12.7 68.1,11L69.7,11C69.7,11.8 69.5,12.7 69.2,13.6ZM77.1,22.3C76.4,22.6 75.6,22.8 74.8,22.8C73.3,22.8 72.2,22.4 71.5,21.5C70.8,20.6 70.4,19.2 70.4,17.3C70.4,15.1 70.8,13.4 71.6,12.3C72.4,11.2 73.5,10.6 74.9,10.6C76.3,10.6 77.3,11.1 78.1,12.1C78.8,13.1 79.1,14.7 79,16.8L72.3,16.8L72.3,17C72.3,18.6 72.5,19.7 73,20.4C73.5,21.1 74.1,21.4 75,21.4C75.5,21.4 76.1,21.3 76.6,21.1C77.1,20.9 77.7,20.6 78.4,20.1L79.1,21.3C78.4,21.7 77.8,22 77.1,22.3ZM76.5,12.9C76.1,12.3 75.5,12 74.8,12C74.1,12 73.5,12.3 73.1,12.9C72.7,13.5 72.5,14.4 72.4,15.5L77,15.5C77.1,14.4 76.9,13.5 76.5,12.9ZM80.5,22.6L80.5,6.5L82.2,6.5L82.2,22.6L80.5,22.6ZM88.1,22.8C86.6,22.8 85.5,22.3 84.8,21.4C84.1,20.4 83.7,18.9 83.7,16.9C83.7,14.8 84.1,13.3 84.8,12.2C85.5,11.2 86.7,10.7 88.3,10.7C89.8,10.7 90.9,11.2 91.6,12.2C92.3,13.2 92.6,14.7 92.6,16.7C92.6,20.8 91.1,22.8 88.1,22.8ZM90.2,13.2C89.8,12.4 89.1,12 88.1,12C87.2,12 86.6,12.4 86.2,13.1C85.8,13.9 85.6,15 85.6,16.6C85.6,18.3 85.8,19.5 86.2,20.2C86.6,20.9 87.3,21.3 88.2,21.3C89.8,21.3 90.7,19.8 90.7,16.7C90.7,15.1 90.5,13.9 90.2,13.2ZM102.4,21.1C101.6,22.2 100.4,22.8 98.7,22.8C98.3,22.8 97.9,22.8 97.6,22.7C97.3,22.7 97,22.6 96.5,22.5L96.5,26.4L94.8,26.4L94.8,10.9L96.3,10.9L96.4,12.4C96.8,11.7 97.2,11.3 97.7,11C98.2,10.7 98.8,10.6 99.6,10.6C100.9,10.6 101.8,11.1 102.5,12.1C103.2,13.1 103.5,14.6 103.5,16.5C103.5,18.5 103.2,20 102.4,21.1ZM101.1,13.3C100.7,12.5 100.1,12.1 99.3,12.1C98.9,12.1 98.5,12.2 98.2,12.4C97.9,12.6 97.6,12.9 97.4,13.2C97.2,13.5 97,13.9 96.8,14.4C96.6,14.9 96.6,15.3 96.6,15.9L96.6,21C96.9,21.1 97.2,21.2 97.6,21.3C98,21.4 98.4,21.4 98.9,21.4C99.9,21.4 100.6,21 101.1,20.3C101.6,19.6 101.8,18.4 101.8,16.9C101.7,15.2 101.5,14 101.1,13.3ZM117.6,22.6L117.6,14.7C117.6,13.9 117.5,13.2 117.4,12.7C117.3,12.2 116.9,12 116.3,12C115.9,12 115.5,12.1 115.1,12.4C114.7,12.7 114.2,13.1 113.5,13.6L113.5,22.5L111.8,22.5L111.8,14.7C111.8,13.9 111.7,13.2 111.6,12.7C111.5,12.2 111.1,12 110.5,12C110.1,12 109.7,12.1 109.3,12.4C108.9,12.7 108.4,13.1 107.7,13.6L107.7,22.5L106,22.5L106,10.9L107.5,10.9L107.6,12.3L109.3,11.1C109.8,10.8 110.4,10.6 111,10.6C111.7,10.6 112.2,10.8 112.5,11.1C112.8,11.4 113.1,11.8 113.3,12.4C113.9,11.9 114.5,11.5 115.1,11.2C115.7,10.9 116.2,10.7 116.8,10.7C117.8,10.7 118.4,11 118.8,11.6C119.2,12.2 119.3,13.1 119.3,14.4L119.3,22.6L117.6,22.6ZM127.5,22.3C126.8,22.6 126,22.8 125.2,22.8C123.7,22.8 122.6,22.4 121.9,21.5C121.2,20.6 120.8,19.2 120.8,17.3C120.8,15.1 121.2,13.4 122,12.3C122.8,11.2 123.9,10.6 125.3,10.6C126.7,10.6 127.7,11.1 128.5,12.1C129.2,13.1 129.5,14.7 129.4,16.8L122.7,16.8L122.7,17C122.7,18.6 122.9,19.7 123.4,20.4C123.9,21.1 124.5,21.4 125.4,21.4C125.9,21.4 126.5,21.3 127,21.1C127.5,20.9 128.1,20.6 128.8,20.1L129.5,21.3C128.8,21.7 128.1,22 127.5,22.3ZM126.8,12.9C126.4,12.3 125.8,12 125.1,12C124.4,12 123.8,12.3 123.4,12.9C123,13.5 122.8,14.4 122.7,15.5L127.4,15.5C127.4,14.4 127.2,13.5 126.8,12.9ZM136.9,22.5L136.9,14.7C136.9,13.9 136.8,13.2 136.6,12.7C136.4,12.2 136,12 135.4,12C135,12 134.6,12.1 134.2,12.4C133.8,12.7 133.2,13.1 132.6,13.6L132.6,22.5L130.9,22.5L130.9,10.9L132.4,10.9L132.5,12.3C133.1,11.9 133.7,11.5 134.2,11.1C134.8,10.8 135.3,10.6 135.9,10.6C136.9,10.6 137.6,10.9 137.9,11.5C138.3,12.1 138.5,13 138.5,14.3L138.5,22.5L136.9,22.5ZM144.7,22.8C144.1,22.8 143.5,22.7 143.1,22.6C142.7,22.5 142.4,22.2 142.2,21.9C142,21.6 141.8,21.2 141.8,20.6C141.7,20.1 141.7,19.4 141.7,18.7L141.7,12.3L140,12.3L140,10.9L141.7,10.9L141.7,7.7L143.4,7.5L143.4,10.9L145.8,10.9L145.7,12.3L143.5,12.3L143.5,19.8C143.5,20.2 143.6,20.5 143.7,20.7C143.8,20.9 144,21.1 144.2,21.2C144.4,21.3 144.7,21.4 145.1,21.4L145.6,21.4L146.1,21.3L146.3,22.7C145.7,22.7 145.2,22.8 144.7,22.8Z" style="fill:rgb(68,63,63);fill-rule:nonzero;"/>
            <path d="M157.4,20.4C157.2,20.9 156.9,21.3 156.5,21.6C156.1,21.9 155.6,22.2 155.1,22.4C154.5,22.6 153.9,22.7 153.3,22.7C151.8,22.7 150.8,22.4 150.1,21.8C149.4,21.2 149.2,20.3 149.3,19.3L150.8,19.1C150.8,19.4 150.8,19.6 150.9,19.9C151,20.2 151.1,20.4 151.3,20.6C151.5,20.8 151.8,21 152.1,21.1C152.5,21.2 152.9,21.3 153.5,21.3C154.3,21.3 154.9,21.1 155.4,20.7C155.9,20.3 156.1,19.7 156.1,19C156.1,18.4 155.9,17.9 155.6,17.6C155.3,17.2 154.9,17 154.4,16.7C153.9,16.5 153.4,16.2 152.8,16C152.2,15.8 151.7,15.5 151.2,15.2C150.7,14.9 150.3,14.5 150,14C149.7,13.5 149.5,12.9 149.5,12.1C149.5,11.6 149.6,11.1 149.8,10.6C150,10.2 150.3,9.8 150.6,9.5C151,9.2 151.4,9 151.9,8.8C152.4,8.6 153,8.6 153.7,8.6C154.4,8.6 155,8.7 155.4,8.9C155.9,9.1 156.3,9.3 156.6,9.6C156.9,9.9 157.1,10.2 157.2,10.6C157.3,11 157.4,11.4 157.4,11.8L155.9,12C155.9,11.7 155.9,11.5 155.8,11.2C155.7,11 155.6,10.7 155.4,10.6C155.2,10.4 155,10.3 154.7,10.2C154.4,10.1 154,10 153.6,10C153.2,10 152.8,10.1 152.5,10.2C152.2,10.3 151.9,10.5 151.7,10.6C151.5,10.8 151.3,11 151.2,11.2C151.1,11.4 151,11.7 151,12C151,12.6 151.2,13.1 151.5,13.4C151.8,13.8 152.3,14 152.8,14.3L154.4,15C155,15.2 155.5,15.5 156,15.8C156.5,16.1 156.9,16.5 157.3,17C157.6,17.5 157.8,18.1 157.8,18.9C157.7,19.4 157.6,19.9 157.4,20.4ZM159.7,22.6L159.7,8.9L166.6,8.9L166.5,10.3L161.4,10.3L161.4,14.8L165.4,14.8L165.4,16.2L161.4,16.2L161.4,21.2L166.7,21.2L166.7,22.6L159.7,22.6ZM168.8,22.6L168.8,8.9L175.7,8.9L175.6,10.3L170.5,10.3L170.5,14.8L174.5,14.8L174.5,16.2L170.5,16.2L170.5,21.2L175.8,21.2L175.8,22.6L168.8,22.6ZM186.8,18.4C186.5,19.3 186.1,20 185.6,20.6C185.1,21.2 184.4,21.7 183.7,22C182.9,22.3 182.1,22.5 181.1,22.5L178.2,22.5L178.2,8.9L181.1,8.9C183.1,8.9 184.7,9.5 185.7,10.7C186.7,11.9 187.2,13.5 187.2,15.6C187.2,16.6 187.1,17.5 186.8,18.4ZM184.4,11.7C183.7,10.7 182.6,10.2 181,10.2L179.9,10.2L179.9,21.1L181.3,21.1C182.7,21.1 183.7,20.6 184.4,19.7C185.1,18.8 185.5,17.4 185.5,15.7C185.4,14 185.1,12.7 184.4,11.7Z" style="fill:rgb(208,66,0);fill-rule:nonzero;"/>
        </g>
        <g id="symbol">
            <path id="surface" d="M30,0L2,0C0.9,0 0,0.9 0,2L0,30C0,31.1 0.9,32 2,32L30,32C31.1,32 32,31.1 32,30L32,2C32,0.9 31.1,0 30,0Z" style="fill:rgb(208,66,0);fill-rule:nonzero;"/>
            <g id="shape" transform="matrix(0.925342,0,0,0.925342,1.19453,2.38906)">
                <path d="M18.1,27.2C18.1,26.6 18.3,26 18.5,25.4C17.9,25.9 17.7,26.5 17.5,27.3C17.6,26.4 18,20.4 18,20.1C19.5,15.7 18.8,2.7 20.8,1C18.6,1.4 17.8,3.7 17.1,5.5C16.4,3.4 17,2 14.6,1.2C16.5,2.8 16.1,4.2 16.5,6.4C15.4,4.9 15.7,3.1 14.4,1.6C14,1.2 12.8,0.3 12.8,0.3C12.8,0.4 13.8,2.3 14,3.4C14.2,4.4 14.6,6.5 14.6,7.3C14.8,11.5 15.8,15.6 16.6,19.8C16.7,20.5 17.1,22.6 17.1,22.6L17.2,23.5C17.1,22.9 16.9,22.4 16.9,22.2C16.7,21.6 16.2,20 16,19.3C14.2,15.6 11,8.5 6.6,7.4C9.1,9.6 11.7,12.5 12.3,15.3C11,13.4 5.8,9.5 3.6,8C7.6,12.1 10.8,16.4 14.3,21C15.3,22.3 16.6,25 16.7,25.6C16.8,26 16.8,27.7 16.9,28.7C15,24 13.9,21.6 10.3,19.5C9.7,19.2 7.8,18.5 7.8,18.5C8.7,19.5 9.7,19.5 10.5,20.8C8.9,19.7 7.2,19.5 5.3,19.5C11.3,22.6 14.5,23.5 16.5,29.4C16.7,30.4 16.4,31 16.4,32L17.7,32L17.7,30.6C17.8,30.2 17.8,28.9 18,28.6C18.6,27 19.6,26.3 21.1,25.3C19.7,25.8 19.1,25.6 18.1,27.2ZM24,13.2C23.5,13.7 22,15.5 22,15.5C22.1,12.9 22.7,10.1 24.4,8.1C22.1,9.6 20.8,13.4 20.1,15.7C19.9,16.6 17.1,22 18.4,24.9C18.6,23.8 19.2,22.8 19.9,21.9C20.2,21.5 21.5,19.4 22.8,16.5C23.9,13.6 25.8,11.8 28.4,10.4C26.5,10.7 25.4,11.8 24,13.2Z" style="fill:white;fill-rule:nonzero;"/>
            </g>
        </g>
    </g>
</svg>
"
+            alt="Development Seed">
+        </a>
+      </div>
+    </div>
+  </body>
+</html>
diff --git a/src/titiler/core/titiler/core/templates/header.html b/src/titiler/core/titiler/core/templates/header.html
new file mode 100644
index 000000000..a3938c37a
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/header.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>{{ template.title }}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.3/css/bootstrap.min.css" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.css" />
+    <style>
+      html { position: relative; min-height: 100%; }
+      body { padding-top: 5rem; margin-bottom: 40px; }
+      #page { padding: 1.5rem 1.5rem; }
+      .navbar { border-bottom: 8px solid #3333A4; }
+      .navbar-brand { font-size: 2rem; color: #3333A4 !important; text-shadow: 2px 2px 4px #ccc; }
+      .json-link { font-weight: normal; }
+    </style>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
+    <script src="https://files.dnr.state.mn.us/lib/bootstrap4/javascripts/bootstrap.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.js"></script>
+  </head>
+  <body>
+    <main role="main" class="container-fluid">
+      <div id="page">
diff --git a/src/titiler/core/titiler/core/templates/icons/clock.html b/src/titiler/core/titiler/core/templates/icons/clock.html
new file mode 100644
index 000000000..139df0679
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/icons/clock.html
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="18px" viewBox="0 -960 960 960" width="18px" fill="#1f1f1f"><path d="m612-292 56-56-148-148v-184h-80v216l172 172ZM480-80q-83 0-156-31.5T197-197q-54-54-85.5-127T80-480q0-83 31.5-156T197-763q54-54 127-85.5T480-880q83 0 156 31.5T763-763q54 54 85.5 127T880-480q0 83-31.5 156T763-197q-54 54-127 85.5T480-80Zm0-400Zm0 320q133 0 226.5-93.5T800-480q0-133-93.5-226.5T480-800q-133 0-226.5 93.5T160-480q0 133 93.5 226.5T480-160Z"/></svg>
diff --git a/src/titiler/core/titiler/core/templates/icons/license.html b/src/titiler/core/titiler/core/templates/icons/license.html
new file mode 100644
index 000000000..624f77ec2
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/icons/license.html
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="18px" viewBox="0 -960 960 960" width="18px" fill="#1f1f1f"><path d="M480-80q-139-35-229.5-159.5T160-516v-244l320-120 320 120v244q0 85-29 163.5T688-214L560-342q-18 11-38.5 16.5T480-320q-66 0-113-47t-47-113q0-66 47-113t113-47q66 0 113 47t47 113q0 22-5.5 42.5T618-398l60 60q20-41 31-86t11-92v-189l-240-90-240 90v189q0 121 68 220t172 132q26-8 49.5-20.5T576-214l56 56q-33 27-71.5 47T480-80Zm0-320q33 0 56.5-23.5T560-480q0-33-23.5-56.5T480-560q-33 0-56.5 23.5T400-480q0 33 23.5 56.5T480-400Zm8-77Z"/></svg>
diff --git a/src/titiler/core/titiler/core/templates/icons/tag.html b/src/titiler/core/titiler/core/templates/icons/tag.html
new file mode 100644
index 000000000..de48df803
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/icons/tag.html
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="18px" viewBox="0 -960 960 960" width="18px" fill="#1f1f1f"><path d="M856-390 570-104q-12 12-27 18t-30 6q-15 0-30-6t-27-18L103-457q-11-11-17-25.5T80-513v-287q0-33 23.5-56.5T160-880h287q16 0 31 6.5t26 17.5l352 353q12 12 17.5 27t5.5 30q0 15-5.5 29.5T856-390ZM513-160l286-286-353-354H160v286l353 354ZM260-640q25 0 42.5-17.5T320-700q0-25-17.5-42.5T260-760q-25 0-42.5 17.5T200-700q0 25 17.5 42.5T260-640Zm220 160Z"/></svg>
diff --git a/src/titiler/core/titiler/core/templates/map.html b/src/titiler/core/titiler/core/templates/map.html
index 700b2dae8..6325e421b 100644
--- a/src/titiler/core/titiler/core/templates/map.html
+++ b/src/titiler/core/titiler/core/templates/map.html
@@ -1,124 +1,319 @@
-<!DOCTYPE html>
-    <html>
-    <head>
-        <meta charset='utf-8' />
-        <title>TiTiler Map Viewer</title>
-        <meta name='viewport' content='initial-scale=1,maximum-scale=1,user-scalable=no' />
-        <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.3/dist/leaflet.css"/>
-        <script src="https://unpkg.com/leaflet@1.9.3/dist/leaflet.js"></script>
-        <script src="https://unpkg.com/proj4@2.3.14/dist/proj4.js"></script>
-        <script src="https://unpkg.com/proj4leaflet@1.0.2/src/proj4leaflet.js"></script>
-        <style>
-            body { margin:0; padding:0; width:100%; height:100%; background-color: #e5e5e5;}
-            #map { position:absolute; top:0; bottom:0; width:100%; }
-        </style>
-    </head>
-    <body>
-
-    <div id='map'></div>
-
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>TiTiler Map Viewer</title>
+    <meta
+      name="viewport"
+      content="initial-scale=1,maximum-scale=1,user-scalable=no"
+    />
+    <link
+      rel="stylesheet"
+      href="https://unpkg.com/leaflet@1.9.3/dist/leaflet.css"
+      integrity="sha384-o/2yZuJZWGJ4s/adjxVW71R+EO/LyCwdQfP5UWSgX/w87iiTXuvDZaejd3TsN7mf"
+      crossorigin="anonymous"
+    />
+    <script
+      src="https://unpkg.com/leaflet@1.9.3/dist/leaflet.js"
+      integrity="sha384-okbbMvvx/qfQkmiQKfd5VifbKZ/W8p1qIsWvE1ROPUfHWsDcC8/BnHohF7vPg2T6"
+      crossorigin="anonymous"
+    ></script>
+    <script
+      src="https://unpkg.com/proj4@2.3.14/dist/proj4.js"
+      integrity="sha384-R7x++v2MKcATI+D1/GJsn636xbHca492Sdpm8BD36lj5vdWB9+OUBpM1oKkrzqv9"
+      crossorigin="anonymous"
+    ></script>
+    <script
+      src="https://unpkg.com/proj4leaflet@1.0.2/src/proj4leaflet.js"
+      integrity="sha384-aDnBHDK9AhLbrYhThBxEVMriFbix8Sz2059IlD3HbZhz7+WNmz+pSkOcI7MY72cE"
+      crossorigin="anonymous"
+    ></script>
+    <style>
+      body {
+        margin: 0;
+        padding: 0;
+        width: 100%;
+        height: 100%;
+        background-color: #e5e5e5;
+      }
+      #map {
+        position: absolute;
+        top: 0;
+        bottom: 0;
+        width: 100%;
+      }
+      .fixed-bottom {
+          position: absolute;
+          left: 0;
+          bottom: 0;
+          z-index: 1000;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="map"></div>
+    <div class="fixed-bottom">
+      <div style="padding: 10px;"">
+        </br>
+        <a href="https://www.developmentseed.org/" target="_blank">
+          <img width=200 src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" viewBox="0 0 188 32" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
    <rect id="hor--pos" x="0" y="0" width="188" height="32" style="fill:none;"/>
    <g id="hor--pos1" serif:id="hor--pos">
        <g id="text">
            <path d="M49,6L49,10.9C49,10.8 48.2,10.8 47.9,10.7C47.6,10.7 47.3,10.6 46.8,10.6C46,10.6 45.2,10.7 44.6,11C44,11.3 43.5,11.7 43.1,12.2C42.7,12.7 42.4,13.4 42.2,14.2C42.1,15 42,15.9 42,16.8C42,18.7 42.3,20.2 43,21.2C43.7,22.2 44.7,22.7 45.9,22.7C46.7,22.7 47.3,22.6 47.8,22.3C48.3,22 48.7,21.8 49.1,21.1L49.2,22.9L51,22.9L51,6L49,6ZM49,17.5C49,18 48.9,18.5 48.8,19C48.7,19.5 48.5,19.9 48.2,20.2C48,20.5 47.7,20.8 47.3,21C47,21.2 46.6,21.3 46.2,21.3C45.4,21.3 44.8,20.9 44.4,20.1C44,19.3 43.8,18.2 43.8,16.6C43.8,15.1 44,14 44.5,13.2C44.9,12.4 45.7,12.1 46.7,12.1C47.2,12.1 47.6,12.1 48,12.2C48.4,12.3 49,12.4 49,12.5L49,17.5ZM58.8,22.3C58.1,22.6 57.3,22.8 56.5,22.8C55,22.8 53.9,22.4 53.2,21.5C52.5,20.6 52.1,19.2 52.1,17.3C52.1,15.1 52.5,13.4 53.3,12.3C54.1,11.2 55.2,10.6 56.6,10.6C58,10.6 59,11.1 59.8,12.1C60.5,13.1 60.8,14.7 60.7,16.8L54,16.8L54,17C54,18.6 54.2,19.7 54.7,20.4C55.2,21.1 55.8,21.4 56.7,21.4C57.2,21.4 57.8,21.3 58.3,21.1C58.8,20.9 59.4,20.6 60.1,20.1L60.8,21.3C60.1,21.7 59.5,22 58.8,22.3ZM58.2,12.9C57.8,12.3 57.2,12 56.5,12C55.8,12 55.2,12.3 54.8,12.9C54.4,13.5 54.2,14.4 54.1,15.5L58.8,15.5C58.8,14.4 58.6,13.5 58.2,12.9ZM69.2,13.6C69,14.5 68.7,15.4 68.4,16.4C68.1,17.3 67.8,18.3 67.5,19.4C67.2,20.4 66.9,21.5 66.5,22.6L64.7,22.6C64.3,21.4 64,20.3 63.6,19.3L62.7,16.3C62.4,15.4 62.2,14.4 61.9,13.6C61.7,12.7 61.5,11.8 61.3,11L63,11L64.2,15.8C64.6,17.4 65.1,19 65.6,20.7L66.9,15.9C67.3,14.3 67.7,12.7 68.1,11L69.7,11C69.7,11.8 69.5,12.7 69.2,13.6ZM77.1,22.3C76.4,22.6 75.6,22.8 74.8,22.8C73.3,22.8 72.2,22.4 71.5,21.5C70.8,20.6 70.4,19.2 70.4,17.3C70.4,15.1 70.8,13.4 71.6,12.3C72.4,11.2 73.5,10.6 74.9,10.6C76.3,10.6 77.3,11.1 78.1,12.1C78.8,13.1 79.1,14.7 79,16.8L72.3,16.8L72.3,17C72.3,18.6 72.5,19.7 73,20.4C73.5,21.1 74.1,21.4 75,21.4C75.5,21.4 76.1,21.3 76.6,21.1C77.1,20.9 77.7,20.6 78.4,20.1L79.1,21.3C78.4,21.7 77.8,22 77.1,22.3ZM76.5,12.9C76.1,12.3 75.5,12 74.8,12C74.1,12 73.5,12.3 73.1,12.9C72.7,13.5 72.5,14.4 72.4,15.5L77,15.5C77.1,14.4 76.9,13.5 76.5,12.9ZM80.5,22.6L80.5,6.5L82.2,6.5L82.2,22.6L80.5,22.6ZM88.1,22.8C86.6,22.8 85.5,22.3 84.8,21.4C84.1,20.4 83.7,18.9 83.7,16.9C83.7,14.8 84.1,13.3 84.8,12.2C85.5,11.2 86.7,10.7 88.3,10.7C89.8,10.7 90.9,11.2 91.6,12.2C92.3,13.2 92.6,14.7 92.6,16.7C92.6,20.8 91.1,22.8 88.1,22.8ZM90.2,13.2C89.8,12.4 89.1,12 88.1,12C87.2,12 86.6,12.4 86.2,13.1C85.8,13.9 85.6,15 85.6,16.6C85.6,18.3 85.8,19.5 86.2,20.2C86.6,20.9 87.3,21.3 88.2,21.3C89.8,21.3 90.7,19.8 90.7,16.7C90.7,15.1 90.5,13.9 90.2,13.2ZM102.4,21.1C101.6,22.2 100.4,22.8 98.7,22.8C98.3,22.8 97.9,22.8 97.6,22.7C97.3,22.7 97,22.6 96.5,22.5L96.5,26.4L94.8,26.4L94.8,10.9L96.3,10.9L96.4,12.4C96.8,11.7 97.2,11.3 97.7,11C98.2,10.7 98.8,10.6 99.6,10.6C100.9,10.6 101.8,11.1 102.5,12.1C103.2,13.1 103.5,14.6 103.5,16.5C103.5,18.5 103.2,20 102.4,21.1ZM101.1,13.3C100.7,12.5 100.1,12.1 99.3,12.1C98.9,12.1 98.5,12.2 98.2,12.4C97.9,12.6 97.6,12.9 97.4,13.2C97.2,13.5 97,13.9 96.8,14.4C96.6,14.9 96.6,15.3 96.6,15.9L96.6,21C96.9,21.1 97.2,21.2 97.6,21.3C98,21.4 98.4,21.4 98.9,21.4C99.9,21.4 100.6,21 101.1,20.3C101.6,19.6 101.8,18.4 101.8,16.9C101.7,15.2 101.5,14 101.1,13.3ZM117.6,22.6L117.6,14.7C117.6,13.9 117.5,13.2 117.4,12.7C117.3,12.2 116.9,12 116.3,12C115.9,12 115.5,12.1 115.1,12.4C114.7,12.7 114.2,13.1 113.5,13.6L113.5,22.5L111.8,22.5L111.8,14.7C111.8,13.9 111.7,13.2 111.6,12.7C111.5,12.2 111.1,12 110.5,12C110.1,12 109.7,12.1 109.3,12.4C108.9,12.7 108.4,13.1 107.7,13.6L107.7,22.5L106,22.5L106,10.9L107.5,10.9L107.6,12.3L109.3,11.1C109.8,10.8 110.4,10.6 111,10.6C111.7,10.6 112.2,10.8 112.5,11.1C112.8,11.4 113.1,11.8 113.3,12.4C113.9,11.9 114.5,11.5 115.1,11.2C115.7,10.9 116.2,10.7 116.8,10.7C117.8,10.7 118.4,11 118.8,11.6C119.2,12.2 119.3,13.1 119.3,14.4L119.3,22.6L117.6,22.6ZM127.5,22.3C126.8,22.6 126,22.8 125.2,22.8C123.7,22.8 122.6,22.4 121.9,21.5C121.2,20.6 120.8,19.2 120.8,17.3C120.8,15.1 121.2,13.4 122,12.3C122.8,11.2 123.9,10.6 125.3,10.6C126.7,10.6 127.7,11.1 128.5,12.1C129.2,13.1 129.5,14.7 129.4,16.8L122.7,16.8L122.7,17C122.7,18.6 122.9,19.7 123.4,20.4C123.9,21.1 124.5,21.4 125.4,21.4C125.9,21.4 126.5,21.3 127,21.1C127.5,20.9 128.1,20.6 128.8,20.1L129.5,21.3C128.8,21.7 128.1,22 127.5,22.3ZM126.8,12.9C126.4,12.3 125.8,12 125.1,12C124.4,12 123.8,12.3 123.4,12.9C123,13.5 122.8,14.4 122.7,15.5L127.4,15.5C127.4,14.4 127.2,13.5 126.8,12.9ZM136.9,22.5L136.9,14.7C136.9,13.9 136.8,13.2 136.6,12.7C136.4,12.2 136,12 135.4,12C135,12 134.6,12.1 134.2,12.4C133.8,12.7 133.2,13.1 132.6,13.6L132.6,22.5L130.9,22.5L130.9,10.9L132.4,10.9L132.5,12.3C133.1,11.9 133.7,11.5 134.2,11.1C134.8,10.8 135.3,10.6 135.9,10.6C136.9,10.6 137.6,10.9 137.9,11.5C138.3,12.1 138.5,13 138.5,14.3L138.5,22.5L136.9,22.5ZM144.7,22.8C144.1,22.8 143.5,22.7 143.1,22.6C142.7,22.5 142.4,22.2 142.2,21.9C142,21.6 141.8,21.2 141.8,20.6C141.7,20.1 141.7,19.4 141.7,18.7L141.7,12.3L140,12.3L140,10.9L141.7,10.9L141.7,7.7L143.4,7.5L143.4,10.9L145.8,10.9L145.7,12.3L143.5,12.3L143.5,19.8C143.5,20.2 143.6,20.5 143.7,20.7C143.8,20.9 144,21.1 144.2,21.2C144.4,21.3 144.7,21.4 145.1,21.4L145.6,21.4L146.1,21.3L146.3,22.7C145.7,22.7 145.2,22.8 144.7,22.8Z" style="fill:rgb(68,63,63);fill-rule:nonzero;"/>
            <path d="M157.4,20.4C157.2,20.9 156.9,21.3 156.5,21.6C156.1,21.9 155.6,22.2 155.1,22.4C154.5,22.6 153.9,22.7 153.3,22.7C151.8,22.7 150.8,22.4 150.1,21.8C149.4,21.2 149.2,20.3 149.3,19.3L150.8,19.1C150.8,19.4 150.8,19.6 150.9,19.9C151,20.2 151.1,20.4 151.3,20.6C151.5,20.8 151.8,21 152.1,21.1C152.5,21.2 152.9,21.3 153.5,21.3C154.3,21.3 154.9,21.1 155.4,20.7C155.9,20.3 156.1,19.7 156.1,19C156.1,18.4 155.9,17.9 155.6,17.6C155.3,17.2 154.9,17 154.4,16.7C153.9,16.5 153.4,16.2 152.8,16C152.2,15.8 151.7,15.5 151.2,15.2C150.7,14.9 150.3,14.5 150,14C149.7,13.5 149.5,12.9 149.5,12.1C149.5,11.6 149.6,11.1 149.8,10.6C150,10.2 150.3,9.8 150.6,9.5C151,9.2 151.4,9 151.9,8.8C152.4,8.6 153,8.6 153.7,8.6C154.4,8.6 155,8.7 155.4,8.9C155.9,9.1 156.3,9.3 156.6,9.6C156.9,9.9 157.1,10.2 157.2,10.6C157.3,11 157.4,11.4 157.4,11.8L155.9,12C155.9,11.7 155.9,11.5 155.8,11.2C155.7,11 155.6,10.7 155.4,10.6C155.2,10.4 155,10.3 154.7,10.2C154.4,10.1 154,10 153.6,10C153.2,10 152.8,10.1 152.5,10.2C152.2,10.3 151.9,10.5 151.7,10.6C151.5,10.8 151.3,11 151.2,11.2C151.1,11.4 151,11.7 151,12C151,12.6 151.2,13.1 151.5,13.4C151.8,13.8 152.3,14 152.8,14.3L154.4,15C155,15.2 155.5,15.5 156,15.8C156.5,16.1 156.9,16.5 157.3,17C157.6,17.5 157.8,18.1 157.8,18.9C157.7,19.4 157.6,19.9 157.4,20.4ZM159.7,22.6L159.7,8.9L166.6,8.9L166.5,10.3L161.4,10.3L161.4,14.8L165.4,14.8L165.4,16.2L161.4,16.2L161.4,21.2L166.7,21.2L166.7,22.6L159.7,22.6ZM168.8,22.6L168.8,8.9L175.7,8.9L175.6,10.3L170.5,10.3L170.5,14.8L174.5,14.8L174.5,16.2L170.5,16.2L170.5,21.2L175.8,21.2L175.8,22.6L168.8,22.6ZM186.8,18.4C186.5,19.3 186.1,20 185.6,20.6C185.1,21.2 184.4,21.7 183.7,22C182.9,22.3 182.1,22.5 181.1,22.5L178.2,22.5L178.2,8.9L181.1,8.9C183.1,8.9 184.7,9.5 185.7,10.7C186.7,11.9 187.2,13.5 187.2,15.6C187.2,16.6 187.1,17.5 186.8,18.4ZM184.4,11.7C183.7,10.7 182.6,10.2 181,10.2L179.9,10.2L179.9,21.1L181.3,21.1C182.7,21.1 183.7,20.6 184.4,19.7C185.1,18.8 185.5,17.4 185.5,15.7C185.4,14 185.1,12.7 184.4,11.7Z" style="fill:rgb(208,66,0);fill-rule:nonzero;"/>
        </g>
        <g id="symbol">
            <path id="surface" d="M30,0L2,0C0.9,0 0,0.9 0,2L0,30C0,31.1 0.9,32 2,32L30,32C31.1,32 32,31.1 32,30L32,2C32,0.9 31.1,0 30,0Z" style="fill:rgb(208,66,0);fill-rule:nonzero;"/>
            <g id="shape" transform="matrix(0.925342,0,0,0.925342,1.19453,2.38906)">
                <path d="M18.1,27.2C18.1,26.6 18.3,26 18.5,25.4C17.9,25.9 17.7,26.5 17.5,27.3C17.6,26.4 18,20.4 18,20.1C19.5,15.7 18.8,2.7 20.8,1C18.6,1.4 17.8,3.7 17.1,5.5C16.4,3.4 17,2 14.6,1.2C16.5,2.8 16.1,4.2 16.5,6.4C15.4,4.9 15.7,3.1 14.4,1.6C14,1.2 12.8,0.3 12.8,0.3C12.8,0.4 13.8,2.3 14,3.4C14.2,4.4 14.6,6.5 14.6,7.3C14.8,11.5 15.8,15.6 16.6,19.8C16.7,20.5 17.1,22.6 17.1,22.6L17.2,23.5C17.1,22.9 16.9,22.4 16.9,22.2C16.7,21.6 16.2,20 16,19.3C14.2,15.6 11,8.5 6.6,7.4C9.1,9.6 11.7,12.5 12.3,15.3C11,13.4 5.8,9.5 3.6,8C7.6,12.1 10.8,16.4 14.3,21C15.3,22.3 16.6,25 16.7,25.6C16.8,26 16.8,27.7 16.9,28.7C15,24 13.9,21.6 10.3,19.5C9.7,19.2 7.8,18.5 7.8,18.5C8.7,19.5 9.7,19.5 10.5,20.8C8.9,19.7 7.2,19.5 5.3,19.5C11.3,22.6 14.5,23.5 16.5,29.4C16.7,30.4 16.4,31 16.4,32L17.7,32L17.7,30.6C17.8,30.2 17.8,28.9 18,28.6C18.6,27 19.6,26.3 21.1,25.3C19.7,25.8 19.1,25.6 18.1,27.2ZM24,13.2C23.5,13.7 22,15.5 22,15.5C22.1,12.9 22.7,10.1 24.4,8.1C22.1,9.6 20.8,13.4 20.1,15.7C19.9,16.6 17.1,22 18.4,24.9C18.6,23.8 19.2,22.8 19.9,21.9C20.2,21.5 21.5,19.4 22.8,16.5C23.9,13.6 25.8,11.8 28.4,10.4C26.5,10.7 25.4,11.8 24,13.2Z" style="fill:white;fill-rule:nonzero;"/>
            </g>
        </g>
    </g>
</svg>
"
+            alt="Development Seed">
+        </a>
+      </div>
+    </div>
     <script type="text/javascript">
 
-const bboxPolygon = (bounds) => {
-    return {
-        'type': 'Feature',
-        'geometry': {
-            'type': 'Polygon',
-            'coordinates': [[
-                [bounds[0], bounds[1]],
-                [bounds[2], bounds[1]],
-                [bounds[2], bounds[3]],
-                [bounds[0], bounds[3]],
-                [bounds[0], bounds[1]]
-            ]]
-        },
-        'properties': {}
-    }
-}
-
-var crs = new L.Proj.CRS(
-    '{{ tms.crs.srs }}',
-    '{{ tms.crs.to_proj4() }}', {
-    origin: [{{ tms.xy_bbox.left }}, {{ tms.xy_bbox.top }}],
-    bounds: L.bounds(
-      L.Point({{ tms.xy_bbox.left}}, {{ tms.xy_bbox.bottom }}),
-      L.Point({{ tms.xy_bbox.right}}, {{ tms.xy_bbox.top }})
-    ),
-    resolutions: {{ resolutions|safe }},
-  }
-);
-
-
-var map = L.map('map', {
-  crs: crs,
-  minZoom: {{ tms.minzoom }},
-  maxZoom: {{ tms.maxzoom }}
-});
-
-const nullIsland = L.marker([0, 0]).addTo(map);
-const madrid = L.marker([40, -3]).addTo(map);
-const london = L.marker([51.50722, -0.1275]).addTo(map)
-const auckland = L.marker([-36.864664, 174.792059]).addTo(map);
-const seattle = L.marker([47.596842, -122.333087]).addTo(map);
-
-if ("{{ tms.identifier }}" === "WebMercatorQuad") {
-  L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
-    attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
-  }).addTo(map);
-}
-
-fetch('{{ tilejson_endpoint|safe }}')
-  .then(res => {
-    if (res.ok) return res.json()
-    throw new Error('Network response was not ok.')
-  })
-  .then(data => {
-    console.log(data)
-
-    let bounds = [...data.bounds]
-
-    let geo;
-    // handle files that span accross dateline
-    if (bounds[0] > bounds[2]) {
-      geo = {
-        "type": "FeatureCollection",
-        "features": [
-          bboxPolygon([-180, bounds[1], bounds[2], bounds[3]]),
-          bboxPolygon([bounds[0], bounds[1], 180, bounds[3]]),
-        ]
-      }
-    } else {
-      geo = {
-        "type": "FeatureCollection",
-        "features": [bboxPolygon(bounds)]
+      const bboxPolygon = (bounds) => {
+          var LL_EPSILON = 1e-6
+          return {
+              'type': 'Feature',
+              'geometry': {
+                  'type': 'Polygon',
+                  'coordinates': [[
+                      [bounds[0] + LL_EPSILON, bounds[1] + LL_EPSILON],
+                      [bounds[2] -  LL_EPSILON, bounds[1] + LL_EPSILON],
+                      [bounds[2] - LL_EPSILON, bounds[3] - LL_EPSILON],
+                      [bounds[0] + LL_EPSILON, bounds[3] - LL_EPSILON],
+                      [bounds[0] + LL_EPSILON, bounds[1] + LL_EPSILON]
+                  ]]
+              },
+              'properties': {}
+          }
       }
-    }
-
-    var aoi = L.geoJSON(geo, {
-        color: '#3bb2d0', fill: false
-    }).addTo(map);
-    map.fitBounds(aoi.getBounds());
-
-    // Bounds crossing dateline
-    if (bounds[0] > bounds[2]) {
-      bounds[0] = bounds[0] - 360
-    }
-    var left = bounds[0],
-      bottom = bounds[1],
-      right = bounds[2],
-      top = bounds[3];
-
-    L.tileLayer(
-      data.tiles[0], {
-        minZoom: data.minzoom,
-        maxNativeZoom: data.maxzoom,
-        bounds: L.latLngBounds([bottom, left], [top, right]),
+
+      var crs = new L.Proj.CRS(
+          '{{ tms.crs.srs }}',
+          '{{ tms.crs.to_proj4() }}', {
+          origin: [{{ tms.xy_bbox.left }}, {{ tms.xy_bbox.top }}],
+          bounds: L.bounds(
+            L.Point({{ tms.xy_bbox.left}}, {{ tms.xy_bbox.bottom }}),
+            L.Point({{ tms.xy_bbox.right}}, {{ tms.xy_bbox.top }})
+          ),
+          resolutions: {{ resolutions|safe }},
+        }
+      );
+
+
+      var map = L.map('map', {
+        crs: crs,
+        minZoom: {{ tms.minzoom }},
+        maxZoom: {{ tms.maxzoom }},
+        attributionControl: false
+      });
+
+      L.control.attribution({prefix: '<a href="https://leafletjs.com" target="_blank">Leaflet</a> | <a href="https://developmentseed.org/titiler" target="_blank">Titiler</a>'}).addTo(map)
+
+      let baseLayers = {};
+      let overlayLayers = {};
+      let activeBaseLayer = null;
+
+      if ("{{ tms.id }}" === "WebMercatorQuad") {
+
+        const esriSatelliteLayer = L.tileLayer(
+          'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}', {
+            attribution: 'Tiles &copy; ESRI &mdash; Source: Esri, DigitalGlobe, GeoEye, i-cubed, USDA FSA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community',
+            maxZoom: 19
+          }
+        );
+        esriSatelliteLayer.addTo(map);
+        baseLayers["Esri Satellite"] = esriSatelliteLayer;
+
+        const osmLayer = L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+            attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+        });
+        osmLayer.addTo(map);
+        baseLayers["OpenStreetMap"] = osmLayer;
+        activeBaseLayer = osmLayer;
       }
-    ).addTo(map);
-  })
-  .catch(err => {
-    console.warn(err)
-  })
+
+      // Add some placemarks for use in validating display with custom TMS
+      var nullIsland = L.marker([0, 0]),
+        madrid = L.marker([40, -3]),
+        london = L.marker([51.50722, -0.1275]),
+        auckland = L.marker([-36.864664, 174.792059]),
+        seattle = L.marker([47.596842, -122.333087]);
+
+      var cities = L.layerGroup([nullIsland, london, auckland, seattle]);
+
+      document.addEventListener('keydown', function(e) {
+        if (e.key === 'b' || e.key === 'B') {
+          if (map.hasLayer(cities)) {
+            map.removeLayer(cities);
+          } else {
+            map.addLayer(cities);
+          }
+        }
+      });
+
+      const toggleButton = L.control({position: 'bottomright'});
+      toggleButton.onAdd = function(map) {
+          const div = L.DomUtil.create('div', 'toggle-cities');
+          div.innerHTML = `
+              <button style="
+                  font-size: 10px;
+                  padding: 2px 5px;
+                  background: rgba(255, 255, 255, 0.8);
+                  border: 1px solid #ccc;
+                  border-radius: 3px;
+                  cursor: pointer;
+              ">⚲</button>
+          `;
+          div.onclick = function() {
+              if (map.hasLayer(cities)) {
+                  map.removeLayer(cities);
+              } else {
+                  map.addLayer(cities);
+              }
+          };
+          return div;
+      };
+      toggleButton.addTo(map);
+
+      // Add the tile layer!
+      fetch('{{ tilejson_endpoint|safe }}')
+        .then(res => {
+          if (res.ok) return res.json()
+          throw new Error('Network response was not ok.')
+        })
+        .then(data => {
+          console.log(data);
+
+          let bounds = [...data.bounds];
+
+          var left = bounds[0],
+            bottom = bounds[1],
+            right = bounds[2],
+            top = bounds[3];
+
+          if (left < right) {
+            left = Math.max(left, {{ tms.bbox.left }});
+            right = Math.min(right, {{ tms.bbox.right }});
+          }
+          bottom = Math.max(bottom, {{ tms.bbox.bottom }});
+          top = Math.min(top, {{ tms.bbox.top }});
+
+          let geo;
+          if (left > right) {
+            geo = {
+              "type": "FeatureCollection",
+              "features": [
+                bboxPolygon([-180, bottom, right, top]),
+                bboxPolygon([left, bottom, 180, top]),
+              ]
+            };
+          } else {
+            geo = {
+              "type": "FeatureCollection",
+              "features": [bboxPolygon([left, bottom, right, top])]
+            };
+          }
+
+          var aoi = L.geoJSON(geo, {
+              color: '#3bb2d0', fill: false
+          }).addTo(map);
+          map.fitBounds(aoi.getBounds());
+
+          if (left > right) {
+            left = right - 360;
+          }
+
+          const tileLayer = L.tileLayer(
+            data.tiles[0], {
+              maxNativeZoom: data.maxzoom,
+              minZoom: data.minzoom,
+              bounds: L.latLngBounds([bottom, left], [top, right]),
+              attribution: data.attribution
+            }
+          );
+
+          overlayLayers["TiTiler Layer"] = tileLayer;
+
+          tileLayer.addTo(map);
+
+          // Add L.control.layers with base and overlay layers
+          L.control.layers(baseLayers, overlayLayers, {collapsed: false}).addTo(map);
+        })
+        .catch(err => {
+          console.warn(err);
+        });
+
+      // run point query on right-click
+      map.on('contextmenu', function(e) {
+        const lat = e.latlng.lat.toFixed(3);
+        const lng = e.latlng.lng.toFixed(3);
+
+        const popup = L.popup()
+          .setLatLng(e.latlng)
+          .setContent("<p>Loading point data...</p>")
+          .openOn(map);
+
+        fetch(`{{ point_endpoint|safe }}`.replace('{lat}', lat).replace('{lon}', lng))
+          .then(res => {
+            if (res.status === 204) return null;
+            if (res.ok) return res.json();
+
+            return res.json().then(errorData => {
+              const error = new Error(errorData.detail || `Server error: ${res.status}`);
+              error.status = res.status;
+              error.errorData = errorData;
+              throw error;
+            })
+          })
+          .then(data => {
+            if (data === null) {
+              popup.setContent(`<p>No data at ${lat}, ${lng}</p>`);
+              return;
+            }
+
+            const renderBandTable = (bandNames, values) => {
+              if (bandNames.length === 1) {
+                const value = values[0] !== null ? values[0] : 'No data';
+                return `<p><strong>Value:</strong> ${value}</p>`;
+              }
+              let html = '<table style="width: 100%; border-collapse: collapse;">';
+              html += '<tr>'
+                    + '<th style="text-align: left; padding: 1px; border-bottom: 1px solid #ddd;">Band</th>'
+                    + '<th style="text-align: right; padding: 1px; border-bottom: 1px solid #ddd;">Value</th>'
+                    + '</tr>';
+              for (let i = 0; i < bandNames.length; i++) {
+                const value = values[i] !== null ? values[i] : 'No data';
+                html += `<tr>
+                  <td style="text-align: left; padding: 1px;">${bandNames[i]}</td>
+                  <td style="text-align: right; padding: 1px;">${value}</td>
+                </tr>`;
+              }
+              html += '</table>';
+              return html;
+            };
+
+            const formatPopupContent = (data) => {
+              let html = `<div style="max-width: 250px;">
+    <p><strong>Coordinates:</strong> ${lat}, ${lng}</p>`;
+
+              if (data.values !== undefined) {
+                // TilerFactory shape: flat band list
+                html += renderBandTable(data.band_names, data.values);
+              } else if (data.assets !== undefined) {
+                // MosaicTilerFactory shape: one entry per asset
+                for (const asset of data.assets) {
+                  html += renderBandTable(asset.band_names, asset.values);
+                }
+              }
+
+              html += '</div>';
+              return html;
+            };
+
+          popup.setContent(formatPopupContent(data));
+        })
+        .catch(err => {
+          if (err.errorData && err.errorData.detail) {
+            popup.setContent(`<p>${err.errorData.detail}</p>`);
+          } else {
+            popup.setContent(`<p>Error: ${err.message || 'An unknown error occurred'}</p>`);
+          }
+        });
+      });
     </script>
-    </body>
-    </html>
+  </body>
+</html>
diff --git a/src/titiler/core/titiler/core/templates/tilematrixset.html b/src/titiler/core/titiler/core/templates/tilematrixset.html
new file mode 100644
index 000000000..e711f5137
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/tilematrixset.html
@@ -0,0 +1,95 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ response.title or response.id }}</h1>
+
+<div class="row">
+  <div class="col-sm">
+    <ul>
+      {% for key in ['title', 'description', 'id', 'uri', 'crs', 'wellKnownScaleSet', 'orderedAxes'] %}
+        {% if response[key]  %}
+          <li><strong>{{ key }}:</strong> {{ response[key] }}</li>
+        {% endif %}
+      {% endfor %}
+
+      <li><strong>Nb TileMatrices:</strong> {{ response.tileMatrices|count }}</li>
+      <li><strong>Min level:</strong> {{ response.tileMatrices[0].id }}</li>
+      <li><strong>Max level:</strong> {{ response.tileMatrices[-1].id }}</li>
+      <li><strong>Origin:</strong> {{ response.tileMatrices[0].pointOfOrigin }}</li>
+      <li><strong>Tile size:</strong> {{ [response.tileMatrices[0].tileWidth, response.tileMatrices[0].tileHeight] }}</li>
+
+    </ul>
+  </div>
+  <div class="col-sm">
+    <div id="map" class="rounded" style="width: 100%; height: 400px">
+      Loading...
+    </div>
+  </div>
+</div>
+
+<script>
+  $(function() {
+    var map = L.map('map').setView([0, 0], 1);
+    map.addLayer(new L.TileLayer(
+      'https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
+        maxZoom: 18,
+        attribution: 'Map data &copy; <a href="https://openstreetmap.org/copyright">OpenStreetMap contributors</a>'
+      }
+    ));
+
+    var bbox = {{ response.bbox or [-180,-90,180,90] }};
+
+    const bboxPolygon = (bounds) => {
+      return {
+        'type': 'Feature',
+        'geometry': {
+            'type': 'Polygon',
+            'coordinates': [[
+                [bounds[0], bounds[1]],
+                [bounds[2], bounds[1]],
+                [bounds[2], bounds[3]],
+                [bounds[0], bounds[3]],
+                [bounds[0], bounds[1]]
+            ]]
+        },
+        'properties': {}
+      }
+    }
+
+    if (bbox[0] > bbox[2]) {
+      geo = {
+        "type": "FeatureCollection",
+        "features": [
+          bboxPolygon([-180, bbox[1], bbox[2], bbox[3]]),
+          bboxPolygon([bbox[0], bbox[1], 180, bbox[3]]),
+        ]
+      }
+    } else {
+      geo = {
+        "type": "FeatureCollection",
+        "features": [bboxPolygon(bbox)]
+      }
+    }
+
+    var aoi = L.geoJSON(geo).addTo(map);
+    map.fitBounds(aoi.getBounds());
+  });
+</script>
+{% include "footer.html" %}
diff --git a/src/titiler/core/titiler/core/templates/tilematrixsets.html b/src/titiler/core/titiler/core/templates/tilematrixsets.html
new file mode 100644
index 000000000..4d6912da6
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/tilematrixsets.html
@@ -0,0 +1,32 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ template.title }}</h1>
+
+<p>This API implements <a target="_blank" href="https://www.ogc.org/standard/tms/">TileMatrixSets</a> that are listed below.</p>
+
+<h2>Links</h2>
+<ul>
+{% for tms in response.tileMatrixSets %}
+  <li> <a href="{{ tms.links[0].href }}">{{ tms.id }}</a></li>
+{% endfor %}
+</ul>
+
+{% include "footer.html" %}
diff --git a/src/titiler/core/titiler/core/templates/tileset.html b/src/titiler/core/titiler/core/templates/tileset.html
new file mode 100644
index 000000000..b6d7a05f9
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/tileset.html
@@ -0,0 +1,126 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/?{{ params }}">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ response.title}}</h1>
+
+<div class="row" style="margin-top: 30px;">
+  <div class="col-sm">
+
+    <h2>Properties</h2>
+    <li><strong>DataType:</strong> {{ response.dataType }}</li>
+    <li><strong>CRS:</strong> {{ response.crs }}</li>
+
+    <h2 style="margin-top: 10px;">TileMatrixSet Limits</h2>
+
+    <table>
+      <tr>
+        <th style="padding: 5px;">Level</th>
+        <th style="padding: 5px;">minTileRow</th>
+        <th style="padding: 5px;">maxTileRow</th>
+        <th style="padding: 5px;">minTileCol</th>
+        <th style="padding: 5px;">maxTileCol</th>
+     </tr>
+      {% for tms in response.tileMatrixSetLimits %}
+      <tr>
+         <td style="text-align: right;">{{ tms.tileMatrix }}</td>
+         <td style="text-align: right;">{{ tms.minTileRow }}</td>
+         <td style="text-align: right;">{{ tms.maxTileRow }}</td>
+         <td style="text-align: right;">{{ tms.minTileCol }}</td>
+         <td style="text-align: right;">{{ tms.maxTileCol }}</td>
+      </tr>
+      {% endfor %}
+    </table>
+
+    <h2 style="margin-top: 10px;">Links</h2>
+    <ul>
+    {% for link in response.links %}
+      {% if link.rel != 'self' %}
+        <li> <a href="{{ link.href }}">{{ link.title }}</a></li>
+      {% endif %}
+    {% endfor %}
+    </ul>
+
+  </div>
+  <div class="col-sm">
+    <div id="map" class="rounded" style="width: 100%; height: 400px">
+      Loading...
+    </div>
+  </div>
+</div>
+
+<script>
+  $(function() {
+    var map = L.map('map').setView([0, 0], 1);
+    map.addLayer(new L.TileLayer(
+      'https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
+        maxZoom: 18,
+        attribution: 'Map data &copy; <a href="https://openstreetmap.org/copyright">OpenStreetMap contributors</a>'
+      }
+    ));
+
+    var bbox;
+    {% if response.boundingBox %}
+    bbox = [
+        {{ response.boundingBox.lowerLeft[0] }},
+        {{ response.boundingBox.lowerLeft[1] }},
+        {{ response.boundingBox.upperRight[0] }},
+        {{ response.boundingBox.upperRight[1] }},
+      ]
+    {% else %}
+      bbox = [-180,-90,180,90]
+    {% endif %};
+
+    const bboxPolygon = (bounds) => {
+      return {
+        'type': 'Feature',
+        'geometry': {
+            'type': 'Polygon',
+            'coordinates': [[
+                [bounds[0], bounds[1]],
+                [bounds[2], bounds[1]],
+                [bounds[2], bounds[3]],
+                [bounds[0], bounds[3]],
+                [bounds[0], bounds[1]]
+            ]]
+        },
+        'properties': {}
+      }
+    }
+
+    if (bbox[0] > bbox[2]) {
+      geo = {
+        "type": "FeatureCollection",
+        "features": [
+          bboxPolygon([-180, bbox[1], bbox[2], bbox[3]]),
+          bboxPolygon([bbox[0], bbox[1], 180, bbox[3]]),
+        ]
+      }
+    } else {
+      geo = {
+        "type": "FeatureCollection",
+        "features": [bboxPolygon(bbox)]
+      }
+    }
+
+    var aoi = L.geoJSON(geo).addTo(map);
+    map.fitBounds(aoi.getBounds());
+  });
+</script>
+{% include "footer.html" %}
diff --git a/src/titiler/core/titiler/core/templates/tilesets.html b/src/titiler/core/titiler/core/templates/tilesets.html
new file mode 100644
index 000000000..3cb8e153e
--- /dev/null
+++ b/src/titiler/core/titiler/core/templates/tilesets.html
@@ -0,0 +1,31 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ template.title }} TileSet list</h1>
+
+<h2>Links</h2>
+<ul>
+{% for tileset in response.tilesets %}
+  <li> <a href="{{ tileset.links[0].href }}">{{ tileset.title }}</a></li>
+{% endfor %}
+</ul>
+
+
+{% include "footer.html" %}
diff --git a/src/titiler/core/titiler/core/templates/wmts.xml b/src/titiler/core/titiler/core/templates/wmts.xml
deleted file mode 100644
index a42f54095..000000000
--- a/src/titiler/core/titiler/core/templates/wmts.xml
+++ /dev/null
@@ -1,62 +0,0 @@
-<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gml="http://www.opengis.net/gml" xsi:schemaLocation="http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd" version="1.0.0">
-    <ows:ServiceIdentification>
-        <ows:Title>"{{ title }}"</ows:Title>
-        <ows:ServiceType>OGC WMTS</ows:ServiceType>
-        <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
-    </ows:ServiceIdentification>
-    <ows:OperationsMetadata>
-        <ows:Operation name="GetCapabilities">
-            <ows:DCP>
-                <ows:HTTP>
-                    <ows:Get xlink:href="{{ request.url }}">
-                        <ows:Constraint name="GetEncoding">
-                            <ows:AllowedValues>
-                                <ows:Value>RESTful</ows:Value>
-                            </ows:AllowedValues>
-                        </ows:Constraint>
-                    </ows:Get>
-                </ows:HTTP>
-            </ows:DCP>
-        </ows:Operation>
-        <ows:Operation name="GetTile">
-            <ows:DCP>
-                <ows:HTTP>
-                    <ows:Get xlink:href="{{ request.url }}">
-                        <ows:Constraint name="GetEncoding">
-                            <ows:AllowedValues>
-                                <ows:Value>RESTful</ows:Value>
-                            </ows:AllowedValues>
-                        </ows:Constraint>
-                    </ows:Get>
-                </ows:HTTP>
-            </ows:DCP>
-        </ows:Operation>
-    </ows:OperationsMetadata>
-    <Contents>
-        <Layer>
-            <ows:Title>{{ title }}</ows:Title>
-            <ows:Identifier>{{ layer_name }}</ows:Identifier>
-            <ows:Abstract>{{ title }}</ows:Abstract>
-            <ows:WGS84BoundingBox crs="urn:ogc:def:crs:OGC:2:84">
-                <ows:LowerCorner>{{ bounds[0] }} {{ bounds[1] }}</ows:LowerCorner>
-                <ows:UpperCorner>{{ bounds[2] }} {{ bounds[3] }}</ows:UpperCorner>
-            </ows:WGS84BoundingBox>
-            <Style isDefault="true">
-                <ows:Identifier>default</ows:Identifier>
-            </Style>
-            <Format>{{ media_type }}</Format>
-            <TileMatrixSetLink>
-                <TileMatrixSet>{{ tms.identifier }}</TileMatrixSet>
-            </TileMatrixSetLink>
-            <ResourceURL format="{{ media_type }}" resourceType="tile" template="{{ tiles_endpoint }}" />
-        </Layer>
-        <TileMatrixSet>
-            <ows:Identifier>{{ tms.identifier }}</ows:Identifier>
-            <ows:SupportedCRS>{{ tms.crs.srs }}</ows:SupportedCRS>
-            {% for item in tileMatrix %}
-            {{ item | safe }}
-            {% endfor %}
-        </TileMatrixSet>
-    </Contents>
-    <ServiceMetadataURL xlink:href="{{ request.url }}" />
-</Capabilities>
diff --git a/src/titiler/core/titiler/core/utils.py b/src/titiler/core/titiler/core/utils.py
new file mode 100644
index 000000000..fa97163e2
--- /dev/null
+++ b/src/titiler/core/titiler/core/utils.py
@@ -0,0 +1,543 @@
+"""titiler.core utilities."""
+
+from __future__ import annotations
+
+import re
+import warnings
+from collections.abc import Callable, Sequence
+from typing import Any, TypedDict, TypeVar, cast
+from urllib.parse import urlencode
+
+import numpy
+import pyproj
+import rasterio
+from fastapi import FastAPI
+from fastapi._compat import (
+    get_definitions,
+    get_flat_models_from_fields,
+    get_model_name_map,
+)
+from fastapi.datastructures import QueryParams
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import (
+    get_dependant,
+    get_flat_params,
+    request_params_to_args,
+)
+from fastapi.openapi.utils import _get_openapi_operation_parameters
+from geojson_pydantic.geometries import MultiPolygon, Polygon
+from morecantile import TileMatrixSet
+from rasterio.dtypes import dtype_ranges
+from rio_tiler.colormap import apply_cmap
+from rio_tiler.errors import InvalidDatatypeWarning
+from rio_tiler.models import ImageData
+from rio_tiler.types import BBox, ColorMapType, IntervalTuple
+from rio_tiler.utils import linear_rescale, render
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.routing import Route, request_response
+from starlette.templating import Jinja2Templates, _TemplateResponse
+
+from titiler.core.resources.enums import ImageType, MediaType
+
+
+def rescale_array(
+    array: numpy.ndarray,
+    mask: numpy.ndarray,
+    in_range: Sequence[IntervalTuple],
+    out_range: Sequence[IntervalTuple] = ((0, 255),),
+    out_dtype: str | numpy.number = "uint8",
+) -> numpy.ndarray:
+    """Rescale data array"""
+    if len(array.shape) < 3:
+        array = numpy.expand_dims(array, axis=0)
+
+    nbands = array.shape[0]
+    if len(in_range) != nbands:
+        in_range = ((in_range[0]),) * nbands
+
+    if len(out_range) != nbands:
+        out_range = ((out_range[0]),) * nbands
+
+    for bdx in range(nbands):
+        array[bdx] = numpy.where(
+            mask[bdx],
+            linear_rescale(
+                array[bdx], in_range=in_range[bdx], out_range=out_range[bdx]
+            ),
+            0,
+        )
+
+    return array.astype(out_dtype)
+
+
+def render_image(  # noqa: C901
+    image: ImageData,
+    colormap: ColorMapType | None = None,
+    output_format: ImageType | None = None,
+    add_mask: bool = True,
+    rescale: Sequence[IntervalTuple] | None = None,
+    color_formula: str | None = None,
+    **kwargs: Any,
+) -> tuple[bytes, str]:
+    """convert image data to file.
+
+    This is adapted from https://github.com/cogeotiff/rio-tiler/blob/066878704f841a332a53027b74f7e0a97f10f4b2/rio_tiler/models.py#L698-L764
+    """
+    if rescale:
+        image.rescale(rescale)
+
+    if color_formula:
+        image.apply_color_formula(color_formula)
+
+    data, mask = image.data.copy(), image.mask.copy()
+    input_range = dtype_ranges[str(data.dtype)]
+    output_range = image.dataset_statistics or (input_range,)
+
+    if colormap:
+        data, alpha_from_cmap = apply_cmap(data, colormap)
+        output_range = (dtype_ranges[str(data.dtype)],)
+        # Combine both Mask from dataset and Alpha band from Colormap
+        mask = numpy.where(
+            mask != input_range[0], alpha_from_cmap, output_range[0][0]
+        ).astype(data.dtype)
+
+    # format-specific valid dtypes
+    format_dtypes = {
+        ImageType.png: ["uint8", "uint16"],
+        ImageType.jpeg: ["uint8"],
+        ImageType.jpg: ["uint8"],
+        ImageType.webp: ["uint8"],
+        ImageType.jp2: ["uint8", "int16", "uint16"],
+    }
+
+    # If output_format is not set, we choose between JPEG and PNG
+    if not output_format:
+        # Check if any alpha value == min datatype value (== Masked)
+        is_masked = (mask == dtype_ranges[str(mask.dtype)][0]).any()
+        output_format = ImageType.png if is_masked else ImageType.jpeg
+        # For automatic format we make sure the output datatype
+        # will be the same for both JPEG and PNG
+        format_dtypes[ImageType.png] = ["uint8"]
+
+    valid_dtypes = format_dtypes.get(output_format, [])
+    if valid_dtypes and data.dtype not in valid_dtypes:
+        warnings.warn(
+            f"Invalid type: `{data.dtype}` for the `{output_format}` driver. "
+            "Data will be rescaled using min/max type bounds or dataset_statistics.",
+            InvalidDatatypeWarning,
+            stacklevel=1,
+        )
+        data = rescale_array(data, mask, in_range=output_range)
+
+    creation_options = {**kwargs, **output_format.profile}
+    if output_format.driver == "GTiff":
+        if "transform" not in creation_options:
+            creation_options.update({"transform": image.transform})
+        if "crs" not in creation_options and image.crs:
+            creation_options.update({"crs": image.crs})
+
+    if add_mask:
+        content = render(
+            data,
+            mask,
+            img_format=output_format.driver,
+            **creation_options,
+        )
+    else:
+        content = render(
+            data,
+            img_format=output_format.driver,
+            **creation_options,
+        )
+
+    return content, output_format.mediatype
+
+
+def bounds_to_geometry(bounds: BBox) -> Polygon | MultiPolygon:
+    """Convert bounds to geometry.
+
+    Note: if bounds are crossing the dateline separation line, a MultiPolygon geometry will be returned.
+
+    """
+    if bounds[0] > bounds[2]:
+        pl = Polygon.from_bounds(-180, bounds[1], bounds[2], bounds[3])
+        pr = Polygon.from_bounds(bounds[0], bounds[1], 180, bounds[3])
+        return MultiPolygon(
+            type="MultiPolygon",
+            coordinates=[pl.coordinates, pr.coordinates],
+        )
+    return Polygon.from_bounds(*bounds)
+
+
+T = TypeVar("T")
+
+ValidParams = dict[str, Any]
+Errors = list[Any]
+
+
+def get_dependency_query_params(
+    dependency: Callable,
+    params: QueryParams | dict,
+) -> tuple[ValidParams, Errors]:
+    """Check QueryParams for Query dependency.
+
+    1. `get_dependant` is used to get the query-parameters required by the `callable`
+    2. we use `request_params_to_args` to construct arguments needed to call the `callable`
+    3. we call the `callable` and catch any errors
+
+    Important: We assume the `callable` in not a co-routine.
+    """
+    dep = get_dependant(path="", call=dependency)
+
+    qp = (
+        QueryParams(urlencode(params, doseq=True))
+        if isinstance(params, dict)
+        else params
+    )
+    return request_params_to_args(dep.query_params, qp)
+
+
+def deserialize_query_params(
+    dependency: Callable[..., T], params: QueryParams | dict
+) -> tuple[T, Errors]:
+    """Deserialize QueryParams for given dependency.
+
+    Parse params as query params and deserialize with dependency.
+
+    Important: We assume the `callable` in not a co-routine.
+    """
+    values, errors = get_dependency_query_params(dependency, params)
+    return dependency(**values), errors
+
+
+def extract_query_params(
+    dependencies: list[Callable],
+    params: QueryParams | dict,
+) -> tuple[ValidParams, Errors]:
+    """Extract query params given list of dependencies."""
+    values = {}
+    errors = []
+    for dep in dependencies:
+        query_params, dep_errors = get_dependency_query_params(dep, params)
+        if query_params:
+            values.update(query_params)
+        errors += dep_errors
+    return values, errors
+
+
+def check_query_params(
+    dependencies: list[Callable], params: QueryParams | dict
+) -> bool:
+    """Check QueryParams for Query dependency.
+
+    1. `get_dependant` is used to get the query-parameters required by the `callable`
+    2. we use `request_params_to_args` to construct arguments needed to call the `callable`
+    3. we call the `callable` and catch any errors
+
+    Important: We assume the `callable` in not a co-routine
+
+    """
+    qp = (
+        QueryParams(urlencode(params, doseq=True))
+        if isinstance(params, dict)
+        else params
+    )
+
+    for dependency in dependencies:
+        try:
+            dep = get_dependant(path="", call=dependency)
+            if dep.query_params:
+                # call the dependency with the query-parameters values
+                query_values, errors = request_params_to_args(dep.query_params, qp)
+                if errors:
+                    return False
+
+                _ = dependency(**query_values)
+
+        except Exception:
+            return False
+
+    return True
+
+
+def dependencies_to_openapi_params(
+    dependencies: list[Callable],
+) -> list[dict[str, Any]]:
+    """Extract OpenAPI query parameter schemas from a list of FastAPI dependencies.
+
+    This Code was generated with help of Claude 2.0. See plans/openapi-params-from-dependencies.prompt.md.
+    """
+    all_fields = []
+    seen: set[str] = set()
+    for dep in dependencies:
+        dependant = get_dependant(path="", call=dep)
+        for field in get_flat_params(dependant):
+            if field.name not in seen:
+                seen.add(field.name)
+                all_fields.append(field)
+
+    if not all_fields:
+        return []
+
+    flat_models = get_flat_models_from_fields(all_fields, known_models=set())
+    model_name_map = get_model_name_map(flat_models)
+    field_mapping, _ = get_definitions(fields=all_fields, model_name_map=model_name_map)
+
+    combined = Dependant(path="")
+    combined.query_params = all_fields
+    return _get_openapi_operation_parameters(
+        dependant=combined,
+        model_name_map=model_name_map,
+        field_mapping=field_mapping,
+    )
+
+
+def accept_media_type(accept: str, mediatypes: list[MediaType]) -> MediaType | None:
+    """Return MediaType based on accept header and available mediatype.
+
+    Links:
+    - https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+    - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept
+
+    """
+    accept_values = {}
+    for m in accept.replace(" ", "").split(","):
+        values = m.split(";")
+        if len(values) == 1:
+            name = values[0]
+            quality = 1.0
+        else:
+            name = values[0]
+            groups = dict([param.split("=") for param in values[1:]])  # type: ignore
+            try:
+                q = groups.get("q")
+                quality = float(q) if q else 1.0
+            except ValueError:
+                quality = 0
+
+        # if quality is 0 we ignore encoding
+        if quality:
+            accept_values[name] = quality
+
+    # Create Preference matrix
+    media_preference = {
+        v: [n for (n, q) in accept_values.items() if q == v]
+        for v in sorted(set(accept_values.values()), reverse=True)
+    }
+
+    # Loop through available compression and encoding preference
+    for _, pref in media_preference.items():
+        for media in mediatypes:
+            if media.value in pref:
+                return media
+
+    # If no specified encoding is supported but "*" is accepted,
+    # take one of the available compressions.
+    if "*" in accept_values and mediatypes:
+        return mediatypes[0]
+
+    return None
+
+
+def update_openapi(app: FastAPI) -> FastAPI:
+    """Update OpenAPI response content-type.
+
+    This function modifies the openapi route to comply with the STAC API spec's required
+    content-type response header.
+
+    Copied from https://github.com/stac-utils/stac-fastapi/blob/main/stac_fastapi/api/stac_fastapi/api/openapi.py
+
+    MIT License
+
+    Copyright (c) 2020 Arturo AI
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+    """
+    # Find the route for the openapi_url in the app
+    openapi_route: Route = next(
+        cast(Route, route)
+        for route in app.router.routes
+        if route.path == app.openapi_url  # type: ignore
+    )
+    # Store the old endpoint function so we can call it from the patched function
+    old_endpoint = openapi_route.endpoint
+
+    # Create a patched endpoint function that modifies the content type of the response
+    async def patched_openapi_endpoint(req: Request) -> Response:
+        # Get the response from the old endpoint function
+        response = await old_endpoint(req)
+        # Update the content type header in place
+        response.headers["content-type"] = (
+            "application/vnd.oai.openapi+json;version=3.0"
+        )
+        # Return the updated response
+        return response
+
+    # When a Route is accessed the `handle` function calls `self.app`. Which is
+    # the endpoint function wrapped with `request_response`. So we need to wrap
+    # our patched function and replace the existing app with it.
+    openapi_route.app = request_response(patched_openapi_endpoint)
+
+    # return the patched app
+    return app
+
+
+def create_html_response(
+    request: Request,
+    data: Any,
+    template_name: str,
+    templates: Jinja2Templates,
+    title: str | None = None,
+    router_prefix: str | None = None,
+    **kwargs: Any,
+) -> _TemplateResponse:
+    """Create Template response."""
+    urlpath = request.url.path
+    if root_path := request.scope.get("root_path"):
+        urlpath = re.sub(r"^" + root_path, "", urlpath)
+
+    if router_prefix:
+        urlpath = re.sub(r"^" + router_prefix, "", urlpath)
+
+    crumbs = []
+    baseurl = str(request.base_url).rstrip("/")
+
+    if router_prefix:
+        baseurl += router_prefix
+
+    crumbpath = str(baseurl)
+    if urlpath == "/":
+        urlpath = ""
+
+    for crumb in urlpath.split("/"):
+        crumbpath = crumbpath.rstrip("/")
+        part = crumb
+        if part is None or part == "":
+            part = "Home"
+        crumbpath += f"/{crumb}"
+        crumbs.append({"url": crumbpath.rstrip("/"), "part": part.capitalize()})
+
+    return templates.TemplateResponse(
+        request,
+        name=f"{template_name}.html",
+        context={
+            "response": data,
+            "template": {
+                "api_root": baseurl,
+                "params": request.query_params,
+                "title": title or template_name,
+            },
+            "crumbs": crumbs,
+            "url": baseurl + urlpath,
+            "params": str(request.url.query),
+            **kwargs,
+        },
+    )
+
+
+class TMSLimits(TypedDict):
+    """TileMatrixSet Limits model."""
+
+    tileMatrix: str
+    minTileRow: int
+    maxTileRow: int
+    minTileCol: int
+    maxTileCol: int
+
+
+def tms_limits(
+    tms: TileMatrixSet,
+    bounds: tuple[float, float, float, float],
+    zooms: tuple[int, int] | None = None,
+    geographic_crs: pyproj.CRS | rasterio.crs.CRS | None = None,
+) -> list[TMSLimits]:
+    """Generate TileMatrixSet limits for given bounds and zoom levels."""
+    if geographic_crs:
+        geographic_crs = rio_crs_to_pyproj(geographic_crs)
+
+    if zooms:
+        minzoom, maxzoom = zooms
+    else:
+        minzoom, maxzoom = tms.minzoom, tms.maxzoom
+
+    tilematrix_limits: list[TMSLimits] = []
+    for zoom in range(minzoom, maxzoom + 1):
+        matrix = tms.matrix(zoom)
+        ulTile = tms.tile(bounds[0], bounds[3], zoom, geographic_crs=geographic_crs)
+        lrTile = tms.tile(bounds[2], bounds[1], zoom, geographic_crs=geographic_crs)
+        minx, maxx = (min(ulTile.x, lrTile.x), max(ulTile.x, lrTile.x))
+        miny, maxy = (min(ulTile.y, lrTile.y), max(ulTile.y, lrTile.y))
+        tilematrix_limits.append(
+            {
+                "tileMatrix": matrix.id,
+                "minTileRow": max(miny, 0),
+                "maxTileRow": min(maxy, matrix.matrixHeight),
+                "minTileCol": max(minx, 0),
+                "maxTileCol": min(maxx, matrix.matrixWidth),
+            }
+        )
+
+    return tilematrix_limits
+
+
+def tms_limits_to_xml(limits: list[TMSLimits]) -> list[str]:
+    """Convert TMS limits to XML."""
+    xml_limits: list[str] = []
+    for limit in limits:
+        xml_limits.append(
+            f"""<TileMatrixLimits>
+                    <TileMatrix>{limit['tileMatrix']}</TileMatrix>
+                    <MinTileRow>{limit['minTileRow']}</MinTileRow>
+                    <MaxTileRow>{limit['maxTileRow']}</MaxTileRow>
+                    <MinTileCol>{limit['minTileCol']}</MinTileCol>
+                    <MaxTileCol>{limit['maxTileCol']}</MaxTileCol>
+                </TileMatrixLimits>""",
+        )
+
+    return xml_limits
+
+
+def tms_to_xml(tms: TileMatrixSet, minzoom, maxzoom) -> list[str]:
+    """Convert TMS Matrices to XML."""
+    xml_matrices: list[str] = []
+    for zoom in range(minzoom, maxzoom + 1):
+        matrix = tms.matrix(zoom)
+        xml_matrices.append(
+            f"""<TileMatrix>
+                    <ows:Identifier>{matrix.id}</ows:Identifier>
+                    <ScaleDenominator>{matrix.scaleDenominator}</ScaleDenominator>
+                    <TopLeftCorner>{matrix.pointOfOrigin[0]} {matrix.pointOfOrigin[1]}</TopLeftCorner>
+                    <TileWidth>{matrix.tileWidth}</TileWidth>
+                    <TileHeight>{matrix.tileHeight}</TileHeight>
+                    <MatrixWidth>{matrix.matrixWidth}</MatrixWidth>
+                    <MatrixHeight>{matrix.matrixHeight}</MatrixHeight>
+                </TileMatrix>""",
+        )
+
+    return xml_matrices
+
+
+def rio_crs_to_pyproj(crs: pyproj.CRS | rasterio.crs.CRS) -> pyproj.CRS:
+    """Convert rasterio CRS to pyproj CRS."""
+    if isinstance(crs, pyproj.CRS):
+        return crs
+
+    with rasterio.Env(OSR_WKT_FORMAT="WKT2_2018"):
+        return pyproj.CRS.from_user_input(crs)
diff --git a/src/titiler/core/titiler/core/validation.py b/src/titiler/core/titiler/core/validation.py
new file mode 100644
index 000000000..5d42dae1b
--- /dev/null
+++ b/src/titiler/core/titiler/core/validation.py
@@ -0,0 +1,131 @@
+"""Dependency validations."""
+
+import re
+from json import JSONDecodeError, loads
+
+from color_operations import parse_operations as parse_color_formula
+from rasterio.crs import CRS
+
+
+def validate_rescale(rescale_strs: list[str]) -> list[str]:
+    """
+    Verify that rescale input matches an accepted pattern.
+    :param rescale_strs: Caller-provided rescale values.
+    :type rescale_strs: list[str]
+    :return: Caller-provided rescale values if validated, otherwise an exception is raised.
+    :rtype: list[str]
+    """
+    validated_rescales: list[str] = []
+    for rescale_str in rescale_strs:
+        error_text = "invalid rescale format"
+        rescale_parts = [
+            re.sub(r"[\[|\]]", "", part) for part in rescale_str.split(",")
+        ]
+        if len(rescale_parts) == 2:
+            try:
+                # Regex validation adds risk, given the different string
+                # formats that can be parsed to float, so simply attempt
+                # to parse.
+                min = float(rescale_parts[0])
+                max = float(rescale_parts[1])
+            except ValueError as e:
+                error_text = f"{error_text}: {e}"
+            else:
+                validated_rescales.append(f"{min},{max}")
+                continue
+        raise ValueError(error_text)
+    return validated_rescales
+
+
+def validate_crs(crs_str: str | None) -> str | None:
+    """
+    Verify that crs input matches an accepted format.
+    :param crs_str: Caller-provided crs value.
+    :type crs_str: str | None
+    :return: Caller-provided crs value if accepted, otherwise an exception is raised.
+    :rtype: str | None
+    """
+    if crs_str is None:
+        return None
+    if crs_str.startswith("[") and crs_str.endswith(
+        "]"
+    ):  # this block lifted from OGCMapsParams
+        crs_str = crs_str[1:-1]
+    try:
+        # CRS does not provide a static `is_valid` check, and "many different kinds" of formats
+        # are supported, making regex impractical.
+        # (https://rasterio.readthedocs.io/en/latest/api/rasterio.crs.html#rasterio.crs.CRS.from_user_input)
+        CRS.from_user_input(crs_str)
+    except ValueError as e:
+        raise ValueError("invalid CRS format") from e
+    else:
+        return crs_str
+
+
+def validate_json(json_str: str | None) -> str | None:
+    """
+    Verify that json input can be parsed.
+    :param json_str: Caller-provided crs value.
+    :type json_str: str | None
+    :return: Caller-provided json_str value if valid, otherwise an exception is raised.
+    :rtype: str | None
+    """
+    if json_str is None:
+        return None
+    try:
+        loads(json_str)
+    except JSONDecodeError as e:
+        raise ValueError("invalid JSON content") from e
+    else:
+        return json_str
+
+
+def validate_color_formula(color_formula_str: str | None) -> str | None:
+    """
+    Verify that color formula can be parsed.
+    :param color_formula_str: Caller-provided color formula value.
+    :type color_formula_str: str | None
+    :return: Caller-provided color formula value if valid, otherwise an exception is raised.
+    :rtype: str | None
+    """
+    if color_formula_str is None:
+        return None
+    try:
+        parse_color_formula(color_formula_str)
+    except Exception as e:
+        raise ValueError("invalid color formula") from e
+    else:
+        return color_formula_str
+
+
+def validate_bbox(bbox_str: str | None) -> str | None:
+    """
+    Verify that bbox can be parsed.
+    :param bbox_str: Caller-provided bbox value.
+    :type bbox_str: str | None
+    :return: Caller-provided bbox_str value if valid, otherwise an exception is raised.
+    :rtype: str | None
+    """
+    if bbox_str is None:
+        return None
+    if re.match(separated_parseable_floats_regex(count=4), bbox_str) or re.match(
+        separated_parseable_floats_regex(count=6), bbox_str
+    ):
+        return bbox_str
+    raise ValueError("invalid bbox content")
+
+
+def separated_parseable_floats_regex(count: int, separator: str = ",") -> str:
+    """
+    Generate a regular expression for n separated strings representing floats.
+    :param count: Number of separated float strings to match
+    :type count: int
+    :param separator: Character used to separate float strings.
+    :type separator: str
+    :return: Generated regular expression.
+    :rtype: str
+    """
+    parseable_float_regex = r"\s*(-)?\d+((\.\d+)(e\d+)?)?\s*"
+    return "^{}$".format(
+        re.escape(separator).join([parseable_float_regex for _ in range(count)])
+    )
diff --git a/src/titiler/extensions/LICENSE b/src/titiler/extensions/LICENSE
new file mode 100644
index 000000000..eb4365951
--- /dev/null
+++ b/src/titiler/extensions/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Development Seed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/titiler/extensions/README.md b/src/titiler/extensions/README.md
index 4ae1309ea..0e86f240c 100644
--- a/src/titiler/extensions/README.md
+++ b/src/titiler/extensions/README.md
@@ -5,14 +5,14 @@ Extent TiTiler Tiler Factories
 ## Installation
 
 ```bash
-$ pip install -U pip
+python -m pip install -U pip
 
 # From Pypi
-$ pip install titiler.extensions
+python -m pip install titiler.extensions
 
 # Or from sources
-$ git clone https://github.com/developmentseed/titiler.git
-$ cd titiler && pip install -e titiler/core -e titiler/extensions
+git clone https://github.com/developmentseed/titiler.git
+cd titiler && python -m pip install -e src/titiler/core -e src/titiler/extensions
 ```
 
 ## Available extensions
@@ -58,19 +58,16 @@ tiler = TilerFactory(
 app.include_router(tiler.router, prefix="/cog")
 ```
 
-See [titiler.application](../application) for a full example.
-
-
 ## Create your own
 
 ```python
 from dataclasses import dataclass, field
 from typing import Tuple, List, Optional
-
+import rasterio
 from starlette.responses import Response
 from fastapi import Depends, FastAPI, Query
-from titiler.core.factory import BaseTilerFactory, FactoryExtension, TilerFactory
-from titiler.core.dependencies import RescalingParams
+from titiler.core.factory import TilerFactory, FactoryExtension
+from titiler.core.dependencies import ImageRenderingParams
 from titiler.core.factory import TilerFactory
 from titiler.core.resources.enums import ImageType
 
@@ -82,8 +79,8 @@ class thumbnailExtension(FactoryExtension):
     # Set some options
     max_size: int = field(default=128)
 
-    # Register method is mandatory and must take a BaseTilerFactory object as input
-    def register(self, factory: BaseTilerFactory):
+    # Register method is mandatory and must take a TilerFactory object as input
+    def register(self, factory: TilerFactory):
         """Register endpoint to the tiler factory."""
 
         # register an endpoint to the factory's router
@@ -103,47 +100,37 @@ class thumbnailExtension(FactoryExtension):
         def thumbnail(
             # we can reuse the factory dependency
             src_path: str = Depends(factory.path_dependency),
+            reader_params=Depends(factory.reader_dependency),
             layer_params=Depends(factory.layer_dependency),
             dataset_params=Depends(factory.dataset_dependency),
             post_process=Depends(factory.process_dependency),
-            rescale: Optional[List[Tuple[float, ...]]] = Depends(RescalingParams),
-            color_formula: Optional[str] = Query(
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
             colormap=Depends(factory.colormap_dependency),
             render_params=Depends(factory.render_dependency),
-            reader_params=Depends(factory.reader_dependency),
             env=Depends(factory.environment_dependency),
         ):
             with rasterio.Env(**env):
-                with self.reader(src_path, **reader_params) as src_dst:
-                        im = src.preview(
-                            max_size=self.max_size,
-                            **layer_params,
-                            **dataset_params,
-                        )
+                with factory.reader(src_path, **reader_params.as_dict()) as src:
+                    image = src.preview(
+                        max_size=self.max_size,
+                        **layer_params.as_dict(),
+                        **dataset_params.as_dict(),
+                    )
 
             if post_process:
                 image = post_process(image)
 
-            if rescale:
-                image.rescale(rescale)
-
-            if color_formula:
-                image.apply_color_formula(color_formula)
-
             format = ImageType.jpeg if image.mask.all() else ImageType.png
 
-            content = image.render(
-                img_format=format.driver,
-                colormap=colormap or dst_colormap,
-                **format.profile,
-                **render_params,
+            if post_process:
+                image = post_process(image)
+
+            content, media_type = factory.render_func(
+                image,
+                colormap=colormap,
+                **render_params.as_dict(),
             )
 
-            return Response(content, media_type=format.mediatype)
+            return Response(content, media_type=media_type)
 
 # Use it
 app = FastAPI()
diff --git a/src/titiler/extensions/pyproject.toml b/src/titiler/extensions/pyproject.toml
index 3c3972416..22e35ce64 100644
--- a/src/titiler/extensions/pyproject.toml
+++ b/src/titiler/extensions/pyproject.toml
@@ -1,8 +1,8 @@
 [project]
-name = "titiler.extensions"
+name = "titiler-extensions"
 description = "Extensions for TiTiler Factories."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 authors = [
     {name = "Vincent Sarago", email = "vincent@developmentseed.com"},
 ]
@@ -21,30 +21,35 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: GIS",
 ]
 dynamic = ["version"]
 dependencies = [
-    "titiler.core==0.11.7"
+    "titiler-core==2.0.1",  # x-release-please-version
+    "typing-extensions; python_version < '3.12'"
 ]
 
 [project.optional-dependencies]
+cogeo = [
+    "rio-cogeo>=7.0,<8.0",
+]
+stac = [
+    "rio-stac>=0.12,<0.13",
+]
+
+[dependency-groups]
 test = [
     "pytest",
     "pytest-cov",
     "pytest-asyncio",
     "httpx",
-    "jsonschema>=3.0",
-]
-cogeo = [
-    "rio-cogeo>=3.1,<4.0",
-]
-stac = [
-    "rio-stac>=0.6,<0.7",
+    "pystac[validation]>=1.0.0,<2.0.0",
+    "owslib",
 ]
 
 [project.urls]
@@ -54,14 +59,15 @@ Issues = "https://github.com/developmentseed/titiler/issues"
 Source = "https://github.com/developmentseed/titiler"
 Changelog = "https://developmentseed.org/titiler/release-notes/"
 
-[build-system]
-requires = ["pdm-pep517"]
-build-backend = "pdm.pep517.api"
-
-[tool.pdm.version]
-source = "file"
+[tool.hatch.version]
 path = "titiler/extensions/__init__.py"
 
-[tool.pdm.build]
-includes = ["titiler/extensions"]
-excludes = ["tests/", "**/.mypy_cache", "**/.DS_Store"]
+[tool.hatch.build.targets.sdist]
+only-include = ["titiler"]
+
+[tool.hatch.build.targets.wheel]
+only-include = ["titiler"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
\ No newline at end of file
diff --git a/src/titiler/extensions/tests/conftest.py b/src/titiler/extensions/tests/conftest.py
index eb44cafa4..51e239533 100644
--- a/src/titiler/extensions/tests/conftest.py
+++ b/src/titiler/extensions/tests/conftest.py
@@ -1,6 +1,6 @@
 """``pytest`` configuration."""
 
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 from rasterio.io import MemoryFile
@@ -17,7 +17,7 @@ def set_env(monkeypatch):
     monkeypatch.setenv("AWS_CONFIG_FILE", "/tmp/noconfigheere")
 
 
-def parse_img(content: bytes) -> Dict[Any, Any]:
+def parse_img(content: bytes) -> dict[Any, Any]:
     """Read tile image and return metadata."""
     with MemoryFile(content) as mem:
         with mem.open() as dst:
diff --git a/src/titiler/extensions/tests/fixtures/render_item.json b/src/titiler/extensions/tests/fixtures/render_item.json
new file mode 100644
index 000000000..48d340c22
--- /dev/null
+++ b/src/titiler/extensions/tests/fixtures/render_item.json
@@ -0,0 +1,358 @@
+{
+    "type": "Feature",
+    "stac_version": "1.0.0",
+    "stac_extensions": [
+        "https://stac-extensions.github.io/eo/v1.0.0/schema.json",
+        "https://stac-extensions.github.io/projection/v1.0.0/schema.json",
+        "https://stac-extensions.github.io/view/v1.0.0/schema.json",
+        "https://stac-extensions.github.io/render/v2.0.0/schema.json",
+        "https://stac-extensions.github.io/virtual-assets/v1.0.0/schema.json",
+        "https://stac-extensions.github.io/web-map-links/v1.2.0/schema.json"
+    ],
+    "id": "LC08_L1TP_044033_20210305_20210312_01_T1",
+    "properties": {
+        "gsd": 30,
+        "platform": "LANDSAT_8",
+        "instruments": [
+            "OLI",
+            "TIRS"
+        ],
+        "eo:cloud_cover": 7.41,
+        "proj:epsg": 32610,
+        "view:sun_azimuth": 149.10910644,
+        "view:sun_elevation": 40.48243563,
+        "view:off_nadir": 0.001,
+        "landsat:scene_id": "LC80440332021064LGN00",
+        "landsat:processing_level": "L1TP",
+        "landsat:collection_number": "01",
+        "landsat:collection_category": "T1",
+        "landsat:cloud_cover_land": 7.4,
+        "landsat:wrs_path": "44",
+        "landsat:wrs_row": "33",
+        "datetime": "2021-03-05T18:45:37.619485Z",
+        "created": "2021-03-16T01:40:56.703Z",
+        "updated": "2021-03-16T01:40:56.703Z",
+        "renders": {
+            "thumbnail": {
+                "title": "Thumbnail",
+                "assets": [
+                    "B4",
+                    "B3",
+                    "B2"
+                ],
+                "rescale": [
+                    [
+                        0,
+                        150
+                    ]
+                ],
+                "colormap_name": "rainbow",
+                "resampling": "bilinear",
+                "bidx": [
+                    1
+                ],
+                "width": 1024,
+                "height": 1024,
+                "bands": [
+                    "B4",
+                    "B3",
+                    "B2"
+                ]
+            },
+            "index": {
+                "title": "Thumbnail",
+                "assets": [
+                    "B5",
+                    "B4"
+                ],
+                "expression": "(b1-b2)/(b1+b2)"
+            },
+            "rgb_old": {
+                "title": "Thumbnail",
+                "assets": [
+                    "B4",
+                    "B3",
+                    "B2"
+                ],
+                "asset_bidx": [
+                    "B4|1",
+                    "B3|1",
+                    "B2|1"
+                ]
+            },
+            "expression_old": {
+                "title": "expression",
+                "assets": [
+                    "B02"
+                ],
+                "asset_expression": [
+                    "B02|b1*2"
+                ]
+            },
+            "missing_asset": {
+                "title": "bad_expression",
+                "expression": "b1*2"
+            },
+            "ndvi": {
+                "title": "Normalized Difference Vegetation Index",
+                "assets": [
+                    "ndvi"
+                ],
+                "resampling": "average",
+                "colormap_name": "ylgn",
+                "extra_param": "that titiler does not know"
+            }
+        }
+    },
+    "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+            [
+                [
+                    -122.49680286164214,
+                    39.958062660227306
+                ],
+                [
+                    -120.31547276090922,
+                    39.578858170656
+                ],
+                [
+                    -120.82135075676177,
+                    37.82701417652536
+                ],
+                [
+                    -122.9993441554352,
+                    38.2150173967007
+                ],
+                [
+                    -122.49680286164214,
+                    39.958062660227306
+                ]
+            ]
+        ]
+    },
+    "links": [
+        {
+            "href": "https://maps.example.com/xyz/{z}/{x}/{y}.png",
+            "rel": "xyz",
+            "type": "image/png",
+            "title": "RGB composite visualized through a XYZ"
+        },
+        {
+            "rel": "xyz",
+            "type": "image/png",
+            "title": "NDVI",
+            "href": "https://api.cogeo.xyz/stac/preview.png?url=https://raw.githubusercontent.com/stac-extensions/raster/main/examples/item-landsat8.json&assets=B5&assets=B4&expression=(b1-b2)/(b1+b2)&max_size=512&width=512&resampling_method=average&rescale=-1,1&color_map=ylgn&return_mask=true",
+            "render": "ndvi"
+        },
+        {
+            "rel": "collection",
+            "href": "https://landsat-stac.s3.amazonaws.com/collections/landsat-8-l1.json",
+            "type": "application/json",
+            "title": "The full collection"
+        }
+    ],
+    "assets": {
+        "index": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/index.html",
+            "type": "application/html",
+            "title": "HTML Page"
+        },
+        "ANG": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_ANG.txt",
+            "type": "text/plain",
+            "title": "ANG Metadata",
+            "roles": [
+                "metadata"
+            ]
+        },
+        "MTL": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_MTL.txt",
+            "type": "text/plain",
+            "title": "MTL Metadata",
+            "roles": [
+                "metadata"
+            ]
+        },
+        "BQA": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_BQA.TIF",
+            "type": "image/tiff; application=geotiff",
+            "title": "Quality Band",
+            "roles": [
+                "quality"
+            ]
+        },
+        "B1": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B1.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B1",
+                    "common_name": "coastal",
+                    "center_wavelength": 0.48,
+                    "full_width_half_max": 0.02
+                }
+            ]
+        },
+        "B2": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B2.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B2",
+                    "common_name": "blue",
+                    "center_wavelength": 0.44,
+                    "full_width_half_max": 0.06
+                }
+            ]
+        },
+        "B3": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B3.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B3",
+                    "common_name": "green",
+                    "center_wavelength": 0.56,
+                    "full_width_half_max": 0.06
+                }
+            ]
+        },
+        "B4": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B4.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B4",
+                    "common_name": "red",
+                    "center_wavelength": 0.65,
+                    "full_width_half_max": 0.04
+                }
+            ]
+        },
+        "B5": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B5.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B5",
+                    "common_name": "nir",
+                    "center_wavelength": 0.86,
+                    "full_width_half_max": 0.03
+                }
+            ]
+        },
+        "B6": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B6.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B6",
+                    "common_name": "swir16",
+                    "center_wavelength": 1.6,
+                    "full_width_half_max": 0.08
+                }
+            ]
+        },
+        "B7": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B7.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B7",
+                    "common_name": "swir22",
+                    "center_wavelength": 2.2,
+                    "full_width_half_max": 0.2
+                }
+            ]
+        },
+        "B8": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B8.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B8",
+                    "common_name": "pan",
+                    "center_wavelength": 0.59,
+                    "full_width_half_max": 0.18
+                }
+            ],
+            "gsd": 15
+        },
+        "B9": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B9.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B9",
+                    "common_name": "cirrus",
+                    "center_wavelength": 1.37,
+                    "full_width_half_max": 0.02
+                }
+            ]
+        },
+        "B10": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B10.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B10",
+                    "common_name": "lwir11",
+                    "center_wavelength": 10.9,
+                    "full_width_half_max": 0.8
+                }
+            ],
+            "gsd": 100
+        },
+        "B11": {
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1/LC08_L1TP_044033_20210305_20210312_01_T1_B11.TIF",
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "eo:bands": [
+                {
+                    "name": "B11",
+                    "common_name": "lwir12",
+                    "center_wavelength": 12,
+                    "full_width_half_max": 1
+                }
+            ],
+            "gsd": 100
+        },
+        "ndvi": {
+            "roles": [
+                "virtual",
+                "data",
+                "index"
+            ],
+            "type": "image/vnd.stac.geotiff; cloud-optimized=true",
+            "href": "https://landsat-pds.s3.us-west-2.amazonaws.com/c1/L8/044/033/LC08_L1TP_044033_20210305_20210312_01_T1#/assets/NDVI",
+            "vrt:hrefs": [
+                {
+                    "key": "B4",
+                    "href": "#/assets/B4"
+                },
+                {
+                    "key": "B5",
+                    "href": "#/assets/B5"
+                }
+            ],
+            "title": "Normalized Difference Vegetation Index",
+            "vrt:algorithm": "band_arithmetic",
+            "vrt:algorithm_opts": {
+                "expression": "(B05-B04)/(B05+B04)",
+                "rescale": [
+                    [
+                        -1,
+                        1
+                    ]
+                ]
+            }
+        }
+    },
+    "bbox": [
+        -123.00234,
+        37.82405,
+        -120.31321,
+        39.95894
+    ],
+    "collection": "landsat-8-l1-c1"
+}
\ No newline at end of file
diff --git a/src/titiler/extensions/tests/test_stac_render.py b/src/titiler/extensions/tests/test_stac_render.py
new file mode 100644
index 000000000..16d6487a9
--- /dev/null
+++ b/src/titiler/extensions/tests/test_stac_render.py
@@ -0,0 +1,103 @@
+"""Test STAC Render extension."""
+
+import os
+from urllib.parse import unquote, urlparse
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from rio_tiler.io import STACReader
+
+from titiler.core.factory import MultiBaseTilerFactory
+from titiler.extensions.render import stacRenderExtension
+from titiler.extensions.wmts import wmtsExtension
+
+stac_item = os.path.join(os.path.dirname(__file__), "fixtures", "render_item.json")
+
+
+def test_stacExtension():
+    """Test stacExtension class."""
+
+    stac_tiler = MultiBaseTilerFactory(reader=STACReader)
+
+    stac_tiler_plus_stac_render = MultiBaseTilerFactory(
+        reader=STACReader, extensions=[stacRenderExtension(), wmtsExtension()]
+    )
+    # Check that we added two routes (/renders & /renders/{render_id}) and `/WMTSCapabilities.xml`
+    assert (
+        len(stac_tiler_plus_stac_render.router.routes)
+        == len(stac_tiler.router.routes) + 3
+    )
+
+    app = FastAPI()
+    app.include_router(stac_tiler_plus_stac_render.router)
+    with TestClient(app) as client:
+        response = client.get("/renders", params={"url": stac_item})
+        assert response.status_code == 200
+        body = response.json()
+        assert body["renders"]
+        assert body["links"]
+
+        self_link = body["links"][0]
+        assert self_link["href"] == response.url
+        assert self_link["rel"] == "self"
+
+        assert "ndvi" in body["renders"]
+        assert "thumbnail" in body["renders"]
+
+        expected_params = {
+            "title": "Normalized Difference Vegetation Index",
+            "assets": ["ndvi"],
+            "resampling": "average",
+            "colormap_name": "ylgn",
+            "extra_param": "that titiler does not know",
+        }
+        assert body["renders"]["ndvi"]["params"] == expected_params
+
+        links = body["renders"]["ndvi"]["links"]
+        assert len(links) == 3
+
+        hrefs = {unquote(urlparse(link["href"]).path) for link in links}
+        expected_hrefs = {
+            "/renders/ndvi",
+            "/WMTSCapabilities.xml",
+            "/{tileMatrixSetId}/tilejson.json",
+        }
+        assert hrefs == expected_hrefs
+
+        response = client.get("/renders/unknown", params={"url": stac_item})
+        assert response.status_code == 404
+        body = response.json()
+        assert body == {"detail": "Render not found"}
+
+        response = client.get("/renders/ndvi", params={"url": stac_item})
+        assert response.status_code == 200
+        body = response.json()
+        assert body["params"]
+        assert body["links"]
+        hrefs = {unquote(urlparse(link["href"]).path) for link in links}
+        assert hrefs == expected_hrefs
+        assert body["params"] == expected_params
+
+        response = client.get("/renders/rgb_old", params={"url": stac_item})
+        assert response.status_code == 200
+        body = response.json()
+        assert body["valid"]
+        assert body["params"] == {
+            "title": "Thumbnail",
+            "assets": ["B4|bidx=1", "B3|bidx=1", "B2|bidx=1"],
+        }
+
+        response = client.get("/renders/expression_old", params={"url": stac_item})
+        assert response.status_code == 200
+        body = response.json()
+        assert body["valid"]
+        assert body["params"] == {
+            "title": "expression",
+            "assets": ["B02|expression=b1*2"],
+        }
+
+        response = client.get("/renders/missing_asset", params={"url": stac_item})
+        assert response.status_code == 200
+        body = response.json()
+        assert not body["valid"]
+        assert body["params"] == {"title": "bad_expression", "expression": "b1*2"}
diff --git a/src/titiler/extensions/tests/test_viewer.py b/src/titiler/extensions/tests/test_viewer.py
index 2a56f119b..18a4cd929 100644
--- a/src/titiler/extensions/tests/test_viewer.py
+++ b/src/titiler/extensions/tests/test_viewer.py
@@ -25,7 +25,9 @@ def test_cogViewerExtension():
 def test_stacViewerExtension():
     """Test stacViewerExtension class."""
     tiler = MultiBaseTilerFactory(reader=STACReader)
-    tiler_plus_viewer = MultiBaseTilerFactory(extensions=[stacViewerExtension()])
+    tiler_plus_viewer = MultiBaseTilerFactory(
+        reader=STACReader, extensions=[stacViewerExtension()]
+    )
     assert len(tiler_plus_viewer.router.routes) == len(tiler.router.routes) + 1
 
     app = FastAPI()
diff --git a/src/titiler/extensions/tests/test_wms.py b/src/titiler/extensions/tests/test_wms.py
index 993817f1f..c7aa2f6de 100644
--- a/src/titiler/extensions/tests/test_wms.py
+++ b/src/titiler/extensions/tests/test_wms.py
@@ -386,3 +386,53 @@ def test_wmsExtension_GetMap():
             -52.301598718454485,
             74.66298001264106,
         ]
+
+
+def test_wmsExtension_GetFeatureInfo():
+    """Test wmsValidateExtension class for GetFeatureInfo request."""
+    tiler_plus_wms = TilerFactory(extensions=[wmsExtension()])
+
+    app = FastAPI()
+    app.include_router(tiler_plus_wms.router)
+
+    with TestClient(app) as client:
+        # Setup the basic GetFeatureInfo request
+        params = {
+            "VERSION": "1.3.0",
+            "REQUEST": "GetFeatureInfo",
+            "LAYERS": cog,
+            "QUERY_LAYERS": cog,
+            "BBOX": "500975.102,8182890.453,501830.647,8183959.884",
+            "CRS": "EPSG:32621",
+            "WIDTH": 334,
+            "HEIGHT": 333,
+            "INFO_FORMAT": "text/html",
+            "I": "0",
+            "J": "0",
+        }
+
+        response = client.get("/wms", params=params)
+
+        assert response.status_code == 200
+        assert response.content == b"2800"
+
+        params = {
+            "VERSION": "1.3.0",
+            "REQUEST": "GetFeatureInfo",
+            "LAYERS": cog,
+            "QUERY_LAYERS": cog,
+            "BBOX": "500975.102,8182890.453,501830.647,8183959.884",
+            "CRS": "EPSG:32621",
+            "WIDTH": 334,
+            "HEIGHT": 333,
+            "INFO_FORMAT": "text/html",
+            "I": "333",
+            "J": "332",
+        }
+
+        response = client.get("/wms", params=params)
+
+        assert response.status_code == 200
+        assert response.content == b"3776"
+
+        # Add additional assertions to check the text response
diff --git a/src/titiler/extensions/tests/test_wmts.py b/src/titiler/extensions/tests/test_wmts.py
new file mode 100644
index 000000000..0aa5d2e8b
--- /dev/null
+++ b/src/titiler/extensions/tests/test_wmts.py
@@ -0,0 +1,133 @@
+"""test WMTS extension."""
+
+import io
+import os
+
+import rasterio
+from fastapi import FastAPI
+from owslib.wmts import WebMapTileService
+from starlette.testclient import TestClient
+
+from titiler.core.factory import TilerFactory
+from titiler.extensions import wmtsExtension
+
+from .conftest import parse_img
+
+DATA_DIR = os.path.join(os.path.dirname(__file__), "fixtures")
+
+
+def test_wmtsExtension():
+    """Test wmtsExtension class."""
+    tiler = TilerFactory()
+    tiler_plus_wmts = TilerFactory(extensions=[wmtsExtension()])
+    assert len(tiler_plus_wmts.router.routes) == len(tiler.router.routes) + 1
+
+    app = FastAPI()
+    app.include_router(tiler_plus_wmts.router)
+    with TestClient(app) as client:
+        response = client.get(f"/WMTSCapabilities.xml?url={DATA_DIR}/cog.tif")
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "application/xml"
+        meta = parse_img(response.content)
+        assert meta["driver"] == "WMTS"
+
+        wmts = WebMapTileService(
+            f"/WMTSCapabilities.xml?url={DATA_DIR}/cog.tif", xml=response.content
+        )
+        assert wmts.version == "1.0.0"
+        assert len(wmts.contents) == 13  # 1 render x 13 TMS
+        assert f"{DATA_DIR}/cog.tif_WebMercatorQuad_default" in wmts.contents
+        assert f"{DATA_DIR}/cog.tif_WorldCRS84Quad_default" in wmts.contents
+
+        layer = wmts.contents[f"{DATA_DIR}/cog.tif_WebMercatorQuad_default"]
+        assert ["5", "6", "7", "8", "9"] == list(
+            layer.tilematrixsetlinks["WebMercatorQuad"].tilematrixlimits
+        )
+
+        assert "WebMercatorQuad" in wmts.tilematrixsets
+        assert "WorldCRS84Quad" in wmts.tilematrixsets
+
+        assert wmts.provider.name == "TiTiler"
+        assert wmts.provider.url == "https://developmentseed.org/titiler/"
+
+        # Validate it's a good WMTS
+        with rasterio.open(io.BytesIO(response.content)) as src:
+            assert not src.crs
+            assert src.profile["driver"] == "WMTS"
+            assert len(src.subdatasets) == 13
+            sds_names = [s.split(",layer=")[1] for s in src.subdatasets]
+            assert f"{DATA_DIR}/cog.tif_WebMercatorQuad_default" in sds_names
+
+        with rasterio.open(
+            io.BytesIO(response.content),
+            layer=f"{DATA_DIR}/cog.tif_WebMercatorQuad_default",
+        ) as sds:
+            assert sds.crs == "epsg:3857"
+
+
+def test_wmtsExtension_with_renders():
+    """Test wmtsExtension class with Renders."""
+    tiler_plus_wmts = TilerFactory(
+        extensions=[
+            wmtsExtension(
+                get_renders=lambda obj: {
+                    "one_band_limit": {
+                        "tilematrixsets": {
+                            "WebMercatorQuad": [0, 1],
+                        },
+                        "spatial_extent": (-180, -90, 180, 90),
+                        "bidx": [1, 2, 3],
+                        "rescale": [[0, 10000], [0, 5000], [0, 1000]],
+                    },
+                    "one_band": {
+                        "bidx": [1],
+                        "rescale": ["0,10000"],
+                    },
+                },
+            )
+        ],
+    )
+
+    app = FastAPI()
+    app.include_router(tiler_plus_wmts.router)
+    with TestClient(app) as client:
+        response = client.get(f"/WMTSCapabilities.xml?url={DATA_DIR}/cog.tif")
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "application/xml"
+        meta = parse_img(response.content)
+        assert meta["driver"] == "WMTS"
+
+        wmts = WebMapTileService(
+            f"/WMTSCapabilities.xml?url={DATA_DIR}/cog.tif", xml=response.content
+        )
+        assert wmts.version == "1.0.0"
+        assert len(wmts.contents) == 39  # (2 renders + default) x 13 TMS
+
+        assert f"{DATA_DIR}/cog.tif_WebMercatorQuad_default" in wmts.contents
+        assert f"{DATA_DIR}/cog.tif_WorldCRS84Quad_default" in wmts.contents
+
+        layer = wmts.contents[f"{DATA_DIR}/cog.tif_WebMercatorQuad_default"]
+        assert ["5", "6", "7", "8", "9"] == list(
+            layer.tilematrixsetlinks["WebMercatorQuad"].tilematrixlimits
+        )
+
+        assert f"{DATA_DIR}/cog.tif_WebMercatorQuad_one_band_limit" in wmts.contents
+        assert f"{DATA_DIR}/cog.tif_WorldCRS84Quad_one_band_limit" in wmts.contents
+
+        layer = wmts.contents[f"{DATA_DIR}/cog.tif_WebMercatorQuad_one_band_limit"]
+        assert ["0", "1"] == list(
+            layer.tilematrixsetlinks["WebMercatorQuad"].tilematrixlimits
+        )
+        assert (
+            layer.tilematrixsetlinks["WebMercatorQuad"].tilematrixlimits["0"].mintilerow
+            == 0
+        )
+
+        assert f"{DATA_DIR}/cog.tif_WebMercatorQuad_one_band" in wmts.contents
+        assert f"{DATA_DIR}/cog.tif_WorldCRS84Quad_one_band" in wmts.contents
+
+        assert "WebMercatorQuad" in wmts.tilematrixsets
+        assert "WorldCRS84Quad" in wmts.tilematrixsets
+
+        assert wmts.provider.name == "TiTiler"
+        assert wmts.provider.url == "https://developmentseed.org/titiler/"
diff --git a/src/titiler/extensions/titiler/extensions/__init__.py b/src/titiler/extensions/titiler/extensions/__init__.py
index 18c28ff64..6b1b92394 100644
--- a/src/titiler/extensions/titiler/extensions/__init__.py
+++ b/src/titiler/extensions/titiler/extensions/__init__.py
@@ -1,8 +1,10 @@
 """titiler.extensions"""
 
-__version__ = "0.11.7"
+__version__ = "2.0.1"  # x-release-please-version
 
 from .cogeo import cogValidateExtension  # noqa
+from .render import stacRenderExtension  # noqa
 from .stac import stacExtension  # noqa
 from .viewer import cogViewerExtension, stacViewerExtension  # noqa
 from .wms import wmsExtension  # noqa
+from .wmts import wmtsExtension  # noqa
diff --git a/src/titiler/extensions/titiler/extensions/cogeo.py b/src/titiler/extensions/titiler/extensions/cogeo.py
index 5b0193060..d2bad458d 100644
--- a/src/titiler/extensions/titiler/extensions/cogeo.py
+++ b/src/titiler/extensions/titiler/extensions/cogeo.py
@@ -1,34 +1,44 @@
 """rio-cogeo Extension."""
 
-from dataclasses import dataclass
+from typing import Annotated
 
+from attrs import define
 from fastapi import Depends, Query
 
-from titiler.core.factory import BaseTilerFactory, FactoryExtension
+from titiler.core.factory import FactoryExtension, TilerFactory
+from titiler.core.resources.responses import JSONResponse
 
 try:
     from rio_cogeo.cogeo import cog_info
     from rio_cogeo.models import Info
 except ImportError:  # pragma: nocover
     cog_info = None  # type: ignore
-    Info = None
+    Info = None  # type: ignore
 
 
-@dataclass
+@define
 class cogValidateExtension(FactoryExtension):
     """Add /validate endpoint to a COG TilerFactory."""
 
-    def register(self, factory: BaseTilerFactory):
+    def register(self, factory: TilerFactory):  # type: ignore [override]
         """Register endpoint to the tiler factory."""
 
         assert (
             cog_info is not None
-        ), "'rio_cogeo' must be installed to use CogValidateExtension"
-
-        @factory.router.get("/validate", response_model=Info)
+        ), "'rio-cogeo' must be installed to use CogValidateExtension"
+
+        @factory.router.get(
+            "/validate",
+            response_model=Info,
+            response_class=JSONResponse,
+            operation_id=f"{factory.operation_prefix}validate",
+        )
         def validate(
-            src_path: str = Depends(factory.path_dependency),
-            strict: bool = Query(False, description="Treat warnings as errors"),
+            src_path=Depends(factory.path_dependency),
+            strict: Annotated[
+                bool,
+                Query(description="Treat warnings as errors"),
+            ] = False,
         ):
             """Validate a COG"""
             return cog_info(src_path, strict=strict)
diff --git a/src/titiler/extensions/titiler/extensions/py.typed b/src/titiler/extensions/titiler/extensions/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/titiler/extensions/titiler/extensions/render.py b/src/titiler/extensions/titiler/extensions/render.py
new file mode 100644
index 000000000..8d1c342a3
--- /dev/null
+++ b/src/titiler/extensions/titiler/extensions/render.py
@@ -0,0 +1,211 @@
+"""STAC Render Extension.
+
+Implements support for reading and applying Item level render extension.
+See: https://github.com/stac-extensions/render
+"""
+
+from typing import Annotated, Any
+from urllib.parse import urlencode
+
+from attrs import define
+from fastapi import Depends, HTTPException, Path, Request
+from pydantic import BaseModel
+from rio_tiler.utils import cast_to_sequence
+from starlette.routing import NoMatchFound
+
+from titiler.core.factory import FactoryExtension, MultiBaseTilerFactory
+from titiler.core.models.OGC import Link
+from titiler.core.utils import check_query_params
+
+
+class RenderItem(BaseModel, extra="allow"):
+    """Render item for stac render extension."""
+
+    title: str | None = None
+    assets: list[str] | None = None
+    expression: str | None = None
+    rescale: list[Annotated[list[float], 2]] | None = None
+    nodata: float | None = None
+    colormap_name: str | None = None
+    colormap: dict | None = None
+    color_formula: str | None = None
+    resampling: str | None = None
+    minmax_zoom: Annotated[list[int], 2] | None = None
+
+
+class RenderItemWithLinks(BaseModel):
+    """Same as RenderItem with url and params."""
+
+    valid: bool
+    params: RenderItem
+    links: list[Link]
+
+
+class RenderItemList(BaseModel):
+    """List of Render Items with links."""
+
+    renders: dict[str, RenderItemWithLinks]
+    links: list[Link]
+
+
+def _adapt_render_for_v2(render: dict) -> None:
+    if assets := render.get("assets"):
+        assets_with_options: dict[str, list] = {
+            asset: [] for asset in cast_to_sequence(assets)
+        }
+
+        # adapt for titiler V2
+        if asset_bidx := render.pop("asset_bidx", None):
+            asset_bidx = cast_to_sequence(asset_bidx)
+            for v in asset_bidx:
+                asset, bidx = v.split("|")
+                if asset in assets_with_options:
+                    assets_with_options[asset].append(f"bidx={bidx}")
+
+        # asset_expression
+        if asset_expr := render.pop("asset_expression", None):
+            asset_expr = cast_to_sequence(asset_expr)
+            for v in asset_expr:
+                asset, expr = v.split("|")
+                if asset in assets_with_options:
+                    assets_with_options[asset].append(f"expression={expr}")
+
+        new_assets = []
+        for asset, options in assets_with_options.items():
+            if options:
+                asset = asset + "|" + "|".join(options)
+            new_assets.append(asset)
+        render["assets"] = new_assets
+
+
+@define
+class stacRenderExtension(FactoryExtension):
+    """Add /renders endpoint to a STAC TilerFactory."""
+
+    def register(self, factory: MultiBaseTilerFactory):  # type: ignore [override]
+        """Register endpoint to the tiler factory."""
+
+        def _prepare_render_item(
+            render_id: str,
+            render: dict,
+            request: Request,
+            src_path: str,
+        ) -> dict:
+            """Prepare single render item."""
+            links: list[dict[str, Any]] = [
+                {
+                    "href": factory.url_for(
+                        request,
+                        "STAC Renders metadata",
+                        render_id=render_id,
+                    )
+                    + "?"
+                    + urlencode({"url": src_path}),
+                    "rel": "self",
+                    "type": "application/json",
+                    "title": f"STAC Renders metadata for {render_id}",
+                }
+            ]
+
+            _adapt_render_for_v2(render)
+
+            # List of dependencies a `/tile` URL should validate
+            # Note: Those dependencies should only require Query() inputs
+            tile_dependencies = [
+                factory.reader_dependency,
+                factory.tile_dependency,
+                factory.layer_dependency,
+                factory.dataset_dependency,
+                factory.process_dependency,
+                # Image rendering Dependencies
+                factory.colormap_dependency,
+                factory.render_dependency,
+            ]
+
+            if check_query_params(tile_dependencies, render):  # type: ignore[arg-type]
+                query_string = urlencode({"url": src_path, **render}, doseq=True)
+                links.append(
+                    {
+                        "href": factory.url_for(
+                            request,
+                            "tilejson",
+                            tileMatrixSetId="{tileMatrixSetId}",
+                        )
+                        + "?"
+                        + query_string,
+                        "rel": "tilesets-map",
+                        "title": f"tilejson file for {render_id}",
+                        "templated": True,
+                    }
+                )
+                try:
+                    links.append(
+                        {
+                            "href": factory.url_for(
+                                request,
+                                "wmts",
+                            )
+                            + "?"
+                            + query_string,
+                            "rel": "tilesets-map",
+                            "title": f"WMTS service for {render_id}",
+                            "templated": True,
+                        },
+                    )
+                except NoMatchFound:
+                    pass
+            else:
+                return {"valid": False, "params": render, "links": links}
+
+            return {"valid": True, "params": render, "links": links}
+
+        @factory.router.get(
+            "/renders",
+            response_model=RenderItemList,
+            response_model_exclude_none=True,
+            name="List STAC Renders metadata",
+            operation_id=f"{factory.operation_prefix}getRenderList",
+        )
+        def render_list(request: Request, src_path=Depends(factory.path_dependency)):
+            with factory.reader(src_path) as src:
+                renders = src.item.properties.get("renders", {})
+
+            prepared_renders = {
+                render_id: _prepare_render_item(render_id, render, request, src_path)
+                for render_id, render in renders.items()
+            }
+            return {
+                "renders": prepared_renders,
+                "links": [
+                    {
+                        "href": str(request.url),
+                        "rel": "self",
+                        "type": "application/json",
+                        "title": "List STAC Renders metadata",
+                    },
+                ],
+            }
+
+        @factory.router.get(
+            "/renders/{render_id}",
+            response_model=RenderItemWithLinks,
+            response_model_exclude_none=True,
+            name="STAC Renders metadata",
+            operation_id=f"{factory.operation_prefix}getRender",
+        )
+        def render(
+            request: Request,
+            render_id: str = Path(
+                description="render id",
+            ),
+            src_path=Depends(factory.path_dependency),
+        ):
+            with factory.reader(src_path) as src:
+                renders = src.item.properties.get("renders", {})
+
+            if render_id not in renders:
+                raise HTTPException(status_code=404, detail="Render not found")
+
+            return _prepare_render_item(
+                render_id, renders[render_id], request, src_path
+            )
diff --git a/src/titiler/extensions/titiler/extensions/stac.py b/src/titiler/extensions/titiler/extensions/stac.py
index 6848c7a35..96ffb8091 100644
--- a/src/titiler/extensions/titiler/extensions/stac.py
+++ b/src/titiler/extensions/titiler/extensions/stac.py
@@ -1,21 +1,18 @@
 """rio-stac Extension."""
 
 import sys
-from dataclasses import dataclass
-from typing import Any, Dict, List, Literal, Optional
+from typing import Annotated, Any, Literal
 
+from attrs import define
 from fastapi import Depends, Query
 
-from titiler.core.factory import BaseTilerFactory, FactoryExtension
+from titiler.core.factory import FactoryExtension, TilerFactory
 
-# Avoids a Pydantic error:
-# TypeError: You should use `typing_extensions.TypedDict` instead of `typing.TypedDict` with Python < 3.9.2.
-# Without it, there is no way to differentiate required and optional fields when subclassed.
-# Ref: https://github.com/pydantic/pydantic/pull/3374
-if sys.version_info < (3, 9, 2):
-    from typing_extensions import TypedDict
-else:
+# Ref: https://docs.pydantic.dev/2.12/errors/usage_errors/#typed-dict-version
+if sys.version_info >= (3, 12):
     from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
 
 try:
     import pystac
@@ -32,21 +29,21 @@ class Item(TypedDict, total=False):
 
     type: str
     stac_version: str
-    stac_extensions: Optional[List[str]]
+    stac_extensions: list[str] | None
     id: str
-    geometry: Dict[str, Any]
-    bbox: List[float]
-    properties: Dict[str, Any]
-    links: List[Dict[str, Any]]
-    assets: Dict[str, Any]
+    geometry: dict[str, Any]
+    bbox: list[float]
+    properties: dict[str, Any]
+    links: list[dict[str, Any]]
+    assets: dict[str, Any]
     collection: str
 
 
-@dataclass
+@define
 class stacExtension(FactoryExtension):
     """Add /stac endpoint to a COG TilerFactory."""
 
-    def register(self, factory: BaseTilerFactory):
+    def register(self, factory: TilerFactory):  # type: ignore [override]
         """Register endpoint to the tiler factory."""
 
         assert (
@@ -56,58 +53,93 @@ def register(self, factory: BaseTilerFactory):
 
         media = [m.value for m in pystac.MediaType] + ["auto"]
 
-        @factory.router.get("/stac", response_model=Item, name="Create STAC Item")
+        @factory.router.get(
+            "/stac",
+            response_model=Item,
+            name="Create STAC Item",
+            operation_id=f"{factory.operation_prefix}createSTAC",
+        )
         def create_stac(
-            src_path: str = Depends(factory.path_dependency),
-            datetime: Optional[str] = Query(
-                None,
-                description="The date and time of the assets, in UTC (e.g 2020-01-01, 2020-01-01T01:01:01).",
-            ),
-            extensions: Optional[List[str]] = Query(
-                None, description="STAC extension URL the Item implements."
-            ),
-            collection: Optional[str] = Query(
-                None, description="The Collection ID that this item belongs to."
-            ),
-            collection_url: Optional[str] = Query(
-                None, description="Link to the STAC Collection."
-            ),
+            src_path=Depends(factory.path_dependency),
+            datetime: Annotated[
+                str | None,
+                Query(
+                    description="The date and time of the assets, in UTC (e.g 2020-01-01, 2020-01-01T01:01:01).",
+                ),
+            ] = None,
+            extensions: Annotated[
+                list[str] | None,
+                Query(description="STAC extension URL the Item implements."),
+            ] = None,
+            collection: Annotated[
+                str | None,
+                Query(description="The Collection ID that this item belongs to."),
+            ] = None,
+            collection_url: Annotated[
+                str | None,
+                Query(description="Link to the STAC Collection."),
+            ] = None,
             # properties: Optional[Dict] = Query(None, description="Additional properties to add in the item."),
-            id: Optional[str] = Query(
-                None,
-                description="Id to assign to the item (default to the source basename).",
-            ),
-            asset_name: Optional[str] = Query(
-                "data", description="asset name for the source (default to 'data')."
-            ),
-            asset_roles: Optional[List[str]] = Query(
-                None, description="list of asset's roles."
-            ),
-            asset_media_type: Literal[tuple(media)] = Query(  # type: ignore
-                "auto", description="Asset's media type"
-            ),
-            asset_href: Optional[str] = Query(
-                None, description="Asset's URI (default to source's path)"
-            ),
-            with_proj: bool = Query(
-                True, description="Add the `projection` extension and properties."
-            ),
-            with_raster: bool = Query(
-                True, description="Add the `raster` extension and properties."
-            ),
-            with_eo: bool = Query(
-                True, description="Add the `eo` extension and properties."
-            ),
-            max_size: Optional[int] = Query(
-                1024,
-                gt=0,
-                description="Limit array size from which to get the raster statistics.",
-            ),
+            id: Annotated[
+                str | None,
+                Query(
+                    description="Id to assign to the item (default to the source basename)."
+                ),
+            ] = None,
+            asset_name: Annotated[
+                str,
+                Query(description="asset name for the source (default to 'data')."),
+            ] = "data",
+            asset_roles: Annotated[
+                list[str] | None,
+                Query(description="list of asset's roles."),
+            ] = None,
+            asset_media_type: Annotated[  # type: ignore
+                Literal[tuple(media)],
+                Query(description="Asset's media type"),
+            ] = "auto",
+            asset_href: Annotated[
+                str | None,
+                Query(description="Asset's URI (default to source's path)"),
+            ] = None,
+            with_proj: Annotated[
+                bool,
+                Query(description="Add the `projection` extension and properties."),
+            ] = True,
+            with_raster: Annotated[
+                bool,
+                Query(description="Add the `raster` extension and properties."),
+            ] = True,
+            with_eo: Annotated[
+                bool,
+                Query(description="Add the `eo` extension and properties."),
+            ] = True,
+            max_size: Annotated[
+                int,
+                Query(
+                    gt=0,
+                    description="Limit array size from which to get the raster statistics.",
+                ),
+            ] = 1024,
+            geom_densify_pts: Annotated[
+                int,
+                Query(
+                    alias="geometry_densify",
+                    ge=0,
+                    description="Number of points to add to each edge to account for nonlinear edges transformation.",
+                ),
+            ] = 0,
+            geom_precision: Annotated[
+                int,
+                Query(
+                    alias="geometry_precision",
+                    ge=-1,
+                    description="Round geometry coordinates to this number of decimal.",
+                ),
+            ] = -1,
         ):
             """Create STAC item."""
-            properties = (
-                {}
-            )  # or properties = properties or {} if we add properties in Query
+            properties = {}  # or properties = properties or {} if we add properties in Query
 
             dt = None
             if datetime:
@@ -138,4 +170,6 @@ def create_stac(
                 with_raster=with_raster,
                 with_eo=with_eo,
                 raster_max_size=max_size,
+                geom_densify_pts=geom_densify_pts,
+                geom_precision=geom_precision,
             ).to_dict()
diff --git a/src/titiler/extensions/titiler/extensions/templates/cog_viewer.html b/src/titiler/extensions/titiler/extensions/templates/cog_viewer.html
index d5e3c448f..54870204a 100644
--- a/src/titiler/extensions/titiler/extensions/templates/cog_viewer.html
+++ b/src/titiler/extensions/titiler/extensions/templates/cog_viewer.html
@@ -4,13 +4,20 @@
     <meta charset='utf-8' />
     <title>TiTiler - Cloud Optimized GeoTIFF Viewer</title>
     <meta name='viewport' content='initial-scale=1,maximum-scale=1,user-scalable=no' />
-
-    <script src='https://api.tiles.mapbox.com/mapbox-gl-js/v1.6.1/mapbox-gl.js'></script>
-    <link href='https://api.tiles.mapbox.com/mapbox-gl-js/v1.6.1/mapbox-gl.css' rel='stylesheet' />
-
-    <link href='https://api.mapbox.com/mapbox-assembly/v0.23.2/assembly.min.css' rel='stylesheet'>
-    <script src='https://api.mapbox.com/mapbox-assembly/v0.23.2/assembly.js'></script>
-    <script src="https://d3js.org/d3.v4.js"></script>
+    <script src="https://unpkg.com/maplibre-gl@2.4.0/dist/maplibre-gl.js"
+            integrity="sha384-d7ZDjW8dICoRWC3wnExUiOx1CgEcPFEPJmTdIo93yyxQLAUbUwa6yKg3tlACCOMf"
+            crossorigin="anonymous"></script>
+    <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@2.4.0/dist/maplibre-gl.css"
+          integrity="sha384-g0Ap4cGP18FAKniFM6i06oyjTpBYleD9hZcGyVnlsc1JFbfedDo1Oqb9qxrxVB3a" crossorigin="anonymous"/>
+
+    <link rel="stylesheet" href="https://api.mapbox.com/mapbox-assembly/v0.23.2/assembly.min.css"
+          integrity="sha384-J8dqIWgJSfbM291RNLiN7cjnxOqlHjAWfkLu/3HiuC1pJLq9ZCYiigcknWfCYi+h" crossorigin="anonymous"/>
+    <script src="https://api.mapbox.com/mapbox-assembly/v0.23.2/assembly.js"
+            integrity="sha384-cARSC/qj9L62maU7YhlT+Ca2yHyUEEnWvMVCilUdW02txMg0Iynxz3gMsvVpV9RG"
+            crossorigin="anonymous"></script>
+    <script src="https://d3js.org/d3.v4.js"
+            integrity="sha384-2D+rRoPOU+IYMo2i8sD/TSf9L+6H+Dt8lxmKl1r7xyEcV83QdtJyeaoE1DHIG3F7"
+            crossorigin="anonymous"></script>
     <style>
       body { margin:0; padding:0; width:100%; height:100%;}
       #map { position:absolute; top:0; bottom:0; width:100%; }
@@ -54,6 +61,9 @@
           display: block;
           padding: 5px;
       }
+      .share-button.hidden {
+        display: none !important;
+      }
       #menu {
         left: 0;
         top: 0;
@@ -170,7 +180,7 @@
           -ms-transition: all .5s ease;
           transition: all ease .5s;
         }
-        .mapboxgl-ctrl-attrib {
+        .maplibregl-ctrl-attrib {
             font-size: 10px;
         }
       }
@@ -284,6 +294,29 @@
           <table id="histogram-table" class="none"></table>
         </div>
 
+        <div class="px6 py6 w-full">
+          <div class="txt-h5 color-black">
+            <svg class="icon icon--l inline-block">
+              <use xlink:href="#icon-share" />
+            </svg>
+            Share
+          </div>
+          <div id="export-div" class="w-full align-center">
+            <button
+              id="btn-export"
+              class="btn bts--xs btn--stroke bg-darken25-on-hover inline-block txt-s color-black mx12 my12"
+            >
+              Show Render Parameters
+            </button>
+            <button
+              id="btn-share-link"
+              class="btn bts--xs btn--stroke bg-darken25-on-hover inline-block txt-s color-black mx12 my12 share-button"
+            >
+              Share Map
+            </button>
+          </div>
+        </div>
+      </div>
       </div>
       <button id='btn-hide'><svg id='hide-arrow' class='icon'><use xlink:href='#icon-arrow-right'/></svg></button>
     </div>
@@ -308,11 +341,10 @@
   colormap: undefined
 }
 
-mapboxgl.accessToken = ''
-
 const tilejson_endpoint = '{{ tilejson_endpoint }}'
 const info_endpoint = '{{ info_endpoint }}'
 const stats_endpoint = '{{ statistics_endpoint }}'
+const viewer_enabled = '{{ viewer_enabled|tojson }}'
 
 const dtype_ranges = {
   'int8': [-128, 127],
@@ -321,33 +353,54 @@
   'int16': [-32768, 32767],
   'uint32': [0, 4294967295],
   'int32': [-2147483648, 2147483647],
+  'float16': [-6.55040e+04, 6.55040e+04],
   'float32': [-3.4028235e+38, 3.4028235e+38],
-  'float64': [-1.7976931348623157e+308, 1.7976931348623157e+308]
+  'float64': [-1.7976931348623157e+308, 1.7976931348623157e+308],
+  'int64': [-9223372036854775808, 9223372036854775807],
+  'uint64': [0, 18446744073709551615],
 }
 
-var map = new mapboxgl.Map({
+function updateShareButtonVisibility() {
+  console.log('updateShareButtonVisibility called');
+  console.log('viewer_enabled:', viewer_enabled);
+
+  const shareButton = document.getElementById('btn-share-link');
+  if (!shareButton) {
+    console.log('Share button not found in the DOM');
+    return;
+  }
+
+  console.log('shareButton:', shareButton);
+
+  if (viewer_enabled === 'true') {
+    console.log('Setting button to visible');
+    shareButton.classList.remove('hidden');
+  } else {
+    console.log('Setting button to hidden');
+    shareButton.classList.add('hidden');
+  }
+}
+updateShareButtonVisibility();
+
+var map = new maplibregl.Map({
   container: 'map',
   style: {
     version: 8,
     sources: {
-      'toner-lite': {
+      'basemap': {
         type: 'raster',
         tiles: [
-          'https://stamen-tiles-a.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png',
-          'https://stamen-tiles-b.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png',
-          'https://stamen-tiles-c.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png',
-          'https://stamen-tiles-d.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png'
+          'https://tile.openstreetmap.org/{z}/{x}/{y}.png'
         ],
         tileSize: 256,
-        attribution:
-          'Map tiles by <a href="http://stamen.com">Stamen Design</a>, under <a href="http://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>. Data by <a href="http://openstreetmap.org">OpenStreetMap</a>, under <a href="http://www.openstreetmap.org/copyright">ODbL</a>.'
+        attribution: '<a href="https://developmentseed.org/titiler" target="_blank">Titiler</a> | <a href="http://www.openstreetmap.org/copyright">© OpenStreetMap</a>'
       }
     },
     layers: [
       {
         'id': 'basemap',
         'type': 'raster',
-        'source': 'toner-lite',
+        'source': 'basemap',
         'minzoom': 0,
         'maxzoom': 20
       }
@@ -421,7 +474,8 @@
 
 const set1bViz = () => {
   params = {
-    url: scope.url
+    url: scope.url,
+    tilesize: 256
   }
   params.bidx = document.getElementById('layer-selector').selectedOptions[0].getAttribute("bidx")
 
@@ -444,7 +498,8 @@
   const b = document.getElementById('b-selector').selectedOptions[0].getAttribute("bidx")
 
   params = {
-    url: scope.url
+    url: scope.url,
+    tilesize: 256
   }
   if (['uint8','int8'].indexOf(scope.data_type) === -1 && !scope.colormap) {
     params.rescale = `${document.getElementById('data-min').value},${document.getElementById('data-max').value}`
@@ -688,7 +743,7 @@
     });
 
     if (!centerMarker) {
-      centerMarker = new mapboxgl.Marker()
+      centerMarker = new maplibregl.Marker()
       .setLngLat([lng, lat])
       .addTo(map);
     } else {
@@ -773,48 +828,6 @@
     }
 }
 
-const addAOI = (bounds) => {
-  if (map.getLayer('aoi-polygon')) map.removeLayer('aoi-polygon')
-  if (map.getSource('aoi')) map.removeSource('aoi')
-
-  // handle files that span accross dateline
-  if (bounds[0] > bounds[2]) {
-    map.addSource('aoi', {
-      'type': 'geojson',
-      'data': {
-        "type": "FeatureCollection",
-        "features": [
-          bboxPolygon([-180, bounds[1], bounds[2], bounds[3]]),
-          bboxPolygon([bounds[0], bounds[1], 180, bounds[3]]),
-        ]
-      }
-    })
-
-  } else {
-    map.addSource('aoi', {
-      'type': 'geojson',
-      'data': {
-        "type": "FeatureCollection",
-        "features": [bboxPolygon(bounds)]
-      }
-    })
-  }
-
-  map.addLayer({
-    id: 'aoi-polygon',
-    type: 'line',
-    source: 'aoi',
-    layout: {
-      'line-cap': 'round',
-      'line-join': 'round'
-    },
-    paint: {
-      'line-color': '#3bb2d0',
-      'line-width': 1
-    }
-  })
-  return
-}
 
 const parseParams = (w_loc) => {
   const param_list = w_loc.replace('?', '').split('&')
@@ -834,8 +847,8 @@
     })
     .then(data => {
       console.log(data)
-      scope.data_type = data.dtype
-      scope.colormap = data.colormap
+      scope.data_type = data.properties.dtype
+      scope.colormap = data.properties.colormap
 
       if (['uint8','int8'].indexOf(scope.data_type) === -1 && !scope.colormap) document.getElementById('minmax-data').classList.remove('none')
 
@@ -843,8 +856,8 @@
       document.getElementById('data-min').value = mm[0]
       document.getElementById('data-max').value = mm[1]
 
-      scope.band_descriptions = data.band_descriptions
-      const band_descr = data.band_descriptions
+      scope.band_descriptions = data.properties.band_descriptions
+      const band_descr = data.properties.band_descriptions
       const nbands = band_descr.length
 
       //Populate Band (1b) selector
@@ -858,54 +871,37 @@
       }
 
       // Populate R/G/B (3b) selectors
-      const rList = document.getElementById('r-selector')
-      for (var i = 0; i < nbands; i++) {
-        let l = document.createElement('option')
-        l.setAttribute('bidx', i + 1)
-        l.setAttribute('bname', band_descr[i][0])
-        l.text = band_descr[i][1] || band_descr[i][0]
-        if (i === 0) l.selected="selected"
-        rList.appendChild(l)
-      }
-
-      const gList = document.getElementById('g-selector')
-      for (var i = 0; i < nbands; i++) {
-        let l = document.createElement('option')
-        l.setAttribute('bidx', i + 1)
-        l.setAttribute('bname', band_descr[i][0])
-        l.text = band_descr[i][1] || band_descr[i][0]
-        if (i === 1) l.selected="selected"
-        gList.appendChild(l)
-      }
-
-      const bList = document.getElementById('b-selector')
-      for (var i = 0; i < nbands; i++) {
-        let l = document.createElement('option')
-        l.setAttribute('bidx', i + 1)
-        l.setAttribute('bname', band_descr[i][0])
-        l.text = band_descr[i][1] || band_descr[i][0]
-        if (band_descr.length > 2 && i === 2) {
-          l.selected="selected"
-        } else {
-          l.selected="selected"
+      ['r-selector', 'g-selector', 'b-selector'].forEach((elId, idx) => {
+        const list = document.getElementById(elId)
+        for (var i = 0; i < nbands; i++) {
+          let l = document.createElement('option')
+          l.setAttribute('bidx', i + 1)
+          l.setAttribute('bname', band_descr[i][0])
+          l.text = band_descr[i][1] || band_descr[i][0]
+          if (i === idx) l.selected="selected"
+          list.appendChild(l)
         }
-        bList.appendChild(l)
-      }
+      })
 
       // remove loader
       document.getElementById('loader').classList.toggle('off')
       document.getElementById('hide-arrow').classList.toggle('off')
       document.getElementById('menu').classList.toggle('off')
 
-      let bounds = [...data.bounds]
+      let bounds = [...data.bbox]
       // Bounds crossing dateline
       if (bounds[0] > bounds[2]) {
         bounds[0] = bounds[0] - 360
       }
-      map.fitBounds(
-        [[bounds[0], bounds[1]], [bounds[2], bounds[3]]]
-      )
-      addAOI(data.bounds)
+      map.fitBounds([[bounds[0], bounds[1]], [bounds[2], bounds[3]]])
+      map.addSource('aoi', {'type': 'geojson', 'data': data})
+      map.addLayer({
+        id: 'aoi-polygon',
+        type: 'line',
+        source: 'aoi',
+        layout: {'line-cap': 'round', 'line-join': 'round'},
+        paint: {'line-color': '#3bb2d0', 'line-width': 1}
+      })
 
       if (nbands === 1) {
         document.getElementById('3b').classList.add('disabled')
@@ -922,7 +918,7 @@
 }
 
 document.getElementById('launch').addEventListener('click', () => {
-  scope.url = document.getElementById('cogeo').value
+  scope.url = encodeURIComponent(document.getElementById('cogeo').value)
   document.getElementById('selector').classList.toggle('none')
   addCogeo()
 })
@@ -935,6 +931,111 @@
     addCogeo()
   }
 })
+
+document.getElementById('btn-share-link').addEventListener('click', () => {
+  const rasterType = document.getElementById("toolbar").querySelector(".active").id;
+
+  let params = new URLSearchParams();
+  params.append('url', scope.url);
+
+  if (rasterType === "1b") {
+
+    params.append('bidx', document.getElementById("layer-selector").selectedOptions[0].getAttribute("bidx"));
+    const colormap_name = document.getElementById('colormap-selector').value;
+    if (colormap_name != "b&w") {
+      params.append('colormap_name', colormap_name);
+    }
+  } else if (rasterType === "3b") {
+    params.append('bidx', document.getElementById("r-selector").selectedOptions[0].getAttribute("bidx"));
+    params.append('bidx', document.getElementById("g-selector").selectedOptions[0].getAttribute("bidx"));
+    params.append('bidx', document.getElementById("b-selector").selectedOptions[0].getAttribute("bidx"));
+  }
+
+  // Add rescale parameter for both 1b and 3b if applicable
+  if (["uint8", "int8"].indexOf(scope.data_type) === -1 && !scope.colormap) {
+    params.append('rescale', `${document.getElementById("data-min").value},${document.getElementById("data-max").value}`);
+  }
+
+  const path_name = `${window.location.pathname}`.replace("viewer", "WebMercatorQuad/map");
+  const shareUrl = `${window.location.origin}${path_name}?${params.toString()}`;
+
+  // Create a temporary input element to copy the URL
+  const tempInput = document.createElement('input');
+  tempInput.value = shareUrl;
+  document.body.appendChild(tempInput);
+  tempInput.select();
+  document.execCommand('copy');
+  document.body.removeChild(tempInput);
+
+  alert('Share link copied to clipboard!');
+});
+
+document.getElementById('btn-export').addEventListener('click', () => {
+  const rasterType = document.getElementById("toolbar").querySelector(".active").id;
+  let params = {};
+
+  if (rasterType === "1b") {
+    // Convert bidx to a single-element array
+    params.bidx = [parseInt(document.getElementById("layer-selector").selectedOptions[0].getAttribute("bidx"))];
+
+    const colormap_name = document.getElementById('colormap-selector').value;
+    if (colormap_name !== "b&w") {
+      params.colormap_name = colormap_name;
+    }
+  } else if (rasterType === "3b") {
+    params.bidx = [
+      parseFloat(document.getElementById("r-selector").selectedOptions[0].getAttribute("bidx")),
+      parseFloat(document.getElementById("g-selector").selectedOptions[0].getAttribute("bidx")),
+      parseFloat(document.getElementById("b-selector").selectedOptions[0].getAttribute("bidx")),
+    ]
+  }
+
+  // Add rescale parameter for both 1b and 3b if applicable
+  if (["uint8", "int8"].indexOf(scope.data_type) === -1 && !scope.colormap) {
+    // Convert rescale to a nested array
+    params.rescale = [[
+      parseFloat(document.getElementById("data-min").value),
+      parseFloat(document.getElementById("data-max").value)
+    ]];
+  }
+
+  showJsonPopup(params);
+});
+function showJsonPopup(jsonContent) {
+  const popup = document.createElement('div');
+  popup.style.position = 'fixed';
+  popup.style.left = '50%';
+  popup.style.top = '50%';
+  popup.style.transform = 'translate(-50%, -50%)';
+  popup.style.backgroundColor = 'white';
+  popup.style.padding = '30px 20px 20px'; // Increased top padding for close button
+  popup.style.border = '1px solid black';
+  popup.style.zIndex = '1000';
+  popup.style.borderRadius = '5px'; // Optional: rounded corners
+  popup.style.boxShadow = '0 4px 6px rgba(0, 0, 0, 0.1)'; // Optional: shadow for depth
+
+  const closeButton = document.createElement('button');
+  closeButton.textContent = '×'; // Using '×' character for close
+  closeButton.style.position = 'absolute';
+  closeButton.style.right = '10px';
+  closeButton.style.top = '10px';
+  closeButton.style.border = 'none';
+  closeButton.style.background = 'none';
+  closeButton.style.fontSize = '20px';
+  closeButton.style.cursor = 'pointer';
+  closeButton.style.color = '#333';
+  closeButton.onclick = () => document.body.removeChild(popup);
+  popup.appendChild(closeButton);
+
+  const pre = document.createElement('pre');
+  pre.textContent = JSON.stringify(jsonContent, null, 2);
+  pre.style.margin = '0'; // Remove default margins
+  pre.style.whiteSpace = 'pre-wrap'; // Allow text to wrap
+  pre.style.wordBreak = 'break-word'; // Break long words if necessary
+  popup.appendChild(pre);
+
+  document.body.appendChild(popup);
+}
     </script>
   </body>
 </html>
diff --git a/src/titiler/extensions/titiler/extensions/templates/stac_viewer.html b/src/titiler/extensions/titiler/extensions/templates/stac_viewer.html
index fe65d66d0..2109e8c11 100644
--- a/src/titiler/extensions/titiler/extensions/templates/stac_viewer.html
+++ b/src/titiler/extensions/titiler/extensions/templates/stac_viewer.html
@@ -4,13 +4,20 @@
     <meta charset='utf-8' />
     <title>TiTiler - STAC Viewer</title>
     <meta name='viewport' content='initial-scale=1,maximum-scale=1,user-scalable=no' />
-
-    <script src='https://api.tiles.mapbox.com/mapbox-gl-js/v1.6.1/mapbox-gl.js'></script>
-    <link href='https://api.tiles.mapbox.com/mapbox-gl-js/v1.6.1/mapbox-gl.css' rel='stylesheet' />
-
-    <link href='https://api.mapbox.com/mapbox-assembly/v0.23.2/assembly.min.css' rel='stylesheet'>
-    <script src='https://api.mapbox.com/mapbox-assembly/v0.23.2/assembly.js'></script>
-    <script src="https://d3js.org/d3.v4.js"></script>
+    <script src="https://unpkg.com/maplibre-gl@2.4.0/dist/maplibre-gl.js"
+            integrity="sha384-d7ZDjW8dICoRWC3wnExUiOx1CgEcPFEPJmTdIo93yyxQLAUbUwa6yKg3tlACCOMf"
+            crossorigin="anonymous"></script>
+    <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@2.4.0/dist/maplibre-gl.css"
+          integrity="sha384-g0Ap4cGP18FAKniFM6i06oyjTpBYleD9hZcGyVnlsc1JFbfedDo1Oqb9qxrxVB3a" crossorigin="anonymous"/>
+
+    <link rel="stylesheet" href="https://api.mapbox.com/mapbox-assembly/v0.23.2/assembly.min.css"
+          integrity="sha384-J8dqIWgJSfbM291RNLiN7cjnxOqlHjAWfkLu/3HiuC1pJLq9ZCYiigcknWfCYi+h" crossorigin="anonymous"/>
+    <script src="https://api.mapbox.com/mapbox-assembly/v0.23.2/assembly.js"
+            integrity="sha384-cARSC/qj9L62maU7YhlT+Ca2yHyUEEnWvMVCilUdW02txMg0Iynxz3gMsvVpV9RG"
+            crossorigin="anonymous"></script>
+    <script src="https://d3js.org/d3.v4.js"
+            integrity="sha384-2D+rRoPOU+IYMo2i8sD/TSf9L+6H+Dt8lxmKl1r7xyEcV83QdtJyeaoE1DHIG3F7"
+            crossorigin="anonymous"></script>
     <style>
       body { margin:0; padding:0; width:100%; height:100%;}
       #map { position:absolute; top:0; bottom:0; width:100%; }
@@ -177,7 +184,7 @@
           -ms-transition: all .5s ease;
           transition: all ease .5s;
         }
-        .mapboxgl-ctrl-attrib {
+        .maplibregl-ctrl-attrib {
           font-size: 10px;
         }
       }
@@ -332,8 +339,6 @@
   dataset_statistics: undefined,
 }
 
-mapboxgl.accessToken = ''
-
 const tilejson_endpoint = '{{ tilejson_endpoint }}'
 const info_endpoint = '{{ info_endpoint }}'
 const stats_endpoint = '{{ statistics_endpoint }}'
@@ -345,33 +350,32 @@
   'int16': [-32768, 32767],
   'uint32': [0, 4294967295],
   'int32': [-2147483648, 2147483647],
+  'float16': [-6.55040e+04, 6.55040e+04],
   'float32': [-3.4028235e+38, 3.4028235e+38],
-  'float64': [-1.7976931348623157e+308, 1.7976931348623157e+308]
+  'float64': [-1.7976931348623157e+308, 1.7976931348623157e+308],
+  'int64': [-9223372036854775808, 9223372036854775807],
+  'uint64': [0, 18446744073709551615],
 }
 
-var map = new mapboxgl.Map({
+var map = new maplibregl.Map({
   container: 'map',
   style: {
     version: 8,
     sources: {
-      'toner-lite': {
+      'basemap': {
         type: 'raster',
         tiles: [
-          'https://stamen-tiles-a.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png',
-          'https://stamen-tiles-b.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png',
-          'https://stamen-tiles-c.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png',
-          'https://stamen-tiles-d.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png'
+          'https://tile.openstreetmap.org/{z}/{x}/{y}.png'
         ],
         tileSize: 256,
-        attribution:
-          'Map tiles by <a href="http://stamen.com">Stamen Design</a>, under <a href="http://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>. Data by <a href="http://openstreetmap.org">OpenStreetMap</a>, under <a href="http://www.openstreetmap.org/copyright">ODbL</a>.'
+        attribution: '<a href="https://developmentseed.org/titiler" target="_blank">Titiler</a> | <a href="http://www.openstreetmap.org/copyright">© OpenStreetMap</a>'
       }
     },
     layers: [
       {
         'id': 'basemap',
         'type': 'raster',
-        'source': 'toner-lite',
+        'source': 'basemap',
         'minzoom': 0,
         'maxzoom': 20
       }
@@ -381,7 +385,6 @@
   zoom: 1
 })
 
-
 map.on('zoom', function (e) {
     const z = (map.getZoom()).toString().slice(0, 6)
     document.getElementById('zoom').textContent = z
@@ -446,13 +449,12 @@
 
 const set1bViz = () => {
     params = {
-      url: scope.url
+      url: scope.url,
+      tilesize: 256
     }
     const asset = document.getElementById('asset-selector').value
-    params.assets = asset
-
     const bidx = document.getElementById('layer-selector').selectedOptions[0].getAttribute("bidx")
-    params.asset_bidx = `${asset}|${bidx}`
+    params.assets = `${asset}|indexes=${bidx}`
 
     if (['uint8','int8'].indexOf(scope.dataset_info[asset].dtype) === -1) {
         params.rescale = `${document.getElementById('data-min').value},${document.getElementById('data-max').value}`
@@ -477,20 +479,19 @@
   const b = document.getElementById('b-selector').selectedOptions[0].getAttribute("bidx")
 
   params = {
-    url: scope.url
+    url: scope.url,
+    tilesize: 256
   }
 
   let asset_params
   let indexes_params
   if (document.getElementById("compose-switch").checked === true) {
-    asset_params = [r, g, b].map(i => `assets=${i}`).join('&')
+    asset_params = [r, g, b].map(i => `assets=${i}|indexes=1`).join('&')
     // When doing assets composition we select the first band (bidx=1)
-    indexes_params =  [r, g, b].map(i => `asset_bidx=${i}|1`).join('&')
     params.rescale = `${document.getElementById('data-min').value},${document.getElementById('data-max').value}`
   } else {
     const asset = document.getElementById('asset-selector').value
-    asset_params = `assets=${asset}`
-    indexes_params =  `asset_bidx=${asset}|${r},${g},${b}`
+    asset_params = `assets=${asset}|indexes=${r},${g},${b}`
     if (['uint8','int8'].indexOf(scope.dataset_info[asset].dtype) === -1) {
       params.rescale = `${document.getElementById('data-min').value},${document.getElementById('data-max').value}`
     }
@@ -501,7 +502,7 @@
   }
 
   const url_params = Object.keys(params).map(i => `${i}=${params[i]}`).join('&')
-  let url = `{{ tilejson_endpoint }}?${url_params}&${asset_params}&${indexes_params}`
+  let url = `{{ tilejson_endpoint }}?${url_params}&${asset_params}`
   setMapLayers(url)
   if (scope.dataset_statistics) addHisto3Bands()
 }
@@ -692,7 +693,7 @@
     });
 
     if (!centerMarker) {
-      centerMarker = new mapboxgl.Marker()
+      centerMarker = new maplibregl.Marker()
       .setLngLat([lng, lat])
       .addTo(map);
     } else {
@@ -807,49 +808,6 @@
   }
 }
 
-const addAOI = (bounds) => {
-  if (map.getLayer('aoi-polygon')) map.removeLayer('aoi-polygon')
-  if (map.getSource('aoi')) map.removeSource('aoi')
-
-  // handle files that span accross dateline
-  if (bounds[0] > bounds[2]) {
-    map.addSource('aoi', {
-      'type': 'geojson',
-      'data': {
-        "type": "FeatureCollection",
-        "features": [
-          bboxPolygon([-180, bounds[1], bounds[2], bounds[3]]),
-          bboxPolygon([bounds[0], bounds[1], 180, bounds[3]]),
-        ]
-      }
-    })
-
-  } else {
-    map.addSource('aoi', {
-      'type': 'geojson',
-      'data': {
-        "type": "FeatureCollection",
-        "features": [bboxPolygon(bounds)]
-      }
-    })
-  }
-
-  map.addLayer({
-    id: 'aoi-polygon',
-    type: 'line',
-    source: 'aoi',
-    layout: {
-      'line-cap': 'round',
-      'line-join': 'round'
-    },
-    paint: {
-      'line-color': '#3bb2d0',
-      'line-width': 1
-    }
-  })
-  return
-}
-
 const updateUI = () => {
   const is_checked = document.getElementById("compose-switch").checked
   const rList = document.getElementById('r-selector')
@@ -900,7 +858,7 @@
       l.setAttribute('bidx', scope.assets[i])
       l.setAttribute('bname', scope.assets[i])
       l.text = scope.assets[i]
-      l.selected = "selected"
+      if (i === 2) l.selected = "selected"
       bList.appendChild(l)
     }
 
@@ -931,39 +889,17 @@
     }
 
     // Populate R/G/B (3b) selectors
-    const rList = document.getElementById('r-selector')
-    for (var i = 0; i < nbands; i++) {
-      let l = document.createElement('option')
-      l.setAttribute('bidx', i + 1)
-      l.setAttribute('bname', band_descr[i][0])
-      l.text = band_descr[i][1] || band_descr[i][0]
-      if (i === 0) l.selected="selected"
-      rList.appendChild(l)
-    }
-
-    const gList = document.getElementById('g-selector')
-    for (var i = 0; i < nbands; i++) {
-      let l = document.createElement('option')
-      l.setAttribute('bidx', i + 1)
-      l.setAttribute('bname', band_descr[i][0])
-      l.text = band_descr[i][1] || band_descr[i][0]
-      if (i === 1) l.selected="selected"
-      gList.appendChild(l)
-    }
-
-    const bList = document.getElementById('b-selector')
-    for (var i = 0; i < nbands; i++) {
-      let l = document.createElement('option')
-      l.setAttribute('bidx', i + 1)
-      l.setAttribute('bname', band_descr[i][0])
-      l.text = band_descr[i][1] || band_descr[i][0]
-      if (band_descr.length > 2 && i === 2) {
-          l.selected="selected"
-      } else {
-          l.selected="selected"
+    ['r-selector', 'g-selector', 'b-selector'].forEach((elId, idx) => {
+      const list = document.getElementById(elId)
+      for (var i = 0; i < nbands; i++) {
+        let l = document.createElement('option')
+        l.setAttribute('bidx', i + 1)
+        l.setAttribute('bname', band_descr[i][0])
+        l.text = band_descr[i][1] || band_descr[i][0]
+        if (i === idx) l.selected="selected"
+        list.appendChild(l)
       }
-      bList.appendChild(l)
-    }
+    })
 
     if (['uint8','int8'].indexOf(info.dtype) === -1) {
       document.getElementById('minmax-data').classList.remove('none')
@@ -974,16 +910,6 @@
     document.getElementById('data-min').value = mm[0]
     document.getElementById('data-max').value = mm[1]
 
-    let bounds = [...info.bounds]
-    // Bounds crossing dateline
-    if (bounds[0] > bounds[2]) {
-      bounds[0] = bounds[0] - 360
-    }
-    map.fitBounds(
-      [[bounds[0], bounds[1]], [bounds[2], bounds[3]]]
-    )
-    addAOI(info.bounds)
-
     if (nbands === 1) {
       document.getElementById('3b').classList.add('disabled')
       document.getElementById('3b').classList.remove('active')
@@ -1019,8 +945,23 @@
       document.getElementById('menu').classList.toggle('off')
       document.getElementById('loader').classList.toggle('off')
 
-      scope.assets =  Object.entries(data).map((e) => {return e[0]})
-      scope.dataset_info = data
+      scope.assets = Object.entries(data.properties).map((e) => {return e[0]})
+      scope.dataset_info = data.properties
+
+      let bounds = [...data.bbox]
+      // Bounds crossing dateline
+      if (bounds[0] > bounds[2]) {
+        bounds[0] = bounds[0] - 360
+      }
+      map.fitBounds([[bounds[0], bounds[1]], [bounds[2], bounds[3]]])
+      map.addSource('aoi', {'type': 'geojson', 'data': data})
+      map.addLayer({
+        id: 'aoi-polygon',
+        type: 'line',
+        source: 'aoi',
+        layout: {'line-cap': 'round', 'line-join': 'round'},
+        paint: {'line-color': '#3bb2d0', 'line-width': 1}
+      })
 
       const assetList = document.getElementById('asset-selector')
       for (var i = 0; i < scope.assets.length; i++) {
@@ -1041,7 +982,7 @@
 }
 
 document.getElementById('launch').addEventListener('click', () => {
-  scope.url = document.getElementById('stac').value
+  scope.url = encodeURIComponent(document.getElementById('stac').value)
   document.getElementById('selector').classList.toggle('none')
   document.getElementById('loader').classList.add('off')
   addStac()
diff --git a/src/titiler/extensions/titiler/extensions/templates/wms_1.0.0.xml b/src/titiler/extensions/titiler/extensions/templates/wms_1.0.0.xml
index 8a06edbaf..110c783ff 100644
--- a/src/titiler/extensions/titiler/extensions/templates/wms_1.0.0.xml
+++ b/src/titiler/extensions/titiler/extensions/templates/wms_1.0.0.xml
@@ -27,6 +27,15 @@
         </HTTP>
       </DCPType>
     </Capabilities>
+    <FeatureInfo>
+      <Format><MIME /></Format>
+      <DCPType>
+        <HTTP>
+          <Get onlineResource="{{ request_url }}" />
+          <Post onlineResource="{{ request_url }}" />
+        </HTTP>
+      </DCPType>
+    </FeatureInfo>
   </Request>
   <Exception>
     <Format><BLANK /><INIMAGE /><WMS_XML /></Format>
diff --git a/src/titiler/extensions/titiler/extensions/templates/wms_1.1.1.xml b/src/titiler/extensions/titiler/extensions/templates/wms_1.1.1.xml
index 18ce6236b..82e1635bd 100644
--- a/src/titiler/extensions/titiler/extensions/templates/wms_1.1.1.xml
+++ b/src/titiler/extensions/titiler/extensions/templates/wms_1.1.1.xml
@@ -29,25 +29,34 @@
         </HTTP>
       </DCPType>
     </GetMap>
+    <GetFeatureInfo>
+      <Format>text/html</Format>
+      <DCPType>
+        <HTTP>
+          <Get><OnlineResource xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="{{ request_url }}"/></Get>
+          <Post><OnlineResource xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="{{ request_url }}"/></Post>
+        </HTTP>
+      </DCPType>
+    </GetFeatureInfo>
   </Request>
   <Exception>
     <Format>application/vnd.ogc.se_xml</Format>
     <Format>application/vnd.ogc.se_inimage</Format>
     <Format>application/vnd.ogc.se_blank</Format>
   </Exception>
-  
+
   <Layer>
     <Name>TiTiler WMS</Name>
     <Title>TiTiler WMS</Title>
     <Abstract>COG URLs specified in the "LAYERS" parameter will show up as available layers</Abstract>
-    
+
     {% for srs in available_epsgs %}
     <SRS>{{srs}}</SRS>
     {% endfor %}
-    
+
     <LatLonBoundingBox minx="{{service_dict['xmin']}}" miny="{{service_dict['ymin']}}" maxx="{{service_dict['xmax']}}" maxy="{{service_dict['ymax']}}" />
     <BoundingBox SRS="EPSG:4326" minx="{{service_dict['xmin']}}" miny="{{service_dict['ymin']}}" maxx="{{service_dict['xmax']}}" maxy="{{service_dict['ymax']}}" />
-    
+
     {% for layer in layers_dict.keys() %}
     <Layer queryable="0" opaque="0" cascaded="0">
         <Name>{{layer}}</Name>
diff --git a/src/titiler/extensions/titiler/extensions/templates/wms_1.3.0.xml b/src/titiler/extensions/titiler/extensions/templates/wms_1.3.0.xml
index bb5395df0..2eea680c4 100644
--- a/src/titiler/extensions/titiler/extensions/templates/wms_1.3.0.xml
+++ b/src/titiler/extensions/titiler/extensions/templates/wms_1.3.0.xml
@@ -29,6 +29,15 @@
         </HTTP>
       </DCPType>
     </GetMap>
+    <GetFeatureInfo>
+      <Format>text/html</Format>
+      <DCPType>
+        <HTTP>
+          <Get><OnlineResource xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="{{ request_url }}"/></Get>
+          <Post><OnlineResource xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="{{ request_url }}"/></Post>
+        </HTTP>
+      </DCPType>
+    </GetFeatureInfo>
   </Request>
   <Exception>
     <Format>XML</Format>
@@ -56,7 +65,7 @@
     <BoundingBox CRS="EPSG:4326" minx="{{service_dict['xmin']}}" miny="{{service_dict['ymin']}}" maxx="{{service_dict['xmax']}}" maxy="{{service_dict['ymax']}}" />
     
     {% for layer in layers_dict.keys() %}
-    <Layer queryable="0" opaque="0" cascaded="0">
+    <Layer queryable="1" opaque="0" cascaded="0">
         <Name>{{layer}}</Name>
         <Title>{{layer}}</Title>
         <Abstract>{{layers_dict[layer]['abstract']}}</Abstract>
diff --git a/src/titiler/extensions/titiler/extensions/templates/wmts.xml b/src/titiler/extensions/titiler/extensions/templates/wmts.xml
new file mode 100644
index 000000000..687b77aec
--- /dev/null
+++ b/src/titiler/extensions/titiler/extensions/templates/wmts.xml
@@ -0,0 +1,90 @@
+<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gml="http://www.opengis.net/gml" xsi:schemaLocation="http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd" version="1.0.0">
+    <ows:ServiceIdentification>
+        <ows:Title>Web Map Tile Service by TiTiler</ows:Title>
+        <ows:ServiceType>OGC WMTS</ows:ServiceType>
+        <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
+    </ows:ServiceIdentification>
+    <ows:ServiceProvider>
+        <ows:ProviderName>TiTiler</ows:ProviderName>
+        <ows:ProviderSite xlink:href="https://developmentseed.org/titiler/"/>
+        <ows:ServiceContact/>
+    </ows:ServiceProvider>
+    <ows:OperationsMetadata>
+        <ows:Operation name="GetCapabilities">
+            <ows:DCP>
+                <ows:HTTP>
+                    <ows:Get xlink:href="{{ request.url | escape }}">
+                        <ows:Constraint name="GetEncoding">
+                            <ows:AllowedValues>
+                                <ows:Value>RESTful</ows:Value>
+                            </ows:AllowedValues>
+                        </ows:Constraint>
+                    </ows:Get>
+                </ows:HTTP>
+            </ows:DCP>
+        </ows:Operation>
+        <ows:Operation name="GetTile">
+            <ows:DCP>
+                <ows:HTTP>
+                    <ows:Get xlink:href="{{ request.url | escape }}">
+                        <ows:Constraint name="GetEncoding">
+                            <ows:AllowedValues>
+                                <ows:Value>RESTful</ows:Value>
+                            </ows:AllowedValues>
+                        </ows:Constraint>
+                    </ows:Get>
+                </ows:HTTP>
+            </ows:DCP>
+        </ows:Operation>
+    </ows:OperationsMetadata>
+    <Contents>
+    {% for layer in layers -%}
+        <Layer>
+            <ows:Title>{{ layer.title }}</ows:Title>
+            <ows:Identifier>{{ layer.identifier }}</ows:Identifier>
+            <ows:{{ layer.bbox_crs_type }} crs="{{ layer.bbox_crs_uri }}">
+                <ows:LowerCorner>{{ layer.bbox[0] }} {{ layer.bbox[1] }}</ows:LowerCorner>
+                <ows:UpperCorner>{{ layer.bbox[2] }} {{ layer.bbox[3] }}</ows:UpperCorner>
+            </ows:{{ layer.bbox_crs_type }}>
+            <Style isDefault="true">
+                <ows:Title>{{ layer.title }}</ows:Title>
+                <ows:Identifier>{{ layer.identifier }}</ows:Identifier>
+            </Style>
+            <Format>{{ media_type }}</Format>
+            <TileMatrixSetLink>
+                <TileMatrixSet>{{ layer.tms_identifier }}</TileMatrixSet>
+                <TileMatrixSetLimits>
+                {% for limit  in layer.tms_limits %}
+                    <TileMatrixLimits>
+                    <TileMatrix>{{ limit.tileMatrix }}</TileMatrix>
+                    <MinTileRow>{{ limit.minTileRow }}</MinTileRow>
+                    <MaxTileRow>{{ limit.maxTileRow }}</MaxTileRow>
+                    <MinTileCol>{{ limit.minTileCol }}</MinTileCol>
+                    <MaxTileCol>{{ limit.maxTileCol }}</MaxTileCol>
+                    </TileMatrixLimits>
+                {% endfor %}
+                </TileMatrixSetLimits>
+            </TileMatrixSetLink>
+            <ResourceURL format="{{ media_type }}" resourceType="tile" template="{{ layer.tiles_url }}?{{ layer.query_string | escape }}" />
+        </Layer>
+    {%- endfor %}
+    {% for tms in tileMatrixSets -%}
+        <TileMatrixSet>
+            <ows:Identifier>{{ tms.id }}</ows:Identifier>
+            <ows:SupportedCRS>{{ tms.crs }}</ows:SupportedCRS>
+            {% for matrix in tms.matrices %}
+            <TileMatrix>
+                <ows:Identifier>{{ matrix.id }}</ows:Identifier>
+                <ScaleDenominator>{{ matrix.scaleDenominator }}</ScaleDenominator>
+                <TopLeftCorner>{{ matrix.pointOfOrigin[0] }} {{ matrix.pointOfOrigin[1] }}</TopLeftCorner>
+                <TileWidth>{{ matrix.tileWidth }}</TileWidth>
+                <TileHeight>{{ matrix.tileHeight }}</TileHeight>
+                <MatrixWidth>{{ matrix.matrixWidth }}</MatrixWidth>
+                <MatrixHeight>{{ matrix.matrixHeight }}</MatrixHeight>
+            </TileMatrix>
+            {% endfor %}
+        </TileMatrixSet>
+    {%- endfor %}
+    </Contents>
+    <ServiceMetadataURL xlink:href="{{ request.url | escape }}" />
+</Capabilities>
diff --git a/src/titiler/extensions/titiler/extensions/viewer.py b/src/titiler/extensions/titiler/extensions/viewer.py
index cdd14192b..cb9a0ab7b 100644
--- a/src/titiler/extensions/titiler/extensions/viewer.py
+++ b/src/titiler/extensions/titiler/extensions/viewer.py
@@ -1,62 +1,75 @@
 """titiler Viewer Extensions."""
 
-from dataclasses import dataclass
-
 import jinja2
+from attrs import define
 from starlette.requests import Request
 from starlette.responses import HTMLResponse
 from starlette.templating import Jinja2Templates
 
-from titiler.core.factory import BaseTilerFactory, FactoryExtension
+from titiler.core.factory import FactoryExtension, TilerFactory
 
-DEFAULT_TEMPLATES = Jinja2Templates(
-    directory="",
+jinja2_env = jinja2.Environment(
+    autoescape=jinja2.select_autoescape(["html"]),
     loader=jinja2.ChoiceLoader([jinja2.PackageLoader(__package__, "templates")]),
-)  # type:ignore
+)
+DEFAULT_TEMPLATES = Jinja2Templates(env=jinja2_env)
 
 
-@dataclass
+@define
 class cogViewerExtension(FactoryExtension):
     """Add /viewer endpoint to the TilerFactory."""
 
     templates: Jinja2Templates = DEFAULT_TEMPLATES
 
-    def register(self, factory: BaseTilerFactory):
+    def register(self, factory: TilerFactory):  # type: ignore [override]
         """Register endpoint to the tiler factory."""
 
-        @factory.router.get("/viewer", response_class=HTMLResponse)
+        @factory.router.get(
+            "/viewer",
+            response_class=HTMLResponse,
+            operation_id=f"{factory.operation_prefix}getViewer",
+        )
         def cog_viewer(request: Request):
             """COG Viewer."""
             return self.templates.TemplateResponse(
+                request,
                 name="cog_viewer.html",
                 context={
-                    "request": request,
-                    "tilejson_endpoint": factory.url_for(request, "tilejson"),
-                    "info_endpoint": factory.url_for(request, "info"),
+                    "tilejson_endpoint": factory.url_for(
+                        request, "tilejson", tileMatrixSetId="WebMercatorQuad"
+                    ),
+                    "info_endpoint": factory.url_for(request, "info_geojson"),
                     "statistics_endpoint": factory.url_for(request, "statistics"),
+                    "viewer_enabled": getattr(factory, "add_viewer", False),
                 },
                 media_type="text/html",
             )
 
 
-@dataclass
+@define
 class stacViewerExtension(FactoryExtension):
     """Add /viewer endpoint to the TilerFactory."""
 
     templates: Jinja2Templates = DEFAULT_TEMPLATES
 
-    def register(self, factory: BaseTilerFactory):
+    def register(self, factory: TilerFactory):  # type: ignore [override]
         """Register endpoint to the tiler factory."""
 
-        @factory.router.get("/viewer", response_class=HTMLResponse)
+        @factory.router.get(
+            "/viewer",
+            response_class=HTMLResponse,
+            operation_id=f"{factory.operation_prefix}getViewer",
+        )
         def stac_viewer(request: Request):
             """STAC Viewer."""
             return self.templates.TemplateResponse(
+                request,
                 name="stac_viewer.html",
                 context={
-                    "request": request,
-                    "tilejson_endpoint": factory.url_for(request, "tilejson"),
-                    "info_endpoint": factory.url_for(request, "info"),
+                    "tilejson_endpoint": factory.url_for(
+                        request, "tilejson", tileMatrixSetId="WebMercatorQuad"
+                    ),
+                    "info_endpoint": factory.url_for(request, "info_geojson"),
                     "statistics_endpoint": factory.url_for(request, "asset_statistics"),
                 },
                 media_type="text/html",
diff --git a/src/titiler/extensions/titiler/extensions/wms.py b/src/titiler/extensions/titiler/extensions/wms.py
index 95948cec1..ee627c694 100644
--- a/src/titiler/extensions/titiler/extensions/wms.py
+++ b/src/titiler/extensions/titiler/extensions/wms.py
@@ -1,29 +1,33 @@
 """wms Extension."""
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 from urllib.parse import urlencode
 
 import jinja2
 import numpy
 import rasterio
-from fastapi import Depends, HTTPException, Query
+from attrs import define, field
+from fastapi import Depends, HTTPException
 from rasterio.crs import CRS
+from rio_tiler.constants import WGS84_CRS
+from rio_tiler.models import ImageData
 from rio_tiler.mosaic import mosaic_reader
 from rio_tiler.mosaic.methods.base import MosaicMethodBase
 from starlette.requests import Request
 from starlette.responses import Response
 from starlette.templating import Jinja2Templates
 
-from titiler.core.dependencies import RescalingParams
-from titiler.core.factory import BaseTilerFactory, FactoryExtension
+from titiler.core.dependencies import RenderingParams
+from titiler.core.factory import FactoryExtension, TilerFactory
 from titiler.core.resources.enums import ImageType, MediaType
 
-DEFAULT_TEMPLATES = Jinja2Templates(
-    directory="",
+jinja2_env = jinja2.Environment(
+    autoescape=jinja2.select_autoescape(["xml"]),
     loader=jinja2.ChoiceLoader([jinja2.PackageLoader(__package__, "templates")]),
-)  # type:ignore
+)
+DEFAULT_TEMPLATES = Jinja2Templates(env=jinja2_env)
 
 
 class WMSMediaType(str, Enum):
@@ -37,28 +41,30 @@ class WMSMediaType(str, Enum):
     webp = "image/webp"
 
 
+@dataclass
 class OverlayMethod(MosaicMethodBase):
     """Overlay data on top."""
 
-    def feed(self, tile):
-        """Add data to tile."""
-        if self.tile is None:
-            self.tile = tile
+    def feed(self, array: numpy.ma.MaskedArray):
+        """Add data to the mosaic array."""
+        if self.mosaic is None:  # type: ignore
+            self.mosaic = array
 
-        pidex = self.tile.mask & ~tile.mask
+        else:
+            pidex = self.mosaic.mask & ~array.mask
 
-        mask = numpy.where(pidex, tile.mask, self.tile.mask)
-        self.tile = numpy.ma.where(pidex, tile, self.tile)
-        self.tile.mask = mask
+            mask = numpy.where(pidex, array.mask, self.mosaic.mask)
+            self.mosaic = numpy.ma.where(pidex, array, self.mosaic)
+            self.mosaic.mask = mask
 
 
-@dataclass
+@define
 class wmsExtension(FactoryExtension):
     """Add /wms endpoint to a TilerFactory."""
 
-    supported_crs: List[str] = field(default_factory=lambda: ["EPSG:4326"])
-    supported_format: List[str] = field(
-        default_factory=lambda: [
+    supported_crs: list[str] = field(default=["EPSG:4326"])
+    supported_format: list[str] = field(
+        default=[
             "image/png",
             "image/jpeg",
             "image/jpg",
@@ -67,12 +73,10 @@ class wmsExtension(FactoryExtension):
             "image/tiff; application=geotiff",
         ]
     )
-    supported_version: List[str] = field(
-        default_factory=lambda: ["1.0.0", "1.1.1", "1.3.0"]
-    )
+    supported_version: list[str] = field(default=["1.0.0", "1.1.1", "1.3.0"])
     templates: Jinja2Templates = DEFAULT_TEMPLATES
 
-    def register(self, factory: BaseTilerFactory):  # noqa: C901
+    def register(self, factory: TilerFactory):  # type: ignore [override] # noqa: C901
         """Register endpoint to the tiler factory."""
 
         @factory.router.get(
@@ -92,6 +96,7 @@ def register(self, factory: BaseTilerFactory):  # noqa: C901
                     },
                 },
             },
+            operation_id=f"{factory.operation_prefix}getWMS",
             openapi_extra={
                 "parameters": [
                     {
@@ -99,10 +104,7 @@ def register(self, factory: BaseTilerFactory):  # noqa: C901
                         "schema": {
                             "title": "Request name",
                             "type": "string",
-                            "enum": [
-                                "GetCapabilities",
-                                "GetMap",
-                            ],
+                            "enum": ["GetCapabilities", "GetMap", "GetFeatureInfo"],
                         },
                         "name": "REQUEST",
                         "in": "query",
@@ -145,6 +147,7 @@ def register(self, factory: BaseTilerFactory):  # noqa: C901
                             "title": "Output format of service metadata/map",
                             "type": "string",
                             "enum": [
+                                "text/html",
                                 "application/xml",
                                 "image/png",
                                 "image/jpeg",
@@ -201,6 +204,24 @@ def register(self, factory: BaseTilerFactory):  # noqa: C901
                         "name": "HEIGHT",
                         "in": "query",
                     },
+                    {
+                        "required": False,
+                        "schema": {
+                            "title": "I Coordinate in pixels of feature in Map CS.",
+                            "type": "integer",
+                        },
+                        "name": "i",
+                        "in": "query",
+                    },
+                    {
+                        "required": False,
+                        "schema": {
+                            "title": "J Coordinate in pixels of feature in Map CS.",
+                            "type": "integer",
+                        },
+                        "name": "j",
+                        "in": "query",
+                    },
                     # Non-Used
                     {
                         "required": False,
@@ -264,17 +285,12 @@ def register(self, factory: BaseTilerFactory):  # noqa: C901
         def wms(  # noqa: C901
             request: Request,
             # vendor (titiler) parameters
+            reader_params=Depends(factory.reader_dependency),
             layer_params=Depends(factory.layer_dependency),
             dataset_params=Depends(factory.dataset_dependency),
             post_process=Depends(factory.process_dependency),
-            rescale: Optional[List[Tuple[float, ...]]] = Depends(RescalingParams),
-            color_formula: Optional[str] = Query(
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
             colormap=Depends(factory.colormap_dependency),
-            reader_params=Depends(factory.reader_dependency),
+            render_params=Depends(RenderingParams),
             env=Depends(factory.environment_dependency),
         ):
             """Return a WMS query for a single COG.
@@ -355,17 +371,21 @@ def wms(  # noqa: C901
                     wms_url += f"?{urlencode(qs)}"
 
                 # Grab information from each layer provided
-                layers_dict: Dict[str, Any] = {}
+                layers_dict: dict[str, Any] = {}
                 for layer in layers:
                     layers_dict[layer] = {}
                     with rasterio.Env(**env):
-                        with factory.reader(layer, **reader_params) as src_dst:
+                        with factory.reader(
+                            layer, **reader_params.as_dict()
+                        ) as src_dst:
                             layers_dict[layer]["srs"] = f"EPSG:{src_dst.crs.to_epsg()}"
                             layers_dict[layer]["bounds"] = src_dst.bounds
-                            layers_dict[layer][
-                                "bounds_wgs84"
-                            ] = src_dst.geographic_bounds
-                            layers_dict[layer]["abstract"] = src_dst.info().json()
+                            layers_dict[layer]["bounds_wgs84"] = (
+                                src_dst.get_geographic_bounds(WGS84_CRS)
+                            )
+                            layers_dict[layer]["abstract"] = (
+                                src_dst.info().model_dump_json()
+                            )
 
                 # Build information for the whole service
                 minx, miny, maxx, maxy = zip(
@@ -373,8 +393,9 @@ def wms(  # noqa: C901
                 )
 
                 return self.templates.TemplateResponse(
-                    f"wms_{version}.xml",
-                    {
+                    request,
+                    name=f"wms_{version}.xml",
+                    context={
                         "request": request,
                         "request_url": wms_url,
                         "formats": self.supported_format,
@@ -391,7 +412,11 @@ def wms(  # noqa: C901
                 )
 
             # GetMap: Return an image chip
-            if request_type.lower() == "getmap":
+            def get_map_data(  # noqa: C901
+                req: dict,
+                req_keys: set,
+                request_type: str,
+            ) -> tuple[ImageData, str | None, bool]:
                 # Required parameters:
                 # - VERSION
                 # - REQUEST=GetMap,
@@ -404,23 +429,12 @@ def wms(  # noqa: C901
                 # - FORMAT
                 # Optional parameters: TRANSPARENT, BGCOLOR, EXCEPTIONS, TIME, ELEVATION, ...
 
-                # List of required parameters (styles and crs are excluded)
-                req_keys = {
-                    "version",
-                    "request",
-                    "layers",
-                    "bbox",
-                    "width",
-                    "height",
-                    "format",
-                }
-
                 intrs = set(req.keys()).intersection(req_keys)
                 missing_keys = req_keys.difference(intrs)
                 if len(missing_keys) > 0:
                     raise HTTPException(
                         status_code=400,
-                        detail=f"Missing 'GetMap' parameters: {missing_keys}",
+                        detail=f"Missing '{request_type}' parameters: {missing_keys}",
                     )
 
                 version = req["version"]
@@ -480,54 +494,99 @@ def wms(  # noqa: C901
                             detail=f"Invalid 'TRANSPARENT' parameter: {transparent}. Should be one of ['FALSE', 'TRUE'].",
                         )
 
-                if req["format"] not in self.supported_format:
-                    raise HTTPException(
-                        status_code=400,
-                        detail=f"Invalid 'FORMAT' parameter: {req['format']}. Should be one of {self.supported_format}.",
-                    )
-                format = ImageType(WMSMediaType(req["format"]).name)
+                if format := req.get("format", None):
+                    if format not in self.supported_format:
+                        raise HTTPException(
+                            status_code=400,
+                            detail=f"Invalid 'FORMAT' parameter: {format}. Should be one of {self.supported_format}.",
+                        )
+                    format = ImageType(WMSMediaType(format).name)
 
                 height, width = int(req["height"]), int(req["width"])
 
                 def _reader(src_path: str):
                     with rasterio.Env(**env):
-                        with factory.reader(src_path, **reader_params) as src_dst:
+                        with factory.reader(
+                            src_path, **reader_params.as_dict()
+                        ) as src_dst:
                             return src_dst.part(
                                 bbox,
                                 width=width,
                                 height=height,
                                 dst_crs=crs,
                                 bounds_crs=crs,
-                                **layer_params,
-                                **dataset_params,
+                                **layer_params.as_dict(),
+                                **dataset_params.as_dict(),
                             )
 
-                image, assets_used = mosaic_reader(
+                image, _ = mosaic_reader(
                     layers,
                     _reader,
                     pixel_selection=OverlayMethod(),
                 )
+                return image, format, transparent
 
-                if post_process:
-                    image = post_process(image)
+            if request_type.lower() == "getmap":
+                # List of required parameters (styles and crs are excluded)
+                req_keys = {
+                    "version",
+                    "request",
+                    "layers",
+                    "bbox",
+                    "width",
+                    "height",
+                    "format",
+                }
 
-                if rescale:
-                    image.rescale(rescale)
+                image, format, transparent = get_map_data(req, req_keys, request_type)
 
-                if color_formula:
-                    image.apply_color_formula(color_formula)
+                if post_process:
+                    image = post_process(image)
 
-                content = image.render(
-                    img_format=format.driver,
+                content, media_type = factory.render_func(
+                    image,
+                    output_format=format,
                     colormap=colormap,
                     add_mask=transparent,
-                    **format.profile,
+                    **render_params.as_dict(),
                 )
-
-                return Response(content, media_type=format.mediatype)
+                return Response(content, media_type=media_type)
 
             elif request_type.lower() == "getfeatureinfo":
-                return Response("Not Implemented", 400)
+                # Required parameters:
+                # - VERSION
+                # - REQUEST=GetFeatureInfo
+                # - LAYERS
+                # - CRS or SRS
+                # - WIDTH
+                # - HEIGHT
+                # - QUERY_LAYERS
+                # - I (Pixel column)
+                # - J (Pixel row)
+                # Optional parameters: INFO_FORMAT, FEATURE_COUNT, ...
+
+                req_keys = {
+                    "version",
+                    "request",
+                    "layers",
+                    "width",
+                    "height",
+                    "query_layers",
+                    "i",
+                    "j",
+                }
+                image, _, _ = get_map_data(req, req_keys, request_type)
+                i = int(req["i"])
+                j = int(req["j"])
+
+                html_content = ""
+                bands_info = []
+                for band in range(image.count):
+                    pixel_value = image.data[band, j, i]
+                    bands_info.append(pixel_value)
+
+                html_content = ",".join([str(band_info) for band_info in bands_info])
+                return Response(html_content, 200)
 
             else:
                 raise HTTPException(
diff --git a/src/titiler/extensions/titiler/extensions/wmts.py b/src/titiler/extensions/titiler/extensions/wmts.py
new file mode 100644
index 000000000..069b3c71a
--- /dev/null
+++ b/src/titiler/extensions/titiler/extensions/wmts.py
@@ -0,0 +1,265 @@
+"""TiTiler WMTS Extension."""
+
+import warnings
+from collections.abc import Callable
+from typing import Annotated, Any
+from urllib.parse import urlencode
+
+import jinja2
+import rasterio
+from attrs import define, field
+from fastapi import Depends, HTTPException, Query
+from morecantile.models import crs_axis_inverted
+from rasterio.crs import CRS
+from rio_tiler.constants import WGS84_CRS
+from rio_tiler.io import BaseReader
+from rio_tiler.utils import CRS_to_urn
+from starlette.datastructures import QueryParams
+from starlette.requests import Request
+from starlette.templating import Jinja2Templates
+
+from titiler.core.factory import FactoryExtension, TilerFactory
+from titiler.core.resources.enums import ImageType
+from titiler.core.resources.responses import XMLResponse
+from titiler.core.utils import (
+    check_query_params,
+    dependencies_to_openapi_params,
+    rio_crs_to_pyproj,
+    tms_limits,
+)
+
+jinja2_env = jinja2.Environment(
+    autoescape=jinja2.select_autoescape(["xml"]),
+    loader=jinja2.ChoiceLoader([jinja2.PackageLoader(__package__, "templates")]),
+)
+DEFAULT_TEMPLATES = Jinja2Templates(env=jinja2_env)
+
+
+@define
+class wmtsExtension(FactoryExtension):
+    """RESTful WMTS service Extension for TilerFactory."""
+
+    # Geographic Coordinate Reference System.
+    crs: CRS = field(default=WGS84_CRS)
+
+    templates: Jinja2Templates = field(default=DEFAULT_TEMPLATES)
+
+    get_renders: Callable[[BaseReader], dict[str, dict[str, Any]]] = field(
+        default=lambda obj: {}
+    )
+
+    # List of dependencies a `/tile` URL should validate
+    # Note: Those dependencies should only require Query() inputs
+    tile_dependencies: list[Callable] | None = field(default=None)
+
+    def register(self, factory: TilerFactory):  # type: ignore [override] # noqa: C901
+        """Register extension's endpoints."""
+        tile_dependencies = (
+            self.tile_dependencies
+            if self.tile_dependencies is not None
+            else [
+                factory.reader_dependency,
+                factory.tile_dependency,
+                factory.layer_dependency,
+                factory.dataset_dependency,
+                factory.process_dependency,
+                factory.colormap_dependency,
+                factory.render_dependency,
+            ]
+        )
+
+        @factory.router.get(
+            "/WMTSCapabilities.xml",
+            response_class=XMLResponse,
+            responses={
+                200: {
+                    "content": {"application/xml": {}},
+                    "description": "Return RESTful WMTS service capabilities document.",
+                }
+            },
+            operation_id=f"{factory.operation_prefix}getWMTS",
+            openapi_extra={
+                "parameters": dependencies_to_openapi_params(tile_dependencies),
+            },
+        )
+        def wmts(  # noqa: C901
+            request: Request,
+            tile_format: Annotated[
+                ImageType,
+                Query(description="Output image type. Default is png."),
+            ] = ImageType.png,
+            use_epsg: Annotated[
+                bool,
+                Query(
+                    description="Use EPSG code, not opengis.net, for the ows:SupportedCRS in the TileMatrixSet (set to True to enable ArcMap compatability)"
+                ),
+            ] = False,
+            src_path=Depends(factory.path_dependency),
+            reader_params=Depends(factory.reader_dependency),
+            env=Depends(factory.environment_dependency),
+        ):
+            """OGC RESTful WMTS endpoint."""
+            with rasterio.Env(**env):
+                with factory.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    dataset_bounds = src_dst.get_geographic_bounds(self.crs)
+                    default_renders = self.get_renders(src_dst)
+
+                renders: list[dict[str, Any]] = []
+
+                ##########################################
+                # 1. Create layers from `renders` metadata
+                for name, values in default_renders.items():
+                    values.pop("tilesize", None)  # Ensure tilesize is not overridden
+                    if check_query_params(tile_dependencies, values):
+                        renders.append(
+                            {
+                                "name": name,
+                                "query_string": urlencode(values, doseq=True)
+                                if values
+                                else None,
+                                "tilematrixsets": values.get("tilematrixsets", {}),
+                                "spatial_extent": values.get("spatial_extent", None),
+                            }
+                        )
+                    else:
+                        warnings.warn(
+                            f"Cannot construct URL for layer `{name}`",
+                            UserWarning,
+                            stacklevel=2,
+                        )
+
+                #######################################
+                # 2. Create layer from query-parameters
+                qs_key_to_remove = [
+                    "tile_format",
+                    "use_epsg",
+                    # Make sure tilesize is not ovewrriden from WMTS request
+                    "tilesize",
+                    # OGC WMTS parameters to ignore
+                    "service",
+                    "request",
+                    "acceptversions",
+                    "sections",
+                    "updatesequence",
+                    "acceptformats",
+                ]
+
+                qs = urlencode(
+                    [
+                        (key, value)
+                        for (key, value) in request.query_params._list
+                        if key.lower() not in qs_key_to_remove
+                    ],
+                    doseq=True,
+                )
+
+                if check_query_params(tile_dependencies, QueryParams(qs)):
+                    renders.append({"name": "default", "query_string": qs})
+
+                #################################################
+                # 3. if there is no layers we raise and exception
+                if not renders:
+                    raise HTTPException(
+                        status_code=400,
+                        detail="Could not find any valid layers in metadata or construct one from Query Parameters.",
+                    )
+
+                layers: list[dict[str, Any]] = []
+                title = src_path if isinstance(src_path, str) else "TiTiler"
+                for render in renders:
+                    # NOTE: Default bounds and CRS for the dataset
+                    bounds = dataset_bounds
+                    geographic_crs = self.crs
+
+                    # NOTE: Custom TiTiler Render key in form of {"spatial_extent": (minx, miny, maxx, maxy)}
+                    # NOTE: We assume the spatial_extent is always in WGS84
+                    if render.get("spatial_extent"):
+                        bounds = render["spatial_extent"]
+                        geographic_crs = WGS84_CRS
+
+                    bbox_crs_type = "WGS84BoundingBox"
+                    bbox_crs_uri = "urn:ogc:def:crs:OGC:2:84"
+                    wmts_bbox = bounds
+                    if geographic_crs != WGS84_CRS:
+                        bbox_crs_type = "BoundingBox"
+                        bbox_crs_uri = CRS_to_urn(geographic_crs)  # type: ignore
+                        # WGS88BoundingBox is always xy ordered, but BoundingBox must match the CRS order
+                        proj_crs = rio_crs_to_pyproj(geographic_crs)
+                        if crs_axis_inverted(proj_crs):
+                            # match the bounding box coordinate order to the CRS
+                            wmts_bbox = [
+                                wmts_bbox[1],
+                                wmts_bbox[0],
+                                wmts_bbox[3],
+                                wmts_bbox[2],
+                            ]
+
+                    for tms_id in factory.supported_tms.list():
+                        tms = factory.supported_tms.get(tms_id)
+
+                        # NOTE: Custom TiTiler Render key in form of {"tilematrixsets": {"{tms_id}": (minzoom, maxzoom)}}
+                        zooms: tuple[int, int] = render.get("tilematrixsets", {}).get(
+                            tms_id
+                        )
+                        # NOTE: If zooms are not in render then we get them from the dataset
+                        if not zooms:
+                            try:
+                                with factory.reader(
+                                    src_path, tms=tms, **reader_params.as_dict()
+                                ) as src_dst:
+                                    zooms = (src_dst.minzoom, src_dst.maxzoom)
+                            except Exception as e:  # noqa
+                                zooms = (tms.minzoom, tms.maxzoom)
+
+                        tilematrixset_limits = tms_limits(
+                            tms,
+                            bounds,
+                            zooms=zooms,
+                            geographic_crs=geographic_crs,
+                        )
+
+                        route_params = {
+                            "z": "{TileMatrix}",
+                            "x": "{TileCol}",
+                            "y": "{TileRow}",
+                            "format": tile_format.value,
+                            "tileMatrixSetId": tms_id,
+                        }
+                        tile_url = factory.url_for(request, "tile", **route_params)
+
+                        layers.append(
+                            {
+                                "title": f"{title}_{tms_id}_{render['name']}",
+                                "identifier": f"{title}_{tms_id}_{render['name']}",
+                                "tms_identifier": tms_id,
+                                "tms_limits": tilematrixset_limits,
+                                "tiles_url": tile_url,
+                                "query_string": render["query_string"],
+                                "bbox_crs_type": bbox_crs_type,
+                                "bbox_crs_uri": bbox_crs_uri,
+                                "bbox": wmts_bbox,
+                            }
+                        )
+
+            tileMatrixSets: list[dict[str, Any]] = []
+            for tms_id in factory.supported_tms.list():
+                tms = factory.supported_tms.get(tms_id)
+                if use_epsg:
+                    supported_crs = f"EPSG:{tms.crs.to_epsg()}"
+                else:
+                    supported_crs = tms.crs.srs
+
+                tileMatrixSets.append(
+                    {"id": tms_id, "crs": supported_crs, "matrices": tms.tileMatrices}
+                )
+
+            return self.templates.TemplateResponse(
+                request,
+                name="wmts.xml",
+                context={
+                    "layers": layers,
+                    "tileMatrixSets": tileMatrixSets,
+                    "media_type": tile_format.mediatype,
+                },
+                media_type="application/xml",
+            )
diff --git a/src/titiler/mosaic/LICENSE b/src/titiler/mosaic/LICENSE
new file mode 100644
index 000000000..eb4365951
--- /dev/null
+++ b/src/titiler/mosaic/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Development Seed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/titiler/mosaic/README.md b/src/titiler/mosaic/README.md
index 010c46fc3..72113a72e 100644
--- a/src/titiler/mosaic/README.md
+++ b/src/titiler/mosaic/README.md
@@ -1,18 +1,23 @@
 ## titiler.mosaic
 
-Adds support for MosaicJSON in Titiler.
+<img style="max-width:400px" src="https://github.com/user-attachments/assets/14b92588-14eb-4b37-b862-cc5d0d8015c9"/>
+
+Adds support for Mosaic in Titiler. `Mosaic's` backend needs to be built on top of rio-tiler's Mosaic Backend https://cogeotiff.github.io/rio-tiler/advanced/mosaic_backend/
 
 ## Installation
 
 ```bash
-$ pip install -U pip
+python -m pip install -U pip
 
 # From Pypi
-$ pip install titiler.mosaic
+python -m pip install titiler.mosaic
 
 # Or from sources
-$ git clone https://github.com/developmentseed/titiler.git
-$ cd titiler && pip install -e titiler/core -e titiler/mosaic
+git clone https://github.com/developmentseed/titiler.git
+cd titiler && python -m pip install -e src/titiler/core -e src/titiler/mosaic
+
+# install cogeo-mosaic for MosaicJSON support
+python -m pip install cogeo-mosaic
 ```
 
 ## How To
@@ -21,30 +26,30 @@ $ cd titiler && pip install -e titiler/core -e titiler/mosaic
 from fastapi import FastAPI
 from titiler.mosaic.factory import MosaicTilerFactory
 
+from cogeo_mosaic.backends import MosaicBackend
+
 # Create a FastAPI application
 app = FastAPI(
-    description="A lightweight Cloud Optimized GeoTIFF tile server",
+    description="A Mosaic tile server",
 )
 
-# Create a set of MosaicJSON endpoints
-mosaic = MosaicTilerFactory()
+# Create a set of Mosaic endpoints using MosaicJSON backend from cogeo-mosaic project
+mosaic = MosaicTilerFactory(backend=MosaicBackend)
 
 # Register the Mosaic endpoints to the application
 app.include_router(mosaic.router, tags=["MosaicJSON"])
 ```
 
-See [titiler.application](../application) for a full example.
-
 ## Package structure
 
 ```
 titiler/
  └── mosaic/
     ├── tests/                   - Tests suite
-    └── titiler/mosaic/            - `core` namespace package
-        ├── resources/
-        |   ├── enums.py         - mosaicJSON enumerations
-        ├── errors.py            - cogeo-mosaic known errors
-        ├── factory.py           - MosaicJSON endpoints factory
-        └── version.py           - version
+    └── titiler/mosaic/          - `mosaic` namespace package
+        ├── models/
+        |   └── responses.py     - mosaic response models
+        ├── errors.py            - mosaic known errors
+        ├── extensions.py        - extensions
+        └── factory.py           - Mosaic endpoints factory
 ```
diff --git a/src/titiler/mosaic/pyproject.toml b/src/titiler/mosaic/pyproject.toml
index 5bcb697c3..2ed3de200 100644
--- a/src/titiler/mosaic/pyproject.toml
+++ b/src/titiler/mosaic/pyproject.toml
@@ -1,8 +1,8 @@
 [project]
-name = "titiler.mosaic"
+name = "titiler-mosaic"
 description = "cogeo-mosaic (MosaicJSON) plugin for TiTiler."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 authors = [
     {name = "Vincent Sarago", email = "vincent@developmentseed.com"},
 ]
@@ -21,24 +21,30 @@ classifiers = [
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: GIS",
 ]
 dynamic = ["version"]
 dependencies = [
-    "titiler.core==0.11.7",
-    "cogeo-mosaic>=5.0,<5.2",
+    "titiler-core==2.0.1",  # x-release-please-version
 ]
 
 [project.optional-dependencies]
+mosaicjson = [
+    "cogeo-mosaic>=9.0,<10.0",
+]
+
+[dependency-groups]
 test = [
     "pytest",
     "pytest-cov",
     "pytest-asyncio",
     "httpx",
+    "owslib",
 ]
 
 [project.urls]
@@ -48,14 +54,15 @@ Issues = "https://github.com/developmentseed/titiler/issues"
 Source = "https://github.com/developmentseed/titiler"
 Changelog = "https://developmentseed.org/titiler/release-notes/"
 
-[build-system]
-requires = ["pdm-pep517"]
-build-backend = "pdm.pep517.api"
-
-[tool.pdm.version]
-source = "file"
+[tool.hatch.version]
 path = "titiler/mosaic/__init__.py"
 
-[tool.pdm.build]
-includes = ["titiler/mosaic"]
-excludes = ["tests/", "**/.mypy_cache", "**/.DS_Store"]
+[tool.hatch.build.targets.sdist]
+only-include = ["titiler"]
+
+[tool.hatch.build.targets.wheel]
+only-include = ["titiler"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/src/titiler/mosaic/tests/conftest.py b/src/titiler/mosaic/tests/conftest.py
index caa12a195..61442364c 100644
--- a/src/titiler/mosaic/tests/conftest.py
+++ b/src/titiler/mosaic/tests/conftest.py
@@ -1,7 +1,7 @@
 """``pytest`` configuration."""
 
 import os
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 from rasterio.io import MemoryFile
@@ -20,7 +20,7 @@ def set_env(monkeypatch):
     monkeypatch.setenv("AWS_CONFIG_FILE", "/tmp/noconfigheere")
 
 
-def parse_img(content: bytes) -> Dict[Any, Any]:
+def parse_img(content: bytes) -> dict[Any, Any]:
     """Read tile image and return metadata."""
     with MemoryFile(content) as mem:
         with mem.open() as dst:
diff --git a/src/titiler/mosaic/tests/test_factory.py b/src/titiler/mosaic/tests/test_factory.py
index abd514f0b..8a661be87 100644
--- a/src/titiler/mosaic/tests/test_factory.py
+++ b/src/titiler/mosaic/tests/test_factory.py
@@ -5,23 +5,33 @@
 from contextlib import contextmanager
 from dataclasses import dataclass
 from io import BytesIO
-from typing import Optional
+from typing import Annotated, Any
+from unittest.mock import patch
 
 import attr
+import morecantile
 import numpy
 from cogeo_mosaic.backends import FileBackend
+from cogeo_mosaic.backends import MosaicBackend as MosaicJSONBackend
 from cogeo_mosaic.mosaic import MosaicJSON
-from fastapi import FastAPI
+from fastapi import FastAPI, Query
+from owslib.wmts import WebMapTileService
+from rio_tiler.mosaic.methods import PixelSelectionMethod
 from starlette.testclient import TestClient
 
 from titiler.core.dependencies import DefaultDependency
+from titiler.core.errors import add_exception_handlers
 from titiler.core.resources.enums import OptionalHeader
+from titiler.mosaic.errors import MOSAIC_STATUS_CODES
+from titiler.mosaic.extensions.mosaicjson import MosaicJSONExtension
+from titiler.mosaic.extensions.wmts import wmtsExtension
 from titiler.mosaic.factory import MosaicTilerFactory
-from titiler.mosaic.resources.enums import PixelSelectionMethod
 
-from .conftest import DATA_DIR
+from .conftest import DATA_DIR, parse_img
 
 assets = [os.path.join(DATA_DIR, asset) for asset in ["cog1.tif", "cog2.tif"]]
+DEFAULT_TMS = morecantile.tms
+NB_DEFAULT_TMS = len(DEFAULT_TMS.list())
 
 
 @contextmanager
@@ -42,15 +52,45 @@ def tmpmosaic():
 def test_MosaicTilerFactory():
     """Test MosaicTilerFactory class."""
     mosaic = MosaicTilerFactory(
+        backend=MosaicJSONBackend,
         optional_headers=[OptionalHeader.x_assets],
         router_prefix="mosaic",
     )
-    assert len(mosaic.router.routes) == 23
+    assert len(mosaic.router.routes) == 12
+
+    @dataclass
+    class MosaicJSONAccessor(DefaultDependency):
+        """MosaicJSON Accessor Options."""
+
+        reverse: Annotated[
+            bool,
+            Query(),
+        ] = False
+
+    mosaic = MosaicTilerFactory(
+        backend=MosaicJSONBackend,
+        assets_accessor_dependency=MosaicJSONAccessor,
+        optional_headers=[
+            OptionalHeader.x_assets,
+            OptionalHeader.server_timing,
+        ],
+        extensions=[MosaicJSONExtension(), wmtsExtension()],
+        add_statistics=True,
+        add_part=True,
+        router_prefix="mosaic",
+    )
+    assert len(mosaic.router.routes) == 21
 
     app = FastAPI()
     app.include_router(mosaic.router, prefix="/mosaic")
     client = TestClient(app)
 
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+
+    response = client.get("/docs")
+    assert response.status_code == 200
+
     with tmpmosaic() as mosaic_file:
         response = client.get(
             "/mosaic/",
@@ -66,13 +106,6 @@ def test_MosaicTilerFactory():
         assert response.status_code == 200
         assert response.json()["mosaicjson"]
 
-        response = client.get(
-            "/mosaic/bounds",
-            params={"url": mosaic_file},
-        )
-        assert response.status_code == 200
-        assert response.json()["bounds"]
-
         response = client.get(
             "/mosaic/info",
             params={"url": mosaic_file},
@@ -93,14 +126,82 @@ def test_MosaicTilerFactory():
             params={"url": mosaic_file},
         )
         assert response.status_code == 200
+        assert response.json()["coordinates"]
+        v = response.json()["assets"]
+        # one asset found
+        assert len(v) == 1
+        assert v[0]["name"]
+        # 3 bands
+        assert len(v[0]["values"]) == 3
+        assert v[0]["band_names"] == ["b1", "b2", "b3"]
+        assert v[0]["band_descriptions"]
+
+        response = client.get(
+            "/mosaic/point/-73,45",
+            params={"url": mosaic_file},
+        )
+        assert response.status_code == 200
+        assert response.json()["coordinates"]
+        v = response.json()["assets"]
+        # two asset found
+        assert len(v) == 2
+        names = [asset["name"] for asset in v]
+        assert names == assets
+
+        response = client.get(
+            "/mosaic/point/-73,45",
+            params={"url": mosaic_file, "reverse": True},
+        )
+        assert response.status_code == 200
+        assert response.json()["coordinates"]
+        v = response.json()["assets"]
+        # two asset found
+        assert len(v) == 2
+        names = [asset["name"] for asset in v]
+        assert names == list(reversed(assets))
+
+        # Masked values
+        response = client.get(
+            "/mosaic/point/-75.759,46.3847",
+            params={"url": mosaic_file},
+        )
+        assert response.status_code == 200
+        assert response.json()["coordinates"]
+        v = response.json()["assets"]
+        # one asset found
+        assert len(v) == 1
+        assert v[0]["name"]
+        # 3 bands
+        assert len(v[0]["values"]) == 3
+        assert v[0]["values"][0] is None
+        assert v[0]["band_names"] == ["b1", "b2", "b3"]
+        assert v[0]["band_descriptions"]
+
+        response = client.get(
+            "/mosaic/point/-7903683.846322423,5780349.220256353",
+            params={"url": mosaic_file, "coord_crs": "epsg:3857"},
+        )
+        assert response.status_code == 200
+
+        response = client.get(
+            "/mosaic/tiles/WebMercatorQuad/7/37/45", params={"url": mosaic_file}
+        )
+        assert response.status_code == 200
+        assert response.headers["X-Assets"]
+        assert response.headers["Server-Timing"]
+        assert response.headers["Content-Crs"]
+        assert response.headers["Content-Bbox"]
 
-        response = client.get("/mosaic/tiles/7/37/45", params={"url": mosaic_file})
+        response = client.get(
+            "/mosaic/tiles/WGS1984Quad/8/148/61", params={"url": mosaic_file}
+        )
         assert response.status_code == 200
         assert response.headers["X-Assets"]
 
         # Buffer
         response = client.get(
-            "/mosaic/tiles/7/37/45.npy", params={"url": mosaic_file, "buffer": 10}
+            "/mosaic/tiles/WebMercatorQuad/7/37/45.npy",
+            params={"url": mosaic_file, "buffer": 10},
         )
         assert response.status_code == 200
         assert response.headers["content-type"] == "application/x-binary"
@@ -108,7 +209,7 @@ def test_MosaicTilerFactory():
         assert npy_tile.shape == (4, 276, 276)  # mask + data
 
         response = client.get(
-            "/mosaic/tilejson.json",
+            "/mosaic/WebMercatorQuad/tilejson.json",
             params={
                 "url": mosaic_file,
                 "tile_format": "png",
@@ -119,39 +220,37 @@ def test_MosaicTilerFactory():
         assert response.status_code == 200
         body = response.json()
         assert (
-            "http://testserver/mosaic/tiles/WebMercatorQuad/{z}/{x}/{y}@1x.png?url="
+            "http://testserver/mosaic/tiles/WebMercatorQuad/{z}/{x}/{y}.png?url="
             in body["tiles"][0]
         )
         assert body["minzoom"] == 6
         assert body["maxzoom"] == 9
 
         response = client.get(
-            "/mosaic/tilejson.json",
+            "/mosaic/WebMercatorQuad/tilejson.json",
             params={
                 "url": mosaic_file,
                 "tile_format": "png",
                 "minzoom": 6,
                 "maxzoom": 9,
-                "TileMatrixSetId": "WebMercatorQuad",
+                "tileMatrixSetId": "WebMercatorQuad",
             },
         )
         assert response.status_code == 200
         body = response.json()
         assert (
-            "http://testserver/mosaic/tiles/WebMercatorQuad/{z}/{x}/{y}@1x.png?url="
+            "http://testserver/mosaic/tiles/WebMercatorQuad/{z}/{x}/{y}.png?url="
             in body["tiles"][0]
         )
         assert body["minzoom"] == 6
         assert body["maxzoom"] == 9
-        assert "TileMatrixSetId" not in body["tiles"][0]
+        assert "tileMatrixSetId" not in body["tiles"][0]
 
         response = client.get(
             "/mosaic/WMTSCapabilities.xml",
             params={
                 "url": mosaic_file,
                 "tile_format": "png",
-                "minzoom": 6,
-                "maxzoom": 9,
             },
         )
         assert response.status_code == 200
@@ -159,12 +258,12 @@ def test_MosaicTilerFactory():
 
         response = client.post(
             "/mosaic/validate",
-            json=MosaicJSON.from_urls(assets).dict(),
+            json=MosaicJSON.from_urls(assets).model_dump(),
         )
         assert response.status_code == 200
 
         response = client.get(
-            "/mosaic/7/36/45/assets",
+            "/mosaic/tiles/WebMercatorQuad/7/36/45/assets",
             params={"url": mosaic_file},
         )
         assert response.status_code == 200
@@ -172,7 +271,32 @@ def test_MosaicTilerFactory():
             filepath.split("/")[-1] in ["cog1.tif"] for filepath in response.json()
         )
 
-        response = client.get("/mosaic/-71,46/assets", params={"url": mosaic_file})
+        response = client.get(
+            "/mosaic/tiles/WGS1984Quad/8/148/61/assets",
+            params={"url": mosaic_file},
+        )
+        assert response.status_code == 200
+        assert all(
+            filepath.split("/")[-1] in ["cog1.tif", "cog2.tif"]
+            for filepath in response.json()
+        )
+
+        response = client.get(
+            "/mosaic/point/-71,46/assets", params={"url": mosaic_file}
+        )
+        assert response.status_code == 200
+        assert response.json() == assets
+
+        response = client.get(
+            "/mosaic/point/-71,46/assets", params={"url": mosaic_file, "reverse": True}
+        )
+        assert response.status_code == 200
+        assert response.json() == list(reversed(assets))
+
+        response = client.get(
+            "/mosaic/point/-7903683.846322423,5780349.220256353/assets",
+            params={"url": mosaic_file, "coord_crs": "epsg:3857"},
+        )
         assert response.status_code == 200
         assert all(
             filepath.split("/")[-1] in ["cog1.tif", "cog2.tif"]
@@ -180,7 +304,7 @@ def test_MosaicTilerFactory():
         )
 
         response = client.get(
-            "/mosaic/-75.9375,43.06888777416962,-73.125,45.089035564831015/assets",
+            "/mosaic/bbox/-75.9375,43.06888777416962,-73.125,45.089035564831015/assets",
             params={"url": mosaic_file},
         )
         assert response.status_code == 200
@@ -190,12 +314,153 @@ def test_MosaicTilerFactory():
         )
 
         response = client.get(
-            "/mosaic/10,10,11,11/assets",
+            "/mosaic/bbox/-8453323.83211421,5322463.153553393,-8140237.76425813,5635549.221409473/assets",
+            params={"url": mosaic_file, "coord_crs": "epsg:3857"},
+        )
+        assert response.status_code == 200
+        assert all(
+            filepath.split("/")[-1] in ["cog1.tif", "cog2.tif"]
+            for filepath in response.json()
+        )
+
+        response = client.get(
+            "/mosaic/bbox/10,10,11,11/assets",
             params={"url": mosaic_file},
         )
         assert response.status_code == 200
         assert response.json() == []
 
+        # OGC Tileset
+        response = client.get(f"/mosaic/tiles?url={mosaic_file}")
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "application/json"
+        resp = response.json()
+        assert len(resp["tilesets"]) == NB_DEFAULT_TMS
+
+        first_tms = resp["tilesets"][0]
+        first_id = DEFAULT_TMS.list()[0]
+        assert first_id in first_tms["title"]
+        assert len(first_tms["links"]) == 2  # no link to the tms definition
+
+        response = client.get(
+            f"/mosaic/tiles?url={mosaic_file}", headers={"Accept": "text/html"}
+        )
+        assert response.status_code == 200
+        assert "text/html" in response.headers["content-type"]
+
+        response = client.get("/mosaic/tiles", params={"url": mosaic_file, "f": "html"})
+        assert response.status_code == 200
+        assert "text/html" in response.headers["content-type"]
+
+        response = client.get(f"/mosaic/tiles/WebMercatorQuad?url={mosaic_file}")
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "application/json"
+        resp = response.json()
+        # covers only 3 zoom levels
+        assert len(resp["tileMatrixSetLimits"]) == 3
+
+        response = client.get(
+            f"/mosaic/tiles/WebMercatorQuad?url={mosaic_file}",
+            headers={"Accept": "text/html"},
+        )
+        assert response.status_code == 200
+        assert "text/html" in response.headers["content-type"]
+
+        response = client.get(
+            "/mosaic/tiles/WebMercatorQuad", params={"url": mosaic_file, "f": "html"}
+        )
+        assert response.status_code == 200
+        assert "text/html" in response.headers["content-type"]
+
+        response = client.get(
+            "/mosaic/bbox/-74,45,-73,46.png",
+            params={"url": mosaic_file, "dst_crs": "EPSG:3857"},
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "image/png"
+        assert response.headers["X-Assets"]
+        assert response.headers["Server-Timing"]
+        assert response.headers["Content-Crs"]
+        assert response.headers["Content-Bbox"]
+
+        meta = parse_img(response.content)
+        assert meta["width"] == 258
+        assert meta["height"] == 367
+
+        response = client.get(
+            "/mosaic/bbox/-74,45,-73,46/100x50.png",
+            params={"url": mosaic_file},
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "image/png"
+        assert response.headers["X-Assets"]
+        assert response.headers["Server-Timing"]
+        assert response.headers["Content-Crs"]
+        assert response.headers["Content-Bbox"]
+
+        meta = parse_img(response.content)
+        assert meta["width"] == 100
+        assert meta["height"] == 50
+
+        # test /feature
+
+        feat = {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    [-74, 45],
+                    [-74, 46],
+                    [-73, 46],
+                    [-73, 45],
+                    [-74, 45],
+                ]
+            ],
+        }
+        response = client.post(
+            "/mosaic/feature",
+            params={"url": mosaic_file, "dst_crs": "EPSG:3857"},
+            json={"type": "Feature", "properties": {}, "geometry": feat},
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "image/png"
+        assert response.headers["X-Assets"]
+        assert response.headers["Server-Timing"]
+        assert response.headers["Content-Crs"]
+        assert response.headers["Content-Bbox"]
+        meta = parse_img(response.content)
+        assert meta["width"] == 258
+        assert meta["height"] == 367
+
+        response = client.post(
+            "/mosaic/feature",
+            params={"url": mosaic_file, "max_size": 200, "dst_crs": "EPSG:3857"},
+            json={"type": "Feature", "properties": {}, "geometry": feat},
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "image/png"
+        meta = parse_img(response.content)
+        assert meta["width"] == 141
+        assert meta["height"] == 200
+
+        response = client.post(
+            "/mosaic/feature.png",
+            params={"url": mosaic_file},
+            json={"type": "Feature", "properties": {}, "geometry": feat},
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "image/png"
+
+        response = client.post(
+            "/mosaic/feature/150x50.png",
+            params={"url": mosaic_file},
+            json={"type": "Feature", "properties": {}, "geometry": feat},
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "image/png"
+        meta = parse_img(response.content)
+        assert meta["width"] == 150
+        assert meta["height"] == 50
+
 
 @dataclass
 class BackendParams(DefaultDependency):
@@ -205,25 +470,10 @@ class BackendParams(DefaultDependency):
     maxzoom: int = 8
 
 
-@attr.s
-class CustomFileBackend(FileBackend):
-    """Fake backend to prove we can overwrite min/max zoom."""
-
-    minzoom: Optional[int] = attr.ib(default=None)
-    maxzoom: Optional[int] = attr.ib(default=None)
-
-    def __attrs_post_init__(self):
-        """Post Init: if not passed in init, try to read from self.input."""
-        self.mosaic_def = self.mosaic_def or self._read()
-        self.minzoom = self.minzoom or self.mosaic_def.minzoom
-        self.maxzoom = self.maxzoom or self.mosaic_def.maxzoom
-        self.bounds = self.mosaic_def.bounds
-
-
 def test_MosaicTilerFactory_BackendParams():
     """Test MosaicTilerFactory factory with Backend dependency."""
     mosaic = MosaicTilerFactory(
-        reader=CustomFileBackend,
+        backend=FileBackend,
         backend_dependency=BackendParams,
         router_prefix="/mosaic",
     )
@@ -233,7 +483,7 @@ def test_MosaicTilerFactory_BackendParams():
 
     with tmpmosaic() as mosaic_file:
         response = client.get(
-            "/mosaic/tilejson.json",
+            "/mosaic/WebMercatorQuad/tilejson.json",
             params={"url": mosaic_file},
         )
         assert response.json()["minzoom"] == 4
@@ -248,9 +498,10 @@ def _multiply_by_two(data, mask):
 
 def test_MosaicTilerFactory_PixelSelectionParams():
     """Test MosaicTilerFactory factory with a customized default PixelSelectionMethod."""
-    mosaic = MosaicTilerFactory(router_prefix="/mosaic")
+    mosaic = MosaicTilerFactory(backend=MosaicJSONBackend, router_prefix="/mosaic")
     mosaic_highest = MosaicTilerFactory(
-        pixel_selection_dependency=lambda: PixelSelectionMethod.highest.method(),
+        backend=MosaicJSONBackend,
+        pixel_selection_dependency=lambda: PixelSelectionMethod.highest.value,
         router_prefix="/mosaic_highest",
     )
 
@@ -260,14 +511,17 @@ def test_MosaicTilerFactory_PixelSelectionParams():
     client = TestClient(app)
 
     with tmpmosaic() as mosaic_file:
-        response = client.get("/mosaic/tiles/7/37/45.npy", params={"url": mosaic_file})
+        response = client.get(
+            "/mosaic/tiles/WebMercatorQuad/7/37/45.npy", params={"url": mosaic_file}
+        )
         assert response.status_code == 200
         assert response.headers["content-type"] == "application/x-binary"
         npy_tile = numpy.load(BytesIO(response.content))
         assert npy_tile.shape == (4, 256, 256)  # mask + data
 
         response = client.get(
-            "/mosaic_highest/tiles/7/37/45.npy", params={"url": mosaic_file}
+            "/mosaic_highest/tiles/WebMercatorQuad/7/37/45.npy",
+            params={"url": mosaic_file},
         )
         assert response.status_code == 200
         assert response.headers["content-type"] == "application/x-binary"
@@ -277,23 +531,421 @@ def test_MosaicTilerFactory_PixelSelectionParams():
         assert (npy_tile != npy_tile_highest).any()
 
 
-def test_MosaicTilerFactory_strict_zoom(monkeypatch):
+@patch("titiler.mosaic.factory.MOSAIC_STRICT_ZOOM", new=True)
+def test_MosaicTilerFactory_strict_zoom():
     """Test MosaicTilerFactory factory with STRICT Zoom Mode"""
-    monkeypatch.setenv("MOSAIC_STRICT_ZOOM", True)
-
-    mosaic = MosaicTilerFactory()
+    mosaic = MosaicTilerFactory(backend=MosaicJSONBackend)
     app = FastAPI()
     app.include_router(mosaic.router)
 
     with TestClient(app) as client:
         with tmpmosaic() as mosaic_file:
-            response = client.get("/tiles/7/37/45.png", params={"url": mosaic_file})
+            response = client.get(
+                "/tiles/WebMercatorQuad/7/37/45.png", params={"url": mosaic_file}
+            )
             assert response.status_code == 200
 
-            response = client.get("/tiles/6/18/22.png", params={"url": mosaic_file})
+            response = client.get(
+                "/tiles/WebMercatorQuad/6/18/22.png", params={"url": mosaic_file}
+            )
             assert response.status_code == 400
             assert "Invalid ZOOM level 6" in response.text
 
-            response = client.get("/tiles/11/594/734.png", params={"url": mosaic_file})
+            response = client.get(
+                "/tiles/WebMercatorQuad/11/594/734.png", params={"url": mosaic_file}
+            )
             assert response.status_code == 400
             assert "Invalid ZOOM level 11" in response.text
+
+
+@dataclass
+class AssetsAccessParams(DefaultDependency):
+    """Backend options to overwrite min/max zoom."""
+
+    limit: Annotated[int, Query()] = 10
+
+
+@attr.s
+class CustomBackend(FileBackend):
+    """Custom FileBackend."""
+
+    def get_assets(
+        self,
+        x: int,
+        y: int,
+        z: int,
+        limit: int | None = None,
+        **kwargs: Any,
+    ) -> list[str]:
+        """Find assets."""
+        assets = super().get_assets(x, y, z)
+
+        if limit and len(assets) > limit:
+            return assets[:limit]
+
+        return assets
+
+
+def test_MosaicTilerFactory_asset_accessor():
+    """Test MosaicTilerFactory factory with Backend dependency."""
+    mosaic = MosaicTilerFactory(
+        backend=CustomBackend,
+        router_prefix="/mosaic",
+        assets_accessor_dependency=AssetsAccessParams,
+    )
+    app = FastAPI()
+    app.include_router(mosaic.router, prefix="/mosaic")
+    client = TestClient(app)
+
+    with tmpmosaic() as mosaic_file:
+        response = client.get(
+            "/mosaic/tiles/WGS1984Quad/8/148/61/assets",
+            params={"url": mosaic_file},
+        )
+        assert response.status_code == 200
+        assert len(response.json()) == 2
+
+        response = client.get(
+            "/mosaic/tiles/WGS1984Quad/8/148/61/assets",
+            params={"url": mosaic_file, "limit": 1},
+        )
+        assert response.status_code == 200
+        assert len(response.json()) == 1
+
+
+def test_ogc_maps_mosaic():
+    """Test TilerFactory class."""
+    mosaic = MosaicTilerFactory(
+        backend=MosaicJSONBackend,
+        add_ogc_maps=True,
+    )
+    app = FastAPI()
+    app.include_router(mosaic.router)
+    add_exception_handlers(app, MOSAIC_STATUS_CODES)
+
+    assert (
+        "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/core" in mosaic.conforms_to
+    )
+
+    with TestClient(app) as client:
+        with tmpmosaic() as mosaic_file:
+            # Conformance Class “Core”
+            response = client.get("/map", params={"url": mosaic_file})
+            assert response.status_code == 501
+
+            # Conformance Class “Spatial Subsetting”
+            # /conf/spatial-subsetting/bbox-crs
+            response = client.get(
+                "/map",
+                params={
+                    "url": mosaic_file,
+                    "bbox": "-74,45,-73,46",
+                },
+            )
+            headers = response.headers
+            # Default CRS for Mosaic is EPSG:4326
+            assert (
+                headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/4326>"
+            )
+            assert headers["Content-Bbox"] == "-74.0,45.0,-73.0,46.0"
+            assert headers["content-type"] == "image/png"
+
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                # tile 9-151-184
+                "bbox": "-8218509.281222152,5557277.704445455,-8140237.7642581295,5635549.221409475",
+                "bbox-crs": "http://www.opengis.net/def/crs/EPSG/0/3857",
+            },
+        )
+        headers = response.headers
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/4326>"
+        assert (
+            headers["Content-Bbox"]
+            == "-73.828125,44.590467181308846,-73.125,45.08903556483102"
+        )
+        assert headers["content-type"] == "image/png"
+
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                # tile 9-151-184
+                "bbox": "-8218509.281222152,5557277.704445455,-8140237.7642581295,5635549.221409475",
+                "bbox-crs": "[EPSG:3857]",
+            },
+        )
+        headers = response.headers
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/4326>"
+        assert (
+            headers["Content-Bbox"]
+            == "-73.828125,44.590467181308846,-73.125,45.08903556483102"
+        )
+        assert headers["content-type"] == "image/png"
+
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                # tile 9-151-184
+                "bbox": "-8218509.281222152,5557277.704445455,-8140237.7642581295,5635549.221409475",
+                "bbox-crs": "[EPSG:3857]",
+                "crs": "[EPSG:3857]",
+            },
+        )
+        assert response.status_code == 200
+        headers = response.headers
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/3857>"
+        assert (
+            headers["Content-Bbox"]
+            == "-8218509.281222152,5557277.704445455,-8140237.7642581295,5635549.221409475"
+        )
+        assert headers["content-type"] == "image/png"
+
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                # tile 4-4-5
+                "bbox": "-10018754.171394622,5009377.085697312,-7514065.628545966,7514065.628545966",
+                "bbox-crs": "[EPSG:3857]",
+                "crs": "[EPSG:3857]",
+            },
+        )
+        assert response.status_code == 200
+        headers = response.headers
+        assert headers["Content-Crs"] == "<http://www.opengis.net/def/crs/EPSG/0/3857>"
+        assert (
+            headers["Content-Bbox"]
+            == "-10018754.171394622,5009377.085697312,-7514065.628545966,7514065.628545966"
+        )
+        assert headers["content-type"] == "image/png"
+        meta = parse_img(response.content)
+        assert meta["width"] == 1024  # default max size
+        assert meta["height"] == 1024
+
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                "bbox": "-74,45,-73,46",
+            },
+            headers={"Accept": "image/jpeg"},
+        )
+        headers = response.headers
+        assert headers["content-type"] == "image/jpeg"
+
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                "bbox": "-74,45,-73,46",
+                "f": "tiff",
+            },
+        )
+        headers = response.headers
+        assert headers["content-type"] == "image/tiff; application=geotiff"
+
+        # Conformance Class “Scaling”
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                "bbox": "-74,45,-73,46",
+                "width": 256,
+            },
+        )
+        assert response.status_code == 200
+        headers = response.headers
+        assert headers["content-type"] == "image/png"
+        meta = parse_img(response.content)
+        assert meta["width"] == 256
+        assert meta["height"] == 256
+
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                "bbox": "-74,45,-73,46",
+                "width": -256,
+            },
+        )
+        assert response.status_code == 422
+
+        # /req/scaling/height-definition
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                "bbox": "-74,45,-73,46",
+                "height": 256,
+            },
+        )
+        assert response.status_code == 200
+        headers = response.headers
+        assert headers["content-type"] == "image/png"
+        meta = parse_img(response.content)
+        assert meta["width"] == 256
+        assert meta["height"] == 256
+
+        response = client.get(
+            "/map",
+            params={
+                "url": mosaic_file,
+                "height": -256,
+            },
+        )
+        assert response.status_code == 422
+
+
+def test_wmts_extension_mosaic():
+    """Test wmtsExtension extension."""
+    mosaic = MosaicTilerFactory(
+        backend=MosaicJSONBackend,
+        extensions=[
+            wmtsExtension(
+                get_renders=lambda obj: {
+                    "one_band_limit": {
+                        "tilematrixsets": {
+                            "WebMercatorQuad": [0, 1],
+                        },
+                        "spatial_extent": (-180, -90, 180, 90),
+                        "bidx": [1, 2, 3],
+                        "rescale": [[0, 10000], [0, 5000], [0, 1000]],
+                    },
+                    "one_band": {
+                        "bidx": [1],
+                        "rescale": ["0,10000"],
+                    },
+                },
+            )
+        ],
+    )
+    app = FastAPI()
+    app.include_router(mosaic.router)
+    add_exception_handlers(app, MOSAIC_STATUS_CODES)
+
+    with TestClient(app) as client:
+        with tmpmosaic() as mosaic_file:
+            response = client.get(f"/WMTSCapabilities.xml?url={mosaic_file}")
+            assert response.status_code == 200
+            assert response.headers["content-type"] == "application/xml"
+            meta = parse_img(response.content)
+            assert meta["driver"] == "WMTS"
+
+            wmts = WebMapTileService(
+                f"/WMTSCapabilities.xml?url={mosaic_file}", xml=response.content
+            )
+            assert wmts.version == "1.0.0"
+            assert len(wmts.contents) == 39  # (2 renders + default) x 13 TMS
+
+            layer = wmts.contents[f"{mosaic_file}_WebMercatorQuad_default"]
+            assert ["7", "8", "9"] == list(
+                layer.tilematrixsetlinks["WebMercatorQuad"].tilematrixlimits
+            )
+
+            layer = wmts.contents[f"{mosaic_file}_WebMercatorQuad_one_band_limit"]
+            assert ["0", "1"] == list(
+                layer.tilematrixsetlinks["WebMercatorQuad"].tilematrixlimits
+            )
+
+
+def test_mosaic_statistics_featurecollection():
+    """Test statistics endpoint with FeatureCollection containing multiple distinct features.
+
+    Regression test for bug where pixel_selection state from feature N
+    carried over to feature N+1, causing ValueError when features have
+    different pixel dimensions.
+    """
+    mosaic = MosaicTilerFactory(
+        backend=MosaicJSONBackend,
+        add_statistics=True,
+        router_prefix="mosaic",
+    )
+    app = FastAPI()
+    app.include_router(mosaic.router, prefix="/mosaic")
+    client = TestClient(app)
+
+    # Two distinct polygons within the mosaic bounds but different sizes
+    # mosaic bounds: [-75.98, 44.93, -71.33, 47.09]
+    feature_a = {
+        "type": "Feature",
+        "properties": {},
+        "geometry": {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    [-74.5, 45.5],
+                    [-74.5, 46.0],
+                    [-74.0, 46.0],
+                    [-74.0, 45.5],
+                    [-74.5, 45.5],
+                ]
+            ],
+        },
+    }
+
+    feature_b = {
+        "type": "Feature",
+        "properties": {},
+        "geometry": {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    [-73.5, 45.0],
+                    [-73.5, 45.3],
+                    [-73.0, 45.3],
+                    [-73.0, 45.0],
+                    [-73.5, 45.0],
+                ]
+            ],
+        },
+    }
+
+    with tmpmosaic() as mosaic_file:
+        # Test 1: Single Feature works
+        response = client.post(
+            "/mosaic/statistics",
+            params={"url": mosaic_file},
+            json=feature_a,
+        )
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "application/geo+json"
+        resp = response.json()
+        assert resp["type"] == "Feature"
+        assert "statistics" in resp["properties"]
+
+        # Test 2: FeatureCollection with 1 feature works
+        fc_single = {"type": "FeatureCollection", "features": [feature_a]}
+        response = client.post(
+            "/mosaic/statistics",
+            params={"url": mosaic_file},
+            json=fc_single,
+        )
+        assert response.status_code == 200
+        resp = response.json()
+        assert resp["type"] == "FeatureCollection"
+        assert len(resp["features"]) == 1
+        assert "statistics" in resp["features"][0]["properties"]
+
+        # Test 3: FeatureCollection with 2 DISTINCT features
+        # This was the bug - pixel_selection state from feature_a
+        # caused ValueError when processing feature_b
+        fc_multi = {"type": "FeatureCollection", "features": [feature_a, feature_b]}
+        response = client.post(
+            "/mosaic/statistics",
+            params={"url": mosaic_file},
+            json=fc_multi,
+        )
+        assert response.status_code == 200
+        resp = response.json()
+        assert resp["type"] == "FeatureCollection"
+        assert len(resp["features"]) == 2
+        assert "statistics" in resp["features"][0]["properties"]
+        assert "statistics" in resp["features"][1]["properties"]
+        # Each feature should have its own statistics
+        stats_a = resp["features"][0]["properties"]["statistics"]
+        stats_b = resp["features"][1]["properties"]["statistics"]
+        assert len(stats_a) > 0
+        assert len(stats_b) > 0
diff --git a/src/titiler/mosaic/titiler/mosaic/__init__.py b/src/titiler/mosaic/titiler/mosaic/__init__.py
index 29d6d4db2..d31c8159e 100644
--- a/src/titiler/mosaic/titiler/mosaic/__init__.py
+++ b/src/titiler/mosaic/titiler/mosaic/__init__.py
@@ -1,6 +1,6 @@
 """titiler.mosaic"""
 
-__version__ = "0.11.7"
+__version__ = "2.0.1"  # x-release-please-version
 
 from . import errors, factory  # noqa
 from .factory import MosaicTilerFactory  # noqa
diff --git a/src/titiler/mosaic/titiler/mosaic/errors.py b/src/titiler/mosaic/titiler/mosaic/errors.py
index 12cbc28e0..15e3ae881 100644
--- a/src/titiler/mosaic/titiler/mosaic/errors.py
+++ b/src/titiler/mosaic/titiler/mosaic/errors.py
@@ -1,18 +1,10 @@
 """Titiler mosaic errors."""
 
-from cogeo_mosaic.errors import (
-    MosaicAuthError,
-    MosaicError,
-    MosaicNotFoundError,
-    NoAssetFoundError,
-)
-from rio_tiler.errors import EmptyMosaicError
+from rio_tiler.errors import EmptyMosaicError, NoAssetFoundError
 from starlette import status
 
 MOSAIC_STATUS_CODES = {
-    MosaicAuthError: status.HTTP_401_UNAUTHORIZED,
-    EmptyMosaicError: status.HTTP_404_NOT_FOUND,
-    MosaicNotFoundError: status.HTTP_404_NOT_FOUND,
-    NoAssetFoundError: status.HTTP_404_NOT_FOUND,
-    MosaicError: status.HTTP_424_FAILED_DEPENDENCY,
+    EmptyMosaicError: status.HTTP_204_NO_CONTENT,
+    NoAssetFoundError: status.HTTP_204_NO_CONTENT,
+    NotImplementedError: status.HTTP_501_NOT_IMPLEMENTED,
 }
diff --git a/src/titiler/mosaic/titiler/mosaic/extensions/__init__.py b/src/titiler/mosaic/titiler/mosaic/extensions/__init__.py
new file mode 100644
index 000000000..a5d0a4d4c
--- /dev/null
+++ b/src/titiler/mosaic/titiler/mosaic/extensions/__init__.py
@@ -0,0 +1 @@
+"""titiler mosaic extensions module."""
diff --git a/src/titiler/mosaic/titiler/mosaic/extensions/mosaicjson.py b/src/titiler/mosaic/titiler/mosaic/extensions/mosaicjson.py
new file mode 100644
index 000000000..7c70af004
--- /dev/null
+++ b/src/titiler/mosaic/titiler/mosaic/extensions/mosaicjson.py
@@ -0,0 +1,63 @@
+"""titiler.mosaic extensions."""
+
+import logging
+
+import rasterio
+from attrs import define
+from fastapi import Depends
+
+from titiler.core.factory import FactoryExtension
+from titiler.mosaic.factory import MosaicTilerFactory
+
+logger = logging.getLogger(__name__)
+
+try:
+    from cogeo_mosaic.mosaic import MosaicJSON
+except ImportError:  # pragma: nocover
+    MosaicJSON = None  # type: ignore
+
+
+@define
+class MosaicJSONExtension(FactoryExtension):
+    """Add MosaicJSON specific endpoints"""
+
+    def register(self, factory: MosaicTilerFactory):  # type: ignore [override] # noqa: C901
+        """Register endpoint to the tiler factory."""
+
+        ############################################################################
+        # /read
+        ############################################################################
+
+        @factory.router.get(
+            "/",
+            response_model=MosaicJSON,
+            response_model_exclude_none=True,
+            responses={200: {"description": "Return MosaicJSON definition"}},
+            operation_id=f"{factory.operation_prefix}getMosaicJSON",
+        )
+        def read(
+            src_path=Depends(factory.path_dependency),
+            backend_params=Depends(factory.backend_dependency),
+            reader_params=Depends(factory.reader_dependency),
+            env=Depends(factory.environment_dependency),
+        ):
+            """Read a MosaicJSON"""
+            with rasterio.Env(**env):
+                logger.info(
+                    f"opening data with backend: {factory.backend} and reader {factory.dataset_reader}"
+                )
+                with factory.backend(
+                    src_path,
+                    reader=factory.dataset_reader,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
+                ) as src_dst:
+                    return src_dst.mosaic_def
+
+        @factory.router.post(
+            "/validate",
+            operation_id=f"{factory.operation_prefix}validate",
+        )
+        def validate(body: MosaicJSON):
+            """Validate a MosaicJSON"""
+            return True
diff --git a/src/titiler/mosaic/titiler/mosaic/extensions/templates/wmts.xml b/src/titiler/mosaic/titiler/mosaic/extensions/templates/wmts.xml
new file mode 100644
index 000000000..687b77aec
--- /dev/null
+++ b/src/titiler/mosaic/titiler/mosaic/extensions/templates/wmts.xml
@@ -0,0 +1,90 @@
+<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gml="http://www.opengis.net/gml" xsi:schemaLocation="http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd" version="1.0.0">
+    <ows:ServiceIdentification>
+        <ows:Title>Web Map Tile Service by TiTiler</ows:Title>
+        <ows:ServiceType>OGC WMTS</ows:ServiceType>
+        <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
+    </ows:ServiceIdentification>
+    <ows:ServiceProvider>
+        <ows:ProviderName>TiTiler</ows:ProviderName>
+        <ows:ProviderSite xlink:href="https://developmentseed.org/titiler/"/>
+        <ows:ServiceContact/>
+    </ows:ServiceProvider>
+    <ows:OperationsMetadata>
+        <ows:Operation name="GetCapabilities">
+            <ows:DCP>
+                <ows:HTTP>
+                    <ows:Get xlink:href="{{ request.url | escape }}">
+                        <ows:Constraint name="GetEncoding">
+                            <ows:AllowedValues>
+                                <ows:Value>RESTful</ows:Value>
+                            </ows:AllowedValues>
+                        </ows:Constraint>
+                    </ows:Get>
+                </ows:HTTP>
+            </ows:DCP>
+        </ows:Operation>
+        <ows:Operation name="GetTile">
+            <ows:DCP>
+                <ows:HTTP>
+                    <ows:Get xlink:href="{{ request.url | escape }}">
+                        <ows:Constraint name="GetEncoding">
+                            <ows:AllowedValues>
+                                <ows:Value>RESTful</ows:Value>
+                            </ows:AllowedValues>
+                        </ows:Constraint>
+                    </ows:Get>
+                </ows:HTTP>
+            </ows:DCP>
+        </ows:Operation>
+    </ows:OperationsMetadata>
+    <Contents>
+    {% for layer in layers -%}
+        <Layer>
+            <ows:Title>{{ layer.title }}</ows:Title>
+            <ows:Identifier>{{ layer.identifier }}</ows:Identifier>
+            <ows:{{ layer.bbox_crs_type }} crs="{{ layer.bbox_crs_uri }}">
+                <ows:LowerCorner>{{ layer.bbox[0] }} {{ layer.bbox[1] }}</ows:LowerCorner>
+                <ows:UpperCorner>{{ layer.bbox[2] }} {{ layer.bbox[3] }}</ows:UpperCorner>
+            </ows:{{ layer.bbox_crs_type }}>
+            <Style isDefault="true">
+                <ows:Title>{{ layer.title }}</ows:Title>
+                <ows:Identifier>{{ layer.identifier }}</ows:Identifier>
+            </Style>
+            <Format>{{ media_type }}</Format>
+            <TileMatrixSetLink>
+                <TileMatrixSet>{{ layer.tms_identifier }}</TileMatrixSet>
+                <TileMatrixSetLimits>
+                {% for limit  in layer.tms_limits %}
+                    <TileMatrixLimits>
+                    <TileMatrix>{{ limit.tileMatrix }}</TileMatrix>
+                    <MinTileRow>{{ limit.minTileRow }}</MinTileRow>
+                    <MaxTileRow>{{ limit.maxTileRow }}</MaxTileRow>
+                    <MinTileCol>{{ limit.minTileCol }}</MinTileCol>
+                    <MaxTileCol>{{ limit.maxTileCol }}</MaxTileCol>
+                    </TileMatrixLimits>
+                {% endfor %}
+                </TileMatrixSetLimits>
+            </TileMatrixSetLink>
+            <ResourceURL format="{{ media_type }}" resourceType="tile" template="{{ layer.tiles_url }}?{{ layer.query_string | escape }}" />
+        </Layer>
+    {%- endfor %}
+    {% for tms in tileMatrixSets -%}
+        <TileMatrixSet>
+            <ows:Identifier>{{ tms.id }}</ows:Identifier>
+            <ows:SupportedCRS>{{ tms.crs }}</ows:SupportedCRS>
+            {% for matrix in tms.matrices %}
+            <TileMatrix>
+                <ows:Identifier>{{ matrix.id }}</ows:Identifier>
+                <ScaleDenominator>{{ matrix.scaleDenominator }}</ScaleDenominator>
+                <TopLeftCorner>{{ matrix.pointOfOrigin[0] }} {{ matrix.pointOfOrigin[1] }}</TopLeftCorner>
+                <TileWidth>{{ matrix.tileWidth }}</TileWidth>
+                <TileHeight>{{ matrix.tileHeight }}</TileHeight>
+                <MatrixWidth>{{ matrix.matrixWidth }}</MatrixWidth>
+                <MatrixHeight>{{ matrix.matrixHeight }}</MatrixHeight>
+            </TileMatrix>
+            {% endfor %}
+        </TileMatrixSet>
+    {%- endfor %}
+    </Contents>
+    <ServiceMetadataURL xlink:href="{{ request.url | escape }}" />
+</Capabilities>
diff --git a/src/titiler/mosaic/titiler/mosaic/extensions/wmts.py b/src/titiler/mosaic/titiler/mosaic/extensions/wmts.py
new file mode 100644
index 000000000..9e35307c3
--- /dev/null
+++ b/src/titiler/mosaic/titiler/mosaic/extensions/wmts.py
@@ -0,0 +1,280 @@
+"""titiler.mosaic wmts extensions."""
+
+import warnings
+from collections.abc import Callable
+from typing import Annotated, Any
+from urllib.parse import urlencode
+
+import jinja2
+import rasterio
+from attrs import define, field
+from fastapi import Depends, HTTPException, Query
+from morecantile.models import crs_axis_inverted
+from rasterio.crs import CRS
+from rio_tiler.constants import WGS84_CRS
+from rio_tiler.mosaic.backend import BaseBackend
+from rio_tiler.utils import CRS_to_urn
+from starlette.datastructures import QueryParams
+from starlette.requests import Request
+from starlette.templating import Jinja2Templates
+
+from titiler.core.factory import FactoryExtension
+from titiler.core.resources.enums import ImageType
+from titiler.core.resources.responses import XMLResponse
+from titiler.core.utils import (
+    check_query_params,
+    dependencies_to_openapi_params,
+    rio_crs_to_pyproj,
+    tms_limits,
+)
+from titiler.mosaic.factory import MosaicTilerFactory
+
+jinja2_env = jinja2.Environment(
+    autoescape=jinja2.select_autoescape(["xml"]),
+    loader=jinja2.ChoiceLoader([jinja2.PackageLoader(__package__, "templates")]),
+)
+DEFAULT_TEMPLATES = Jinja2Templates(env=jinja2_env)
+
+
+@define
+class wmtsExtension(FactoryExtension):
+    """RESTful WMTS service Extension for MosaicTilerFactory."""
+
+    # Geographic Coordinate Reference System.
+    crs: CRS = field(default=WGS84_CRS)
+
+    templates: Jinja2Templates = field(default=DEFAULT_TEMPLATES)
+
+    get_renders: Callable[[BaseBackend], dict[str, dict[str, Any]]] = field(
+        default=lambda obj: {}
+    )
+
+    # List of dependencies a `/tile` URL should validate
+    # Note: Those dependencies should only require Query() inputs
+    tile_dependencies: list[Callable] | None = field(default=None)
+
+    def register(self, factory: MosaicTilerFactory):  # type: ignore [override] # noqa: C901
+        """Register endpoint to the tiler factory."""
+
+        tile_dependencies = (
+            self.tile_dependencies
+            if self.tile_dependencies is not None
+            else [
+                factory.layer_dependency,
+                factory.dataset_dependency,
+                factory.pixel_selection_dependency,
+                factory.process_dependency,
+                factory.colormap_dependency,
+                factory.render_dependency,
+                factory.tile_dependency,
+                factory.assets_accessor_dependency,
+                factory.reader_dependency,
+                factory.backend_dependency,
+            ]
+        )
+
+        @factory.router.get(
+            "/WMTSCapabilities.xml",
+            response_class=XMLResponse,
+            responses={
+                200: {
+                    "content": {"application/xml": {}},
+                    "description": "Return RESTful WMTS service capabilities document.",
+                }
+            },
+            operation_id=f"{factory.operation_prefix}getWMTS",
+            openapi_extra={
+                "parameters": dependencies_to_openapi_params(tile_dependencies),
+            },
+        )
+        def wmts(  # noqa: C901
+            request: Request,
+            tile_format: Annotated[
+                ImageType,
+                Query(description="Output image type. Default is png."),
+            ] = ImageType.png,
+            use_epsg: Annotated[
+                bool,
+                Query(
+                    description="Use EPSG code, not opengis.net, for the ows:SupportedCRS in the TileMatrixSet (set to True to enable ArcMap compatability)"
+                ),
+            ] = False,
+            src_path=Depends(factory.path_dependency),
+            backend_params=Depends(factory.backend_dependency),
+            reader_params=Depends(factory.reader_dependency),
+            env=Depends(factory.environment_dependency),
+        ):
+            """OGC RESTful WMTS endpoint."""
+            with rasterio.Env(**env):
+                with factory.backend(
+                    src_path,
+                    reader=factory.dataset_reader,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
+                ) as src_dst:
+                    dataset_bounds = src_dst.get_geographic_bounds(self.crs)
+                    default_renders = self.get_renders(src_dst)
+
+                renders: list[dict[str, Any]] = []
+
+                ##########################################
+                # 1. Create layers from `renders` metadata
+                for name, values in default_renders.items():
+                    values.pop("tilesize", None)  # Ensure tilesize is not overridden
+                    if check_query_params(tile_dependencies, values):
+                        renders.append(
+                            {
+                                "name": name,
+                                "query_string": urlencode(values, doseq=True)
+                                if values
+                                else None,
+                                "tilematrixsets": values.get("tilematrixsets", {}),
+                                "spatial_extent": values.get("spatial_extent", None),
+                            }
+                        )
+                    else:
+                        warnings.warn(
+                            f"Cannot construct URL for layer `{name}`",
+                            UserWarning,
+                            stacklevel=2,
+                        )
+
+                #######################################
+                # 2. Create layer from query-parameters
+                qs_key_to_remove = [
+                    "tile_format",
+                    "use_epsg",
+                    # Make sure tilesize is not ovewrriden from WMTS request
+                    "tilesize",
+                    # OGC WMTS parameters to ignore
+                    "service",
+                    "request",
+                    "acceptversions",
+                    "sections",
+                    "updatesequence",
+                    "acceptformats",
+                ]
+
+                qs = urlencode(
+                    [
+                        (key, value)
+                        for (key, value) in request.query_params._list
+                        if key.lower() not in qs_key_to_remove
+                    ],
+                    doseq=True,
+                )
+
+                if check_query_params(tile_dependencies, QueryParams(qs)):
+                    renders.append({"name": "default", "query_string": qs})
+
+                #################################################
+                # 3. if there is no layers we raise and exception
+                if not renders:
+                    raise HTTPException(
+                        status_code=400,
+                        detail="Could not find any valid layers in metadata or construct one from Query Parameters.",
+                    )
+
+                layers: list[dict[str, Any]] = []
+                title = src_path if isinstance(src_path, str) else "TiTiler Mosaic"
+                for render in renders:
+                    # NOTE: Default bounds and CRS for the dataset
+                    bounds = dataset_bounds
+                    geographic_crs = self.crs
+
+                    # NOTE: Custom TiTiler Render key in form of {"spatial_extent": (minx, miny, maxx, maxy)}
+                    # NOTE: We assume the spatial_extent is always in WGS84
+                    if render.get("spatial_extent"):
+                        bounds = render["spatial_extent"]
+                        geographic_crs = WGS84_CRS
+
+                    bbox_crs_type = "WGS84BoundingBox"
+                    bbox_crs_uri = "urn:ogc:def:crs:OGC:2:84"
+                    wmts_bbox = bounds
+                    if geographic_crs != WGS84_CRS:
+                        bbox_crs_type = "BoundingBox"
+                        bbox_crs_uri = CRS_to_urn(geographic_crs)  # type: ignore
+                        # WGS88BoundingBox is always xy ordered, but BoundingBox must match the CRS order
+                        proj_crs = rio_crs_to_pyproj(geographic_crs)
+                        if crs_axis_inverted(proj_crs):
+                            # match the bounding box coordinate order to the CRS
+                            wmts_bbox = [
+                                wmts_bbox[1],
+                                wmts_bbox[0],
+                                wmts_bbox[3],
+                                wmts_bbox[2],
+                            ]
+
+                    for tms_id in factory.supported_tms.list():
+                        tms = factory.supported_tms.get(tms_id)
+
+                        # NOTE: Custom TiTiler Render key in form of {"tilematrixsets": {"{tms_id}": (minzoom, maxzoom)}}
+                        zooms: tuple[int, int] = render.get("tilematrixsets", {}).get(
+                            tms_id
+                        )
+                        # NOTE: If zooms are not in renders then we get them from the backend
+                        if not zooms:
+                            try:
+                                with factory.backend(
+                                    src_path,
+                                    tms=tms,
+                                    reader=factory.dataset_reader,
+                                    reader_options=reader_params.as_dict(),
+                                    **backend_params.as_dict(),
+                                ) as src_dst:
+                                    zooms = (src_dst.minzoom, src_dst.maxzoom)
+                            except Exception as e:  # noqa
+                                zooms = (tms.minzoom, tms.maxzoom)
+
+                        tilematrixset_limits = tms_limits(
+                            tms,
+                            bounds,
+                            zooms=zooms,
+                            geographic_crs=geographic_crs,
+                        )
+
+                        route_params = {
+                            "z": "{TileMatrix}",
+                            "x": "{TileCol}",
+                            "y": "{TileRow}",
+                            "format": tile_format.value,
+                            "tileMatrixSetId": tms_id,
+                        }
+                        tile_url = factory.url_for(request, "tile", **route_params)
+
+                        layers.append(
+                            {
+                                "title": f"{title}_{tms_id}_{render['name']}",
+                                "identifier": f"{title}_{tms_id}_{render['name']}",
+                                "tms_identifier": tms_id,
+                                "tms_limits": tilematrixset_limits,
+                                "tiles_url": tile_url,
+                                "query_string": render["query_string"],
+                                "bbox_crs_type": bbox_crs_type,
+                                "bbox_crs_uri": bbox_crs_uri,
+                                "bbox": wmts_bbox,
+                            }
+                        )
+
+            tileMatrixSets: list[dict[str, Any]] = []
+            for tms_id in factory.supported_tms.list():
+                tms = factory.supported_tms.get(tms_id)
+                if use_epsg:
+                    supported_crs = f"EPSG:{tms.crs.to_epsg()}"
+                else:
+                    supported_crs = tms.crs.srs
+
+                tileMatrixSets.append(
+                    {"id": tms_id, "crs": supported_crs, "matrices": tms.tileMatrices}
+                )
+
+            return self.templates.TemplateResponse(
+                request,
+                name="wmts.xml",
+                context={
+                    "layers": layers,
+                    "tileMatrixSets": tileMatrixSets,
+                    "media_type": tile_format.mediatype,
+                },
+                media_type="application/xml",
+            )
diff --git a/src/titiler/mosaic/titiler/mosaic/factory.py b/src/titiler/mosaic/titiler/mosaic/factory.py
index 2a618266c..6072fdb57 100644
--- a/src/titiler/mosaic/titiler/mosaic/factory.py
+++ b/src/titiler/mosaic/titiler/mosaic/factory.py
@@ -1,290 +1,629 @@
 """TiTiler.mosaic Router factories."""
 
+import logging
 import os
-from dataclasses import dataclass
-from typing import Callable, Dict, Literal, Optional, Type, Union
+from collections.abc import Callable
+from typing import Annotated, Any, Literal
 from urllib.parse import urlencode
 
 import rasterio
-from cogeo_mosaic.backends import BaseBackend, MosaicBackend
-from cogeo_mosaic.models import Info as mosaicInfo
-from cogeo_mosaic.mosaic import MosaicJSON
-from fastapi import Depends, HTTPException, Path, Query
-from geojson_pydantic.features import Feature
+from attrs import define, field
+from fastapi import Body, Depends, HTTPException, Path, Query
+from geojson_pydantic.features import Feature, FeatureCollection
 from geojson_pydantic.geometries import Polygon
-from morecantile import tms
+from morecantile import tms as morecantile_tms
 from morecantile.defaults import TileMatrixSets
-from rio_tiler.constants import MAX_THREADS
-from rio_tiler.io import BaseReader, MultiBandReader, MultiBaseReader, Reader
-from rio_tiler.models import Bounds
+from pydantic import Field
+from rio_tiler.constants import MAX_THREADS, WGS84_CRS
+from rio_tiler.io import BaseReader, MultiBaseReader, Reader
+from rio_tiler.mosaic.backend import BaseBackend, MosaicInfo
+from rio_tiler.mosaic.methods import PixelSelectionMethod
 from rio_tiler.mosaic.methods.base import MosaicMethodBase
+from rio_tiler.types import ColorMapType
+from rio_tiler.utils import CRS_to_uri
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, Response
+from starlette.routing import NoMatchFound
 
-from titiler.core.dependencies import DefaultDependency
-from titiler.core.factory import BaseTilerFactory, img_endpoint_params
+from titiler.core.algorithm import BaseAlgorithm
+from titiler.core.algorithm import algorithms as available_algorithms
+from titiler.core.dependencies import (
+    BidxExprParams,
+    ColorMapParams,
+    CoordCRSParams,
+    CRSParams,
+    DatasetParams,
+    DefaultDependency,
+    DstCRSParams,
+    HistogramParams,
+    ImageRenderingParams,
+    OGCMapsParams,
+    PartFeatureParams,
+    StatisticsParams,
+    TileParams,
+)
+from titiler.core.factory import BaseFactory, img_endpoint_params
 from titiler.core.models.mapbox import TileJSON
+from titiler.core.models.OGC import TileSet, TileSetList
+from titiler.core.models.responses import StatisticsGeoJSON
 from titiler.core.resources.enums import ImageType, MediaType, OptionalHeader
-from titiler.core.resources.responses import GeoJSONResponse, JSONResponse, XMLResponse
+from titiler.core.resources.responses import GeoJSONResponse, JSONResponse
+from titiler.core.utils import (
+    accept_media_type,
+    bounds_to_geometry,
+    create_html_response,
+    render_image,
+    tms_limits,
+)
 from titiler.mosaic.models.responses import Point
-from titiler.mosaic.resources.enums import PixelSelectionMethod
 
-# BaseBackend does not support other TMS than WebMercator
-mosaic_tms = TileMatrixSets({"WebMercatorQuad": tms.get("WebMercatorQuad")})
+MOSAIC_THREADS = int(os.getenv("MOSAIC_CONCURRENCY", MAX_THREADS))
+MOSAIC_STRICT_ZOOM = str(os.getenv("MOSAIC_STRICT_ZOOM", False)).lower() in [
+    "true",
+    "yes",
+]
+
+logger = logging.getLogger(__name__)
 
 
 def PixelSelectionParams(
-    pixel_selection: PixelSelectionMethod = Query(
-        PixelSelectionMethod.first,
-        description="Pixel selection method.",
-    )
+    pixel_selection: Annotated[  # type: ignore
+        Literal[tuple([e.name for e in PixelSelectionMethod])],
+        Query(description="Pixel selection method."),
+    ] = "first",
 ) -> MosaicMethodBase:
     """
     Returns the mosaic method used to combine datasets together.
     """
-    return pixel_selection.method()
+    return PixelSelectionMethod[pixel_selection].value
 
 
-@dataclass
-class MosaicTilerFactory(BaseTilerFactory):
-    """
-    MosaicTiler Factory.
+def DatasetPathParams(url: Annotated[str, Query(description="Mosaic URL")]) -> str:
+    """Create dataset path from args"""
+    return url
 
-    The main difference with titiler.endpoint.factory.TilerFactory is that this factory
-    needs the `reader` to be of `cogeo_mosaic.backends.BaseBackend` type (e.g MosaicBackend) and a `dataset_reader` (BaseReader).
-    """
 
-    reader: Type[BaseBackend] = MosaicBackend
-    dataset_reader: Union[
-        Type[BaseReader],
-        Type[MultiBaseReader],
-        Type[MultiBandReader],
-    ] = Reader
+@define(kw_only=True)
+class MosaicTilerFactory(BaseFactory):
+    """MosaicTiler Factory."""
+
+    backend: type[BaseBackend]
+    backend_dependency: type[DefaultDependency] = DefaultDependency
+
+    dataset_reader: type[BaseReader] | type[MultiBaseReader] = Reader
+    reader_dependency: type[DefaultDependency] = DefaultDependency
 
-    backend_dependency: Type[DefaultDependency] = DefaultDependency
+    # Path Dependency
+    path_dependency: Callable[..., Any] = DatasetPathParams
+
+    # Backend.get_assets() Options
+    assets_accessor_dependency: type[DefaultDependency] = DefaultDependency
+
+    # Indexes/Expression Dependencies
+    layer_dependency: type[DefaultDependency] = BidxExprParams
+
+    # Rasterio Dataset Options (nodata, unscale, resampling, reproject)
+    dataset_dependency: type[DefaultDependency] = DatasetParams
+
+    # Tile/Tilejson Dependencies
+    tile_dependency: type[DefaultDependency] = TileParams
+
+    # Post Processing Dependencies (algorithm)
+    process_dependency: Callable[..., BaseAlgorithm | None] = (
+        available_algorithms.dependency
+    )
+
+    # Statistics/Histogram Dependencies
+    stats_dependency: type[DefaultDependency] = StatisticsParams
+    histogram_dependency: type[DefaultDependency] = HistogramParams
+
+    # Crop endpoints Dependencies
+    img_part_dependency: type[DefaultDependency] = PartFeatureParams
+
+    # Image rendering Dependencies
+    colormap_dependency: Callable[..., ColorMapType | None] = ColorMapParams
+    render_dependency: type[DefaultDependency] = ImageRenderingParams
 
     pixel_selection_dependency: Callable[..., MosaicMethodBase] = PixelSelectionParams
 
-    supported_tms: TileMatrixSets = mosaic_tms
-    default_tms: str = "WebMercatorQuad"
+    # GDAL ENV dependency
+    environment_dependency: Callable[..., dict] = field(default=lambda: {})
+
+    supported_tms: TileMatrixSets = morecantile_tms
+
+    render_func: Callable[..., tuple[bytes, str]] = render_image
+
+    optional_headers: list[OptionalHeader] = field(factory=list)
 
     # Add/Remove some endpoints
     add_viewer: bool = True
+    add_statistics: bool = False
+    add_part: bool = False
+    add_ogc_maps: bool = False
 
-    def register_routes(self):
-        """
-        This Method register routes to the router.
-
-        Because we wrap the endpoints in a class we cannot define the routes as
-        methods (because of the self argument). The HACK is to define routes inside
-        the class method and register them after the class initialization.
+    conforms_to: set[str] = field(
+        factory=lambda: {
+            # https://docs.ogc.org/is/20-057/20-057.html#toc30
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/tileset",
+            # https://docs.ogc.org/is/20-057/20-057.html#toc34
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/tilesets-list",
+            # https://docs.ogc.org/is/20-057/20-057.html#toc65
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/core",
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/png",
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/jpeg",
+            "http://www.opengis.net/spec/ogcapi-tiles-1/1.0/conf/tiff",
+        }
+    )
 
-        """
+    def register_routes(self):
+        """This Method register routes to the router."""
 
-        self.read()
-        self.bounds()
         self.info()
+        self.tilesets()
         self.tile()
+        if self.add_viewer:
+            self.map_viewer()
         self.tilejson()
-        self.wmts()
         self.point()
-        self.validate()
         self.assets()
 
-        # Optional Routes
-        if self.add_viewer:
-            self.map_viewer()
+        if self.add_part:
+            self.part()
+
+        if self.add_statistics:
+            self.statistics()
+
+        if self.add_ogc_maps:
+            self.ogc_maps()
 
     ############################################################################
-    # /read
+    # /info
     ############################################################################
-    def read(self):
-        """Register / (Get) Read endpoint."""
+    def info(self):
+        """Register /info endpoint"""
 
         @self.router.get(
-            "/",
-            response_model=MosaicJSON,
-            response_model_exclude_none=True,
-            responses={200: {"description": "Return MosaicJSON definition"}},
+            "/info",
+            responses={
+                200: {
+                    "description": "Return info about the MosaicJSON",
+                    "model": MosaicInfo,
+                }
+            },
+            operation_id=f"{self.operation_prefix}getInfo",
         )
-        def read(
+        def info(
             src_path=Depends(self.path_dependency),
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
-            """Read a MosaicJSON"""
+            """Return basic info."""
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    return src_dst.mosaic_def
-
-    ############################################################################
-    # /bounds
-    ############################################################################
-    def bounds(self):
-        """Register /bounds endpoint."""
+                    return src_dst.info()
 
         @self.router.get(
-            "/bounds",
-            response_model=Bounds,
-            responses={200: {"description": "Return the bounds of the MosaicJSON"}},
+            "/info.geojson",
+            response_model=Feature,
+            response_model_exclude_none=True,
+            response_class=GeoJSONResponse,
+            responses={
+                200: {
+                    "content": {"application/geo+json": {}},
+                    "description": "Return mosaic's basic info as a GeoJSON feature.",
+                    "model": Feature[Polygon, MosaicInfo],
+                }
+            },
+            operation_id=f"{self.operation_prefix}getInfoGeoJSON",
         )
-        def bounds(
+        def info_geojson(
             src_path=Depends(self.path_dependency),
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
+            crs=Depends(CRSParams),
             env=Depends(self.environment_dependency),
         ):
-            """Return the bounds of the MosaicJSON."""
+            """Return mosaic's basic info as a GeoJSON feature."""
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    return {"bounds": src_dst.geographic_bounds}
+                    bounds = src_dst.get_geographic_bounds(crs or WGS84_CRS)
+                    geometry = bounds_to_geometry(bounds)
+
+                    return Feature(
+                        type="Feature",
+                        bbox=bounds,
+                        geometry=geometry,
+                        properties=src_dst.info(),
+                    )
 
     ############################################################################
-    # /info
+    # /tileset
     ############################################################################
-    def info(self):
-        """Register /info endpoint"""
+    def tilesets(self):  # noqa: C901
+        """Register OGC tilesets endpoints."""
 
         @self.router.get(
-            "/info",
-            response_model=mosaicInfo,
-            responses={200: {"description": "Return info about the MosaicJSON"}},
+            "/tiles",
+            response_model=TileSetList,
+            response_class=JSONResponse,
+            response_model_exclude_none=True,
+            responses={
+                200: {
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    }
+                }
+            },
+            summary="Retrieve a list of available raster tilesets for the specified dataset.",
+            operation_id=f"{self.operation_prefix}getTileSetList",
         )
-        def info(
+        async def tileset_list(
+            request: Request,
             src_path=Depends(self.path_dependency),
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
+            crs=Depends(CRSParams),
             env=Depends(self.environment_dependency),
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
         ):
-            """Return basic info."""
+            """Retrieve a list of available raster tilesets for the specified dataset."""
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    return src_dst.info()
+                    bounds = src_dst.get_geographic_bounds(crs or WGS84_CRS)
+
+            collection_bbox = {
+                "lowerLeft": [bounds[0], bounds[1]],
+                "upperRight": [bounds[2], bounds[3]],
+                "crs": CRS_to_uri(crs or WGS84_CRS),
+            }
+
+            qs = [
+                (key, value)
+                for (key, value) in request.query_params._list
+                if key.lower() not in ["crs"]
+            ]
+            query_string = f"?{urlencode(qs)}" if qs else ""
+
+            tilesets: list[dict[str, Any]] = []
+            for tms in self.supported_tms.list():
+                tileset: dict[str, Any] = {
+                    "title": f"tileset tiled using {tms} TileMatrixSet",
+                    "dataType": "map",
+                    "crs": self.supported_tms.get(tms).crs,
+                    "boundingBox": collection_bbox,
+                    "links": [
+                        {
+                            "href": self.url_for(
+                                request, "tileset", tileMatrixSetId=tms
+                            )
+                            + query_string,
+                            "rel": "self",
+                            "type": "application/json",
+                            "title": f"Tileset tiled using {tms} TileMatrixSet",
+                        },
+                        {
+                            "href": self.url_for(
+                                request,
+                                "tile",
+                                tileMatrixSetId=tms,
+                                z="{z}",
+                                x="{x}",
+                                y="{y}",
+                            )
+                            + query_string,
+                            "rel": "tile",
+                            "title": "Templated link for retrieving Raster tiles",
+                        },
+                    ],
+                }
+
+                try:
+                    tileset["links"].append(
+                        {
+                            "href": str(
+                                request.url_for("tilematrixset", tileMatrixSetId=tms)
+                            ),
+                            "rel": "http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme",
+                            "type": "application/json",
+                            "title": f"Definition of '{tms}' tileMatrixSet",
+                        }
+                    )
+                except NoMatchFound:
+                    pass
+
+                tilesets.append(tileset)
+
+            data = TileSetList.model_validate({"tilesets": tilesets})
+
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
+
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    data.model_dump(exclude_none=True, mode="json"),
+                    title="Tilesets",
+                    template_name="tilesets",
+                    templates=self.templates,
+                )
+
+            return data
 
         @self.router.get(
-            "/info.geojson",
-            response_model=Feature[Polygon, mosaicInfo],
+            "/tiles/{tileMatrixSetId}",
+            response_model=TileSet,
+            response_class=JSONResponse,
             response_model_exclude_none=True,
-            response_class=GeoJSONResponse,
             responses={
                 200: {
-                    "content": {"application/geo+json": {}},
-                    "description": "Return mosaic's basic info as a GeoJSON feature.",
+                    "content": {
+                        "application/json": {},
+                        "text/html": {},
+                    }
                 }
             },
+            summary="Retrieve the raster tileset metadata for the specified dataset and tiling scheme (tile matrix set).",
+            operation_id=f"{self.operation_prefix}getTileSet",
         )
-        def info_geojson(
+        async def tileset(
+            request: Request,
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
             src_path=Depends(self.path_dependency),
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
+            f: Annotated[
+                Literal["html", "json"] | None,
+                Query(
+                    description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+                ),
+            ] = None,
         ):
-            """Return mosaic's basic info as a GeoJSON feature."""
+            """Retrieve the raster tileset metadata for the specified dataset and tiling scheme (tile matrix set)."""
+            tms = self.supported_tms.get(tileMatrixSetId)
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
+                    tms=tms,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    info = src_dst.info()
-                    return Feature(
-                        type="Feature",
-                        geometry=Polygon.from_bounds(*info.bounds),
-                        properties=info,
+                    bounds = src_dst.get_geographic_bounds(tms.rasterio_geographic_crs)
+                    minzoom = src_dst.minzoom
+                    maxzoom = src_dst.maxzoom
+
+                    collection_bbox = {
+                        "lowerLeft": [bounds[0], bounds[1]],
+                        "upperRight": [bounds[2], bounds[3]],
+                        "crs": CRS_to_uri(tms.rasterio_geographic_crs),
+                    }
+
+                    tilematrix_limits = tms_limits(
+                        tms,
+                        bounds,
+                        zooms=(minzoom, maxzoom),
                     )
 
+            query_string = (
+                f"?{urlencode(request.query_params._list)}"
+                if request.query_params._list
+                else ""
+            )
+
+            links = [
+                {
+                    "href": self.url_for(
+                        request,
+                        "tileset",
+                        tileMatrixSetId=tileMatrixSetId,
+                    ),
+                    "rel": "self",
+                    "type": "application/json",
+                    "title": f"Tileset tiled using {tileMatrixSetId} TileMatrixSet",
+                },
+                {
+                    "href": self.url_for(
+                        request,
+                        "tile",
+                        tileMatrixSetId=tileMatrixSetId,
+                        z="{z}",
+                        x="{x}",
+                        y="{y}",
+                    )
+                    + query_string,
+                    "rel": "tile",
+                    "title": "Templated link for retrieving Raster tiles",
+                    "templated": True,
+                },
+            ]
+            try:
+                links.append(
+                    {
+                        "href": str(
+                            request.url_for(
+                                "tilematrixset", tileMatrixSetId=tileMatrixSetId
+                            )
+                        ),
+                        "rel": "http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme",
+                        "type": "application/json",
+                        "title": f"Definition of '{tileMatrixSetId}' tileMatrixSet",
+                    }
+                )
+            except NoMatchFound:
+                pass
+
+            if self.add_viewer:
+                links.append(
+                    {
+                        "href": self.url_for(
+                            request,
+                            "map_viewer",
+                            tileMatrixSetId=tileMatrixSetId,
+                        )
+                        + query_string,
+                        "type": "text/html",
+                        "rel": "data",
+                        "title": f"Map viewer for '{tileMatrixSetId}' tileMatrixSet",
+                    }
+                )
+
+            data = TileSet.model_validate(
+                {
+                    "title": f"tileset tiled using {tileMatrixSetId} TileMatrixSet",
+                    "dataType": "map",
+                    "crs": tms.crs,
+                    "boundingBox": collection_bbox,
+                    "links": links,
+                    "tileMatrixSetLimits": tilematrix_limits,
+                }
+            )
+
+            if f:
+                output_type = MediaType[f]
+            else:
+                accepted_media = [MediaType.html, MediaType.json]
+                output_type = (
+                    accept_media_type(request.headers.get("accept", ""), accepted_media)
+                    or MediaType.json
+                )
+
+            if output_type == MediaType.html:
+                return create_html_response(
+                    request,
+                    data,
+                    title=tileMatrixSetId,
+                    template_name="tileset",
+                    templates=self.templates,
+                )
+
+            return data
+
     ############################################################################
     # /tiles
     ############################################################################
     def tile(self):  # noqa: C901
         """Register /tiles endpoints."""
 
-        @self.router.get(r"/tiles/{z}/{x}/{y}", **img_endpoint_params)
-        @self.router.get(r"/tiles/{z}/{x}/{y}.{format}", **img_endpoint_params)
-        @self.router.get(r"/tiles/{z}/{x}/{y}@{scale}x", **img_endpoint_params)
-        @self.router.get(r"/tiles/{z}/{x}/{y}@{scale}x.{format}", **img_endpoint_params)
-        @self.router.get(r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}", **img_endpoint_params)
-        @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}.{format}", **img_endpoint_params
-        )
         @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}@{scale}x", **img_endpoint_params
+            "/tiles/{tileMatrixSetId}/{z}/{x}/{y}",
+            operation_id=f"{self.operation_prefix}getTile",
+            **img_endpoint_params,
         )
         @self.router.get(
-            r"/tiles/{TileMatrixSetId}/{z}/{x}/{y}@{scale}x.{format}",
+            "/tiles/{tileMatrixSetId}/{z}/{x}/{y}.{format}",
+            operation_id=f"{self.operation_prefix}getTileWithFormat",
             **img_endpoint_params,
         )
         def tile(
-            z: int = Path(..., ge=0, le=30, description="Mercator tiles's zoom level"),
-            x: int = Path(..., description="Mercator tiles's column"),
-            y: int = Path(..., description="Mercator tiles's row"),
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
-                self.default_tms,
-                description=f"TileMatrixSet Name (default: '{self.default_tms}')",
-            ),  # noqa
-            scale: int = Query(
-                1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."
-            ),
-            format: ImageType = Query(
-                None, description="Output image type. Default is auto."
-            ),
+            z: Annotated[
+                int,
+                Path(
+                    description="Identifier (Z) selecting one of the scales defined in the TileMatrixSet and representing the scaleDenominator the tile.",
+                ),
+            ],
+            x: Annotated[
+                int,
+                Path(
+                    description="Column (X) index of the tile on the selected TileMatrix. It cannot exceed the MatrixHeight-1 for the selected TileMatrix.",
+                ),
+            ],
+            y: Annotated[
+                int,
+                Path(
+                    description="Row (Y) index of the tile on the selected TileMatrix. It cannot exceed the MatrixWidth-1 for the selected TileMatrix.",
+                ),
+            ],
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
+            format: Annotated[
+                ImageType | None,
+                Field(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg).",
+                ),
+            ] = None,
+            tilesize: Annotated[
+                int | None,
+                Query(gt=0, description="Tilesize in pixels."),
+            ] = None,
             src_path=Depends(self.path_dependency),
+            backend_params=Depends(self.backend_dependency),
+            reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
             layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
             pixel_selection=Depends(self.pixel_selection_dependency),
-            buffer: Optional[float] = Query(
-                None,
-                gt=0,
-                title="Tile buffer.",
-                description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * tile_buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
-            ),
+            tile_params=Depends(self.tile_dependency),
             post_process=Depends(self.process_dependency),
-            rescale=Depends(self.rescale_dependency),
-            color_formula: Optional[str] = Query(
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
             colormap=Depends(self.colormap_dependency),
             render_params=Depends(self.render_dependency),
-            backend_params=Depends(self.backend_dependency),
-            reader_params=Depends(self.reader_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Create map tile from a COG."""
-            threads = int(os.getenv("MOSAIC_CONCURRENCY", MAX_THREADS))
-
-            strict_zoom = str(os.getenv("MOSAIC_STRICT_ZOOM", False)).lower() in [
-                "true",
-                "yes",
-            ]
-
+            tms = self.supported_tms.get(tileMatrixSetId)
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
+                    tms=tms,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-
-                    if strict_zoom and (z < src_dst.minzoom or z > src_dst.maxzoom):
+                    if MOSAIC_STRICT_ZOOM and (
+                        z < src_dst.minzoom or z > src_dst.maxzoom
+                    ):
                         raise HTTPException(
                             400,
                             f"Invalid ZOOM level {z}. Should be between {src_dst.minzoom} and {src_dst.maxzoom}",
@@ -294,95 +633,91 @@ def tile(
                         x,
                         y,
                         z,
+                        tilesize=tilesize,
+                        search_options=assets_accessor_params.as_dict(),
                         pixel_selection=pixel_selection,
-                        tilesize=scale * 256,
-                        threads=threads,
-                        buffer=buffer,
-                        **layer_params,
-                        **dataset_params,
+                        threads=MOSAIC_THREADS,
+                        **tile_params.as_dict(),
+                        **layer_params.as_dict(),
+                        **dataset_params.as_dict(),
                     )
 
             if post_process:
                 image = post_process(image)
 
-            if rescale:
-                image.rescale(rescale)
-
-            if color_formula:
-                image.apply_color_formula(color_formula)
-
-            if colormap:
-                image = image.apply_colormap(colormap)
-
-            if not format:
-                format = ImageType.jpeg if image.mask.all() else ImageType.png
-
-            content = image.render(
-                img_format=format.driver,
-                **format.profile,
-                **render_params,
+            content, media_type = self.render_func(
+                image,
+                output_format=format,
+                colormap=colormap,
+                **render_params.as_dict(),
             )
 
-            headers: Dict[str, str] = {}
+            headers: dict[str, str] = {}
             if OptionalHeader.x_assets in self.optional_headers:
                 headers["X-Assets"] = ",".join(assets)
 
-            return Response(content, media_type=format.mediatype, headers=headers)
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
+
+            if (
+                OptionalHeader.server_timing in self.optional_headers
+                and image.metadata.get("timings")
+            ):
+                headers["Server-Timing"] = ", ".join(
+                    [f"{name};dur={time}" for (name, time) in image.metadata["timings"]]
+                )
+
+            return Response(content, media_type=media_type, headers=headers)
 
     def tilejson(self):  # noqa: C901
         """Add tilejson endpoint."""
 
         @self.router.get(
-            "/tilejson.json",
-            response_model=TileJSON,
-            responses={200: {"description": "Return a tilejson"}},
-            response_model_exclude_none=True,
-        )
-        @self.router.get(
-            "/{TileMatrixSetId}/tilejson.json",
+            "/{tileMatrixSetId}/tilejson.json",
             response_model=TileJSON,
             responses={200: {"description": "Return a tilejson"}},
             response_model_exclude_none=True,
+            operation_id=f"{self.operation_prefix}getTileJSON",
         )
         def tilejson(
             request: Request,
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
-                self.default_tms,
-                description=f"TileMatrixSet Name (default: '{self.default_tms}')",
-            ),  # noqa
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
+            tilesize: Annotated[
+                int | None,
+                Query(gt=0, description="Tilesize in pixels. Default to 512."),
+            ] = None,
+            tile_format: Annotated[
+                ImageType | None,
+                Query(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg).",
+                ),
+            ] = None,
+            minzoom: Annotated[
+                int | None,
+                Query(description="Overwrite default minzoom."),
+            ] = None,
+            maxzoom: Annotated[
+                int | None,
+                Query(description="Overwrite default maxzoom."),
+            ] = None,
             src_path=Depends(self.path_dependency),
-            tile_format: Optional[ImageType] = Query(
-                None, description="Output image type. Default is auto."
-            ),
-            tile_scale: int = Query(
-                1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."
-            ),
-            minzoom: Optional[int] = Query(
-                None, description="Overwrite default minzoom."
-            ),
-            maxzoom: Optional[int] = Query(
-                None, description="Overwrite default maxzoom."
-            ),
-            layer_params=Depends(self.layer_dependency),  # noqa
-            dataset_params=Depends(self.dataset_dependency),  # noqa
-            pixel_selection=Depends(self.pixel_selection_dependency),  # noqa
-            buffer: Optional[float] = Query(  # noqa
-                None,
-                gt=0,
-                title="Tile buffer.",
-                description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * tile_buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
-            ),
-            post_process=Depends(self.process_dependency),  # noqa
-            rescale=Depends(self.rescale_dependency),  # noqa
-            color_formula: Optional[str] = Query(  # noqa
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
-            colormap=Depends(self.colormap_dependency),  # noqa
-            render_params=Depends(self.render_dependency),  # noqa
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            pixel_selection=Depends(self.pixel_selection_dependency),
+            tile_params=Depends(self.tile_dependency),
+            post_process=Depends(self.process_dependency),
+            colormap=Depends(self.colormap_dependency),
+            render_params=Depends(self.render_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Return TileJSON document for a COG."""
@@ -390,8 +725,7 @@ def tilejson(
                 "z": "{z}",
                 "x": "{x}",
                 "y": "{y}",
-                "scale": tile_scale,
-                "TileMatrixSetId": TileMatrixSetId,
+                "tileMatrixSetId": tileMatrixSetId,
             }
             if tile_format:
                 route_params["format"] = tile_format.value
@@ -400,342 +734,710 @@ def tilejson(
             qs_key_to_remove = [
                 "tilematrixsetid",
                 "tile_format",
-                "tile_scale",
                 "minzoom",
                 "maxzoom",
             ]
-            qs = [
+            qs: list[tuple[str, Any]] = [
                 (key, value)
                 for (key, value) in request.query_params._list
                 if key.lower() not in qs_key_to_remove
             ]
+            if "tilesize" not in request.query_params:
+                qs.append(("tilesize", 512))
+
             if qs:
                 tiles_url += f"?{urlencode(qs)}"
 
+            tms = self.supported_tms.get(tileMatrixSetId)
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
+                    tms=tms,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    center = list(src_dst.mosaic_def.center)
-                    if minzoom is not None:
-                        center[-1] = minzoom
+                    bounds = src_dst.get_geographic_bounds(tms.rasterio_geographic_crs)
+                    minzoom = minzoom if minzoom is not None else src_dst.minzoom
+                    maxzoom = maxzoom if maxzoom is not None else src_dst.maxzoom
+                    center = (
+                        (bounds[0] + bounds[2]) / 2,
+                        (bounds[1] + bounds[3]) / 2,
+                        minzoom,
+                    )
                     return {
-                        "bounds": src_dst.bounds,
-                        "center": tuple(center),
-                        "minzoom": minzoom if minzoom is not None else src_dst.minzoom,
-                        "maxzoom": maxzoom if maxzoom is not None else src_dst.maxzoom,
+                        "bounds": bounds,
+                        "center": center,
+                        "minzoom": minzoom,
+                        "maxzoom": maxzoom,
                         "tiles": [tiles_url],
+                        "attribution": os.environ.get("TITILER_DEFAULT_ATTRIBUTION"),
                     }
 
     def map_viewer(self):  # noqa: C901
-        """Register /map endpoint."""
+        """Register /map.html endpoint."""
 
-        @self.router.get("/map", response_class=HTMLResponse)
-        @self.router.get("/{TileMatrixSetId}/map", response_class=HTMLResponse)
+        @self.router.get(
+            "/{tileMatrixSetId}/map.html",
+            response_class=HTMLResponse,
+            operation_id=f"{self.operation_prefix}getMapViewer",
+        )
         def map_viewer(
             request: Request,
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
+            tile_format: Annotated[
+                ImageType | None,
+                Query(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg).",
+                ),
+            ] = None,
+            tilesize: Annotated[
+                int,
+                Query(gt=0, description="Tilesize in pixels. Default to 256."),
+            ] = 256,
+            minzoom: Annotated[
+                int | None,
+                Query(description="Overwrite default minzoom."),
+            ] = None,
+            maxzoom: Annotated[
+                int | None,
+                Query(description="Overwrite default maxzoom."),
+            ] = None,
             src_path=Depends(self.path_dependency),
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
-                self.default_tms,
-                description=f"TileMatrixSet Name (default: '{self.default_tms}')",
-            ),
-            tile_format: Optional[ImageType] = Query(
-                None, description="Output image type. Default is auto."
-            ),
-            tile_scale: int = Query(
-                1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."
-            ),
-            minzoom: Optional[int] = Query(
-                None, description="Overwrite default minzoom."
-            ),
-            maxzoom: Optional[int] = Query(
-                None, description="Overwrite default maxzoom."
-            ),
-            layer_params=Depends(self.layer_dependency),  # noqa
-            dataset_params=Depends(self.dataset_dependency),  # noqa
-            pixel_selection=Depends(self.pixel_selection_dependency),  # noqa
-            buffer: Optional[float] = Query(  # noqa
-                None,
-                gt=0,
-                title="Tile buffer.",
-                description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * tile_buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
-            ),
-            rescale=Depends(self.rescale_dependency),  # noqa
-            color_formula: Optional[str] = Query(  # noqa
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
-            colormap=Depends(self.colormap_dependency),  # noqa
-            render_params=Depends(self.render_dependency),  # noqa
-            backend_params=Depends(self.backend_dependency),  # noqa
-            reader_params=Depends(self.reader_dependency),  # noqa
-            env=Depends(self.environment_dependency),  # noqa
+            backend_params=Depends(self.backend_dependency),
+            reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            pixel_selection=Depends(self.pixel_selection_dependency),
+            tile_params=Depends(self.tile_dependency),
+            post_process=Depends(self.process_dependency),
+            colormap=Depends(self.colormap_dependency),
+            render_params=Depends(self.render_dependency),
+            env=Depends(self.environment_dependency),
         ):
             """Return TileJSON document for a dataset."""
             tilejson_url = self.url_for(
-                request, "tilejson", TileMatrixSetId=TileMatrixSetId
+                request,
+                "tilejson",
+                tileMatrixSetId=tileMatrixSetId,
             )
+            qs = list(request.query_params._list)
+            if "tilesize" not in request.query_params:
+                qs.append(("tilesize", tilesize))
+
+            tilejson_url += f"?{urlencode(qs)}"
+
+            point_url = self.url_for(request, "point", lon="{lon}", lat="{lat}")
             if request.query_params._list:
-                tilejson_url += f"?{urlencode(request.query_params._list)}"
+                qs_key_to_remove = [
+                    "tilesize",
+                    "tile_format",
+                    "minzoom",
+                    "maxzoom",
+                    "buffer",
+                    "padding",
+                    "colormap",
+                    "colormap_name",
+                ]
+                qs = [
+                    (key, value)
+                    for (key, value) in request.query_params._list
+                    if key.lower() not in qs_key_to_remove
+                ]
+                if qs:
+                    point_url += f"?{urlencode(qs)}"
 
-            tms = self.supported_tms.get(TileMatrixSetId)
+            tms = self.supported_tms.get(tileMatrixSetId)
             return self.templates.TemplateResponse(
+                request,
                 name="map.html",
                 context={
-                    "request": request,
                     "tilejson_endpoint": tilejson_url,
+                    "point_endpoint": point_url,
                     "tms": tms,
-                    "resolutions": [tms._resolution(matrix) for matrix in tms],
+                    "resolutions": [matrix.cellSize for matrix in tms],
                 },
                 media_type="text/html",
             )
 
-    def wmts(self):  # noqa: C901
-        """Add wmts endpoint."""
+    ############################################################################
+    # /point (Optional)
+    ############################################################################
+    def point(self):
+        """Register /point endpoint."""
 
-        @self.router.get("/WMTSCapabilities.xml", response_class=XMLResponse)
         @self.router.get(
-            "/{TileMatrixSetId}/WMTSCapabilities.xml", response_class=XMLResponse
+            "/point/{lon},{lat}",
+            response_model=Point,
+            response_class=JSONResponse,
+            responses={200: {"description": "Return a value for a point"}},
+            operation_id=f"{self.operation_prefix}getDataForPoint",
         )
-        def wmts(
-            request: Request,
-            TileMatrixSetId: Literal[tuple(self.supported_tms.list())] = Query(
-                self.default_tms,
-                description=f"TileMatrixSet Name (default: '{self.default_tms}')",
-            ),  # noqa
+        def point(
+            lon: Annotated[float, Path(description="Longitude")],
+            lat: Annotated[float, Path(description="Latitude")],
             src_path=Depends(self.path_dependency),
-            tile_format: ImageType = Query(
-                ImageType.png, description="Output image type. Default is png."
-            ),
-            tile_scale: int = Query(
-                1, gt=0, lt=4, description="Tile size scale. 1=256x256, 2=512x512..."
-            ),
-            minzoom: Optional[int] = Query(
-                None, description="Overwrite default minzoom."
-            ),
-            maxzoom: Optional[int] = Query(
-                None, description="Overwrite default maxzoom."
-            ),
-            layer_params=Depends(self.layer_dependency),  # noqa
-            dataset_params=Depends(self.dataset_dependency),  # noqa
-            pixel_selection=Depends(self.pixel_selection_dependency),  # noqa
-            buffer: Optional[float] = Query(  # noqa
-                None,
-                gt=0,
-                title="Tile buffer.",
-                description="Buffer on each side of the given tile. It must be a multiple of `0.5`. Output **tilesize** will be expanded to `tilesize + 2 * tile_buffer` (e.g 0.5 = 257x257, 1.0 = 258x258).",
-            ),
-            post_process=Depends(self.process_dependency),  # noqa
-            rescale=Depends(self.rescale_dependency),  # noqa
-            color_formula: Optional[str] = Query(  # noqa
-                None,
-                title="Color Formula",
-                description="rio-color formula (info: https://github.com/mapbox/rio-color)",
-            ),
-            colormap=Depends(self.colormap_dependency),  # noqa
-            render_params=Depends(self.render_dependency),  # noqa
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
             env=Depends(self.environment_dependency),
         ):
-            """OGC WMTS endpoint."""
-            route_params = {
-                "z": "{TileMatrix}",
-                "x": "{TileCol}",
-                "y": "{TileRow}",
-                "scale": tile_scale,
-                "format": tile_format.value,
-                "TileMatrixSetId": TileMatrixSetId,
+            """Get Point value for a Mosaic."""
+            with rasterio.Env(**env):
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
+                    src_path,
+                    reader=self.dataset_reader,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
+                ) as src_dst:
+                    values = src_dst.point(
+                        lon,
+                        lat,
+                        coord_crs=coord_crs or WGS84_CRS,
+                        search_options=assets_accessor_params.as_dict(),
+                        threads=MOSAIC_THREADS,
+                        **layer_params.as_dict(),
+                        **dataset_params.as_dict(),
+                    )
+
+            return {
+                "coordinates": [lon, lat],
+                "assets": [
+                    {
+                        "name": asset_name,
+                        "values": pt.array.tolist(),
+                        "band_names": pt.band_names,
+                        "band_descriptions": pt.band_descriptions,
+                    }
+                    for asset_name, pt in values
+                ],
             }
-            tiles_url = self.url_for(request, "tile", **route_params)
 
-            qs_key_to_remove = [
-                "tilematrixsetid",
-                "tile_format",
-                "tile_scale",
-                "minzoom",
-                "maxzoom",
-                "service",
-                "request",
-            ]
-            qs = [
-                (key, value)
-                for (key, value) in request.query_params._list
-                if key.lower() not in qs_key_to_remove
-            ]
-            if qs:
-                tiles_url += f"?{urlencode(qs)}"
+    def statistics(self):
+        """Register /statistics endpoint."""
+
+        @self.router.post(
+            "/statistics",
+            response_model=StatisticsGeoJSON,
+            response_model_exclude_none=True,
+            response_class=GeoJSONResponse,
+            responses={
+                200: {
+                    "content": {"application/geo+json": {}},
+                    "description": "Return statistics for geojson features.",
+                }
+            },
+            operation_id=f"{self.operation_prefix}postStatisticsForGeoJSON",
+        )
+        def geojson_statistics(
+            geojson: Annotated[
+                FeatureCollection | Feature,
+                Body(description="GeoJSON Feature or FeatureCollection."),
+            ],
+            src_path=Depends(self.path_dependency),
+            backend_params=Depends(self.backend_dependency),
+            reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            dst_crs=Depends(DstCRSParams),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            pixel_selection=Depends(self.pixel_selection_dependency),
+            image_params=Depends(self.img_part_dependency),
+            post_process=Depends(self.process_dependency),
+            stats_params=Depends(self.stats_dependency),
+            histogram_params=Depends(self.histogram_dependency),
+            env=Depends(self.environment_dependency),
+        ):
+            """Get Statistics from a geojson feature or featureCollection."""
+            fc = geojson
+            if isinstance(fc, Feature):
+                fc = FeatureCollection(type="FeatureCollection", features=[geojson])
 
-            tms = self.supported_tms.get(TileMatrixSetId)
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    bounds = src_dst.geographic_bounds
-                    minzoom = minzoom if minzoom is not None else src_dst.minzoom
-                    maxzoom = maxzoom if maxzoom is not None else src_dst.maxzoom
+                    for i, feature in enumerate(fc.features):
+                        shape = feature.model_dump(exclude_none=True)
 
-            tileMatrix = []
-            for zoom in range(minzoom, maxzoom + 1):
-                matrix = tms.matrix(zoom)
-                tm = f"""
-                        <TileMatrix>
-                            <ows:Identifier>{matrix.identifier}</ows:Identifier>
-                            <ScaleDenominator>{matrix.scaleDenominator}</ScaleDenominator>
-                            <TopLeftCorner>{matrix.topLeftCorner[0]} {matrix.topLeftCorner[1]}</TopLeftCorner>
-                            <TileWidth>{matrix.tileWidth}</TileWidth>
-                            <TileHeight>{matrix.tileHeight}</TileHeight>
-                            <MatrixWidth>{matrix.matrixWidth}</MatrixWidth>
-                            <MatrixHeight>{matrix.matrixHeight}</MatrixHeight>
-                        </TileMatrix>"""
-                tileMatrix.append(tm)
+                        logger.info(f"feature {i}: reading data")
+                        image, assets = src_dst.feature(
+                            shape,
+                            shape_crs=coord_crs or WGS84_CRS,
+                            dst_crs=dst_crs,
+                            align_bounds_with_dataset=True,
+                            search_options=assets_accessor_params.as_dict(),
+                            pixel_selection=pixel_selection,
+                            threads=MOSAIC_THREADS,
+                            **layer_params.as_dict(),
+                            **dataset_params.as_dict(),
+                            **image_params.as_dict(),
+                        )
 
-            return self.templates.TemplateResponse(
-                "wmts.xml",
-                {
-                    "request": request,
-                    "tiles_endpoint": tiles_url,
-                    "bounds": bounds,
-                    "tileMatrix": tileMatrix,
-                    "tms": tms,
-                    "title": "Mosaic",
-                    "layer_name": "mosaic",
-                    "media_type": tile_format.mediatype,
-                },
-                media_type=MediaType.xml.value,
-            )
+                        coverage_array = image.get_coverage_array(
+                            shape,
+                            shape_crs=coord_crs or WGS84_CRS,
+                        )
 
-    ############################################################################
-    # /point (Optional)
-    ############################################################################
-    def point(self):
-        """Register /point endpoint."""
+                        if post_process:
+                            logger.info(f"feature {i}: post processing image")
+                            image = post_process(image)
+
+                        logger.info(f"feature {i}: calculating statistics")
+                        stats = image.statistics(
+                            **stats_params.as_dict(),
+                            hist_options=histogram_params.as_dict(),
+                            coverage=coverage_array,
+                        )
+
+                        feature.properties = feature.properties or {}
+                        feature.properties.update({"statistics": stats})
+                        feature.properties.update({"used_assets": assets})
+
+            return fc.features[0] if isinstance(geojson, Feature) else fc
+
+    def part(self):  # noqa: C901
+        """Register /bbox and /feature endpoint."""
 
+        # GET endpoints
         @self.router.get(
-            r"/point/{lon},{lat}",
-            response_model=Point,
-            response_class=JSONResponse,
-            responses={200: {"description": "Return a value for a point"}},
+            "/bbox/{minx},{miny},{maxx},{maxy}.{format}",
+            operation_id=f"{self.operation_prefix}getDataForBoundingBoxWithFormat",
+            **img_endpoint_params,
         )
-        def point(
-            response: Response,
-            lon: float = Path(..., description="Longitude"),
-            lat: float = Path(..., description="Latitude"),
+        @self.router.get(
+            "/bbox/{minx},{miny},{maxx},{maxy}/{width}x{height}.{format}",
+            operation_id=f"{self.operation_prefix}getDataForBoundingBoxWithSizesAndFormat",
+            **img_endpoint_params,
+        )
+        def bbox_image(
+            minx: Annotated[float, Path(description="Bounding box min X")],
+            miny: Annotated[float, Path(description="Bounding box min Y")],
+            maxx: Annotated[float, Path(description="Bounding box max X")],
+            maxy: Annotated[float, Path(description="Bounding box max Y")],
+            format: Annotated[
+                ImageType,
+                Field(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg)."
+                ),
+            ],
             src_path=Depends(self.path_dependency),
+            backend_params=Depends(self.backend_dependency),
+            reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            dst_crs=Depends(DstCRSParams),
             layer_params=Depends(self.layer_dependency),
             dataset_params=Depends(self.dataset_dependency),
+            pixel_selection=Depends(self.pixel_selection_dependency),
+            image_params=Depends(self.img_part_dependency),
+            post_process=Depends(self.process_dependency),
+            colormap=Depends(self.colormap_dependency),
+            render_params=Depends(self.render_dependency),
+            env=Depends(self.environment_dependency),
+        ):
+            """Create image from a bbox."""
+            with rasterio.Env(**env):
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
+                    src_path,
+                    reader=self.dataset_reader,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
+                ) as src_dst:
+                    image, assets = src_dst.part(
+                        [minx, miny, maxx, maxy],
+                        dst_crs=dst_crs,
+                        bounds_crs=coord_crs or WGS84_CRS,
+                        search_options=assets_accessor_params.as_dict(),
+                        pixel_selection=pixel_selection,
+                        threads=MOSAIC_THREADS,
+                        **layer_params.as_dict(),
+                        **dataset_params.as_dict(),
+                        **image_params.as_dict(),
+                    )
+                    dst_colormap = getattr(src_dst, "colormap", None)
+
+            if post_process:
+                image = post_process(image)
+
+            content, media_type = self.render_func(
+                image,
+                output_format=format,
+                colormap=colormap or dst_colormap,
+                **render_params.as_dict(),
+            )
+
+            headers: dict[str, str] = {}
+            if OptionalHeader.x_assets in self.optional_headers:
+                headers["X-Assets"] = ",".join(assets)
+
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
+
+            if (
+                OptionalHeader.server_timing in self.optional_headers
+                and image.metadata.get("timings")
+            ):
+                headers["Server-Timing"] = ", ".join(
+                    [f"{name};dur={time}" for (name, time) in image.metadata["timings"]]
+                )
+
+            return Response(content, media_type=media_type, headers=headers)
+
+        @self.router.post(
+            "/feature",
+            operation_id=f"{self.operation_prefix}postDataForGeoJSON",
+            **img_endpoint_params,
+        )
+        @self.router.post(
+            "/feature.{format}",
+            operation_id=f"{self.operation_prefix}postDataForGeoJSONWithFormat",
+            **img_endpoint_params,
+        )
+        @self.router.post(
+            "/feature/{width}x{height}.{format}",
+            operation_id=f"{self.operation_prefix}postDataForGeoJSONWithSizesAndFormat",
+            **img_endpoint_params,
+        )
+        def feature_image(
+            geojson: Annotated[Feature, Body(description="GeoJSON Feature.")],
+            src_path=Depends(self.path_dependency),
+            format: Annotated[
+                ImageType | None,
+                Field(
+                    description="Default will be automatically defined if the output image needs a mask (png) or not (jpeg)."
+                ),
+            ] = None,
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            dst_crs=Depends(DstCRSParams),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            image_params=Depends(self.img_part_dependency),
+            pixel_selection=Depends(self.pixel_selection_dependency),
+            post_process=Depends(self.process_dependency),
+            colormap=Depends(self.colormap_dependency),
+            render_params=Depends(self.render_dependency),
             env=Depends(self.environment_dependency),
         ):
-            """Get Point value for a Mosaic."""
-            threads = int(os.getenv("MOSAIC_CONCURRENCY", MAX_THREADS))
-
+            """Create image from a geojson feature."""
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    values = src_dst.point(
-                        lon,
-                        lat,
-                        threads=threads,
-                        **layer_params,
-                        **dataset_params,
+                    image, assets = src_dst.feature(
+                        geojson.model_dump(exclude_none=True),
+                        shape_crs=coord_crs or WGS84_CRS,
+                        dst_crs=dst_crs,
+                        search_options=assets_accessor_params.as_dict(),
+                        pixel_selection=pixel_selection,
+                        threads=MOSAIC_THREADS,
+                        **layer_params.as_dict(),
+                        **image_params.as_dict(),
+                        **dataset_params.as_dict(),
                     )
 
-            return {
-                "coordinates": [lon, lat],
-                "values": [
-                    (src, pts.data.tolist(), pts.band_names) for src, pts in values
-                ],
-            }
+            if post_process:
+                image = post_process(image)
 
-    def validate(self):
-        """Register /validate endpoint."""
+            content, media_type = self.render_func(
+                image,
+                output_format=format,
+                colormap=colormap,
+                **render_params.as_dict(),
+            )
 
-        @self.router.post("/validate")
-        def validate(body: MosaicJSON):
-            """Validate a MosaicJSON"""
-            return True
+            headers: dict[str, str] = {}
+            if OptionalHeader.x_assets in self.optional_headers:
+                headers["X-Assets"] = ",".join(assets)
+
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
+
+            if (
+                OptionalHeader.server_timing in self.optional_headers
+                and image.metadata.get("timings")
+            ):
+                headers["Server-Timing"] = ", ".join(
+                    [f"{name};dur={time}" for (name, time) in image.metadata["timings"]]
+                )
+
+            return Response(content, media_type=media_type, headers=headers)
 
     def assets(self):
         """Register /assets endpoint."""
 
         @self.router.get(
-            r"/{minx},{miny},{maxx},{maxy}/assets",
+            "/bbox/{minx},{miny},{maxx},{maxy}/assets",
             responses={200: {"description": "Return list of COGs in bounding box"}},
+            operation_id=f"{self.operation_prefix}getAssetsForBoundingBox",
         )
         def assets_for_bbox(
+            minx: Annotated[float, Path(description="Bounding box min X")],
+            miny: Annotated[float, Path(description="Bounding box min Y")],
+            maxx: Annotated[float, Path(description="Bounding box max X")],
+            maxy: Annotated[float, Path(description="Bounding box max Y")],
             src_path=Depends(self.path_dependency),
-            minx: float = Query(None, description="Left side of bounding box"),
-            miny: float = Query(None, description="Bottom of bounding box"),
-            maxx: float = Query(None, description="Right side of bounding box"),
-            maxy: float = Query(None, description="Top of bounding box"),
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
+            coord_crs=Depends(CoordCRSParams),
             env=Depends(self.environment_dependency),
         ):
             """Return a list of assets which overlap a bounding box"""
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    return src_dst.assets_for_bbox(minx, miny, maxx, maxy)
+                    return src_dst.assets_for_bbox(
+                        minx,
+                        miny,
+                        maxx,
+                        maxy,
+                        coord_crs=coord_crs or WGS84_CRS,
+                        **assets_accessor_params.as_dict(),
+                    )
 
         @self.router.get(
-            r"/{lng},{lat}/assets",
+            "/point/{lon},{lat}/assets",
             responses={200: {"description": "Return list of COGs"}},
+            operation_id=f"{self.operation_prefix}getAssetsForPoint",
         )
         def assets_for_lon_lat(
+            lon: Annotated[float, Path(description="Longitude")],
+            lat: Annotated[float, Path(description="Latitude")],
             src_path=Depends(self.path_dependency),
-            lng: float = Query(None, description="Longitude"),
-            lat: float = Query(None, description="Latitude"),
+            coord_crs=Depends(CoordCRSParams),
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Return a list of assets which overlap a point"""
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    return src_dst.assets_for_point(lng, lat)
+                    return src_dst.assets_for_point(
+                        lon,
+                        lat,
+                        coord_crs=coord_crs or WGS84_CRS,
+                        **assets_accessor_params.as_dict(),
+                    )
 
         @self.router.get(
-            r"/{z}/{x}/{y}/assets",
+            "/tiles/{tileMatrixSetId}/{z}/{x}/{y}/assets",
             responses={200: {"description": "Return list of COGs"}},
+            operation_id=f"{self.operation_prefix}getAssetsForTile",
         )
         def assets_for_tile(
-            z: int = Path(..., ge=0, le=30, description="Mercator tiles's zoom level"),
-            x: int = Path(..., description="Mercator tiles's column"),
-            y: int = Path(..., description="Mercator tiles's row"),
+            tileMatrixSetId: Annotated[
+                Literal[tuple(self.supported_tms.list())],
+                Path(
+                    description="Identifier selecting one of the TileMatrixSetId supported."
+                ),
+            ],
+            z: Annotated[
+                int,
+                Path(
+                    description="Identifier (Z) selecting one of the scales defined in the TileMatrixSet and representing the scaleDenominator the tile.",
+                ),
+            ],
+            x: Annotated[
+                int,
+                Path(
+                    description="Column (X) index of the tile on the selected TileMatrix. It cannot exceed the MatrixHeight-1 for the selected TileMatrix.",
+                ),
+            ],
+            y: Annotated[
+                int,
+                Path(
+                    description="Row (Y) index of the tile on the selected TileMatrix. It cannot exceed the MatrixWidth-1 for the selected TileMatrix.",
+                ),
+            ],
             src_path=Depends(self.path_dependency),
             backend_params=Depends(self.backend_dependency),
             reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
             env=Depends(self.environment_dependency),
         ):
             """Return a list of assets which overlap a given tile"""
+            tms = self.supported_tms.get(tileMatrixSetId)
+            with rasterio.Env(**env):
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
+                    src_path,
+                    tms=tms,
+                    reader=self.dataset_reader,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
+                ) as src_dst:
+                    return src_dst.assets_for_tile(
+                        x,
+                        y,
+                        z,
+                        **assets_accessor_params.as_dict(),
+                    )
+
+    ############################################################################
+    # OGC Maps (Optional)
+    ############################################################################
+    def ogc_maps(self):  # noqa: C901
+        """Register OGC Maps /map` endpoint."""
+
+        self.conforms_to.update(
+            {
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/core",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/crs",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/scaling",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/scaling/width-definition",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/scaling/height-definition",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/spatial-subsetting",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/spatial-subsetting/bbox-definition",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/spatial-subsetting/bbox-crs",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/spatial-subsetting/crs-curie",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/png",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/jpeg",
+                "https://www.opengis.net/spec/ogcapi-maps-1/1.0/conf/tiff",
+            }
+        )
+
+        @self.router.get(
+            "/map",
+            operation_id=f"{self.operation_prefix}getMap",
+            **img_endpoint_params,
+        )
+        def get_map(
+            src_path=Depends(self.path_dependency),
+            ogc_params=Depends(OGCMapsParams),
+            backend_params=Depends(self.backend_dependency),
+            reader_params=Depends(self.reader_dependency),
+            assets_accessor_params=Depends(self.assets_accessor_dependency),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            pixel_selection=Depends(self.pixel_selection_dependency),
+            post_process=Depends(self.process_dependency),
+            colormap=Depends(self.colormap_dependency),
+            render_params=Depends(self.render_dependency),
+            env=Depends(self.environment_dependency),
+        ) -> Response:
+            """OGC Maps API."""
             with rasterio.Env(**env):
-                with self.reader(
+                logger.info(
+                    f"opening data with backend: {self.backend} and reader {self.dataset_reader}"
+                )
+                with self.backend(
                     src_path,
                     reader=self.dataset_reader,
-                    reader_options={**reader_params},
-                    **backend_params,
+                    reader_options=reader_params.as_dict(),
+                    **backend_params.as_dict(),
                 ) as src_dst:
-                    return src_dst.assets_for_tile(x, y, z)
+                    if ogc_params.bbox is not None:
+                        image, assets = src_dst.part(
+                            ogc_params.bbox,
+                            dst_crs=ogc_params.crs or src_dst.crs,
+                            bounds_crs=ogc_params.bbox_crs or WGS84_CRS,
+                            search_options=assets_accessor_params.as_dict(),
+                            pixel_selection=pixel_selection,
+                            threads=MOSAIC_THREADS,
+                            width=ogc_params.width,
+                            height=ogc_params.height,
+                            max_size=ogc_params.max_size,
+                            **layer_params.as_dict(),
+                            **dataset_params.as_dict(),
+                        )
+
+                    else:
+                        # NOTE: Defaults backends do not support preview
+                        image, assets = src_dst.preview(
+                            search_options=assets_accessor_params.as_dict(),
+                            pixel_selection=pixel_selection,
+                            threads=MOSAIC_THREADS,
+                            width=ogc_params.width,
+                            height=ogc_params.height,
+                            max_size=ogc_params.max_size,
+                            dst_crs=ogc_params.crs or src_dst.crs,
+                            **layer_params.as_dict(),
+                            **dataset_params.as_dict(),
+                        )
+                    dst_colormap = getattr(src_dst, "colormap", None)
+
+            if post_process:
+                image = post_process(image)
+
+            content, media_type = self.render_func(
+                image,
+                output_format=ogc_params.format,
+                colormap=colormap or dst_colormap,
+                **render_params.as_dict(),
+            )
+
+            headers: dict[str, str] = {}
+            if OptionalHeader.x_assets in self.optional_headers:
+                headers["X-Assets"] = ",".join(assets)
+
+            if image.bounds is not None:
+                headers["Content-Bbox"] = ",".join(map(str, image.bounds))
+            if uri := CRS_to_uri(image.crs):
+                headers["Content-Crs"] = f"<{uri}>"
+
+            if (
+                OptionalHeader.server_timing in self.optional_headers
+                and image.metadata.get("timings")
+            ):
+                headers["Server-Timing"] = ", ".join(
+                    [f"{name};dur={time}" for (name, time) in image.metadata["timings"]]
+                )
+
+            return Response(content, media_type=media_type, headers=headers)
diff --git a/src/titiler/mosaic/titiler/mosaic/models/responses.py b/src/titiler/mosaic/titiler/mosaic/models/responses.py
index 1ad45c778..82749e9d1 100644
--- a/src/titiler/mosaic/titiler/mosaic/models/responses.py
+++ b/src/titiler/mosaic/titiler/mosaic/models/responses.py
@@ -1,10 +1,17 @@
 """TiTiler.mosaic response models."""
 
-from typing import List, Tuple
-
 from pydantic import BaseModel
 
 
+class AssetPoint(BaseModel):
+    """Model for Point value per asset"""
+
+    name: str
+    values: list[float | None]
+    band_names: list[str]
+    band_descriptions: list[str] | None = None
+
+
 class Point(BaseModel):
     """
     Point model.
@@ -13,5 +20,5 @@ class Point(BaseModel):
 
     """
 
-    coordinates: List[float]
-    values: List[Tuple[str, List[float], List[str]]]
+    coordinates: list[float]
+    assets: list[AssetPoint]
diff --git a/src/titiler/mosaic/titiler/mosaic/py.typed b/src/titiler/mosaic/titiler/mosaic/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/titiler/mosaic/titiler/mosaic/resources/__init__.py b/src/titiler/mosaic/titiler/mosaic/resources/__init__.py
deleted file mode 100644
index 60f13dcb0..000000000
--- a/src/titiler/mosaic/titiler/mosaic/resources/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""titiler.core.resources."""
diff --git a/src/titiler/mosaic/titiler/mosaic/resources/enums.py b/src/titiler/mosaic/titiler/mosaic/resources/enums.py
deleted file mode 100644
index 53822891d..000000000
--- a/src/titiler/mosaic/titiler/mosaic/resources/enums.py
+++ /dev/null
@@ -1,22 +0,0 @@
-"""Titiler.mosaic Enums."""
-
-from enum import Enum
-from types import DynamicClassAttribute
-
-from rio_tiler.mosaic.methods import defaults
-
-
-class PixelSelectionMethod(str, Enum):
-    """rio-tiler.mosaic pixel selection methods"""
-
-    first = "first"
-    highest = "highest"
-    lowest = "lowest"
-    mean = "mean"
-    median = "median"
-    stdev = "stdev"
-
-    @DynamicClassAttribute
-    def method(self):
-        """Return rio-tiler-mosaic pixel selection class"""
-        return getattr(defaults, f"{self._value_.title()}Method")
diff --git a/src/titiler/xarray/LICENSE b/src/titiler/xarray/LICENSE
new file mode 100644
index 000000000..eb4365951
--- /dev/null
+++ b/src/titiler/xarray/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Development Seed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/titiler/xarray/README.md b/src/titiler/xarray/README.md
new file mode 100644
index 000000000..cab2aa033
--- /dev/null
+++ b/src/titiler/xarray/README.md
@@ -0,0 +1,108 @@
+## titiler.xarray
+
+Adds support for Xarray Dataset (NetCDF/Zarr) in Titiler.
+
+## Installation
+
+```bash
+python -m pip install -U pip
+
+# From Pypi
+python -m pip install "titiler.xarray[full]"
+
+# Or from sources
+git clone https://github.com/developmentseed/titiler.git
+cd titiler && python -m pip install -e src/titiler/core -e "src/titiler/xarray"
+```
+
+#### Installation options
+
+Default installation for `titiler.xarray` DOES NOT include `fsspec` or any storage's specific dependencies (e.g `s3fs`) nor `engine` dependencies (`zarr`, `h5netcdf`). This is to ease the customization and deployment of user's applications. If you want to use the default's dataset reader you will need to at least use the `[minimal]` dependencies (e.g `python -m pip install "titiler.xarray[minimal]"`).
+
+Here is the list of available options:
+
+- **fs**: `h5netcdf`,  `fsspec`, `s3fs`, `aiohttp`, `gcsfs`
+
+#### Dependencies
+
+Titiler.xarray follows [SPEC 0](https://scientific-python.org/specs/spec-0000/), similar to [xarray](https://docs.xarray.dev/en/v2025.09.0/getting-started-guide/installing.html#minimum-dependency-versions).
+
+## How To
+
+```python
+from fastapi import FastAPI
+
+from titiler.xarray.extensions import VariablesExtension
+from titiler.xarray.factory import TilerFactory
+
+app = FastAPI(
+    openapi_url="/api",
+    docs_url="/api.html",
+    description="""Xarray based tiles server for MultiDimensional dataset (Zarr/NetCDF).
+
+---
+
+**Documentation**: <a href="https://developmentseed.org/titiler/" target="_blank">https://developmentseed.org/titiler/</a>
+
+**Source Code**: <a href="https://github.com/developmentseed/titiler" target="_blank">https://github.com/developmentseed/titiler</a>
+
+---
+    """,
+)
+
+md = TilerFactory(
+    router_prefix="/md",
+    extensions=[
+        VariablesExtension(),
+    ],
+)
+app.include_router(md.router, prefix="/md", tags=["Multi Dimensional"])
+```
+
+## Package structure
+
+```
+titiler/
+ └── xarray/
+    ├── tests/                   - Tests suite
+    └── titiler/xarray/          - `xarray` namespace package
+        ├── dependencies.py      - titiler-xarray dependencies
+        ├── extensions.py        - titiler-xarray extensions
+        ├── main.py              - main fastapi application
+        ├── io.py                - titiler-xarray Readers
+        └── factory.py           - endpoints factory
+```
+
+## Custom Dataset Opener
+
+A default Dataset IO is provided within `titiler.xarray.io.Reader` class with only support for Zarr dataset (via xarray+zarr-python). 
+
+For other dataset (e.g NetCDF), you can use `titiler.xarray.io.FsReader` which use the optional dependencies (`fsspec`, `netcdf5`).
+
+```
+python -m pip install "titiler.xarray[fs]"
+```
+
+Example of application with `fsspec` reader:
+
+```python
+from fastapi import FastAPI
+from titiler.xarray.extensions import VariablesExtension
+from titiler.xarray.factory import TilerFactory
+from titiler.xarray.io import FsReader
+
+# Create FastAPI application
+app = FastAPI(openapi_url="/api", docs_url="/api.html")
+
+# Create custom endpoints with the FsReader
+md = TilerFactory(
+    reader=FsReader,
+    router_prefix="/md",
+    extensions=[
+        # we also want to use the simple opener for the Extension
+        VariablesExtension(dataset_opener=xarray.open_dataset),
+    ],
+)
+
+app.include_router(md.router, prefix="/md", tags=["Multi Dimensional"])
+```
diff --git a/src/titiler/xarray/examples/local.py b/src/titiler/xarray/examples/local.py
new file mode 100644
index 000000000..a377ee0e7
--- /dev/null
+++ b/src/titiler/xarray/examples/local.py
@@ -0,0 +1,112 @@
+# /// script
+# dependencies = [
+#   "titiler.xarray[full]",
+#   "starlette_cramjam",
+#   "uvicorn",
+# ]
+# ///
+"""Example of Application."""
+
+from datetime import datetime
+
+import numpy
+import xarray
+from fastapi import FastAPI
+from rio_tiler.io.xarray import XarrayReader
+from starlette.middleware.cors import CORSMiddleware
+from starlette_cramjam.middleware import CompressionMiddleware
+
+from titiler.core.dependencies import DefaultDependency
+from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
+from titiler.core.factory import AlgorithmFactory, ColorMapFactory, TMSFactory
+from titiler.core.middleware import CacheControlMiddleware
+from titiler.xarray.factory import TilerFactory
+
+
+def XarrayDataArray() -> xarray.DataArray:
+    """Custom Dependency which return a DataArray."""
+    arr = numpy.linspace(1, 1000, 1000 * 2000).reshape(1, 1000, 2000)
+    data = xarray.DataArray(
+        arr,
+        dims=("time", "y", "x"),
+        coords={
+            "x": numpy.arange(-170, 170, 0.17),
+            "y": numpy.arange(-80, 80, 0.16),
+            "time": [datetime(2022, 1, 1)],
+        },
+    )
+    data.attrs.update({"valid_min": arr.min(), "valid_max": arr.max(), "fill_value": 0})
+    data.rio.write_crs("epsg:4326", inplace=True)
+    return data
+
+
+app = FastAPI(
+    title="TiTiler with support of Multidimensional dataset",
+    openapi_url="/api",
+    docs_url="/api.html",
+    version="0.1.0",
+)
+
+
+md = TilerFactory(
+    router_prefix="/md",
+    # Use rio-tiler XarrayReader which accept xarray.DataArray as input
+    reader=XarrayReader,
+    # Use our custom dependency which return a xarray.DataArray
+    path_dependency=XarrayDataArray,
+    # Set the reader_dependency to `empty`
+    reader_dependency=DefaultDependency,
+)
+app.include_router(md.router, prefix="/md", tags=["Multi Dimensional"])
+
+# TileMatrixSets endpoints
+app.include_router(TMSFactory().router, tags=["Tiling Schemes"])
+
+###############################################################################
+# Algorithms endpoints
+app.include_router(
+    AlgorithmFactory().router,
+    tags=["Algorithms"],
+)
+
+# Colormaps endpoints
+app.include_router(
+    ColorMapFactory().router,
+    tags=["ColorMaps"],
+)
+
+add_exception_handlers(app, DEFAULT_STATUS_CODES)
+
+# Set all CORS enabled origins
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins="*",
+    allow_credentials=True,
+    allow_methods=["GET"],
+    allow_headers=["*"],
+)
+
+app.add_middleware(
+    CompressionMiddleware,
+    minimum_size=0,
+    exclude_mediatype={
+        "image/jpeg",
+        "image/jpg",
+        "image/png",
+        "image/jp2",
+        "image/webp",
+    },
+    compression_level=6,
+)
+
+app.add_middleware(
+    CacheControlMiddleware,
+    cachecontrol="public, max-age=3600",
+    exclude_path={r"/healthz"},
+)
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app=app, host="127.0.0.1", port=8080, log_level="info")
diff --git a/src/titiler/xarray/notebooks/xarray_dataset_cache.ipynb b/src/titiler/xarray/notebooks/xarray_dataset_cache.ipynb
new file mode 100644
index 000000000..a7692741d
--- /dev/null
+++ b/src/titiler/xarray/notebooks/xarray_dataset_cache.ipynb
@@ -0,0 +1,167 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Add Caching Layer for Xarray Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pickle\n",
+    "from typing import Any, Callable, List, Optional\n",
+    "\n",
+    "import attr\n",
+    "import xarray\n",
+    "from morecantile import TileMatrixSet\n",
+    "from rio_tiler.constants import WEB_MERCATOR_TMS\n",
+    "from rio_tiler.io.xarray import XarrayReader\n",
+    "\n",
+    "from titiler.xarray.io import xarray_open_dataset, get_variable\n",
+    "\n",
+    "from diskcache import Cache\n",
+    "\n",
+    "cache_client = Cache()\n",
+    "\n",
+    "\n",
+    "@attr.s\n",
+    "class CustomReader(XarrayReader):\n",
+    "    \"\"\"Reader: Open Zarr file and access DataArray.\"\"\"\n",
+    "\n",
+    "    src_path: str = attr.ib()\n",
+    "    variable: str = attr.ib()\n",
+    "\n",
+    "    # xarray.Dataset options\n",
+    "    opener: Callable[..., xarray.Dataset] = attr.ib(default=xarray_open_dataset)\n",
+    "\n",
+    "    group: Optional[Any] = attr.ib(default=None)\n",
+    "    decode_times: bool = attr.ib(default=False)\n",
+    "\n",
+    "    # xarray.DataArray options\n",
+    "    sel: Optional[List[str]] = attr.ib(default=None)\n",
+    "    method: Optional[str] = attr.ib(default=None)\n",
+    "\n",
+    "    tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)\n",
+    "\n",
+    "    ds: xarray.Dataset = attr.ib(init=False)\n",
+    "    input: xarray.DataArray = attr.ib(init=False)\n",
+    "\n",
+    "    _dims: List = attr.ib(init=False, factory=list)\n",
+    "\n",
+    "    def __attrs_post_init__(self):\n",
+    "        \"\"\"Set bounds and CRS.\"\"\"\n",
+    "        ds = None\n",
+    "        # Generate cache key and attempt to fetch the dataset from cache\n",
+    "        cache_key = f\"{self.src_path}_group:{self.group}_time:{self.decode_times}\"\n",
+    "        data_bytes = cache_client.get(cache_key)\n",
+    "        if data_bytes:\n",
+    "            print(f\"Found dataset in Cache {cache_key}\")\n",
+    "            ds = pickle.loads(data_bytes)\n",
+    "\n",
+    "        self.ds = ds or self.opener(\n",
+    "            self.src_path,\n",
+    "            group=self.group,\n",
+    "            decode_times=self.decode_times,\n",
+    "        )\n",
+    "        if not ds:\n",
+    "            # Serialize the dataset to bytes using pickle\n",
+    "            cache_key = f\"{self.src_path}_group:{self.group}_time:{self.decode_times}\"\n",
+    "            data_bytes = pickle.dumps(self.ds)\n",
+    "            print(f\"Adding dataset in Cache: {cache_key}\")\n",
+    "            cache_client.set(cache_key, data_bytes, tag=\"data\", expire=300)\n",
+    "\n",
+    "        self.input = get_variable(\n",
+    "            self.ds,\n",
+    "            self.variable,\n",
+    "            sel=self.sel,\n",
+    "            method=self.method,\n",
+    "        )\n",
+    "        super().__attrs_post_init__()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found dataset in Cache ../tests/fixtures/dataset_2d.nc_group:None_time:False\n",
+      "<xarray.Dataset> Size: 16MB\n",
+      "Dimensions:  (x: 2000, y: 1000)\n",
+      "Coordinates:\n",
+      "  * x        (x) float64 16kB -170.0 -169.8 -169.7 -169.5 ... 169.5 169.7 169.8\n",
+      "  * y        (y) float64 8kB -80.0 -79.84 -79.68 -79.52 ... 79.52 79.68 79.84\n",
+      "Data variables:\n",
+      "    dataset  (y, x) float64 16MB ...\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x16b1fc7d0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "with CustomReader(\"../tests/fixtures/dataset_2d.nc\", \"dataset\") as src:\n",
+    "    print(src.ds)\n",
+    "    tile = src.tms.tile(src.bounds[0], src.bounds[1], src.minzoom)\n",
+    "    img = src.tile(*tile)\n",
+    "\n",
+    "plt.imshow(img.data_as_image())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py39",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/src/titiler/xarray/notebooks/xarray_reader.ipynb b/src/titiler/xarray/notebooks/xarray_reader.ipynb
new file mode 100644
index 000000000..33da74dd3
--- /dev/null
+++ b/src/titiler/xarray/notebooks/xarray_reader.ipynb
@@ -0,0 +1,324 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using titiler.xarray Reader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from titiler.xarray.io import Reader\n",
+    "\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "    \"bounds\": [\n",
+      "        -170.085,\n",
+      "        -80.08,\n",
+      "        169.914999999975,\n",
+      "        79.91999999999659\n",
+      "    ],\n",
+      "    \"crs\": \"http://www.opengis.net/def/crs/EPSG/0/4326\",\n",
+      "    \"band_metadata\": [\n",
+      "        [\n",
+      "            \"b1\",\n",
+      "            {}\n",
+      "        ]\n",
+      "    ],\n",
+      "    \"band_descriptions\": [\n",
+      "        [\n",
+      "            \"b1\",\n",
+      "            \"dataset\"\n",
+      "        ]\n",
+      "    ],\n",
+      "    \"dtype\": \"float64\",\n",
+      "    \"nodata_type\": \"Nodata\",\n",
+      "    \"colorinterp\": null,\n",
+      "    \"scales\": null,\n",
+      "    \"offsets\": null,\n",
+      "    \"colormap\": null,\n",
+      "    \"name\": \"dataset\",\n",
+      "    \"count\": 1,\n",
+      "    \"width\": 2000,\n",
+      "    \"height\": 1000,\n",
+      "    \"dimensions\": [\n",
+      "        \"y\",\n",
+      "        \"x\"\n",
+      "    ],\n",
+      "    \"attrs\": {\n",
+      "        \"valid_min\": 1.0,\n",
+      "        \"valid_max\": 1000.0,\n",
+      "        \"fill_value\": 0\n",
+      "    }\n",
+      "}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x11df61ca0>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# With a simple 2 Dataset\n",
+    "with Reader(\"../tests/fixtures/dataset_2d.nc\", \"dataset\") as src:\n",
+    "    print(src.info().model_dump_json(indent=4))\n",
+    "\n",
+    "    tile = src.tms.tile(src.bounds[0], src.bounds[1], src.minzoom)\n",
+    "    img = src.tile(*tile)\n",
+    "\n",
+    "plt.imshow(img.data_as_image())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "    \"bounds\": [\n",
+      "        -170.085,\n",
+      "        -80.08,\n",
+      "        169.914999999975,\n",
+      "        79.91999999999659\n",
+      "    ],\n",
+      "    \"crs\": \"http://www.opengis.net/def/crs/EPSG/0/4326\",\n",
+      "    \"band_metadata\": [\n",
+      "        [\n",
+      "            \"b1\",\n",
+      "            {}\n",
+      "        ],\n",
+      "        [\n",
+      "            \"b2\",\n",
+      "            {}\n",
+      "        ]\n",
+      "    ],\n",
+      "    \"band_descriptions\": [\n",
+      "        [\n",
+      "            \"b1\",\n",
+      "            \"2022-01-01T00:00:00.000000000\"\n",
+      "        ],\n",
+      "        [\n",
+      "            \"b2\",\n",
+      "            \"2023-01-01T00:00:00.000000000\"\n",
+      "        ]\n",
+      "    ],\n",
+      "    \"dtype\": \"float64\",\n",
+      "    \"nodata_type\": \"Nodata\",\n",
+      "    \"colorinterp\": null,\n",
+      "    \"scales\": null,\n",
+      "    \"offsets\": null,\n",
+      "    \"colormap\": null,\n",
+      "    \"name\": \"dataset\",\n",
+      "    \"count\": 2,\n",
+      "    \"width\": 2000,\n",
+      "    \"height\": 1000,\n",
+      "    \"dimensions\": [\n",
+      "        \"time\",\n",
+      "        \"y\",\n",
+      "        \"x\"\n",
+      "    ],\n",
+      "    \"attrs\": {\n",
+      "        \"valid_min\": 1.0,\n",
+      "        \"valid_max\": 1000.0,\n",
+      "        \"fill_value\": 0\n",
+      "    }\n",
+      "}\n",
+      "There are 2 Time Values (represented as Bands)\n",
+      "[('b1', '2022-01-01T00:00:00.000000000'), ('b2', '2023-01-01T00:00:00.000000000')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# With a 3D Dataset (Time, X, Y)\n",
+    "with Reader(\"../tests/fixtures/dataset_3d.nc\", \"dataset\") as src:\n",
+    "    info = src.info()\n",
+    "\n",
+    "    print(info.model_dump_json(indent=4))\n",
+    "    print(\"There are 2 Time Values (represented as Bands)\")\n",
+    "    print(info.band_descriptions)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x138e27a70>"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# View the first time value\n",
+    "with Reader(\"../tests/fixtures/dataset_3d.nc\", \"dataset\") as src:\n",
+    "    tile = src.tms.tile(src.bounds[0], src.bounds[1], src.minzoom)\n",
+    "    img = src.tile(*tile, indexes=1)\n",
+    "\n",
+    "plt.imshow(img.data_as_image())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x13ebc25d0>"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# View the second time value\n",
+    "with Reader(\"../tests/fixtures/dataset_3d.nc\", \"dataset\") as src:\n",
+    "    tile = src.tms.tile(src.bounds[0], src.bounds[1], src.minzoom)\n",
+    "    img = src.tile(*tile, indexes=2)\n",
+    "\n",
+    "plt.imshow(img.data_as_image())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('b1', '2023-01-01T00:00:00.000000000')]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x11f958410>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Select time with Xarray Sel method\n",
+    "with Reader(\n",
+    "    \"../tests/fixtures/dataset_3d.nc\",\n",
+    "    \"dataset\",\n",
+    "    sel=[\"time=2023-01-01\"],\n",
+    "    method=\"nearest\",\n",
+    ") as src:\n",
+    "    print(src.info().band_descriptions)\n",
+    "    tile = src.tms.tile(src.bounds[0], src.bounds[1], src.minzoom)\n",
+    "    img = src.tile(*tile)\n",
+    "\n",
+    "plt.imshow(img.data_as_image())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py39",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/src/titiler/xarray/pyproject.toml b/src/titiler/xarray/pyproject.toml
new file mode 100644
index 000000000..7351e405d
--- /dev/null
+++ b/src/titiler/xarray/pyproject.toml
@@ -0,0 +1,89 @@
+[project]
+name = "titiler-xarray"
+description = "Xarray plugin for TiTiler."
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    {name = "Vincent Sarago", email = "vincent@developmentseed.com"},
+    {name = "Aimee Barciauskas", email = "aimee@developmentseed.com"},
+]
+license = {text = "MIT"}
+keywords = [
+    "TiTiler",
+    "Xarray",
+    "Zarr",
+    "NetCDF",
+    "HDF",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: GIS",
+]
+dynamic = ["version"]
+dependencies = [
+    "titiler-core==2.0.1",  # x-release-please-version
+    "xarray",
+    "rioxarray",
+    "obstore",
+    "zarr>=3.1,<4.0",
+]
+
+[project.optional-dependencies]
+fs = [
+    "h5netcdf",
+    "h5py",
+    "fsspec",
+    "s3fs>=2025.2.0",
+    "aiohttp",
+    "gcsfs",
+    "requests",
+]
+telemetry = [
+    "opentelemetry-api",
+    "opentelemetry-sdk",
+    "opentelemetry-instrumentation-fastapi",
+    "opentelemetry-instrumentation-logging",
+    "opentelemetry-exporter-otlp",
+]
+
+[dependency-groups]
+test = [
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "httpx",
+    "h5netcdf",
+    "h5py",
+    "fsspec",
+    "s3fs",
+    "aiohttp",
+    "requests",
+]
+
+[project.urls]
+Homepage = "https://developmentseed.org/titiler/"
+Documentation = "https://developmentseed.org/titiler/"
+Issues = "https://github.com/developmentseed/titiler/issues"
+Source = "https://github.com/developmentseed/titiler"
+Changelog = "https://developmentseed.org/titiler/release-notes/"
+
+[tool.hatch.version]
+path = "titiler/xarray/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+only-include = ["titiler"]
+
+[tool.hatch.build.targets.wheel]
+only-include = ["titiler"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/src/titiler/xarray/requirements-upstream.txt b/src/titiler/xarray/requirements-upstream.txt
new file mode 100644
index 000000000..29984f095
--- /dev/null
+++ b/src/titiler/xarray/requirements-upstream.txt
@@ -0,0 +1,5 @@
+xarray@git+https://github.com/pydata/xarray.git
+universal_pathlib@git+https://github.com/fsspec/universal_pathlib.git
+numcodecs@git+https://github.com/zarr-developers/numcodecs.git
+ujson@git+https://github.com/ultrajson/ultrajson.git
+zarr@git+https://github.com/zarr-developers/zarr-python.git
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/conftest.py b/src/titiler/xarray/tests/conftest.py
new file mode 100644
index 000000000..dc4af91ae
--- /dev/null
+++ b/src/titiler/xarray/tests/conftest.py
@@ -0,0 +1 @@
+"""titiler.xarray test configuration."""
diff --git a/src/titiler/xarray/tests/fixtures/dataset_2d.nc b/src/titiler/xarray/tests/fixtures/dataset_2d.nc
new file mode 100644
index 000000000..2b0b42adc
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_2d.nc differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.nc b/src/titiler/xarray/tests/fixtures/dataset_3d.nc
new file mode 100644
index 000000000..c367e452e
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.nc differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zattrs b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zattrs
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zattrs
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zgroup b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zgroup
new file mode 100644
index 000000000..3b7daf227
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zgroup
@@ -0,0 +1,3 @@
+{
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zmetadata b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zmetadata
new file mode 100644
index 000000000..061ce5cb0
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/.zmetadata
@@ -0,0 +1,119 @@
+{
+    "metadata": {
+        ".zattrs": {},
+        ".zgroup": {
+            "zarr_format": 2
+        },
+        "dataset/.zarray": {
+            "chunks": [
+                1,
+                250,
+                500
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                2,
+                1000,
+                2000
+            ],
+            "zarr_format": 2
+        },
+        "dataset/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "time",
+                "y",
+                "x"
+            ],
+            "valid_max": 1000.0,
+            "valid_min": 0.0
+        },
+        "time/.zarray": {
+            "chunks": [
+                2
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<i8",
+            "fill_value": null,
+            "filters": null,
+            "order": "C",
+            "shape": [
+                2
+            ],
+            "zarr_format": 2
+        },
+        "time/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "time"
+            ],
+            "calendar": "proleptic_gregorian",
+            "units": "days since 2022-01-01 00:00:00"
+        },
+        "x/.zarray": {
+            "chunks": [
+                2000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                2000
+            ],
+            "zarr_format": 2
+        },
+        "x/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "x"
+            ]
+        },
+        "y/.zarray": {
+            "chunks": [
+                1000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                1000
+            ],
+            "zarr_format": 2
+        },
+        "y/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "y"
+            ]
+        }
+    },
+    "zarr_consolidated_format": 1
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/.zarray b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/.zarray
new file mode 100644
index 000000000..1114507a2
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/.zarray
@@ -0,0 +1,24 @@
+{
+    "chunks": [
+        1,
+        250,
+        500
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        2,
+        1000,
+        2000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/.zattrs b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/.zattrs
new file mode 100644
index 000000000..92811b655
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/.zattrs
@@ -0,0 +1,9 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "time",
+        "y",
+        "x"
+    ],
+    "valid_max": 1000.0,
+    "valid_min": 0.0
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.0
new file mode 100644
index 000000000..193516262
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.1 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.1
new file mode 100644
index 000000000..02f3eb367
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.2 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.2
new file mode 100644
index 000000000..27ee5dd95
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.2 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.3 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.3
new file mode 100644
index 000000000..9a5a77329
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.0.3 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.0
new file mode 100644
index 000000000..7483a4407
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.1 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.1
new file mode 100644
index 000000000..1351e3dc7
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.2 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.2
new file mode 100644
index 000000000..7bebebde0
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.2 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.3 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.3
new file mode 100644
index 000000000..cfe62a706
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.1.3 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.0
new file mode 100644
index 000000000..70cd4693f
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.1 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.1
new file mode 100644
index 000000000..5b2412be6
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.2 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.2
new file mode 100644
index 000000000..05912ac30
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.2 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.3 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.3
new file mode 100644
index 000000000..0a0772799
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.2.3 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.0
new file mode 100644
index 000000000..4c596c1fd
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.1 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.1
new file mode 100644
index 000000000..dff32093b
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.2 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.2
new file mode 100644
index 000000000..3c3e8b338
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.2 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.3 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.3
new file mode 100644
index 000000000..692ca6dbe
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/0.3.3 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.0
new file mode 100644
index 000000000..78d0463ae
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.1 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.1
new file mode 100644
index 000000000..2b8487a3d
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.2 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.2
new file mode 100644
index 000000000..a14ed689f
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.2 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.3 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.3
new file mode 100644
index 000000000..803e1cad7
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.0.3 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.0
new file mode 100644
index 000000000..98af409b5
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.1 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.1
new file mode 100644
index 000000000..ccd75df31
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.2 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.2
new file mode 100644
index 000000000..35b639d06
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.2 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.3 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.3
new file mode 100644
index 000000000..5c608e707
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.1.3 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.0
new file mode 100644
index 000000000..5401c33b3
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.1 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.1
new file mode 100644
index 000000000..076551c44
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.2 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.2
new file mode 100644
index 000000000..8b7d1f4e7
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.2 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.3 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.3
new file mode 100644
index 000000000..e3aa4636d
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.2.3 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.0
new file mode 100644
index 000000000..bf3cf57ed
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.1 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.1
new file mode 100644
index 000000000..d5aa1af89
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.2 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.2
new file mode 100644
index 000000000..3fe725ab5
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.2 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.3 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.3
new file mode 100644
index 000000000..4636302ed
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/dataset/1.3.3 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/.zarray b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/.zarray
new file mode 100644
index 000000000..5a5b33285
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        2
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<i8",
+    "fill_value": null,
+    "filters": null,
+    "order": "C",
+    "shape": [
+        2
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/.zattrs b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/.zattrs
new file mode 100644
index 000000000..342871520
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/.zattrs
@@ -0,0 +1,7 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "time"
+    ],
+    "calendar": "proleptic_gregorian",
+    "units": "days since 2022-01-01 00:00:00"
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/0
new file mode 100644
index 000000000..db2a2a192
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/time/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/.zarray b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/.zarray
new file mode 100644
index 000000000..4a4ca60db
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        2000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        2000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/.zattrs b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/.zattrs
new file mode 100644
index 000000000..4b15671e1
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "x"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/0
new file mode 100644
index 000000000..fc622fb50
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/x/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/.zarray b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/.zarray
new file mode 100644
index 000000000..cc70c6c0f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        1000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        1000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/.zattrs b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/.zattrs
new file mode 100644
index 000000000..64ccf306f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "y"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/0 b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/0
new file mode 100644
index 000000000..09c474b91
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_3d.zarr/y/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/dataset_4d.nc b/src/titiler/xarray/tests/fixtures/dataset_4d.nc
new file mode 100644
index 000000000..48cfac1cc
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/dataset_4d.nc differ
diff --git a/src/titiler/xarray/tests/fixtures/generate_fixtures.ipynb b/src/titiler/xarray/tests/fixtures/generate_fixtures.ipynb
new file mode 100644
index 000000000..137c104c1
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/generate_fixtures.ipynb
@@ -0,0 +1,195 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import xarray\n",
+    "import numpy\n",
+    "from datetime import datetime"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 2D\n",
+    "arr = numpy.linspace(1, 1000, 1000 * 2000).reshape(1000, 2000)\n",
+    "data = xarray.DataArray(\n",
+    "    arr,\n",
+    "    dims=(\"y\", \"x\"),\n",
+    "    coords={\n",
+    "        \"x\": numpy.arange(-170, 170, 0.17),\n",
+    "        \"y\": numpy.arange(-80, 80, 0.16),\n",
+    "    },\n",
+    ")\n",
+    "data.attrs.update({\"valid_min\": arr.min(), \"valid_max\": arr.max(), \"fill_value\": 0})\n",
+    "ds = data.to_dataset(name=\"dataset\")\n",
+    "\n",
+    "ds.to_netcdf(\"dataset_2d.nc\", encoding={\"dataset\": {\"zlib\": True, \"complevel\": 9}})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 3D\n",
+    "arr = numpy.linspace(1, 1000, 1000 * 2000 * 2).reshape(2, 1000, 2000)\n",
+    "data = xarray.DataArray(\n",
+    "    arr,\n",
+    "    dims=(\"time\", \"y\", \"x\"),\n",
+    "    coords={\n",
+    "        \"x\": numpy.arange(-170, 170, 0.17),\n",
+    "        \"y\": numpy.arange(-80, 80, 0.16),\n",
+    "        \"time\": [datetime(2022, 1, 1), datetime(2023, 1, 1)],\n",
+    "    },\n",
+    ")\n",
+    "data.attrs.update({\"valid_min\": arr.min(), \"valid_max\": arr.max(), \"fill_value\": 0})\n",
+    "ds = data.to_dataset(name=\"dataset\")\n",
+    "\n",
+    "ds.to_netcdf(\"dataset_3d.nc\", encoding={\"dataset\": {\"zlib\": True, \"complevel\": 9}})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 4D\n",
+    "arr = numpy.linspace(1, 1000, 1000 * 2000 * 2).reshape(2, 1, 1000, 2000)\n",
+    "data = xarray.DataArray(\n",
+    "    arr,\n",
+    "    dims=(\"time\", \"z\", \"y\", \"x\"),\n",
+    "    coords={\n",
+    "        \"x\": numpy.arange(-170, 170, 0.17),\n",
+    "        \"y\": numpy.arange(-80, 80, 0.16),\n",
+    "        \"z\": [0],\n",
+    "        \"time\": [datetime(2022, 1, 1), datetime(2023, 1, 1)],\n",
+    "    },\n",
+    ")\n",
+    "data.attrs.update({\"valid_min\": arr.min(), \"valid_max\": arr.max(), \"fill_value\": 0})\n",
+    "ds = data.to_dataset(name=\"dataset\")\n",
+    "\n",
+    "ds.to_netcdf(\"dataset_4d.nc\", encoding={\"dataset\": {\"zlib\": True, \"complevel\": 9}})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 3D Zarr\n",
+    "arr = numpy.linspace(0, 1000, 1000 * 2000 * 2).reshape(2, 1000, 2000)\n",
+    "data = xarray.DataArray(\n",
+    "    arr,\n",
+    "    dims=(\"time\", \"y\", \"x\"),\n",
+    "    coords={\n",
+    "        \"x\": numpy.arange(-170, 170, 0.17),\n",
+    "        \"y\": numpy.arange(-80, 80, 0.16),\n",
+    "        \"time\": [datetime(2022, 1, 1), datetime(2023, 1, 1)],\n",
+    "    },\n",
+    ")\n",
+    "data.attrs.update({\"valid_min\": arr.min(), \"valid_max\": arr.max()})\n",
+    "assert data.dims == (\"time\", \"y\", \"x\")\n",
+    "\n",
+    "ds = data.to_dataset(name=\"dataset\")\n",
+    "\n",
+    "ds.to_zarr(\"dataset_3d.zarr\", mode=\"w\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Zarr Pyramid\n",
+    "def create_dataset(decimation: int = 0):\n",
+    "    dec = decimation or 1  # make sure we don't / by 0\n",
+    "    width = 2000 // dec\n",
+    "    height = 1000 // dec\n",
+    "\n",
+    "    x_res = abs(-170 - 170) / width\n",
+    "    y_res = abs(-80 - 80) / height\n",
+    "\n",
+    "    arr = numpy.zeros((height, width), dtype=\"uint8\") + 1 + decimation\n",
+    "\n",
+    "    data = xarray.DataArray(\n",
+    "        arr,\n",
+    "        dims=(\"y\", \"x\"),\n",
+    "        coords={\n",
+    "            \"x\": numpy.arange(-170, 170, x_res),\n",
+    "            \"y\": numpy.arange(-80, 80, y_res),\n",
+    "        },\n",
+    "    )\n",
+    "    data.attrs.update({\"valid_min\": arr.min(), \"valid_max\": arr.max(), \"fill_value\": 0})\n",
+    "    return data.to_dataset(name=\"dataset\")\n",
+    "\n",
+    "\n",
+    "for ix, dec in enumerate([0, 2, 4]):\n",
+    "    ds = create_dataset(dec)\n",
+    "    ds.to_zarr(store=\"pyramid.zarr\", mode=\"w\", group=ix)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import fsspec\n",
+    "from kerchunk.hdf import SingleHdf5ToZarr\n",
+    "\n",
+    "with fsspec.open(\"dataset_3d.nc\", mode=\"rb\", anon=True) as infile:\n",
+    "    h5chunks = SingleHdf5ToZarr(infile, \"dataset_3d.nc\", inline_threshold=100)\n",
+    "\n",
+    "    with open(\"reference.json\", \"w\") as f:\n",
+    "        f.write(json.dumps(h5chunks.translate()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py39",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/.zgroup b/src/titiler/xarray/tests/fixtures/pyramid.zarr/.zgroup
new file mode 100644
index 000000000..3b7daf227
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/.zgroup
@@ -0,0 +1,3 @@
+{
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/.zmetadata b/src/titiler/xarray/tests/fixtures/pyramid.zarr/.zmetadata
new file mode 100644
index 000000000..d5f815b0d
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/.zmetadata
@@ -0,0 +1,263 @@
+{
+    "metadata": {
+        ".zgroup": {
+            "zarr_format": 2
+        },
+        "0/.zattrs": {},
+        "0/.zgroup": {
+            "zarr_format": 2
+        },
+        "0/dataset/.zarray": {
+            "chunks": [
+                250,
+                1000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "|u1",
+            "fill_value": null,
+            "filters": null,
+            "order": "C",
+            "shape": [
+                1000,
+                2000
+            ],
+            "zarr_format": 2
+        },
+        "0/dataset/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "y",
+                "x"
+            ],
+            "fill_value": 0,
+            "valid_max": 1,
+            "valid_min": 1
+        },
+        "0/x/.zarray": {
+            "chunks": [
+                2000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                2000
+            ],
+            "zarr_format": 2
+        },
+        "0/x/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "x"
+            ]
+        },
+        "0/y/.zarray": {
+            "chunks": [
+                1000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                1000
+            ],
+            "zarr_format": 2
+        },
+        "0/y/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "y"
+            ]
+        },
+        "1/.zattrs": {},
+        "1/.zgroup": {
+            "zarr_format": 2
+        },
+        "1/dataset/.zarray": {
+            "chunks": [
+                250,
+                1000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "|u1",
+            "fill_value": null,
+            "filters": null,
+            "order": "C",
+            "shape": [
+                500,
+                1000
+            ],
+            "zarr_format": 2
+        },
+        "1/dataset/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "y",
+                "x"
+            ],
+            "fill_value": 0,
+            "valid_max": 3,
+            "valid_min": 3
+        },
+        "1/x/.zarray": {
+            "chunks": [
+                1000
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                1000
+            ],
+            "zarr_format": 2
+        },
+        "1/x/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "x"
+            ]
+        },
+        "1/y/.zarray": {
+            "chunks": [
+                500
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                500
+            ],
+            "zarr_format": 2
+        },
+        "1/y/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "y"
+            ]
+        },
+        "2/.zattrs": {},
+        "2/.zgroup": {
+            "zarr_format": 2
+        },
+        "2/dataset/.zarray": {
+            "chunks": [
+                250,
+                500
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "|u1",
+            "fill_value": null,
+            "filters": null,
+            "order": "C",
+            "shape": [
+                250,
+                500
+            ],
+            "zarr_format": 2
+        },
+        "2/dataset/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "y",
+                "x"
+            ],
+            "fill_value": 0,
+            "valid_max": 5,
+            "valid_min": 5
+        },
+        "2/x/.zarray": {
+            "chunks": [
+                500
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                500
+            ],
+            "zarr_format": 2
+        },
+        "2/x/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "x"
+            ]
+        },
+        "2/y/.zarray": {
+            "chunks": [
+                250
+            ],
+            "compressor": {
+                "blocksize": 0,
+                "clevel": 5,
+                "cname": "lz4",
+                "id": "blosc",
+                "shuffle": 1
+            },
+            "dtype": "<f8",
+            "fill_value": "NaN",
+            "filters": null,
+            "order": "C",
+            "shape": [
+                250
+            ],
+            "zarr_format": 2
+        },
+        "2/y/.zattrs": {
+            "_ARRAY_DIMENSIONS": [
+                "y"
+            ]
+        }
+    },
+    "zarr_consolidated_format": 1
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/.zattrs
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/.zattrs
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/.zgroup b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/.zgroup
new file mode 100644
index 000000000..3b7daf227
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/.zgroup
@@ -0,0 +1,3 @@
+{
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/.zarray
new file mode 100644
index 000000000..8011735a8
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/.zarray
@@ -0,0 +1,22 @@
+{
+    "chunks": [
+        250,
+        1000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "|u1",
+    "fill_value": null,
+    "filters": null,
+    "order": "C",
+    "shape": [
+        1000,
+        2000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/.zattrs
new file mode 100644
index 000000000..621ae8587
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/.zattrs
@@ -0,0 +1,9 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "y",
+        "x"
+    ],
+    "fill_value": 0,
+    "valid_max": 1,
+    "valid_min": 1
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/0.0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/0.0
new file mode 100644
index 000000000..a4fc70df4
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/0.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/0.1 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/0.1
new file mode 100644
index 000000000..a4fc70df4
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/0.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/1.0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/1.0
new file mode 100644
index 000000000..a4fc70df4
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/1.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/1.1 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/1.1
new file mode 100644
index 000000000..a4fc70df4
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/1.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/2.0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/2.0
new file mode 100644
index 000000000..a4fc70df4
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/2.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/2.1 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/2.1
new file mode 100644
index 000000000..a4fc70df4
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/2.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/3.0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/3.0
new file mode 100644
index 000000000..a4fc70df4
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/3.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/3.1 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/3.1
new file mode 100644
index 000000000..a4fc70df4
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/dataset/3.1 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/.zarray
new file mode 100644
index 000000000..4a4ca60db
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        2000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        2000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/.zattrs
new file mode 100644
index 000000000..4b15671e1
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "x"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/0
new file mode 100644
index 000000000..fc622fb50
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/x/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/.zarray
new file mode 100644
index 000000000..cc70c6c0f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        1000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        1000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/.zattrs
new file mode 100644
index 000000000..64ccf306f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "y"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/0
new file mode 100644
index 000000000..09c474b91
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/0/y/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/.zattrs
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/.zattrs
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/.zgroup b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/.zgroup
new file mode 100644
index 000000000..3b7daf227
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/.zgroup
@@ -0,0 +1,3 @@
+{
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/.zarray
new file mode 100644
index 000000000..783cb8c2a
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/.zarray
@@ -0,0 +1,22 @@
+{
+    "chunks": [
+        250,
+        1000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "|u1",
+    "fill_value": null,
+    "filters": null,
+    "order": "C",
+    "shape": [
+        500,
+        1000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/.zattrs
new file mode 100644
index 000000000..a95e52ce6
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/.zattrs
@@ -0,0 +1,9 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "y",
+        "x"
+    ],
+    "fill_value": 0,
+    "valid_max": 3,
+    "valid_min": 3
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/0.0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/0.0
new file mode 100644
index 000000000..d1aecea66
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/0.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/1.0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/1.0
new file mode 100644
index 000000000..d1aecea66
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/dataset/1.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/.zarray
new file mode 100644
index 000000000..cc70c6c0f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        1000
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        1000
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/.zattrs
new file mode 100644
index 000000000..4b15671e1
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "x"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/0
new file mode 100644
index 000000000..5e1f66ec6
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/x/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/.zarray
new file mode 100644
index 000000000..13b44f5eb
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        500
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        500
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/.zattrs
new file mode 100644
index 000000000..64ccf306f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "y"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/0
new file mode 100644
index 000000000..54c0c1be0
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/1/y/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/.zattrs
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/.zattrs
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/.zgroup b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/.zgroup
new file mode 100644
index 000000000..3b7daf227
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/.zgroup
@@ -0,0 +1,3 @@
+{
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/.zarray
new file mode 100644
index 000000000..a51dab910
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/.zarray
@@ -0,0 +1,22 @@
+{
+    "chunks": [
+        250,
+        500
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "|u1",
+    "fill_value": null,
+    "filters": null,
+    "order": "C",
+    "shape": [
+        250,
+        500
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/.zattrs
new file mode 100644
index 000000000..67d1029bb
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/.zattrs
@@ -0,0 +1,9 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "y",
+        "x"
+    ],
+    "fill_value": 0,
+    "valid_max": 5,
+    "valid_min": 5
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/0.0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/0.0
new file mode 100644
index 000000000..460d0214b
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/dataset/0.0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/.zarray
new file mode 100644
index 000000000..13b44f5eb
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        500
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        500
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/.zattrs
new file mode 100644
index 000000000..4b15671e1
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "x"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/0
new file mode 100644
index 000000000..812363787
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/x/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/.zarray b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/.zarray
new file mode 100644
index 000000000..e4074a34a
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/.zarray
@@ -0,0 +1,20 @@
+{
+    "chunks": [
+        250
+    ],
+    "compressor": {
+        "blocksize": 0,
+        "clevel": 5,
+        "cname": "lz4",
+        "id": "blosc",
+        "shuffle": 1
+    },
+    "dtype": "<f8",
+    "fill_value": "NaN",
+    "filters": null,
+    "order": "C",
+    "shape": [
+        250
+    ],
+    "zarr_format": 2
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/.zattrs b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/.zattrs
new file mode 100644
index 000000000..64ccf306f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/.zattrs
@@ -0,0 +1,5 @@
+{
+    "_ARRAY_DIMENSIONS": [
+        "y"
+    ]
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/0 b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/0
new file mode 100644
index 000000000..20e61f2ac
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/pyramid.zarr/2/y/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/dataset/c/0/0/0/0/0 b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/dataset/c/0/0/0/0/0
new file mode 100644
index 000000000..5a6149609
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/dataset/c/0/0/0/0/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/dataset/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/dataset/zarr.json
new file mode 100644
index 000000000..7a4516ad8
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/dataset/zarr.json
@@ -0,0 +1,55 @@
+{
+  "shape": [
+    2,
+    1,
+    1,
+    33,
+    35
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        2,
+        1,
+        1,
+        33,
+        35
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "time",
+    "universe",
+    "z",
+    "y",
+    "x"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/time/c/0 b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/time/c/0
new file mode 100644
index 000000000..b654ea3ea
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/time/c/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/time/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/time/zarr.json
new file mode 100644
index 000000000..a92fef5d9
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/time/zarr.json
@@ -0,0 +1,46 @@
+{
+  "shape": [
+    2
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        2
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "units": "days since 2022-01-01 00:00:00",
+    "calendar": "proleptic_gregorian"
+  },
+  "dimension_names": [
+    "time"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/universe/c/0 b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/universe/c/0
new file mode 100644
index 000000000..8199ee838
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/universe/c/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/universe/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/universe/zarr.json
new file mode 100644
index 000000000..f10cdfe82
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/universe/zarr.json
@@ -0,0 +1,48 @@
+{
+  "shape": [
+    1
+  ],
+  "data_type": {
+    "name": "fixed_length_utf32",
+    "configuration": {
+      "length_bytes": 36
+    }
+  },
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": "",
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "universe"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/x/c/0 b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/x/c/0
new file mode 100644
index 000000000..ac17695f0
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/x/c/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/x/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/x/zarr.json
new file mode 100644
index 000000000..554fb6b44
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/x/zarr.json
@@ -0,0 +1,43 @@
+{
+  "shape": [
+    35
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        35
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "x"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/y/c/0 b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/y/c/0
new file mode 100644
index 000000000..776eef565
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/y/c/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/y/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/y/zarr.json
new file mode 100644
index 000000000..34a5b009f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/y/zarr.json
@@ -0,0 +1,43 @@
+{
+  "shape": [
+    33
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        33
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "y"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/z/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/z/zarr.json
new file mode 100644
index 000000000..d510e37fd
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/z/zarr.json
@@ -0,0 +1,43 @@
+{
+  "shape": [
+    1
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "z"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/zarr.json
new file mode 100644
index 000000000..a4e1bbe85
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_5d.zarr/zarr.json
@@ -0,0 +1,289 @@
+{
+  "attributes": {},
+  "zarr_format": 3,
+  "consolidated_metadata": {
+    "kind": "inline",
+    "must_understand": false,
+    "metadata": {
+      "dataset": {
+        "shape": [
+          2,
+          1,
+          1,
+          33,
+          35
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              2,
+              1,
+              1,
+              33,
+              35
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "time",
+          "universe",
+          "z",
+          "y",
+          "x"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "time": {
+        "shape": [
+          2
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              2
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "units": "days since 2022-01-01 00:00:00",
+          "calendar": "proleptic_gregorian"
+        },
+        "dimension_names": [
+          "time"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "universe": {
+        "shape": [
+          1
+        ],
+        "data_type": {
+          "name": "fixed_length_utf32",
+          "configuration": {
+            "length_bytes": 36
+          }
+        },
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              1
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": "",
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "universe"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "x": {
+        "shape": [
+          35
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              35
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "x"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "y": {
+        "shape": [
+          33
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              33
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "y"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "z": {
+        "shape": [
+          1
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              1
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "z"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      }
+    }
+  },
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/dataset/c/0/0 b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/dataset/c/0/0
new file mode 100644
index 000000000..7e97d1d73
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/dataset/c/0/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/dataset/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/dataset/zarr.json
new file mode 100644
index 000000000..6c3b63191
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/dataset/zarr.json
@@ -0,0 +1,48 @@
+{
+  "shape": [
+    33,
+    35
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        33,
+        35
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "grid_mapping": "spatial_ref"
+  },
+  "dimension_names": [
+    "y",
+    "x"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/spatial_ref/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/spatial_ref/zarr.json
new file mode 100644
index 000000000..bfae8ad70
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/spatial_ref/zarr.json
@@ -0,0 +1,48 @@
+{
+  "shape": [],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": []
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "crs_wkt": "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AXIS[\"Latitude\",NORTH],AXIS[\"Longitude\",EAST],AUTHORITY[\"EPSG\",\"4326\"]]",
+    "semi_major_axis": 6378137.0,
+    "semi_minor_axis": 6356752.314245179,
+    "inverse_flattening": 298.257223563,
+    "reference_ellipsoid_name": "WGS 84",
+    "longitude_of_prime_meridian": 0.0,
+    "prime_meridian_name": "Greenwich",
+    "geographic_crs_name": "WGS 84",
+    "horizontal_datum_name": "World Geodetic System 1984",
+    "grid_mapping_name": "latitude_longitude",
+    "spatial_ref": "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AXIS[\"Latitude\",NORTH],AXIS[\"Longitude\",EAST],AUTHORITY[\"EPSG\",\"4326\"]]"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/x/c/0 b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/x/c/0
new file mode 100644
index 000000000..ac17695f0
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/x/c/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/x/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/x/zarr.json
new file mode 100644
index 000000000..554fb6b44
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/x/zarr.json
@@ -0,0 +1,43 @@
+{
+  "shape": [
+    35
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        35
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "x"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/y/c/0 b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/y/c/0
new file mode 100644
index 000000000..301dc3603
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/y/c/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/y/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/y/zarr.json
new file mode 100644
index 000000000..34a5b009f
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/y/zarr.json
@@ -0,0 +1,43 @@
+{
+  "shape": [
+    33
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        33
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "y"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/zarr.json
new file mode 100644
index 000000000..99319b8c5
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord.zarr/zarr.json
@@ -0,0 +1,195 @@
+{
+  "attributes": {
+    "grid_mapping": "spatial_ref"
+  },
+  "zarr_format": 3,
+  "consolidated_metadata": {
+    "kind": "inline",
+    "must_understand": false,
+    "metadata": {
+      "dataset": {
+        "shape": [
+          33,
+          35
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              33,
+              35
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "grid_mapping": "spatial_ref"
+        },
+        "dimension_names": [
+          "y",
+          "x"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "spatial_ref": {
+        "shape": [],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": []
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "crs_wkt": "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AXIS[\"Latitude\",NORTH],AXIS[\"Longitude\",EAST],AUTHORITY[\"EPSG\",\"4326\"]]",
+          "semi_major_axis": 6378137.0,
+          "semi_minor_axis": 6356752.314245179,
+          "inverse_flattening": 298.257223563,
+          "reference_ellipsoid_name": "WGS 84",
+          "longitude_of_prime_meridian": 0.0,
+          "prime_meridian_name": "Greenwich",
+          "geographic_crs_name": "WGS 84",
+          "horizontal_datum_name": "World Geodetic System 1984",
+          "grid_mapping_name": "latitude_longitude",
+          "spatial_ref": "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AXIS[\"Latitude\",NORTH],AXIS[\"Longitude\",EAST],AUTHORITY[\"EPSG\",\"4326\"]]"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "x": {
+        "shape": [
+          35
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              35
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "x"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "y": {
+        "shape": [
+          33
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              33
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "y"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      }
+    }
+  },
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/dataset/c/0/0 b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/dataset/c/0/0
new file mode 100644
index 000000000..7e97d1d73
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/dataset/c/0/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/dataset/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/dataset/zarr.json
new file mode 100644
index 000000000..88d8344b6
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/dataset/zarr.json
@@ -0,0 +1,46 @@
+{
+  "shape": [
+    33,
+    35
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        33,
+        35
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "yy",
+    "x"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/x/c/0 b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/x/c/0
new file mode 100644
index 000000000..ac17695f0
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/x/c/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/x/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/x/zarr.json
new file mode 100644
index 000000000..554fb6b44
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/x/zarr.json
@@ -0,0 +1,43 @@
+{
+  "shape": [
+    35
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        35
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "x"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/yy/c/0 b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/yy/c/0
new file mode 100644
index 000000000..776eef565
Binary files /dev/null and b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/yy/c/0 differ
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/yy/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/yy/zarr.json
new file mode 100644
index 000000000..64d7b7441
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/yy/zarr.json
@@ -0,0 +1,43 @@
+{
+  "shape": [
+    33
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        33
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "yy"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/zarr.json b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/zarr.json
new file mode 100644
index 000000000..d79056667
--- /dev/null
+++ b/src/titiler/xarray/tests/fixtures/zarr_invalid_coord_name.zarr/zarr.json
@@ -0,0 +1,143 @@
+{
+  "attributes": {},
+  "zarr_format": 3,
+  "consolidated_metadata": {
+    "kind": "inline",
+    "must_understand": false,
+    "metadata": {
+      "dataset": {
+        "shape": [
+          33,
+          35
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              33,
+              35
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "yy",
+          "x"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "x": {
+        "shape": [
+          35
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              35
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "x"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "yy": {
+        "shape": [
+          33
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              33
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "yy"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      }
+    }
+  },
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/src/titiler/xarray/tests/test_dependencies.py b/src/titiler/xarray/tests/test_dependencies.py
new file mode 100644
index 000000000..7c50d3e3c
--- /dev/null
+++ b/src/titiler/xarray/tests/test_dependencies.py
@@ -0,0 +1,74 @@
+"""test dependencies."""
+
+from fastapi import Depends, FastAPI
+from starlette.testclient import TestClient
+
+from titiler.xarray import dependencies
+
+
+def test_xarray_tile():
+    """Create App."""
+    app = FastAPI()
+
+    @app.get("/")
+    def endpoint(
+        params=Depends(dependencies.CompatXarrayParams),
+    ):
+        """return params."""
+        return params.as_dict()
+
+    with TestClient(app) as client:
+        response = client.get("/")
+        params = response.json()
+        assert params == {}
+
+        response = client.get("/", params={"variable": "yo"})
+        params = response.json()
+        assert params == {"variable": "yo"}
+
+        response = client.get("/", params={"sel": "yo=yo"})
+        params = response.json()
+        assert params == {"sel": ["yo=yo"]}
+
+        response = client.get("/", params={"sel": "yo=1.0"})
+        params = response.json()
+        assert params == {"sel": ["yo=1.0"]}
+
+        response = client.get("/", params={"sel": ["yo=yo", "ye=ye"]})
+        params = response.json()
+        assert params == {"sel": ["yo=yo", "ye=ye"]}
+
+        response = client.get("/?sel=yo=yo&sel=ye=ye")
+        params = response.json()
+        assert params == {"sel": ["yo=yo", "ye=ye"]}
+
+        response = client.get("/", params={"sel": "yo"})
+        assert response.status_code == 422
+
+        response = client.get("/", params={"sel": "=yo"})
+        assert response.status_code == 422
+
+        response = client.get("/", params={"sel": "yo="})
+        assert response.status_code == 422
+
+        response = client.get("/", params={"sel": "time=near::2023-01-01"})
+        assert response.status_code == 422
+
+        response = client.get("/", params={"sel": ["yo=nearest::yo", "ye=ye"]})
+        params = response.json()
+        assert params == {"sel": ["yo=nearest::yo", "ye=ye"]}
+
+        response = client.get(
+            "/", params={"sel": ["yo=nearest::2023-01-01T00:00:00", "ye=ye"]}
+        )
+        params = response.json()
+        assert params == {"sel": ["yo=nearest::2023-01-01T00:00:00", "ye=ye"]}
+
+        response = client.get(
+            "/", params={"sel": ["yo=2023-01-01T00:00:00::nearest", "ye=ye"]}
+        )
+        assert response.status_code == 422
+
+        response = client.get("/", params={"sel": ["yo=2023-01-01T00:00:00", "ye=ye"]})
+        params = response.json()
+        assert params == {"sel": ["yo=2023-01-01T00:00:00", "ye=ye"]}
diff --git a/src/titiler/xarray/tests/test_factory.py b/src/titiler/xarray/tests/test_factory.py
new file mode 100644
index 000000000..6c0448d97
--- /dev/null
+++ b/src/titiler/xarray/tests/test_factory.py
@@ -0,0 +1,570 @@
+"""test titiler.xarray factory."""
+
+import os
+
+import pytest
+from fastapi import FastAPI
+from rasterio.io import MemoryFile
+from starlette.testclient import TestClient
+
+from titiler.xarray.extensions import DatasetMetadataExtension, VariablesExtension
+from titiler.xarray.factory import TilerFactory
+from titiler.xarray.io import FsReader, fs_open_dataset
+
+prefix = os.path.join(os.path.dirname(__file__), "fixtures")
+
+dataset_2d_nc = os.path.join(prefix, "dataset_2d.nc")
+dataset_3d_nc = os.path.join(prefix, "dataset_3d.nc")
+dataset_3d_zarr = os.path.join(prefix, "dataset_3d.zarr")
+dataset_4d_nc = os.path.join(prefix, "dataset_4d.nc")
+zarr_pyramid = os.path.join(prefix, "pyramid.zarr")
+
+
+def test_deprecated_extension():
+    """Test factory with options."""
+    """Test TilerFactory class."""
+    with pytest.warns(DeprecationWarning):
+        md = TilerFactory(extensions=[VariablesExtension()])
+    assert len(md.router.routes) == 16
+
+
+def test_tiler_factory():
+    """Test factory with options."""
+    """Test TilerFactory class."""
+    md = TilerFactory()
+    assert len(md.router.routes) == 15
+
+    with pytest.warns(UserWarning):
+        md = TilerFactory(
+            # /preview, /preview.{format}, /preview/{width}x{height}.{format}
+            add_preview=True,
+        )
+        assert len(md.router.routes) == 18
+
+    md = TilerFactory(
+        router_prefix="/md",
+        # /dataset, /dataset/dict, /dataset/keys
+        extensions=[DatasetMetadataExtension()],
+    )
+    assert len(md.router.routes) == 18
+
+    app = FastAPI()
+    app.include_router(md.router, prefix="/md")
+    client = TestClient(app)
+
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+
+    response = client.get("/docs")
+    assert response.status_code == 200
+
+
+@pytest.fixture
+def app():
+    """App fixture."""
+    md = TilerFactory(
+        router_prefix="/md",
+        extensions=[
+            DatasetMetadataExtension(dataset_opener=fs_open_dataset),
+        ],
+        reader=FsReader,
+    )
+    assert len(md.router.routes) == 18
+
+    app = FastAPI()
+    app.include_router(md.router, prefix="/md")
+    with TestClient(app) as client:
+        yield client
+
+
+@pytest.fixture
+def app_zarr():
+    """App fixture."""
+    md = TilerFactory(
+        router_prefix="/md",
+        extensions=[
+            DatasetMetadataExtension(),
+        ],
+    )
+    assert len(md.router.routes) == 18
+
+    app = FastAPI()
+    app.include_router(md.router, prefix="/md")
+    with TestClient(app) as client:
+        yield client
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [dataset_2d_nc, dataset_3d_nc, dataset_3d_zarr],
+)
+def test_dataset_extension(filename, app):
+    """Test /dataset endpoints."""
+    resp = app.get("/md/dataset/keys", params={"url": filename})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert resp.json() == ["dataset"]
+
+    resp = app.get("/md/dataset/dict", params={"url": filename})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert resp.json()["data_vars"]["dataset"]
+
+    resp = app.get("/md/dataset/", params={"url": filename})
+    assert resp.status_code == 200
+    assert "text/html" in resp.headers["content-type"]
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [dataset_2d_nc, dataset_3d_nc, dataset_3d_zarr],
+)
+def test_info(filename, app):
+    """Test /info endpoints."""
+    # missing variable parameter
+    resp = app.get("/md/info", params={"url": filename})
+    assert resp.status_code == 422
+
+    resp = app.get("/md/info", params={"url": filename, "variable": "dataset"})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+
+    resp = app.get(
+        "/md/info", params={"url": filename, "variable": "dataset", "show_times": True}
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+
+    resp = app.get("/md/info.geojson", params={"url": filename, "variable": "dataset"})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/geo+json"
+
+    resp = app.get(
+        "/md/info.geojson",
+        params={"url": filename, "variable": "dataset", "show_times": True},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/geo+json"
+
+
+def test_info_da_options(app):
+    """Test /info endpoints with Dataarray options."""
+    resp = app.get(
+        "/md/info",
+        params={"url": dataset_4d_nc, "variable": "dataset", "sel": "time=2023-01-01"},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    body = resp.json()
+    assert body["band_descriptions"] == [["b1", "0"]]
+
+    resp = app.get(
+        "/md/info",
+        params={"url": dataset_4d_nc, "variable": "dataset", "sel": "z=0"},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    body = resp.json()
+    assert body["band_descriptions"] == [
+        ["b1", "2022-01-01T00:00:00.000000000"],
+        ["b2", "2023-01-01T00:00:00.000000000"],
+    ]
+
+    resp = app.get(
+        "/md/info",
+        params={
+            "url": dataset_4d_nc,
+            "variable": "dataset",
+            "sel": "z=nearest::1",
+        },
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    body = resp.json()
+    assert body["band_descriptions"] == [
+        ["b1", "2022-01-01T00:00:00.000000000"],
+        ["b2", "2023-01-01T00:00:00.000000000"],
+    ]
+
+    resp = app.get(
+        "/md/info",
+        params={
+            "url": dataset_3d_nc,
+            "variable": "dataset",
+            "sel": "time=2023-01-01",
+            "decode_times": True,
+        },
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    body = resp.json()
+    assert body["band_descriptions"] == [["b1", "2023-01-01T00:00:00.000000000"]]
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [dataset_2d_nc, dataset_3d_nc, dataset_3d_zarr],
+)
+def test_tiles(filename, app):
+    """Test /tiles endpoints."""
+    # missing variable parameter
+    resp = app.get("/md/tiles/WebMercatorQuad/0/0/0", params={"url": filename})
+    assert resp.status_code == 422
+
+    resp = app.get(
+        "/md/tiles/WebMercatorQuad/0/0/0",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/png"
+
+    resp = app.get(
+        "/md/tiles/WebMercatorQuad/0/0/0.jpeg",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/jpeg"
+
+    resp = app.get(
+        "/md/WebMercatorQuad/tilejson.json",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [dataset_2d_nc, dataset_3d_nc, dataset_3d_zarr],
+)
+def test_point(filename, app):
+    """Test /point endpoint."""
+    # missing variable parameter
+    resp = app.get("/md/point/0,0", params={"url": filename})
+    assert resp.status_code == 422
+
+    resp = app.get("/md/point/0,0", params={"url": filename, "variable": "dataset"})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [dataset_2d_nc, dataset_3d_nc, dataset_3d_zarr],
+)
+def test_statistics(filename, app):
+    """Test /statistics endpoint."""
+    feat = {
+        "type": "Feature",
+        "properties": {},
+        "geometry": {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    (-100.0, -25.0),
+                    (40.0, -25.0),
+                    (40.0, 60.0),
+                    (-100.0, 60.0),
+                    (-100.0, -25.0),
+                ]
+            ],
+        },
+    }
+
+    # missing variable parameter
+    resp = app.post("/md/statistics", params={"url": filename}, json=feat)
+    assert resp.status_code == 422
+
+    resp = app.post(
+        "/md/statistics", params={"url": filename, "variable": "dataset"}, json=feat
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/geo+json"
+
+    resp = app.post(
+        "/md/statistics",
+        params={
+            "url": filename,
+            "variable": "dataset",
+            "max_size": 100,
+            "resampling_method": "bilinear",
+        },
+        json=feat,
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/geo+json"
+
+    resp = app.post(
+        "/md/statistics",
+        params={"url": filename, "variable": "dataset", "height": 100, "width": 100},
+        json=feat,
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/geo+json"
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [dataset_2d_nc, dataset_3d_nc, dataset_3d_zarr],
+)
+def test_part(filename, app):
+    """Test /feature and /bbox endpoints."""
+    feat = {
+        "type": "Feature",
+        "properties": {},
+        "geometry": {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    (-100.0, -25.0),
+                    (40.0, -25.0),
+                    (40.0, 60.0),
+                    (-100.0, 60.0),
+                    (-100.0, -25.0),
+                ]
+            ],
+        },
+    }
+
+    # missing variable parameter
+    resp = app.post("/md/feature", params={"url": filename}, json=feat)
+    assert resp.status_code == 422
+
+    resp = app.post(
+        "/md/feature",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+        json=feat,
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/jpeg"
+
+    resp = app.post(
+        "/md/feature.png",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+        json=feat,
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/png"
+
+    resp = app.post(
+        "/md/feature/100x100.png",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+        json=feat,
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/png"
+
+    resp = app.get(
+        "/md/bbox/-100,-25,40,60.jpeg",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/jpeg"
+
+    resp = app.get(
+        "/md/bbox/-100,-25,40,60/100x100.png",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/png"
+
+
+@pytest.mark.parametrize(
+    "group",
+    [0, 1, 2],
+)
+def test_zarr_group(group, app):
+    """Test /tiles endpoints."""
+    resp = app.get(
+        f"/md/tiles/WebMercatorQuad/{group}/0/0.tif",
+        params={"url": zarr_pyramid, "variable": "dataset", "group": str(group)},
+    )
+    assert resp.status_code == 200
+    # see src/titiler/xarray/tests/fixtures/generate_fixtures.ipynb
+    # for structure of zarr pyramid
+    with MemoryFile(resp.content) as mem:
+        with mem.open() as dst:
+            arr = dst.read(1)
+            assert arr.max() == group * 2 + 1
+
+    resp = app.get(
+        "/md/point/0,0",
+        params={"url": zarr_pyramid, "variable": "dataset", "group": str(group)},
+    )
+    assert resp.json()["values"] == [group * 2 + 1]
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [dataset_2d_nc, dataset_3d_nc, dataset_3d_zarr],
+)
+def test_preview(filename):
+    """App fixture."""
+    with pytest.warns(UserWarning):
+        md = TilerFactory(add_preview=True, reader=FsReader)
+
+    app = FastAPI()
+    app.include_router(md.router)
+    with TestClient(app) as client:
+        resp = client.get(
+            "/preview",
+            params={
+                "url": filename,
+                "variable": "dataset",
+                "rescale": "0,500",
+                "bidx": 1,
+            },
+        )
+        assert resp.status_code == 200
+        assert resp.headers["content-type"] == "image/jpeg"
+
+        resp = client.get(
+            "/preview.png",
+            params={
+                "url": filename,
+                "variable": "dataset",
+                "rescale": "0,500",
+                "bidx": 1,
+            },
+        )
+        assert resp.status_code == 200
+        assert resp.headers["content-type"] == "image/png"
+
+        resp = client.get(
+            "/preview/1024x1024.png",
+            params={
+                "url": filename,
+                "variable": "dataset",
+                "rescale": "0,500",
+                "bidx": 1,
+            },
+        )
+        assert resp.status_code == 200
+        assert resp.headers["content-type"] == "image/png"
+        with MemoryFile(resp.content) as mem:
+            with mem.open() as dst:
+                assert dst.width == 1024
+                assert dst.height == 1024
+
+
+def test_app_zarr(app_zarr):
+    """Test endpoints with Zarr Reader."""
+    filename = dataset_3d_zarr
+
+    resp = app_zarr.get("/md/dataset/keys", params={"url": filename})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert resp.json() == ["dataset"]
+
+    resp = app_zarr.get("/md/dataset/dict", params={"url": filename})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert resp.json()["data_vars"]["dataset"]
+
+    resp = app_zarr.get("/md/dataset/", params={"url": filename})
+    assert resp.status_code == 200
+    assert "text/html" in resp.headers["content-type"]
+
+    resp = app_zarr.get("/md/info", params={"url": filename, "variable": "dataset"})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+
+    resp = app_zarr.get(
+        "/md/tiles/WebMercatorQuad/0/0/0",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/png"
+
+    resp = app_zarr.get(
+        "/md/WebMercatorQuad/tilejson.json",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+
+    resp = app_zarr.get(
+        "/md/point/0,0", params={"url": filename, "variable": "dataset"}
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    r = resp.json()
+    assert r["coordinates"] == [0, 0]
+    assert r["band_names"] == ["b1", "b2"]
+    assert r["band_descriptions"] == [
+        "2022-01-01T00:00:00.000000000",
+        "2023-01-01T00:00:00.000000000",
+    ]
+
+    feat = {
+        "type": "Feature",
+        "properties": {},
+        "geometry": {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    (-100.0, -25.0),
+                    (40.0, -25.0),
+                    (40.0, 60.0),
+                    (-100.0, 60.0),
+                    (-100.0, -25.0),
+                ]
+            ],
+        },
+    }
+
+    resp = app_zarr.post(
+        "/md/statistics", params={"url": filename, "variable": "dataset"}, json=feat
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/geo+json"
+
+    feat = {
+        "type": "Feature",
+        "properties": {},
+        "geometry": {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    (-100.0, -25.0),
+                    (40.0, -25.0),
+                    (40.0, 60.0),
+                    (-100.0, 60.0),
+                    (-100.0, -25.0),
+                ]
+            ],
+        },
+    }
+
+    resp = app_zarr.post(
+        "/md/feature",
+        params={"url": filename, "variable": "dataset", "rescale": "0,500", "bidx": 1},
+        json=feat,
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "image/jpeg"
+
+
+@pytest.mark.parametrize(
+    "group",
+    [0, 1, 2],
+)
+def test_group_open_zarr(group, app_zarr):
+    """Test /tiles endpoints."""
+    resp = app_zarr.get(
+        f"/md/tiles/WebMercatorQuad/{group}/0/0.tif",
+        params={"url": zarr_pyramid, "variable": "dataset", "group": str(group)},
+    )
+    assert resp.status_code == 200
+    # see src/titiler/xarray/tests/fixtures/generate_fixtures.ipynb
+    # for structure of zarr pyramid
+    with MemoryFile(resp.content) as mem:
+        with mem.open() as dst:
+            arr = dst.read(1)
+            assert arr.max() == group * 2 + 1
+
+    resp = app_zarr.get(
+        "/md/point/0,0",
+        params={"url": zarr_pyramid, "variable": "dataset", "group": str(group)},
+    )
+    assert resp.json()["values"] == [group * 2 + 1]
diff --git a/src/titiler/xarray/tests/test_io_tools.py b/src/titiler/xarray/tests/test_io_tools.py
new file mode 100644
index 000000000..ba933c960
--- /dev/null
+++ b/src/titiler/xarray/tests/test_io_tools.py
@@ -0,0 +1,411 @@
+"""test titiler.xarray.io utility functions."""
+
+import os
+from datetime import datetime
+from typing import Any
+from urllib.parse import urlparse
+
+import numpy
+import pytest
+import xarray
+
+from titiler.xarray.io import (
+    Reader,
+    _parse_dsl,
+    fs_open_dataset,
+    get_variable,
+    open_zarr,
+)
+
+prefix = os.path.join(os.path.dirname(__file__), "fixtures")
+
+
+def test_get_variable():
+    """test io.get_variable."""
+    arr = numpy.arange(0, 33 * 35 * 2).reshape(2, 33, 35)
+    data = xarray.DataArray(
+        arr,
+        dims=("time", "y", "x"),
+        coords={
+            "x": numpy.arange(-170, 180, 10),
+            "y": numpy.arange(-80, 85, 5),
+            "time": [datetime(2022, 1, 1), datetime(2023, 1, 1)],
+        },
+    )
+    data.attrs.update({"valid_min": arr.min(), "valid_max": arr.max()})
+    assert not data.rio.crs
+    assert data.dims == ("time", "y", "x")
+
+    ds = data.to_dataset(name="dataset")
+    da = get_variable(ds, "dataset")
+    assert da.rio.crs
+    assert da.dims == ("time", "y", "x")
+    assert da["time"].shape == (2,)
+
+    da = get_variable(ds, "dataset", sel=["time=2022-01-01"])
+    assert da.rio.crs
+    assert da.dims == ("y", "x")
+    assert da["time"] == numpy.datetime64("2022-01-01")
+
+    da = get_variable(ds, "dataset", sel=["time=2023-01-01T00:00:00"])
+    assert da.rio.crs
+    assert da.dims == ("y", "x")
+    assert da["time"] == numpy.datetime64("2023-01-01")
+
+    # no time for 2022-12-01T00:00:00
+    with pytest.raises(KeyError):
+        get_variable(ds, "dataset", sel=["time=2022-12-01", "time=2023-01-01"])
+
+    da = get_variable(
+        ds,
+        "dataset",
+        sel=["time=nearest::2022-12-01", "time=nearest::2023-01-01"],
+    )
+    assert da.rio.crs
+    assert da.dims == ("time", "y", "x")
+    assert da["time"].shape == (2,)
+    assert da["time"][0] == numpy.datetime64("2023-01-01")
+    assert da["time"][1] == numpy.datetime64("2023-01-01")
+
+    da = get_variable(ds, "dataset", sel=["time=2022-01-01", "time=2023-01-01"])
+    assert da.rio.crs
+    assert da.dims == ("time", "y", "x")
+    assert da["time"].shape == (2,)
+    assert da["time"][0] == numpy.datetime64("2022-01-01")
+    assert da["time"][1] == numpy.datetime64("2023-01-01")
+
+    # Select the Nearest Time
+    da = get_variable(ds, "dataset", sel=["time=nearest::2024-01-01T01:00:00"])
+    assert da.rio.crs
+    assert da.dims == ("y", "x")
+    assert da["time"] == numpy.datetime64("2023-01-01")
+
+    data = data.rename({"y": "Lat", "x": "Lon"})
+    assert data.dims == ("time", "Lat", "Lon")
+    ds = data.to_dataset(name="dataset")
+    da = get_variable(ds, "dataset")
+    assert da.rio.crs
+    assert da.dims == ("time", "y", "x")
+
+    # 4D dataset
+    arr = numpy.arange(0, 33 * 35 * 2).reshape(2, 1, 33, 35)
+    data = xarray.DataArray(
+        arr,
+        dims=("time", "z", "y", "x"),
+        coords={
+            "x": numpy.arange(-170, 180, 10),
+            "y": numpy.arange(-80, 85, 5),
+            "z": [0],
+            "time": [datetime(2022, 1, 1), datetime(2023, 1, 1)],
+        },
+    )
+    ds = data.to_dataset(name="dataset")
+
+    # We need to reduce the dim
+    with pytest.raises(AssertionError):
+        get_variable(ds, "dataset")
+
+    # Reduce on Z
+    da = get_variable(ds, "dataset", sel=["z=0"])
+    assert da.rio.crs
+    assert da.dims == ("time", "y", "x")
+
+    # 5D dataset
+    arr = numpy.arange(0, 33 * 35 * 2).reshape(2, 1, 1, 33, 35)
+    data = xarray.DataArray(
+        arr,
+        dims=("time", "universe", "z", "y", "x"),
+        coords={
+            "x": numpy.arange(-170, 180, 10),
+            "y": numpy.arange(-80, 85, 5),
+            "z": [0],
+            "universe": ["somewhere"],
+            "time": [datetime(2022, 1, 1), datetime(2023, 1, 1)],
+        },
+    )
+    ds = data.to_dataset(name="dataset")
+    with pytest.raises(AssertionError):
+        get_variable(ds, "dataset")
+
+    with pytest.raises(AssertionError):
+        da = get_variable(ds, "dataset", sel=["universe=somewhere"])
+
+    da = get_variable(ds, "dataset", sel=["universe=somewhere", "time=2022-01-01"])
+    assert da.rio.crs
+    assert da.dims == ("z", "y", "x")
+
+    # 5D dataset
+    arr = numpy.arange(0, 33 * 35 * 2).reshape(2, 1, 1, 33, 35)
+    data = xarray.DataArray(
+        arr,
+        dims=("time", "universe", "z", "y", "x"),
+        coords={
+            "x": numpy.arange(-170, 180, 10),
+            "y": numpy.arange(-80, 85, 5),
+            "z": [0],
+            "universe": ["somewhere"],
+            "time": [datetime(2022, 1, 1), datetime(2023, 1, 1)],
+        },
+    )
+
+    da = get_variable(
+        ds, "dataset", sel=["universe=somewhere", "time=2022-01-01T00:00:00"]
+    )
+    assert da.rio.crs
+    assert da.dims == ("z", "y", "x")
+
+    # 5D dataset
+    arr = numpy.arange(0, 33 * 35 * 2).reshape(2, 33, 35)
+    data = xarray.DataArray(
+        arr,
+        dims=("time", "haut_bas", "gauche_droite"),
+        coords={
+            "gauche_droite": numpy.arange(-170, 180, 10),
+            "haut_bas": numpy.arange(-80, 85, 5),
+            "time": [datetime(2022, 1, 1), datetime(2023, 1, 1)],
+        },
+    )
+
+    ds = data.to_dataset(name="dataset")
+    with pytest.raises(ValueError):
+        da = get_variable(ds, "dataset")
+
+
+def test_get_variable_datetime_tz():
+    """test io.get_variable with datetime and timezones."""
+    arr = numpy.arange(0, 33 * 35 * 2).reshape(2, 33, 35)
+    data = xarray.DataArray(
+        arr,
+        dims=("time", "y", "x"),
+        coords={
+            "x": numpy.arange(-170, 180, 10),
+            "y": numpy.arange(-80, 85, 5),
+            "time": [
+                datetime(2022, 1, 1),
+                datetime(2023, 1, 1),
+            ],
+        },
+    )
+    data.attrs.update({"valid_min": arr.min(), "valid_max": arr.max()})
+    assert not data.rio.crs
+    assert data.dims == ("time", "y", "x")
+    ds = data.to_dataset(name="dataset")
+
+    da = get_variable(ds, "dataset", sel=["time=nearest::2023-01-01T00:00:00"])
+    assert da.rio.crs
+    assert da.dims == ("y", "x")
+    assert da["time"] == numpy.datetime64("2023-01-01")
+
+    da = get_variable(ds, "dataset", sel=["time=nearest::2023-01-01T00:00:00Z"])
+    assert da.rio.crs
+    assert da.dims == ("y", "x")
+    assert da["time"] == numpy.datetime64("2023-01-01")
+
+    da = get_variable(
+        ds,
+        "dataset",
+        sel=["time=nearest::2023-01-01T00:00:00+03:00"],
+    )
+    assert da.rio.crs
+    assert da.dims == ("y", "x")
+    assert da["time"] == numpy.datetime64("2023-01-01")
+
+
+@pytest.mark.parametrize(
+    "protocol,filename",
+    [
+        ("file://", "dataset_2d.nc"),
+        ("file://", "dataset_3d.nc"),
+        ("file://", "dataset_3d.zarr"),
+        ("", "dataset_2d.nc"),
+        ("", "dataset_3d.nc"),
+        ("", "dataset_3d.zarr"),
+    ],
+)
+def test_reader(protocol, filename):
+    """test reader."""
+    src_path = protocol + os.path.join(protocol, prefix, filename)
+    with Reader(src_path, variable="dataset", opener=fs_open_dataset) as src:
+        assert src.info()
+        assert src.tile(0, 0, 0)
+
+    with Reader(src_path, variable="dataset", group="/", opener=fs_open_dataset) as src:
+        assert src.info()
+        assert src.tile(0, 0, 0)
+
+
+def test_opener():
+    """test custom opener"""
+    src_path = "file://" + os.path.join("file://", prefix, "dataset_2d.nc")
+
+    def custom_netcdf_opener(  # noqa: C901
+        src_path: str,
+        special_arg: bool,
+        group: str | None = None,
+        decode_times: bool = True,
+    ) -> xarray.Dataset:
+        """Open Xarray dataset with fsspec.
+
+        Args:
+            src_path (str): dataset path.
+            group (Optional, str): path to the netCDF/Zarr group in the given file to open given as a str.
+            decode_times (bool):  If True, decode times encoded in the standard NetCDF datetime format into datetime objects. Otherwise, leave them encoded as numbers.
+
+        Returns:
+            xarray.Dataset
+
+        """
+        import fsspec  # noqa
+
+        parsed = urlparse(src_path)
+        protocol = parsed.scheme or "file"
+
+        if not special_arg:
+            raise ValueError("you forgot the special_arg :(")
+
+        xr_open_args: dict[str, Any] = {
+            "decode_coords": "all",
+            "decode_times": decode_times,
+            "engine": "h5netcdf",
+            "lock": False,
+        }
+
+        # Argument if we're opening a datatree
+        if group is not None:
+            xr_open_args["group"] = group
+
+        fs = fsspec.filesystem(protocol)
+        ds = xarray.open_dataset(fs.open(src_path), **xr_open_args)
+        return ds
+
+    with Reader(
+        src_path=src_path,
+        opener=custom_netcdf_opener,
+        opener_options={"special_arg": True},
+        variable="dataset",
+    ) as src:
+        assert src.info()
+
+    with pytest.raises(ValueError):
+        with Reader(
+            src_path=src_path,
+            opener=custom_netcdf_opener,
+            opener_options={"special_arg": False},
+            variable="dataset",
+        ) as src:
+            pass
+
+
+@pytest.mark.parametrize(
+    "group",
+    [0, 1, 2],
+)
+def test_zarr_group(group):
+    """test reader."""
+    src_path = os.path.join(prefix, "pyramid.zarr")
+
+    with Reader(src_path, variable="dataset", group=str(group)) as src:
+        assert src.info()
+        assert src.tile(0, 0, 0)
+        assert src.point(0, 0).data[0] == group * 2 + 1
+
+
+@pytest.mark.parametrize(
+    "src_path,options",
+    [
+        ("s3://mur-sst/zarr-v1", {"anon": True}),
+        (
+            "https://nasa-power.s3.amazonaws.com/syn1deg/temporal/power_syn1deg_monthly_temporal_lst.zarr",
+            {},
+        ),
+        (os.path.join(prefix, "dataset_3d.zarr"), {}),
+    ],
+)
+def test_io_fs_open_dataset(src_path, options):
+    """test fs_open_dataset with cloud hosted files."""
+    with fs_open_dataset(src_path, **options) as ds:
+        assert list(ds.data_vars)
+
+
+@pytest.mark.parametrize(
+    "src_path,options",
+    [
+        # Let's assume we don't have S3 Credentials
+        ("s3://mur-sst/zarr-v1", {"skip_signature": True}),
+        ("s3://mur-sst/zarr-v1", {"skip_signature": True, "region": "us-west-2"}),
+        # HTTS url are considered public
+        ("https://mur-sst.s3.us-west-2.amazonaws.com/zarr-v1", {}),
+        # NOTE: https://github.com/developmentseed/obstore/pull/590
+        # (
+        #     "https://nasa-power.s3.amazonaws.com/syn1deg/temporal/power_syn1deg_monthly_temporal_lst.zarr",
+        #     {},
+        # ),
+        (
+            "https://nasa-power.s3.us-west-2.amazonaws.com/syn1deg/temporal/power_syn1deg_monthly_temporal_lst.zarr",
+            {},
+        ),
+        (os.path.join(prefix, "dataset_3d.zarr"), {}),
+    ],
+)
+def test_io_open_zarr(src_path, options):
+    """test open_zarr with cloud hosted files."""
+    with open_zarr(src_path, **options) as ds:
+        assert list(ds.data_vars)
+
+
+@pytest.mark.parametrize(
+    "sel,expected",
+    [
+        (
+            ["time=2022-01-01", "level=10"],
+            [
+                {"dimension": "time", "values": ["2022-01-01"], "method": None},
+                {"dimension": "level", "values": ["10"], "method": None},
+            ],
+        ),
+        (
+            ["time=2022-01-01", "time=2022-01-02"],
+            [
+                {
+                    "dimension": "time",
+                    "values": ["2022-01-01", "2022-01-02"],
+                    "method": None,
+                },
+            ],
+        ),
+        (
+            ["time=pad::2022-01-01", "time=2022-01-02", "level=nearest::10"],
+            [
+                {
+                    "dimension": "time",
+                    "values": ["2022-01-01", "2022-01-02"],
+                    "method": "pad",
+                },
+                {"dimension": "level", "values": ["10"], "method": "nearest"},
+            ],
+        ),
+        (
+            ["time=nearest::2022-01-01T00:00:00", "level=nearest::10"],
+            [
+                {
+                    "dimension": "time",
+                    "values": ["2022-01-01T00:00:00"],
+                    "method": "nearest",
+                },
+                {"dimension": "level", "values": ["10"], "method": "nearest"},
+            ],
+        ),
+        ([], []),
+    ],
+)
+def test_parse_dsl(sel, expected):
+    """test _parse_dsl function."""
+    result = _parse_dsl(sel)
+    assert result == expected
+
+
+def test_parse_dsl_invalid():
+    """Should raise a ValueError when multiple methods are set for a dimension."""
+    sel = ["time=pad::2022-01-01", "time=nearest::2022-01-02"]
+    with pytest.raises(ValueError):
+        _parse_dsl(sel)
diff --git a/src/titiler/xarray/tests/test_validate_extension.py b/src/titiler/xarray/tests/test_validate_extension.py
new file mode 100644
index 000000000..2439e8012
--- /dev/null
+++ b/src/titiler/xarray/tests/test_validate_extension.py
@@ -0,0 +1,105 @@
+"""test titiler.xarray factory."""
+
+import os
+
+import pytest
+from fastapi import FastAPI
+from starlette.testclient import TestClient
+
+from titiler.xarray.extensions import ValidateExtension
+from titiler.xarray.factory import TilerFactory
+
+prefix = os.path.join(os.path.dirname(__file__), "fixtures")
+dataset_3d_zarr = os.path.join(prefix, "dataset_3d.zarr")
+zarr_pyramid = os.path.join(prefix, "pyramid.zarr")
+zarr_coord = os.path.join(prefix, "zarr_invalid_coord.zarr")
+zarr_coord_name = os.path.join(prefix, "zarr_invalid_coord_name.zarr")
+zarr_5d = os.path.join(prefix, "zarr_5d.zarr")
+
+
+@pytest.fixture
+def app_zarr():
+    """App fixture."""
+    md = TilerFactory(
+        router_prefix="/md",
+        extensions=[
+            ValidateExtension(),
+        ],
+    )
+    assert len(md.router.routes) == 16
+
+    app = FastAPI()
+    app.include_router(md.router, prefix="/md")
+    with TestClient(app) as client:
+        yield client
+
+
+def test_validate_extension(app_zarr):
+    """Test /dataset endpoints."""
+    resp = app_zarr.get("/md/validate", params={"url": dataset_3d_zarr})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert list(resp.json()) == ["dataset"]
+    assert resp.json()["dataset"]["compatible_with_titiler"]
+
+    resp = app_zarr.get(
+        "/md/validate", params={"url": dataset_3d_zarr, "variables": "dataset"}
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert list(resp.json()) == ["dataset"]
+    assert resp.json()["dataset"]["compatible_with_titiler"]
+
+    resp = app_zarr.get("/md/validate", params={"url": zarr_pyramid, "group": "0"})
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert list(resp.json()) == ["dataset"]
+    assert resp.json()["dataset"]["compatible_with_titiler"]
+
+    resp = app_zarr.get(
+        "/md/validate",
+        params={"url": zarr_pyramid, "group": "0", "variables": "dataset"},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    assert list(resp.json()) == ["dataset"]
+    assert resp.json()["dataset"]["compatible_with_titiler"]
+
+    resp = app_zarr.get(
+        "/md/validate",
+        params={"url": zarr_coord},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    val = resp.json()
+    assert list(val) == ["dataset"]
+    assert not val["dataset"]["compatible_with_titiler"]
+    assert val["dataset"]["errors"] == [
+        "Dataset bounds are not valid, must be in [-180, 180] and [-90, 90]"
+    ]
+
+    resp = app_zarr.get(
+        "/md/validate",
+        params={"url": zarr_coord},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    val = resp.json()
+    assert list(val) == ["dataset"]
+    assert not val["dataset"]["compatible_with_titiler"]
+    assert val["dataset"]["errors"] == [
+        "Dataset bounds are not valid, must be in [-180, 180] and [-90, 90]"
+    ]
+
+    resp = app_zarr.get(
+        "/md/validate",
+        params={"url": zarr_5d},
+    )
+    assert resp.status_code == 200
+    assert resp.headers["content-type"] == "application/json"
+    val = resp.json()
+    assert list(val) == ["dataset"]
+    assert val["dataset"]["compatible_with_titiler"]
+    assert val["dataset"]["warnings"] == [
+        "DataArray has too many dimension (5) for titiler.xarray, dimensions reduction (sel) will be required."
+    ]
diff --git a/src/titiler/xarray/titiler/xarray/__init__.py b/src/titiler/xarray/titiler/xarray/__init__.py
new file mode 100644
index 000000000..25fcc4fab
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/__init__.py
@@ -0,0 +1,3 @@
+"""titiler.xarray"""
+
+__version__ = "2.0.1"  # x-release-please-version
diff --git a/src/titiler/xarray/titiler/xarray/dependencies.py b/src/titiler/xarray/titiler/xarray/dependencies.py
new file mode 100644
index 000000000..dc8ea6d8d
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/dependencies.py
@@ -0,0 +1,163 @@
+"""titiler.xarray dependencies."""
+
+from dataclasses import dataclass
+from typing import Annotated
+
+import numpy
+from fastapi import Query
+from pydantic import Field
+from pydantic.types import StringConstraints
+from rio_tiler.types import RIOResampling, WarpResampling
+
+from titiler.core.dependencies import DefaultDependency
+
+
+@dataclass
+class XarrayIOParams(DefaultDependency):
+    """Dataset IO Options."""
+
+    group: Annotated[
+        str | None,
+        Query(
+            description="Select a specific zarr group from a zarr hierarchy. Could be associated with a zoom level or dataset."
+        ),
+    ] = None
+
+    decode_times: Annotated[
+        bool | None,
+        Query(
+            title="decode_times",
+            description="Whether to decode times",
+        ),
+    ] = None
+
+
+SelDimStr = Annotated[
+    str,
+    StringConstraints(
+        pattern=r"^[^=]+=((nearest|pad|ffill|backfill|bfill)::)?([^=:]|:[^:])+$"
+    ),
+]
+
+
+@dataclass
+class XarrayDsParams(DefaultDependency):
+    """Xarray Dataset Options."""
+
+    variable: Annotated[str, Query(description="Xarray Variable name.")]
+
+    sel: Annotated[
+        list[SelDimStr] | None,
+        Query(
+            description="Xarray Indexing using dimension names `{dimension}={value}` or `{dimension}={method}::{value}`.",
+        ),
+    ] = None
+
+
+@dataclass
+class XarrayParams(XarrayIOParams, XarrayDsParams):
+    """Xarray Reader dependency."""
+
+    pass
+
+
+@dataclass
+class CompatXarrayParams(XarrayIOParams):
+    """Custom XarrayParams endpoints.
+
+    This Dependency aims to be used in a tiler where both GDAL/Xarray dataset would be supported.
+    By default `variable` won't be required but when using an Xarray dataset,
+    it would fail without the variable query-parameter set.
+    """
+
+    variable: Annotated[str | None, Query(description="Xarray Variable name.")] = None
+
+    sel: Annotated[
+        list[SelDimStr] | None,
+        Query(
+            description="Xarray Indexing using dimension names `{dimension}={value}` or `{dimension}={method}::{value}`.",
+        ),
+    ] = None
+
+
+@dataclass
+class DatasetParams(DefaultDependency):
+    """Low level WarpedVRT Optional parameters."""
+
+    nodata: Annotated[
+        str | int | float | None,
+        Query(
+            title="Nodata value",
+            description="Overwrite internal Nodata value",
+        ),
+    ] = None
+    reproject_method: Annotated[
+        WarpResampling | None,
+        Query(
+            alias="reproject",
+            description="WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.",
+        ),
+    ] = None
+
+    def __post_init__(self):
+        """Post Init."""
+        if self.nodata is not None:
+            self.nodata = numpy.nan if self.nodata == "nan" else float(self.nodata)
+
+
+# Custom PartFeatureParams which add `resampling`
+@dataclass
+class PartFeatureParams(DefaultDependency):
+    """Common parameters for bbox and feature."""
+
+    max_size: Annotated[
+        int | None, Field(description="Maximum image size to read onto.")
+    ] = None
+    height: Annotated[int | None, Field(description="Force output image height.")] = (
+        None
+    )
+    width: Annotated[int | None, Field(description="Force output image width.")] = None
+    resampling_method: Annotated[
+        RIOResampling | None,
+        Query(
+            alias="resampling",
+            description="RasterIO resampling algorithm. Defaults to `nearest`.",
+        ),
+    ] = None
+
+    def __post_init__(self):
+        """Post Init."""
+        if self.width or self.height:
+            self.max_size = None
+
+
+# Custom PreviewParams which add `resampling`
+@dataclass
+class PreviewParams(DefaultDependency):
+    """Common Preview parameters."""
+
+    max_size: Annotated[
+        int | None, Field(description="Maximum image size to read onto.")
+    ] = 1024
+    height: Annotated[int | None, Field(description="Force output image height.")] = (
+        None
+    )
+    width: Annotated[int | None, Field(description="Force output image width.")] = None
+    resampling_method: Annotated[
+        RIOResampling | None,
+        Query(
+            alias="resampling",
+            description="RasterIO resampling algorithm. Defaults to `nearest`.",
+        ),
+    ] = None
+
+    def __post_init__(self):
+        """Post Init."""
+        if self.width or self.height:
+            self.max_size = None
+
+        # NOTE: By default we don't exclude None when we forward the parameter to the preview() method
+        # because we need to be able to pass max_size=None
+        # So we need to set the `resampling_method` to a default = 'nearest'
+        # https://github.com/developmentseed/titiler/blob/b8cc304382d0cb3b4f16cea9dbb0cfba35517085/src/titiler/core/titiler/core/factory.py#L1300
+        self.resampling_method = self.resampling_method or "nearest"
diff --git a/src/titiler/xarray/titiler/xarray/extensions.py b/src/titiler/xarray/titiler/xarray/extensions.py
new file mode 100644
index 000000000..27dfa8a83
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/extensions.py
@@ -0,0 +1,235 @@
+"""titiler.xarray Extensions."""
+
+import sys
+import warnings
+from collections.abc import Callable
+from typing import Annotated
+
+import xarray
+from attrs import define
+from fastapi import Depends, Query
+from rio_tiler.constants import WGS84_CRS
+from starlette.responses import HTMLResponse
+
+from titiler.core.dependencies import DefaultDependency
+from titiler.core.factory import FactoryExtension
+from titiler.core.resources.enums import MediaType
+from titiler.xarray.dependencies import XarrayIOParams
+from titiler.xarray.factory import TilerFactory
+from titiler.xarray.io import X_DIM_NAMES, Y_DIM_NAMES, open_zarr
+
+# Ref: https://docs.pydantic.dev/2.12/errors/usage_errors/#typed-dict-version
+if sys.version_info >= (3, 12):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+
+@define
+class VariablesExtension(FactoryExtension):
+    """Add /variables endpoint to a Xarray TilerFactory."""
+
+    # Custom dependency for /variables
+    io_dependency: type[DefaultDependency] = XarrayIOParams
+    dataset_opener: Callable[..., xarray.Dataset] = open_zarr
+
+    def __attrs_post_init__(self):
+        """raise deprecation warning."""
+        warnings.warn(
+            "VariablesExtension extension is deprecated and will be removed in next titiler version",
+            DeprecationWarning,
+            stacklevel=1,
+        )
+
+    def register(self, factory: TilerFactory):  # type: ignore [override]
+        """Register endpoint to the tiler factory."""
+
+        @factory.router.get(
+            "/variables",
+            response_model=list[str],
+            responses={200: {"description": "Return Xarray Dataset variables."}},
+        )
+        def variables(
+            src_path=Depends(factory.path_dependency),
+            io_params=Depends(self.io_dependency),
+        ):
+            """return available variables."""
+            with self.dataset_opener(src_path, **io_params.as_dict()) as ds:
+                return list(ds.data_vars)  # type: ignore
+
+
+@define
+class DatasetMetadataExtension(FactoryExtension):
+    """Add dataset metadata endpoints to a Xarray TilerFactory."""
+
+    io_dependency: type[DefaultDependency] = XarrayIOParams
+    dataset_opener: Callable[..., xarray.Dataset] = open_zarr
+
+    def register(self, factory: TilerFactory):  # type: ignore [override] # noqa: C901
+        """Register endpoint to the tiler factory."""
+
+        @factory.router.get(
+            "/dataset/",
+            responses={
+                200: {
+                    "description": "Returns the HTML representation of the Xarray Dataset.",
+                    "content": {
+                        MediaType.html.value: {},
+                    },
+                },
+            },
+            response_class=HTMLResponse,
+        )
+        def dataset_metadata_html(
+            src_path=Depends(factory.path_dependency),
+            io_params=Depends(self.io_dependency),
+        ):
+            """Returns the HTML representation of the Xarray Dataset."""
+            with self.dataset_opener(src_path, **io_params.as_dict()) as ds:
+                return HTMLResponse(ds._repr_html_())
+
+        @factory.router.get(
+            "/dataset/dict",
+            responses={
+                200: {"description": "Returns the full Xarray dataset as a dictionary."}
+            },
+        )
+        def dataset_metadata_dict(
+            src_path=Depends(factory.path_dependency),
+            io_params=Depends(self.io_dependency),
+        ):
+            """Returns the full Xarray dataset as a dictionary."""
+            with self.dataset_opener(src_path, **io_params.as_dict()) as ds:
+                return ds.to_dict(data=False)
+
+        @factory.router.get(
+            "/dataset/keys",
+            response_model=list[str],
+            responses={
+                200: {
+                    "description": "Returns the list of keys/variables in the Dataset."
+                }
+            },
+        )
+        def dataset_variables(
+            src_path=Depends(factory.path_dependency),
+            io_params=Depends(self.io_dependency),
+        ):
+            """Returns the list of keys/variables in the Dataset."""
+            with self.dataset_opener(src_path, **io_params.as_dict()) as ds:
+                return list(ds.data_vars)
+
+
+class ValidationInfo(TypedDict):
+    """Variable Validation model."""
+
+    compatible_with_titiler: bool
+    errors: list[str]
+    warnings: list[str]
+
+
+@define
+class ValidateExtension(FactoryExtension):
+    """Add /validate endpoints to a Xarray TilerFactory."""
+
+    io_dependency: type[DefaultDependency] = XarrayIOParams
+    dataset_opener: Callable[..., xarray.Dataset] = open_zarr
+
+    def _validate_variable(self, da: xarray.DataArray) -> ValidationInfo:  # noqa: C901
+        errors: list[str] = []
+        warnings: list[str] = []
+
+        if len(da.dims) not in [2, 3]:
+            warnings.append(
+                f"DataArray has too many dimension ({len(da.dims)}) for titiler.xarray, dimensions reduction (sel) will be required.",
+            )
+
+        if "y" not in da.dims:
+            try:
+                y_dim = next(name for name in Y_DIM_NAMES if name in da.dims)
+                da = da.rename({y_dim: "y"})
+
+            except StopIteration:
+                errors.append(
+                    "Dataset does not have compatible `Y` spatial coordinates"
+                )
+
+        if "x" not in da.dims:
+            try:
+                x_dim = next(name for name in X_DIM_NAMES if name in da.dims)
+                da = da.rename({x_dim: "x"})
+            except StopIteration:
+                errors.append(
+                    "Dataset does not have compatible `X` spatial coordinates"
+                )
+
+        if {"x", "y"}.issubset(set(da.dims)):
+            if extra_dims := [d for d in da.dims if d not in ["x", "y"]]:
+                da = da.transpose(*extra_dims, "y", "x")
+            else:
+                da = da.transpose("y", "x")
+
+            bounds = da.rio.bounds()
+            if not bounds:
+                errors.append("Dataset does not have rioxarray bounds")
+
+            res = da.rio.resolution()
+            if not res:
+                errors.append("Dataset does not have rioxarray resolution")
+
+            if res and bounds:
+                crs = da.rio.crs or "epsg:4326"
+                xres, yres = map(abs, res)
+
+                # Adjust the longitude coordinates to the -180 to 180 range
+                if crs == "epsg:4326" and (da.x > 180 + xres / 2).any():
+                    da = da.assign_coords(x=(da.x + 180) % 360 - 180)
+
+                    # Sort the dataset by the updated longitude coordinates
+                    da = da.sortby(da.x)
+
+                bounds = tuple(da.rio.bounds())
+                if crs == WGS84_CRS and (
+                    bounds[0] + xres / 2 < -180
+                    or bounds[1] + yres / 2 < -90
+                    or bounds[2] - xres / 2 > 180
+                    or bounds[3] - yres / 2 > 90
+                ):
+                    errors.append(
+                        "Dataset bounds are not valid, must be in [-180, 180] and [-90, 90]"
+                    )
+
+            if not da.rio.transform():
+                errors.append("Dataset does not have rioxarray transform")
+
+        return {
+            "compatible_with_titiler": True if not errors else False,
+            "errors": errors,
+            "warnings": warnings,
+        }
+
+    def register(self, factory: TilerFactory):  # type: ignore [override] # noqa: C901
+        """Register endpoint to the tiler factory."""
+
+        @factory.router.get(
+            "/validate",
+            responses={
+                200: {
+                    "content": {
+                        "application/json": {},
+                    },
+                },
+            },
+            response_model=dict[str, ValidationInfo],
+        )
+        def validate_dataset(
+            src_path=Depends(factory.path_dependency),
+            io_params=Depends(self.io_dependency),
+            variables: Annotated[
+                list[str] | None, Query(description="Xarray Variable name.")
+            ] = None,
+        ):
+            """Returns the HTML representation of the Xarray Dataset."""
+            with self.dataset_opener(src_path, **io_params.as_dict()) as dst:
+                variables = variables or list(dst.data_vars)  # type: ignore
+                return {v: self._validate_variable(dst[v]) for v in variables}
diff --git a/src/titiler/xarray/titiler/xarray/factory.py b/src/titiler/xarray/titiler/xarray/factory.py
new file mode 100644
index 000000000..68aab715f
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/factory.py
@@ -0,0 +1,234 @@
+"""TiTiler.xarray factory."""
+
+import logging
+import warnings
+from collections.abc import Callable
+from typing import Annotated, Any
+
+import rasterio
+from attrs import define
+from fastapi import Body, Depends, Query
+from geojson_pydantic.features import Feature, FeatureCollection
+from rio_tiler.constants import WGS84_CRS
+from rio_tiler.io import XarrayReader
+from rio_tiler.models import Info
+
+from titiler.core.dependencies import (
+    BidxParams,
+    CoordCRSParams,
+    CRSParams,
+    DatasetPathParams,
+    DefaultDependency,
+    DstCRSParams,
+    HistogramParams,
+    StatisticsParams,
+)
+from titiler.core.factory import TilerFactory as BaseTilerFactory
+from titiler.core.models.responses import InfoGeoJSON, StatisticsGeoJSON
+from titiler.core.resources.responses import GeoJSONResponse, JSONResponse
+from titiler.core.utils import bounds_to_geometry
+from titiler.xarray.dependencies import (
+    DatasetParams,
+    PartFeatureParams,
+    PreviewParams,
+    XarrayParams,
+)
+from titiler.xarray.io import Reader
+
+logger = logging.getLogger(__name__)
+
+
+@define(kw_only=True)
+class TilerFactory(BaseTilerFactory):
+    """Xarray Tiler Factory."""
+
+    reader: type[XarrayReader] = Reader
+
+    path_dependency: Callable[..., Any] = DatasetPathParams
+
+    reader_dependency: type[DefaultDependency] = XarrayParams
+
+    # Indexes Dependencies
+    layer_dependency: type[DefaultDependency] = BidxParams
+
+    # Dataset Options (nodata, reproject)
+    dataset_dependency: type[DefaultDependency] = DatasetParams
+
+    # Tile/Tilejson/WMTS Dependencies  (Not used in titiler.xarray)
+    tile_dependency: type[DefaultDependency] = DefaultDependency
+
+    # Statistics/Histogram Dependencies
+    stats_dependency: type[DefaultDependency] = StatisticsParams
+    histogram_dependency: type[DefaultDependency] = HistogramParams
+
+    img_preview_dependency: type[DefaultDependency] = PreviewParams
+    img_part_dependency: type[DefaultDependency] = PartFeatureParams
+
+    add_viewer: bool = True
+    add_part: bool = True
+
+    # /map endpoints disabled by default
+    add_ogc_maps: bool = False
+
+    # /preview endpoints disabled by default
+    add_preview: bool = False
+
+    def __attrs_post_init__(self):
+        """Raise warning if preview is enabled."""
+        if self.add_preview:
+            warnings.warn(
+                "`preview` endpoints enabled Xarray based TilerFactory. MultiDim dataset might not be suitable for preview.",
+                UserWarning,
+                stacklevel=1,
+            )
+
+        super().__attrs_post_init__()
+
+    # Custom /info endpoints (adds `show_times` options)
+    def info(self):
+        """Register /info endpoint."""
+
+        @self.router.get(
+            "/info",
+            response_model=Info,
+            response_model_exclude_none=True,
+            response_class=JSONResponse,
+            responses={200: {"description": "Return dataset's basic info."}},
+            operation_id=f"{self.operation_prefix}getInfo",
+        )
+        def info_endpoint(
+            src_path=Depends(self.path_dependency),
+            reader_params=Depends(self.reader_dependency),
+            show_times: Annotated[
+                bool | None,
+                Query(description="Show info about the time dimension"),
+            ] = None,
+            env=Depends(self.environment_dependency),
+        ) -> Info:
+            """Return dataset's basic info."""
+            with rasterio.Env(**env):
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    info = src_dst.info().model_dump()
+                    if show_times and "time" in src_dst.input.dims:
+                        times = [str(x.data) for x in src_dst.input.time]
+                        info["count"] = len(times)
+                        info["times"] = times
+
+            return Info(**info)
+
+        @self.router.get(
+            "/info.geojson",
+            response_model=InfoGeoJSON,
+            response_model_exclude_none=True,
+            response_class=GeoJSONResponse,
+            responses={
+                200: {
+                    "content": {"application/geo+json": {}},
+                    "description": "Return dataset's basic info as a GeoJSON feature.",
+                }
+            },
+            operation_id=f"{self.operation_prefix}getInfoGeoJSON",
+        )
+        def info_geojson(
+            src_path=Depends(self.path_dependency),
+            reader_params=Depends(self.reader_dependency),
+            show_times: Annotated[
+                bool | None,
+                Query(description="Show info about the time dimension"),
+            ] = None,
+            crs=Depends(CRSParams),
+            env=Depends(self.environment_dependency),
+        ):
+            """Return dataset's basic info as a GeoJSON feature."""
+            with rasterio.Env(**env):
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    bounds = src_dst.get_geographic_bounds(crs or WGS84_CRS)
+                    geometry = bounds_to_geometry(bounds)
+                    info = src_dst.info().model_dump()
+                    if show_times and "time" in src_dst.input.dims:
+                        times = [str(x.data) for x in src_dst.input.time]
+                        info["count"] = len(times)
+                        info["times"] = times
+
+            return Feature(
+                type="Feature",
+                bbox=bounds,
+                geometry=geometry,
+                properties=info,
+            )
+
+    # custom /statistics endpoints (remove /statistics - GET)
+    def statistics(self):
+        """add statistics endpoints."""
+
+        # POST endpoint
+        @self.router.post(
+            "/statistics",
+            response_model=StatisticsGeoJSON,
+            response_model_exclude_none=True,
+            response_class=GeoJSONResponse,
+            responses={
+                200: {
+                    "content": {"application/geo+json": {}},
+                    "description": "Return dataset's statistics from feature or featureCollection.",
+                }
+            },
+            operation_id=f"{self.operation_prefix}postStatisticsForGeoJSON",
+        )
+        def geojson_statistics(
+            geojson: Annotated[
+                FeatureCollection | Feature,
+                Body(description="GeoJSON Feature or FeatureCollection."),
+            ],
+            src_path=Depends(self.path_dependency),
+            reader_params=Depends(self.reader_dependency),
+            coord_crs=Depends(CoordCRSParams),
+            dst_crs=Depends(DstCRSParams),
+            layer_params=Depends(self.layer_dependency),
+            dataset_params=Depends(self.dataset_dependency),
+            image_params=Depends(self.img_part_dependency),
+            post_process=Depends(self.process_dependency),
+            stats_params=Depends(self.stats_dependency),
+            histogram_params=Depends(self.histogram_dependency),
+            env=Depends(self.environment_dependency),
+        ):
+            """Get Statistics from a geojson feature or featureCollection."""
+            fc = geojson
+            if isinstance(fc, Feature):
+                fc = FeatureCollection(type="FeatureCollection", features=[geojson])
+
+            with rasterio.Env(**env):
+                logger.info(f"opening data with reader: {self.reader}")
+                with self.reader(src_path, **reader_params.as_dict()) as src_dst:
+                    for feature in fc.features:
+                        shape = feature.model_dump(exclude_none=True)
+                        image = src_dst.feature(
+                            shape,
+                            shape_crs=coord_crs or WGS84_CRS,
+                            dst_crs=dst_crs,
+                            **layer_params.as_dict(),
+                            **image_params.as_dict(),
+                            **dataset_params.as_dict(),
+                        )
+
+                        # Get the coverage % array
+                        coverage_array = image.get_coverage_array(
+                            shape,
+                            shape_crs=coord_crs or WGS84_CRS,
+                        )
+
+                        if post_process:
+                            image = post_process(image)
+
+                        stats = image.statistics(
+                            **stats_params.as_dict(),
+                            hist_options=histogram_params.as_dict(),
+                            coverage=coverage_array,
+                        )
+
+                        feature.properties = feature.properties or {}
+                        feature.properties.update({"statistics": stats})
+
+            return fc.features[0] if isinstance(geojson, Feature) else fc
diff --git a/src/titiler/xarray/titiler/xarray/io.py b/src/titiler/xarray/titiler/xarray/io.py
new file mode 100644
index 000000000..5c080a3eb
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/io.py
@@ -0,0 +1,382 @@
+"""titiler.xarray.io"""
+
+from __future__ import annotations
+
+import os
+import re
+from collections.abc import Callable
+from functools import cache
+from pathlib import Path
+from typing import Any, Literal, TypedDict
+from urllib.parse import urlparse
+
+import attr
+import httpx
+import obstore
+import xarray
+import zarr
+from morecantile import TileMatrixSet
+from rio_tiler.constants import WEB_MERCATOR_TMS
+from rio_tiler.io.xarray import Options, XarrayReader
+from zarr.storage import ObjectStore
+
+X_DIM_NAMES = ["lon", "longitude", "LON", "LONGITUDE", "Lon", "Longitude"]
+Y_DIM_NAMES = ["lat", "latitude", "LAT", "LATITUDE", "Lat", "Latitude"]
+
+
+def _find_bucket_region(bucket: str, use_https: bool = True) -> str | None:
+    prefix = "https" if use_https else "http"
+    response = httpx.get(f"{prefix}://{bucket}.s3.amazonaws.com")
+    return response.headers.get("x-amz-bucket-region")
+
+
+@cache
+def open_zarr(  # noqa: C901
+    src_path: str,
+    group: str | None = None,
+    decode_times: bool = True,
+    decode_coords: str = "all",
+    infer_region: bool = True,
+    **kwargs: Any,
+) -> xarray.Dataset:
+    """Open Xarray dataset with fsspec.
+
+    Args:
+        src_path (str): dataset path.
+        group (Optional, str): path to the netCDF/Zarr group in the given file to open given as a str.
+        decode_times (bool):  If True, decode times encoded in the standard NetCDF datetime format into datetime objects. Otherwise, leave them encoded as numbers.
+
+    Returns:
+        xarray.Dataset
+
+    """
+    parsed = urlparse(src_path)
+    if not parsed.scheme:
+        src_path = str(Path(src_path).resolve())
+        src_path = "file://" + src_path
+
+    # Arguments for xarray.open_dataset
+    # Default args
+    xr_open_args: dict[str, Any] = {
+        "engine": "zarr",
+        "decode_coords": decode_coords,
+        "decode_times": decode_times,
+    }
+
+    # Argument if we're opening a datatree
+    if group is not None:
+        xr_open_args["group"] = group
+
+    config = {**kwargs}
+    # We can't expect the users to pass a REGION so we guess it
+    if parsed.scheme == "s3" or "amazonaws.com" in parsed.netloc:
+        if "region" not in config and infer_region:
+            region_name_env = (
+                os.environ.get("AWS_REGION", os.environ.get("AWS_DEFAULT_REGION"))
+                or None
+            )
+
+            # s3:// urls
+            if parsed.scheme == "s3":
+                config["region"] = _find_bucket_region(parsed.netloc) or region_name_env
+
+            # https://{bucket}.s3.{region}?.amazonaws.com urls
+            else:
+                # We assume that https:// url are public object
+                config["skip_signature"] = True
+
+                # Get Region from URL or guess if needed
+                if expr := re.compile(
+                    r"(?P<bucket>[a-z0-9\.\-_]+)\.s3"
+                    r"(\.dualstack)?"
+                    r"(\.(?P<region>[a-z0-9\-_]+))?"
+                    r"\.amazonaws\.(com|cn)",
+                    re.IGNORECASE,
+                ).match(parsed.netloc):
+                    bucket = expr.groupdict()["bucket"]
+                    if not expr.groupdict().get("region"):
+                        config["region"] = (
+                            _find_bucket_region(bucket) or region_name_env
+                        )
+
+    store = obstore.store.from_url(src_path, config=config)  # type: ignore
+    zarr_store = ObjectStore(store=store, read_only=True)
+    ds = xarray.open_dataset(zarr_store, **xr_open_args)  # type: ignore [arg-type]
+
+    return ds
+
+
+def _arrange_dims(da: xarray.DataArray) -> xarray.DataArray:
+    """Arrange coordinates and time dimensions.
+
+    An rioxarray.exceptions.InvalidDimensionOrder error is raised if the coordinates are not in the correct order time, y, and x.
+    See: https://github.com/corteva/rioxarray/discussions/674
+
+    We conform to using x and y as the spatial dimension names..
+
+    """
+    if "x" not in da.dims and "y" not in da.dims:
+        try:
+            y_dim = next(name for name in Y_DIM_NAMES if name in da.dims)
+            x_dim = next(name for name in X_DIM_NAMES if name in da.dims)
+        except StopIteration as e:
+            raise ValueError(
+                f"Couldn't find X and Y spatial coordinates in {da.dims}"
+            ) from e
+
+        da = da.rename({y_dim: "y", x_dim: "x"})
+
+    if extra_dims := [d for d in da.dims if d not in ["x", "y"]]:
+        da = da.transpose(*extra_dims, "y", "x")
+    else:
+        da = da.transpose("y", "x")
+
+    # If min/max values are stored in `valid_range` we add them in `valid_min/valid_max`
+    vmin, vmax = da.attrs.get("valid_min"), da.attrs.get("valid_max")
+    if "valid_range" in da.attrs and not (vmin is not None and vmax is not None):
+        valid_range = da.attrs.get("valid_range")
+        da.attrs.update({"valid_min": valid_range[0], "valid_max": valid_range[1]})  # type: ignore
+
+    return da
+
+
+class selector(TypedDict):
+    """STAC Item."""
+
+    dimension: str
+    values: list[Any]
+    method: Literal["nearest", "pad", "ffill", "backfill", "bfill"] | None
+
+
+def _parse_dsl(sel: list[str] | None) -> list[selector]:
+    """Parse sel DSL into dictionary.
+
+    Args:
+        sel (list of str, optional): List of Xarray Indexes.
+
+    Returns:
+        list: list of dimension/values/method.
+
+    """
+    sel = sel or []
+
+    _idx: dict[str, list] = {}
+    for s in sel:
+        val: str | slice
+        dim, val = s.split("=")
+
+        if dim in _idx:
+            _idx[dim].append(val)
+        else:
+            _idx[dim] = [val]
+
+    # Loop through all dimension=values selectors
+    # - parse method::value if provided
+    # - check if multiple methods are provided for the same dimension
+    # - cast values to the dimension dtype
+    # - apply the selection
+    selectors: list[selector] = []
+    for dimension, values in _idx.items():
+        methods, values = zip(  # type: ignore
+            *[v.split("::", 1) if "::" in v else (None, v) for v in values]
+        )
+        method_sets = {m for m in methods if m is not None}
+        if len(method_sets) > 1:
+            raise ValueError(
+                f"Multiple selection methods provided for dimension {dimension}: {methods}"
+            )
+        method = method_sets.pop() if method_sets else None
+
+        selectors.append(
+            {
+                "dimension": dimension,
+                "values": list(values),
+                "method": method,
+            }
+        )
+
+    return selectors
+
+
+def get_variable(
+    ds: xarray.Dataset,
+    variable: str,
+    sel: list[str] | None = None,
+) -> xarray.DataArray:
+    """Get Xarray variable as DataArray.
+
+    Args:
+        ds (xarray.Dataset): Xarray Dataset.
+        variable (str): Variable to extract from the Dataset.
+        sel (list of str, optional): List of Xarray Indexes.
+
+    Returns:
+        xarray.DataArray: 2D or 3D DataArray.
+
+    """
+    da = ds[variable]
+
+    for selector in _parse_dsl(sel):
+        dimension = selector["dimension"]
+        values = selector["values"]
+        method = selector["method"]
+
+        # TODO: add more casting
+        # cast string to dtype of the dimension
+        if da[dimension].dtype != "O":
+            values = [da[dimension].dtype.type(v) for v in values]
+
+        da = da.sel(
+            {dimension: values[0] if len(values) < 2 else values},
+            method=method,
+        )
+
+    da = _arrange_dims(da)
+
+    # Make sure we have a valid CRS
+    crs = da.rio.crs or "epsg:4326"
+    da = da.rio.write_crs(crs)
+
+    if crs == "epsg:4326" and (da.x > 180).any():
+        # Adjust the longitude coordinates to the -180 to 180 range
+        da = da.assign_coords(x=(da.x + 180) % 360 - 180)
+
+        # Sort the dataset by the updated longitude coordinates
+        da = da.sortby(da.x)
+
+    assert len(da.dims) in [2, 3], "titiler.xarray can only work with 2D or 3D dataset"
+
+    return da
+
+
+@attr.s
+class Reader(XarrayReader):
+    """Reader: Open Zarr file and access DataArray."""
+
+    src_path: str = attr.ib()
+    variable: str = attr.ib()
+
+    # xarray.Dataset options
+    opener: Callable[..., xarray.Dataset] = attr.ib(default=open_zarr)
+    opener_options: dict = attr.ib(factory=dict)
+
+    group: str | None = attr.ib(default=None)
+    decode_times: bool = attr.ib(default=True)
+
+    # xarray.DataArray options
+    sel: list[str] | None = attr.ib(default=None)
+    method: Literal["nearest", "pad", "ffill", "backfill", "bfill"] | None = attr.ib(
+        default=None
+    )
+
+    tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
+
+    options: Options = attr.ib()
+
+    ds: xarray.Dataset = attr.ib(init=False)
+    input: xarray.DataArray = attr.ib(init=False)
+
+    _dims: list = attr.ib(init=False, factory=list)
+
+    @options.default
+    def _options_default(self):
+        return {}
+
+    def __attrs_post_init__(self):
+        """Set bounds and CRS."""
+        opener_options = {
+            "group": self.group,
+            "decode_times": self.decode_times,
+            **self.opener_options,
+        }
+
+        self.ds = self.opener(self.src_path, **opener_options)
+        self.input = get_variable(
+            self.ds,
+            self.variable,
+            sel=self.sel,
+        )
+        super().__attrs_post_init__()
+
+    def close(self):
+        """Close xarray dataset."""
+        self.ds.close()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Support using with Context Managers."""
+        self.close()
+
+
+def fs_open_dataset(  # noqa: C901
+    src_path: str,
+    group: str | None = None,
+    decode_times: bool = True,
+    decode_coords: str = "all",
+    **kwargs,
+) -> xarray.Dataset:
+    """Open Xarray dataset with fsspec.
+
+    Args:
+        src_path (str): dataset path.
+        group (Optional, str): path to the netCDF/Zarr group in the given file to open given as a str.
+        decode_times (bool):  If True, decode times encoded in the standard NetCDF datetime format into datetime objects. Otherwise, leave them encoded as numbers.
+
+    Returns:
+        xarray.Dataset
+
+    """
+    import fsspec  # noqa
+
+    try:
+        import h5netcdf
+    except ImportError:  # pragma: nocover
+        h5netcdf = None  # type: ignore
+
+    parsed = urlparse(src_path)
+    protocol = parsed.scheme or "file"
+
+    # Arguments for xarray.open_dataset
+    # Default args
+    xr_open_args: dict[str, Any] = {
+        "decode_coords": decode_coords,
+        "decode_times": decode_times,
+    }
+
+    # Argument if we're opening a datatree
+    if group is not None:
+        xr_open_args["group"] = group
+
+    # NetCDF arguments
+    if any(src_path.lower().endswith(ext) for ext in [".nc", ".nc4"]):
+        assert (
+            h5netcdf is not None
+        ), "'h5netcdf' must be installed to read NetCDF dataset"
+
+        xr_open_args.update(
+            {
+                "engine": "h5netcdf",
+                "lock": False,
+            }
+        )
+        fs = fsspec.filesystem(protocol, **kwargs)
+        ds = xarray.open_dataset(fs.open(src_path), **xr_open_args)
+
+    # Fallback to Zarr
+    else:
+        store = zarr.storage.FsspecStore.from_url(
+            src_path, storage_options={"asynchronous": True, **kwargs}
+        )
+        ds = xarray.open_zarr(store, **xr_open_args)
+
+    return ds
+
+
+# Compat
+xarray_open_dataset = fs_open_dataset
+
+
+@attr.s
+class FsReader(Reader):
+    """Reader with fs_open_dataset opener"""
+
+    opener: Callable[..., xarray.Dataset] = attr.ib(default=fs_open_dataset)
diff --git a/src/titiler/xarray/titiler/xarray/main.py b/src/titiler/xarray/titiler/xarray/main.py
new file mode 100644
index 000000000..8984dd951
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/main.py
@@ -0,0 +1,487 @@
+"""titiler.xarray application."""
+
+import json
+import logging
+import os
+from logging import config as log_config
+from typing import Annotated, Literal
+
+import jinja2
+import rasterio
+import xarray
+import zarr
+from fastapi import Depends, FastAPI, HTTPException, Query, Security
+from fastapi.security.api_key import APIKeyQuery
+from pydantic import field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from starlette.middleware.cors import CORSMiddleware
+from starlette.requests import Request
+from starlette.templating import Jinja2Templates
+from starlette_cramjam.middleware import CompressionMiddleware
+
+from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
+from titiler.core.factory import AlgorithmFactory, ColorMapFactory, TMSFactory
+from titiler.core.middleware import (
+    CacheControlMiddleware,
+    LoggerMiddleware,
+    TotalTimeMiddleware,
+)
+from titiler.core.models.OGC import Conformance, Landing
+from titiler.core.resources.enums import MediaType
+from titiler.core.utils import accept_media_type, create_html_response, update_openapi
+from titiler.xarray import __version__ as titiler_version
+from titiler.xarray.extensions import DatasetMetadataExtension, ValidateExtension
+from titiler.xarray.factory import TilerFactory
+
+logging.getLogger("rasterio.session").setLevel(logging.ERROR)
+logging.getLogger("rio-tiler").setLevel(logging.ERROR)
+
+
+class ApiSettings(BaseSettings):
+    """FASTAPI application settings."""
+
+    name: str = "TiTiler with support of Zarr dataset"
+    description: str = """A modern dynamic tile server built on top of FastAPI and Rasterio/GDAL/Xarray for Zarr dataset.
+
+---
+
+**Documentation**: <a href="https://developmentseed.org/titiler/" target="_blank">https://developmentseed.org/titiler/</a>
+
+**Source Code**: <a href="https://github.com/developmentseed/titiler" target="_blank">https://github.com/developmentseed/titiler</a>
+
+---
+    """
+
+    cors_origins: str = "*"
+    cors_allow_methods: str = "GET"
+    cachecontrol: str = "public, max-age=3600"
+    root_path: str = ""
+    debug: bool = False
+
+    template_directory: str | None = None
+
+    telemetry_enabled: bool = False
+
+    # an API key required to access any endpoint, passed via the ?access_token= query parameter
+    global_access_token: str | None = None
+
+    model_config = SettingsConfigDict(
+        env_prefix="TITILER_XARRAY_API_", env_file=".env", extra="ignore"
+    )
+
+    @field_validator("cors_origins")
+    def parse_cors_origin(cls, v):
+        """Parse CORS origins."""
+        return [origin.strip() for origin in v.split(",")]
+
+    @field_validator("cors_allow_methods")
+    def parse_cors_allow_methods(cls, v):
+        """Parse CORS allowed methods."""
+        return [method.strip().upper() for method in v.split(",")]
+
+
+api_settings = ApiSettings()
+
+templates_location: list[jinja2.PackageLoader | jinja2.FileSystemLoader] = (
+    [jinja2.FileSystemLoader(api_settings.template_directory)]
+    if api_settings.template_directory
+    else []
+)
+
+# default template directory
+templates_location.extend(
+    [
+        jinja2.FileSystemLoader(os.path.join(os.path.dirname(__file__), "templates")),
+        jinja2.PackageLoader("titiler.core", "templates"),
+    ]
+)
+
+jinja2_env = jinja2.Environment(
+    autoescape=jinja2.select_autoescape(["html", "xml"]),
+    loader=jinja2.ChoiceLoader(templates_location),
+)
+titiler_templates = Jinja2Templates(env=jinja2_env)
+
+app_dependencies = []
+if api_settings.global_access_token:
+    ###############################################################################
+    # Setup a global API access key, if configured
+    api_key_query = APIKeyQuery(name="access_token", auto_error=False)
+
+    def validate_access_token(access_token: str = Security(api_key_query)):
+        """Validates API key access token, set as the `api_settings.global_access_token` value.
+        Returns True if no access token is required, or if the access token is valid.
+        Raises an HTTPException (401) if the access token is required but invalid/missing.
+        """
+        if not access_token:
+            raise HTTPException(status_code=401, detail="Missing `access_token`")
+
+        # if access_token == `token` then OK
+        if access_token != api_settings.global_access_token:
+            raise HTTPException(status_code=401, detail="Invalid `access_token`")
+
+        return True
+
+    app_dependencies.append(Depends(validate_access_token))
+
+
+app = FastAPI(
+    title=api_settings.name,
+    openapi_url="/api",
+    docs_url="/api.html",
+    description=api_settings.description,
+    version=titiler_version,
+    root_path=api_settings.root_path,
+    dependencies=app_dependencies,
+)
+
+update_openapi(app)
+
+TITILER_CONFORMS_TO = {
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/core",
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/landing-page",
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/oas30",
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/html",
+    "http://www.opengis.net/spec/ogcapi-common-1/1.0/conf/json",
+}
+
+
+md = TilerFactory(
+    extensions=[
+        DatasetMetadataExtension(),
+        ValidateExtension(),
+    ],
+    enable_telemetry=api_settings.telemetry_enabled,
+    templates=titiler_templates,
+)
+app.include_router(md.router, tags=["Multi Dimensional"])
+
+TITILER_CONFORMS_TO.update(md.conforms_to)
+
+# TileMatrixSets endpoints
+tms = TMSFactory(templates=titiler_templates)
+app.include_router(tms.router, tags=["Tiling Schemes"])
+TITILER_CONFORMS_TO.update(tms.conforms_to)
+
+###############################################################################
+# Algorithms endpoints
+algorithms = AlgorithmFactory(templates=titiler_templates)
+app.include_router(
+    algorithms.router,
+    tags=["Algorithms"],
+)
+TITILER_CONFORMS_TO.update(algorithms.conforms_to)
+
+# Colormaps endpoints
+cmaps = ColorMapFactory(templates=titiler_templates)
+app.include_router(
+    cmaps.router,
+    tags=["ColorMaps"],
+)
+TITILER_CONFORMS_TO.update(cmaps.conforms_to)
+
+add_exception_handlers(app, DEFAULT_STATUS_CODES)
+
+# Set all CORS enabled origins
+if api_settings.cors_origins:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=api_settings.cors_origins,
+        allow_credentials=True,
+        allow_methods=api_settings.cors_allow_methods,
+        allow_headers=["*"],
+    )
+
+app.add_middleware(
+    CompressionMiddleware,
+    minimum_size=0,
+    exclude_mediatype={
+        "image/jpeg",
+        "image/jpg",
+        "image/png",
+        "image/jp2",
+        "image/webp",
+    },
+    compression_level=6,
+)
+
+app.add_middleware(
+    CacheControlMiddleware,
+    cachecontrol=api_settings.cachecontrol,
+    exclude_path={r"/healthz"},
+)
+
+
+if api_settings.debug:
+    app.add_middleware(LoggerMiddleware)
+    app.add_middleware(TotalTimeMiddleware)
+
+    log_config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "detailed": {
+                    "format": "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+                },
+                "request": {
+                    "format": (
+                        "%(asctime)s - %(levelname)s - %(name)s - %(message)s "
+                        + json.dumps(
+                            {
+                                k: f"%({k})s"
+                                for k in [
+                                    "http.method",
+                                    "http.referer",
+                                    "http.request.header.origin",
+                                    "http.route",
+                                    "http.target",
+                                    "http.request.header.content-length",
+                                    "http.request.header.accept-encoding",
+                                    "http.request.header.origin",
+                                    "titiler.path_params",
+                                    "titiler.query_params",
+                                ]
+                            }
+                        )
+                    ),
+                },
+            },
+            "handlers": {
+                "console_detailed": {
+                    "class": "logging.StreamHandler",
+                    "level": "WARNING",
+                    "formatter": "detailed",
+                    "stream": "ext://sys.stdout",
+                },
+                "console_request": {
+                    "class": "logging.StreamHandler",
+                    "level": "DEBUG",
+                    "formatter": "request",
+                    "stream": "ext://sys.stdout",
+                },
+            },
+            "loggers": {
+                "titiler": {
+                    "level": "INFO",
+                    "handlers": ["console_detailed"],
+                    "propagate": False,
+                },
+                "titiler.requests": {
+                    "level": "INFO",
+                    "handlers": ["console_request"],
+                    "propagate": False,
+                },
+            },
+        }
+    )
+
+
+@app.get(
+    "/healthz",
+    description="Health Check.",
+    summary="Health Check.",
+    operation_id="healthCheck",
+    tags=["Health Check"],
+)
+def application_health_check():
+    """Health check."""
+    return {
+        "versions": {
+            "titiler": titiler_version,
+            "rasterio": rasterio.__version__,
+            "gdal": rasterio.__gdal_version__,
+            "proj": rasterio.__proj_version__,
+            "geos": rasterio.__geos_version__,
+            "xarray": xarray.__version__,
+            "zarr": zarr.__version__,
+        }
+    }
+
+
+@app.get(
+    "/",
+    response_model=Landing,
+    response_model_exclude_none=True,
+    responses={
+        200: {
+            "content": {
+                "text/html": {},
+                "application/json": {},
+            }
+        },
+    },
+    tags=["OGC Common"],
+)
+def landing(
+    request: Request,
+    f: Annotated[
+        Literal["html", "json"] | None,
+        Query(
+            description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+        ),
+    ] = None,
+):
+    """TiTiler landing page."""
+    data = {
+        "title": "TiTiler + Xarray",
+        "description": "A modern dynamic tile server built on top of FastAPI and Rasterio/GDAL/Xarray for Zarr dataset.",
+        "links": [
+            {
+                "title": "Landing page",
+                "href": str(request.url_for("landing")),
+                "type": "text/html",
+                "rel": "self",
+            },
+            {
+                "title": "The API definition (JSON)",
+                "href": str(request.url_for("openapi")),
+                "type": "application/vnd.oai.openapi+json;version=3.0",
+                "rel": "service-desc",
+            },
+            {
+                "title": "The API documentation",
+                "href": str(request.url_for("swagger_ui_html")),
+                "type": "text/html",
+                "rel": "service-doc",
+            },
+            {
+                "title": "Conformance Declaration",
+                "href": str(request.url_for("conformance")),
+                "type": "text/html",
+                "rel": "http://www.opengis.net/def/rel/ogc/1.0/conformance",
+            },
+            {
+                "title": "List of Available TileMatrixSets",
+                "href": str(request.url_for("tilematrixsets")),
+                "type": "application/json",
+                "rel": "http://www.opengis.net/def/rel/ogc/1.0/tiling-schemes",
+            },
+            {
+                "title": "List of Available Algorithms",
+                "href": str(request.url_for("available_algorithms")),
+                "type": "application/json",
+                "rel": "data",
+            },
+            {
+                "title": "List of Available ColorMaps",
+                "href": str(request.url_for("available_colormaps")),
+                "type": "application/json",
+                "rel": "data",
+            },
+            {
+                "title": "TiTiler Documentation (external link)",
+                "href": "https://developmentseed.org/titiler/",
+                "type": "text/html",
+                "rel": "doc",
+            },
+            {
+                "title": "TiTiler.Xarray source code (external link)",
+                "href": "https://github.com/developmentseed/titiler/tree/main/src/titiler/xarray",
+                "type": "text/html",
+                "rel": "doc",
+            },
+        ],
+    }
+
+    if f:
+        output_type = MediaType[f]
+    else:
+        accepted_media = [MediaType.html, MediaType.json]
+        output_type = (
+            accept_media_type(request.headers.get("accept", ""), accepted_media)
+            or MediaType.json
+        )
+
+    if output_type == MediaType.html:
+        return create_html_response(
+            request,
+            data,
+            title="TiTiler Xarray",
+            template_name="landing",
+            templates=titiler_templates,
+        )
+
+    return data
+
+
+@app.get(
+    "/conformance",
+    response_model=Conformance,
+    response_model_exclude_none=True,
+    responses={
+        200: {
+            "content": {
+                "text/html": {},
+                "application/json": {},
+            }
+        },
+    },
+    tags=["OGC Common"],
+)
+def conformance(
+    request: Request,
+    f: Annotated[
+        Literal["html", "json"] | None,
+        Query(
+            description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
+        ),
+    ] = None,
+):
+    """Conformance classes.
+
+    Called with `GET /conformance`.
+
+    Returns:
+        Conformance classes which the server conforms to.
+
+    """
+    data = {"conformsTo": sorted(TITILER_CONFORMS_TO)}
+
+    if f:
+        output_type = MediaType[f]
+    else:
+        accepted_media = [MediaType.html, MediaType.json]
+        output_type = (
+            accept_media_type(request.headers.get("accept", ""), accepted_media)
+            or MediaType.json
+        )
+
+    if output_type == MediaType.html:
+        return create_html_response(
+            request,
+            data,
+            title="Conformance",
+            template_name="conformance",
+            templates=titiler_templates,
+        )
+
+    return data
+
+
+if api_settings.telemetry_enabled:
+    from opentelemetry import trace
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+    from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+    from opentelemetry.instrumentation.logging import LoggingInstrumentor
+    from opentelemetry.sdk.resources import SERVICE_NAME, SERVICE_VERSION, Resource
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+    LoggingInstrumentor().instrument(set_logging_format=True)
+    FastAPIInstrumentor.instrument_app(app)
+
+    resource = Resource.create(
+        {
+            SERVICE_NAME: "titiler",
+            SERVICE_VERSION: titiler_version,
+        }
+    )
+
+    provider = TracerProvider(resource=resource)
+
+    # uses the OTEL_EXPORTER_OTLP_ENDPOINT env var
+    processor = BatchSpanProcessor(OTLPSpanExporter())
+    provider.add_span_processor(processor)
+
+    trace.set_tracer_provider(provider)
diff --git a/src/titiler/xarray/titiler/xarray/py.typed b/src/titiler/xarray/titiler/xarray/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/titiler/xarray/titiler/xarray/templates/conformance.html b/src/titiler/xarray/titiler/xarray/templates/conformance.html
new file mode 100644
index 000000000..0471b3683
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/templates/conformance.html
@@ -0,0 +1,32 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ template.title }}</h1>
+
+<p>This API implements the conformance classes from standards and community specifications that are listed below.</p>
+
+<h2>Links</h2>
+<ul>
+{% for url in response.conformsTo %}
+  <li> <a target="_blank" href="{{ url }}">{{ url }}</a></li>
+{% endfor %}
+</ul>
+
+{% include "footer.html" %}
diff --git a/src/titiler/xarray/titiler/xarray/templates/header.html b/src/titiler/xarray/titiler/xarray/templates/header.html
new file mode 100644
index 000000000..a60001b62
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/templates/header.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>{{ template.title }}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.3/css/bootstrap.min.css" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.css" />
+    <style>
+      html { position: relative; min-height: 100%; }
+      body { padding-top: 5rem; margin-bottom: 40px; }
+      #page { padding: 1.5rem 1.5rem; }
+      .navbar { border-bottom: 8px solid #3333A4; }
+      .navbar-brand { font-size: 2rem; color: #3333A4 !important; text-shadow: 2px 2px 4px #ccc; }
+      .json-link { font-weight: normal; }
+    </style>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
+    <script src="https://files.dnr.state.mn.us/lib/bootstrap4/javascripts/bootstrap.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.js"></script>
+  </head>
+  <body>
+    <nav class="navbar navbar-expand-md navbar-light fixed-top bg-light">
+      <a href="{{ template.api_root }}" style="width: 35px;height: auto;">
+        <img width=40 src="data:image/png;base64,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" alt="TiTiler">
+      </a>
+      <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbar" aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">
+        <span class="navbar-toggler-icon"></span>
+      </button>
+      <div class="collapse navbar-collapse" id="navbar">
+        <ul class="navbar-nav mr-auto">
+          <li class="nav-item dropdown">
+            <a class="nav-link dropdown-toggle" href="{{ template.api_root }}" id="links" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Links</a>
+            <div class="dropdown-menu" aria-labelledby="account">
+              <a class="dropdown-item" href="{{ template.api_root }}/">Home</a>
+              <a class="dropdown-item" href="{{ template.api_root }}/conformance">Conformance</a>
+              <a class="dropdown-item" href="{{ template.api_root }}/api.html">API Documentation</a>
+            </div>
+          </li>
+        </ul>
+      </div>
+    </nav>
+
+    <main role="main" class="container-fluid">
+      <div id="page">
diff --git a/src/titiler/xarray/titiler/xarray/templates/landing.html b/src/titiler/xarray/titiler/xarray/templates/landing.html
new file mode 100644
index 000000000..f9696c6b8
--- /dev/null
+++ b/src/titiler/xarray/titiler/xarray/templates/landing.html
@@ -0,0 +1,49 @@
+{% include "header.html" %}
+{% if params %}
+  {% set urlq = url + '?' + params + '&' %}
+  {% else %}
+  {% set urlq = url + '?' %}
+{% endif %}
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb bg-light">
+    {% for crumb in crumbs %}
+      {% if not loop.last %}
+    <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
+      {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
+      {% endif %}
+    {% endfor %}
+
+    <li class="ml-auto json-link"><a target="_blank" href="{{ urlq }}f=json">JSON</a></li>
+  </ol>
+</nav>
+
+<h1>{{ response.title }}</h1>
+<p>
+  {{ response.description }}
+</p>
+
+<pre>
+   __     __   __     __ __                                                                                
+  |  \   |  \ |  \   |  \  \                                                                               
+ _| ▓▓_   \▓▓_| ▓▓_   \▓▓ ▓▓ ______   ______         __    __  ______   ______   ______   ______  __    __ 
+|   ▓▓ \ |  \   ▓▓ \ |  \ ▓▓/      \ /      \       |  \  /  \|      \ /      \ /      \ |      \|  \  |  \
+ \▓▓▓▓▓▓ | ▓▓\▓▓▓▓▓▓ | ▓▓ ▓▓  ▓▓▓▓▓▓\  ▓▓▓▓▓▓\      \\▓▓\/  ▓▓ \▓▓▓▓▓▓\  ▓▓▓▓▓▓\  ▓▓▓▓▓▓\ \▓▓▓▓▓▓\ ▓▓  | ▓▓
+  | ▓▓ __| ▓▓ | ▓▓ __| ▓▓ ▓▓ ▓▓    ▓▓ ▓▓              >▓▓  ▓▓ /      ▓▓ ▓▓   \▓▓ ▓▓   \▓▓/      ▓▓ ▓▓  | ▓▓
+  | ▓▓|  \ ▓▓ | ▓▓|  \ ▓▓ ▓▓ ▓▓▓▓▓▓▓▓ ▓▓      ▓▓▓▓▓▓ /  ▓▓▓▓\|  ▓▓▓▓▓▓▓ ▓▓     | ▓▓     |  ▓▓▓▓▓▓▓ ▓▓__/ ▓▓
+   \▓▓  ▓▓ ▓▓  \▓▓  ▓▓ ▓▓ ▓▓\▓▓     \ ▓▓            |  ▓▓ \▓▓\\▓▓    ▓▓ ▓▓     | ▓▓      \▓▓    ▓▓\▓▓    ▓▓
+    \▓▓▓▓ \▓▓   \▓▓▓▓ \▓▓\▓▓ \▓▓▓▓▓▓▓\▓▓             \▓▓   \▓▓ \▓▓▓▓▓▓▓\▓▓      \▓▓       \▓▓▓▓▓▓▓_\▓▓▓▓▓▓▓
+                                                                                                 |  \__| ▓▓
+                                                                                                  \▓▓    ▓▓
+                                                                                                   \▓▓▓▓▓▓ 
+
+  </pre>
+
+<h2>Links</h2>
+<ul>
+{% for link in response.links %}
+  <li> <a href="{{ link.href }}">{{ link.title or link.rel }}</a></li>
+{% endfor %}
+</ul>
+
+{% include "footer.html" %}
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 000000000..0ace14e43
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,6250 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+resolution-markers = [
+    "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.13.*' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.12.*' and sys_platform == 'win32'",
+    "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version < '3.12' and sys_platform == 'win32'",
+    "python_full_version < '3.12' and sys_platform == 'emscripten'",
+    "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+
+[manifest]
+members = [
+    "titiler",
+    "titiler-application",
+    "titiler-core",
+    "titiler-extensions",
+    "titiler-mosaic",
+    "titiler-xarray",
+]
+
+[[package]]
+name = "affine"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/69/98/d2f0bb06385069e799fc7d2870d9e078cfa0fa396dc8a2b81227d0da08b9/affine-2.4.0.tar.gz", hash = "sha256:a24d818d6a836c131976d22f8c27b8d3ca32d0af64c1d8d29deb7bafa4da1eea", size = 17132, upload-time = "2023-01-19T23:44:30.696Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/f7/85273299ab57117850cc0a936c64151171fac4da49bc6fba0dad984a7c5f/affine-2.4.0-py3-none-any.whl", hash = "sha256:8a3df80e2b2378aef598a83c1392efd47967afec4242021a0b06b4c7cbc61a92", size = 15662, upload-time = "2023-01-19T23:44:28.833Z" },
+]
+
+[[package]]
+name = "aiobotocore"
+version = "3.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "aioitertools" },
+    { name = "botocore" },
+    { name = "jmespath" },
+    { name = "multidict" },
+    { name = "python-dateutil" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/9f/a0568deaf008f4a7e3d57a7f80f1537df894df0e49bd4a790bb22f9a2d8e/aiobotocore-3.3.0.tar.gz", hash = "sha256:9abc21d91edd6c9c2e4a07e11bdfcbb159f0b9116ab2a0a5a349113533a18fb2", size = 122940, upload-time = "2026-03-18T09:58:49.077Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/54/a295bd8d7ac900c339b2c7024ed0ff9538afb60e92eb0979b8bb49deb20e/aiobotocore-3.3.0-py3-none-any.whl", hash = "sha256:9125ab2b63740dfe3b66b8d5a90d13aed9587b850aa53225ef214a04a1aa7fdc", size = 87817, upload-time = "2026-03-18T09:58:47.466Z" },
+]
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/4a/064321452809dae953c1ed6e017504e72551a26b6f5708a5a80e4bf556ff/aiohttp-3.13.4.tar.gz", hash = "sha256:d97a6d09c66087890c2ab5d49069e1e570583f7ac0314ecf98294c1b6aaebd38", size = 7859748, upload-time = "2026-03-28T17:19:40.6Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/7e/cb94129302d78c46662b47f9897d642fd0b33bdfef4b73b20c6ced35aa4c/aiohttp-3.13.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8ea0c64d1bcbf201b285c2246c51a0c035ba3bbd306640007bc5844a3b4658c1", size = 760027, upload-time = "2026-03-28T17:15:33.022Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/cd/2db3c9397c3bd24216b203dd739945b04f8b87bb036c640da7ddb63c75ef/aiohttp-3.13.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6f742e1fa45c0ed522b00ede565e18f97e4cf8d1883a712ac42d0339dfb0cce7", size = 508325, upload-time = "2026-03-28T17:15:34.714Z" },
+    { url = "https://files.pythonhosted.org/packages/36/a3/d28b2722ec13107f2e37a86b8a169897308bab6a3b9e071ecead9d67bd9b/aiohttp-3.13.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dcfb50ee25b3b7a1222a9123be1f9f89e56e67636b561441f0b304e25aaef8f", size = 502402, upload-time = "2026-03-28T17:15:36.409Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/d6/acd47b5f17c4430e555590990a4746efbcb2079909bb865516892bf85f37/aiohttp-3.13.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3262386c4ff370849863ea93b9ea60fd59c6cf56bf8f93beac625cf4d677c04d", size = 1771224, upload-time = "2026-03-28T17:15:38.223Z" },
+    { url = "https://files.pythonhosted.org/packages/98/af/af6e20113ba6a48fd1cd9e5832c4851e7613ef50c7619acdaee6ec5f1aff/aiohttp-3.13.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:473bb5aa4218dd254e9ae4834f20e31f5a0083064ac0136a01a62ddbae2eaa42", size = 1731530, upload-time = "2026-03-28T17:15:39.988Z" },
+    { url = "https://files.pythonhosted.org/packages/81/16/78a2f5d9c124ad05d5ce59a9af94214b6466c3491a25fb70760e98e9f762/aiohttp-3.13.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e56423766399b4c77b965f6aaab6c9546617b8994a956821cc507d00b91d978c", size = 1827925, upload-time = "2026-03-28T17:15:41.944Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/1f/79acf0974ced805e0e70027389fccbb7d728e6f30fcac725fb1071e63075/aiohttp-3.13.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8af249343fafd5ad90366a16d230fc265cf1149f26075dc9fe93cfd7c7173942", size = 1923579, upload-time = "2026-03-28T17:15:44.071Z" },
+    { url = "https://files.pythonhosted.org/packages/af/53/29f9e2054ea6900413f3b4c3eb9d8331f60678ec855f13ba8714c47fd48d/aiohttp-3.13.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bc0a5cf4f10ef5a2c94fdde488734b582a3a7a000b131263e27c9295bd682d9", size = 1767655, upload-time = "2026-03-28T17:15:45.911Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/57/462fe1d3da08109ba4aa8590e7aed57c059af2a7e80ec21f4bac5cfe1094/aiohttp-3.13.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5c7ff1028e3c9fc5123a865ce17df1cb6424d180c503b8517afbe89aa566e6be", size = 1630439, upload-time = "2026-03-28T17:15:48.11Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/4b/4813344aacdb8127263e3eec343d24e973421143826364fa9fc847f6283f/aiohttp-3.13.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ba5cf98b5dcb9bddd857da6713a503fa6d341043258ca823f0f5ab7ab4a94ee8", size = 1745557, upload-time = "2026-03-28T17:15:50.13Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/01/1ef1adae1454341ec50a789f03cfafe4c4ac9c003f6a64515ecd32fe4210/aiohttp-3.13.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:d85965d3ba21ee4999e83e992fecb86c4614d6920e40705501c0a1f80a583c12", size = 1741796, upload-time = "2026-03-28T17:15:52.351Z" },
+    { url = "https://files.pythonhosted.org/packages/22/04/8cdd99af988d2aa6922714d957d21383c559835cbd43fbf5a47ddf2e0f05/aiohttp-3.13.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:49f0b18a9b05d79f6f37ddd567695943fcefb834ef480f17a4211987302b2dc7", size = 1805312, upload-time = "2026-03-28T17:15:54.407Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/7f/b48d5577338d4b25bbdbae35c75dbfd0493cb8886dc586fbfb2e90862239/aiohttp-3.13.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7f78cb080c86fbf765920e5f1ef35af3f24ec4314d6675d0a21eaf41f6f2679c", size = 1621751, upload-time = "2026-03-28T17:15:56.564Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/89/4eecad8c1858e6d0893c05929e22343e0ebe3aec29a8a399c65c3cc38311/aiohttp-3.13.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:67a3ec705534a614b68bbf1c70efa777a21c3da3895d1c44510a41f5a7ae0453", size = 1826073, upload-time = "2026-03-28T17:15:58.489Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/9dc8293ed31b46c39c9c513ac7ca152b3c3d38e0ea111a530ad12001b827/aiohttp-3.13.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d6630ec917e85c5356b2295744c8a97d40f007f96a1c76bf1928dc2e27465393", size = 1760083, upload-time = "2026-03-28T17:16:00.677Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/19/8bbf6a4994205d96831f97b7d21a0feed120136e6267b5b22d229c6dc4dc/aiohttp-3.13.4-cp311-cp311-win32.whl", hash = "sha256:54049021bc626f53a5394c29e8c444f726ee5a14b6e89e0ad118315b1f90f5e3", size = 439690, upload-time = "2026-03-28T17:16:02.902Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f5/ac409ecd1007528d15c3e8c3a57d34f334c70d76cfb7128a28cffdebd4c1/aiohttp-3.13.4-cp311-cp311-win_amd64.whl", hash = "sha256:c033f2bc964156030772d31cbf7e5defea181238ce1f87b9455b786de7d30145", size = 463824, upload-time = "2026-03-28T17:16:05.058Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bd/ede278648914cabbabfdf95e436679b5d4156e417896a9b9f4587169e376/aiohttp-3.13.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ee62d4471ce86b108b19c3364db4b91180d13fe3510144872d6bad5401957360", size = 752158, upload-time = "2026-03-28T17:16:06.901Z" },
+    { url = "https://files.pythonhosted.org/packages/90/de/581c053253c07b480b03785196ca5335e3c606a37dc73e95f6527f1591fe/aiohttp-3.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c0fd8f41b54b58636402eb493afd512c23580456f022c1ba2db0f810c959ed0d", size = 501037, upload-time = "2026-03-28T17:16:08.82Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f9/a5ede193c08f13cc42c0a5b50d1e246ecee9115e4cf6e900d8dbd8fd6acb/aiohttp-3.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4baa48ce49efd82d6b1a0be12d6a36b35e5594d1dd42f8bfba96ea9f8678b88c", size = 501556, upload-time = "2026-03-28T17:16:10.63Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/10/88ff67cd48a6ec36335b63a640abe86135791544863e0cfe1f065d6cef7a/aiohttp-3.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d738ebab9f71ee652d9dbd0211057690022201b11197f9a7324fd4dba128aa97", size = 1757314, upload-time = "2026-03-28T17:16:12.498Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/15/fdb90a5cf5a1f52845c276e76298c75fbbcc0ac2b4a86551906d54529965/aiohttp-3.13.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0ce692c3468fa831af7dceed52edf51ac348cebfc8d3feb935927b63bd3e8576", size = 1731819, upload-time = "2026-03-28T17:16:14.558Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/df/28146785a007f7820416be05d4f28cc207493efd1e8c6c1068e9bdc29198/aiohttp-3.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8e08abcfe752a454d2cb89ff0c08f2d1ecd057ae3e8cc6d84638de853530ebab", size = 1793279, upload-time = "2026-03-28T17:16:16.594Z" },
+    { url = "https://files.pythonhosted.org/packages/10/47/689c743abf62ea7a77774d5722f220e2c912a77d65d368b884d9779ef41b/aiohttp-3.13.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5977f701b3fff36367a11087f30ea73c212e686d41cd363c50c022d48b011d8d", size = 1891082, upload-time = "2026-03-28T17:16:18.71Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/b6/f7f4f318c7e58c23b761c9b13b9a3c9b394e0f9d5d76fbc6622fa98509f6/aiohttp-3.13.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:54203e10405c06f8b6020bd1e076ae0fe6c194adcee12a5a78af3ffa3c57025e", size = 1773938, upload-time = "2026-03-28T17:16:21.125Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/06/f207cb3121852c989586a6fc16ff854c4fcc8651b86c5d3bd1fc83057650/aiohttp-3.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:358a6af0145bc4dda037f13167bef3cce54b132087acc4c295c739d05d16b1c3", size = 1579548, upload-time = "2026-03-28T17:16:23.588Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/58/e1289661a32161e24c1fe479711d783067210d266842523752869cc1d9c2/aiohttp-3.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:898ea1850656d7d61832ef06aa9846ab3ddb1621b74f46de78fbc5e1a586ba83", size = 1714669, upload-time = "2026-03-28T17:16:25.713Z" },
+    { url = "https://files.pythonhosted.org/packages/96/0a/3e86d039438a74a86e6a948a9119b22540bae037d6ba317a042ae3c22711/aiohttp-3.13.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7bc30cceb710cf6a44e9617e43eebb6e3e43ad855a34da7b4b6a73537d8a6763", size = 1754175, upload-time = "2026-03-28T17:16:28.18Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/30/e717fc5df83133ba467a560b6d8ef20197037b4bb5d7075b90037de1018e/aiohttp-3.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4a31c0c587a8a038f19a4c7e60654a6c899c9de9174593a13e7cc6e15ff271f9", size = 1762049, upload-time = "2026-03-28T17:16:30.941Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/28/8f7a2d4492e336e40005151bdd94baf344880a4707573378579f833a64c1/aiohttp-3.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2062f675f3fe6e06d6113eb74a157fb9df58953ffed0cdb4182554b116545758", size = 1570861, upload-time = "2026-03-28T17:16:32.953Z" },
+    { url = "https://files.pythonhosted.org/packages/78/45/12e1a3d0645968b1c38de4b23fdf270b8637735ea057d4f84482ff918ad9/aiohttp-3.13.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d1ba8afb847ff80626d5e408c1fdc99f942acc877d0702fe137015903a220a9", size = 1790003, upload-time = "2026-03-28T17:16:35.468Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/0f/60374e18d590de16dcb39d6ff62f39c096c1b958e6f37727b5870026ea30/aiohttp-3.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b08149419994cdd4d5eecf7fd4bc5986b5a9380285bcd01ab4c0d6bfca47b79d", size = 1737289, upload-time = "2026-03-28T17:16:38.187Z" },
+    { url = "https://files.pythonhosted.org/packages/02/bf/535e58d886cfbc40a8b0013c974afad24ef7632d645bca0b678b70033a60/aiohttp-3.13.4-cp312-cp312-win32.whl", hash = "sha256:fc432f6a2c4f720180959bc19aa37259651c1a4ed8af8afc84dd41c60f15f791", size = 434185, upload-time = "2026-03-28T17:16:40.735Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/1a/d92e3325134ebfff6f4069f270d3aac770d63320bd1fcd0eca023e74d9a8/aiohttp-3.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:6148c9ae97a3e8bff9a1fc9c757fa164116f86c100468339730e717590a3fb77", size = 461285, upload-time = "2026-03-28T17:16:42.713Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/ac/892f4162df9b115b4758d615f32ec63d00f3084c705ff5526630887b9b42/aiohttp-3.13.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:63dd5e5b1e43b8fb1e91b79b7ceba1feba588b317d1edff385084fcc7a0a4538", size = 745744, upload-time = "2026-03-28T17:16:44.67Z" },
+    { url = "https://files.pythonhosted.org/packages/97/a9/c5b87e4443a2f0ea88cb3000c93a8fdad1ee63bffc9ded8d8c8e0d66efc6/aiohttp-3.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:746ac3cc00b5baea424dacddea3ec2c2702f9590de27d837aa67004db1eebc6e", size = 498178, upload-time = "2026-03-28T17:16:46.766Z" },
+    { url = "https://files.pythonhosted.org/packages/94/42/07e1b543a61250783650df13da8ddcdc0d0a5538b2bd15cef6e042aefc61/aiohttp-3.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bda8f16ea99d6a6705e5946732e48487a448be874e54a4f73d514660ff7c05d3", size = 498331, upload-time = "2026-03-28T17:16:48.9Z" },
+    { url = "https://files.pythonhosted.org/packages/20/d6/492f46bf0328534124772d0cf58570acae5b286ea25006900650f69dae0e/aiohttp-3.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4b061e7b5f840391e3f64d0ddf672973e45c4cfff7a0feea425ea24e51530fc2", size = 1744414, upload-time = "2026-03-28T17:16:50.968Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/4d/e02627b2683f68051246215d2d62b2d2f249ff7a285e7a858dc47d6b6a14/aiohttp-3.13.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b252e8d5cd66184b570d0d010de742736e8a4fab22c58299772b0c5a466d4b21", size = 1719226, upload-time = "2026-03-28T17:16:53.173Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/6c/5d0a3394dd2b9f9aeba6e1b6065d0439e4b75d41f1fb09a3ec010b43552b/aiohttp-3.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20af8aad61d1803ff11152a26146d8d81c266aa8c5aa9b4504432abb965c36a0", size = 1782110, upload-time = "2026-03-28T17:16:55.362Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/2d/c20791e3437700a7441a7edfb59731150322424f5aadf635602d1d326101/aiohttp-3.13.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:13a5cc924b59859ad2adb1478e31f410a7ed46e92a2a619d6d1dd1a63c1a855e", size = 1884809, upload-time = "2026-03-28T17:16:57.734Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/94/d99dbfbd1924a87ef643833932eb2a3d9e5eee87656efea7d78058539eff/aiohttp-3.13.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:534913dfb0a644d537aebb4123e7d466d94e3be5549205e6a31f72368980a81a", size = 1764938, upload-time = "2026-03-28T17:17:00.221Z" },
+    { url = "https://files.pythonhosted.org/packages/49/61/3ce326a1538781deb89f6cf5e094e2029cd308ed1e21b2ba2278b08426f6/aiohttp-3.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:320e40192a2dcc1cf4b5576936e9652981ab596bf81eb309535db7e2f5b5672f", size = 1570697, upload-time = "2026-03-28T17:17:02.985Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/77/4ab5a546857bb3028fbaf34d6eea180267bdab022ee8b1168b1fcde4bfdd/aiohttp-3.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9e587fcfce2bcf06526a43cb705bdee21ac089096f2e271d75de9c339db3100c", size = 1702258, upload-time = "2026-03-28T17:17:05.28Z" },
+    { url = "https://files.pythonhosted.org/packages/79/63/d8f29021e39bc5af8e5d5e9da1b07976fb9846487a784e11e4f4eeda4666/aiohttp-3.13.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:9eb9c2eea7278206b5c6c1441fdd9dc420c278ead3f3b2cc87f9b693698cc500", size = 1740287, upload-time = "2026-03-28T17:17:07.712Z" },
+    { url = "https://files.pythonhosted.org/packages/55/3a/cbc6b3b124859a11bc8055d3682c26999b393531ef926754a3445b99dfef/aiohttp-3.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:29be00c51972b04bf9d5c8f2d7f7314f48f96070ca40a873a53056e652e805f7", size = 1753011, upload-time = "2026-03-28T17:17:10.053Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/30/836278675205d58c1368b21520eab9572457cf19afd23759216c04483048/aiohttp-3.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90c06228a6c3a7c9f776fe4fc0b7ff647fffd3bed93779a6913c804ae00c1073", size = 1566359, upload-time = "2026-03-28T17:17:12.433Z" },
+    { url = "https://files.pythonhosted.org/packages/50/b4/8032cc9b82d17e4277704ba30509eaccb39329dc18d6a35f05e424439e32/aiohttp-3.13.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:a533ec132f05fd9a1d959e7f34184cd7d5e8511584848dab85faefbaac573069", size = 1785537, upload-time = "2026-03-28T17:17:14.721Z" },
+    { url = "https://files.pythonhosted.org/packages/17/7d/5873e98230bde59f493bf1f7c3e327486a4b5653fa401144704df5d00211/aiohttp-3.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1c946f10f413836f82ea4cfb90200d2a59578c549f00857e03111cf45ad01ca5", size = 1740752, upload-time = "2026-03-28T17:17:17.387Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/f2/13e46e0df051494d7d3c68b7f72d071f48c384c12716fc294f75d5b1a064/aiohttp-3.13.4-cp313-cp313-win32.whl", hash = "sha256:48708e2706106da6967eff5908c78ca3943f005ed6bcb75da2a7e4da94ef8c70", size = 433187, upload-time = "2026-03-28T17:17:19.523Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/c0/649856ee655a843c8f8664592cfccb73ac80ede6a8c8db33a25d810c12db/aiohttp-3.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:74a2eb058da44fa3a877a49e2095b591d4913308bb424c418b77beb160c55ce3", size = 459778, upload-time = "2026-03-28T17:17:21.964Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/29/6657cc37ae04cacc2dbf53fb730a06b6091cc4cbe745028e047c53e6d840/aiohttp-3.13.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:e0a2c961fc92abeff61d6444f2ce6ad35bb982db9fc8ff8a47455beacf454a57", size = 749363, upload-time = "2026-03-28T17:17:24.044Z" },
+    { url = "https://files.pythonhosted.org/packages/90/7f/30ccdf67ca3d24b610067dc63d64dcb91e5d88e27667811640644aa4a85d/aiohttp-3.13.4-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:153274535985a0ff2bff1fb6c104ed547cec898a09213d21b0f791a44b14d933", size = 499317, upload-time = "2026-03-28T17:17:26.199Z" },
+    { url = "https://files.pythonhosted.org/packages/93/13/e372dd4e68ad04ee25dafb050c7f98b0d91ea643f7352757e87231102555/aiohttp-3.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:351f3171e2458da3d731ce83f9e6b9619e325c45cbd534c7759750cabf453ad7", size = 500477, upload-time = "2026-03-28T17:17:28.279Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/fe/ee6298e8e586096fb6f5eddd31393d8544f33ae0792c71ecbb4c2bef98ac/aiohttp-3.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f989ac8bc5595ff761a5ccd32bdb0768a117f36dd1504b1c2c074ed5d3f4df9c", size = 1737227, upload-time = "2026-03-28T17:17:30.587Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/b9/a7a0463a09e1a3fe35100f74324f23644bfc3383ac5fd5effe0722a5f0b7/aiohttp-3.13.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d36fc1709110ec1e87a229b201dd3ddc32aa01e98e7868083a794609b081c349", size = 1694036, upload-time = "2026-03-28T17:17:33.29Z" },
+    { url = "https://files.pythonhosted.org/packages/57/7c/8972ae3fb7be00a91aee6b644b2a6a909aedb2c425269a3bfd90115e6f8f/aiohttp-3.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42adaeea83cbdf069ab94f5103ce0787c21fb1a0153270da76b59d5578302329", size = 1786814, upload-time = "2026-03-28T17:17:36.035Z" },
+    { url = "https://files.pythonhosted.org/packages/93/01/c81e97e85c774decbaf0d577de7d848934e8166a3a14ad9f8aa5be329d28/aiohttp-3.13.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:92deb95469928cc41fd4b42a95d8012fa6df93f6b1c0a83af0ffbc4a5e218cde", size = 1866676, upload-time = "2026-03-28T17:17:38.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/5f/5b46fe8694a639ddea2cd035bf5729e4677ea882cb251396637e2ef1590d/aiohttp-3.13.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0c0c7c07c4257ef3a1df355f840bc62d133bcdef5c1c5ba75add3c08553e2eed", size = 1740842, upload-time = "2026-03-28T17:17:40.783Z" },
+    { url = "https://files.pythonhosted.org/packages/20/a2/0d4b03d011cca6b6b0acba8433193c1e484efa8d705ea58295590fe24203/aiohttp-3.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f062c45de8a1098cb137a1898819796a2491aec4e637a06b03f149315dff4d8f", size = 1566508, upload-time = "2026-03-28T17:17:43.235Z" },
+    { url = "https://files.pythonhosted.org/packages/98/17/e689fd500da52488ec5f889effd6404dece6a59de301e380f3c64f167beb/aiohttp-3.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:76093107c531517001114f0ebdb4f46858ce818590363e3e99a4a2280334454a", size = 1700569, upload-time = "2026-03-28T17:17:46.165Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/0d/66402894dbcf470ef7db99449e436105ea862c24f7ea4c95c683e635af35/aiohttp-3.13.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6f6ec32162d293b82f8b63a16edc80769662fbd5ae6fbd4936d3206a2c2cc63b", size = 1707407, upload-time = "2026-03-28T17:17:48.825Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/eb/af0ab1a3650092cbd8e14ef29e4ab0209e1460e1c299996c3f8288b3f1ff/aiohttp-3.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5903e2db3d202a00ad9f0ec35a122c005e85d90c9836ab4cda628f01edf425e2", size = 1752214, upload-time = "2026-03-28T17:17:51.206Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/bf/72326f8a98e4c666f292f03c385545963cc65e358835d2a7375037a97b57/aiohttp-3.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2d5bea57be7aca98dbbac8da046d99b5557c5cf4e28538c4c786313078aca09e", size = 1562162, upload-time = "2026-03-28T17:17:53.634Z" },
+    { url = "https://files.pythonhosted.org/packages/67/9f/13b72435f99151dd9a5469c96b3b5f86aa29b7e785ca7f35cf5e538f74c0/aiohttp-3.13.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:bcf0c9902085976edc0232b75006ef38f89686901249ce14226b6877f88464fb", size = 1768904, upload-time = "2026-03-28T17:17:55.991Z" },
+    { url = "https://files.pythonhosted.org/packages/18/bc/28d4970e7d5452ac7776cdb5431a1164a0d9cf8bd2fffd67b4fb463aa56d/aiohttp-3.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c3295f98bfeed2e867cab588f2a146a9db37a85e3ae9062abf46ba062bd29165", size = 1723378, upload-time = "2026-03-28T17:17:58.348Z" },
+    { url = "https://files.pythonhosted.org/packages/53/74/b32458ca1a7f34d65bdee7aef2036adbe0438123d3d53e2b083c453c24dd/aiohttp-3.13.4-cp314-cp314-win32.whl", hash = "sha256:a598a5c5767e1369d8f5b08695cab1d8160040f796c4416af76fd773d229b3c9", size = 438711, upload-time = "2026-03-28T17:18:00.728Z" },
+    { url = "https://files.pythonhosted.org/packages/40/b2/54b487316c2df3e03a8f3435e9636f8a81a42a69d942164830d193beb56a/aiohttp-3.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:c555db4bc7a264bead5a7d63d92d41a1122fcd39cc62a4db815f45ad46f9c2c8", size = 464977, upload-time = "2026-03-28T17:18:03.367Z" },
+    { url = "https://files.pythonhosted.org/packages/47/fb/e41b63c6ce71b07a59243bb8f3b457ee0c3402a619acb9d2c0d21ef0e647/aiohttp-3.13.4-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45abbbf09a129825d13c18c7d3182fecd46d9da3cfc383756145394013604ac1", size = 781549, upload-time = "2026-03-28T17:18:05.779Z" },
+    { url = "https://files.pythonhosted.org/packages/97/53/532b8d28df1e17e44c4d9a9368b78dcb6bf0b51037522136eced13afa9e8/aiohttp-3.13.4-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:74c80b2bc2c2adb7b3d1941b2b60701ee2af8296fc8aad8b8bc48bc25767266c", size = 514383, upload-time = "2026-03-28T17:18:08.096Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/1f/62e5d400603e8468cd635812d99cb81cfdc08127a3dc474c647615f31339/aiohttp-3.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c97989ae40a9746650fa196894f317dafc12227c808c774929dda0ff873a5954", size = 518304, upload-time = "2026-03-28T17:18:10.642Z" },
+    { url = "https://files.pythonhosted.org/packages/90/57/2326b37b10896447e3c6e0cbef4fe2486d30913639a5cfd1332b5d870f82/aiohttp-3.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dae86be9811493f9990ef44fff1685f5c1a3192e9061a71a109d527944eed551", size = 1893433, upload-time = "2026-03-28T17:18:13.121Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/b4/a24d82112c304afdb650167ef2fe190957d81cbddac7460bedd245f765aa/aiohttp-3.13.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1db491abe852ca2fa6cc48a3341985b0174b3741838e1341b82ac82c8bd9e871", size = 1755901, upload-time = "2026-03-28T17:18:16.21Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/2d/0883ef9d878d7846287f036c162a951968f22aabeef3ac97b0bea6f76d5d/aiohttp-3.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0e5d701c0aad02a7dce72eef6b93226cf3734330f1a31d69ebbf69f33b86666e", size = 1876093, upload-time = "2026-03-28T17:18:18.703Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/52/9204bb59c014869b71971addad6778f005daa72a96eed652c496789d7468/aiohttp-3.13.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8ac32a189081ae0a10ba18993f10f338ec94341f0d5df8fff348043962f3c6f8", size = 1970815, upload-time = "2026-03-28T17:18:21.858Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/b5/e4eb20275a866dde0f570f411b36c6b48f7b53edfe4f4071aa1b0728098a/aiohttp-3.13.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98e968cdaba43e45c73c3f306fca418c8009a957733bac85937c9f9cf3f4de27", size = 1816223, upload-time = "2026-03-28T17:18:24.729Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/23/e98075c5bb146aa61a1239ee1ac7714c85e814838d6cebbe37d3fe19214a/aiohttp-3.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca114790c9144c335d538852612d3e43ea0f075288f4849cf4b05d6cd2238ce7", size = 1649145, upload-time = "2026-03-28T17:18:27.269Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/c1/7bad8be33bb06c2bb224b6468874346026092762cbec388c3bdb65a368ee/aiohttp-3.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ea2e071661ba9cfe11eabbc81ac5376eaeb3061f6e72ec4cc86d7cdd1ffbdbbb", size = 1816562, upload-time = "2026-03-28T17:18:29.847Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/10/c00323348695e9a5e316825969c88463dcc24c7e9d443244b8a2c9cf2eae/aiohttp-3.13.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:34e89912b6c20e0fd80e07fa401fd218a410aa1ce9f1c2f1dad6db1bd0ce0927", size = 1800333, upload-time = "2026-03-28T17:18:32.269Z" },
+    { url = "https://files.pythonhosted.org/packages/84/43/9b2147a1df3559f49bd723e22905b46a46c068a53adb54abdca32c4de180/aiohttp-3.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0e217cf9f6a42908c52b46e42c568bd57adc39c9286ced31aaace614b6087965", size = 1820617, upload-time = "2026-03-28T17:18:35.238Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/7f/b3481a81e7a586d02e99387b18c6dafff41285f6efd3daa2124c01f87eae/aiohttp-3.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:0c296f1221e21ba979f5ac1964c3b78cfde15c5c5f855ffd2caab337e9cd9182", size = 1643417, upload-time = "2026-03-28T17:18:37.949Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/72/07181226bc99ce1124e0f89280f5221a82d3ae6a6d9d1973ce429d48e52b/aiohttp-3.13.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d99a9d168ebaffb74f36d011750e490085ac418f4db926cce3989c8fe6cb6b1b", size = 1849286, upload-time = "2026-03-28T17:18:40.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/e6/1b3566e103eca6da5be4ae6713e112a053725c584e96574caf117568ffef/aiohttp-3.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cb19177205d93b881f3f89e6081593676043a6828f59c78c17a0fd6c1fbed2ba", size = 1782635, upload-time = "2026-03-28T17:18:43.073Z" },
+    { url = "https://files.pythonhosted.org/packages/37/58/1b11c71904b8d079eb0c39fe664180dd1e14bebe5608e235d8bfbadc8929/aiohttp-3.13.4-cp314-cp314t-win32.whl", hash = "sha256:c606aa5656dab6552e52ca368e43869c916338346bfaf6304e15c58fb113ea30", size = 472537, upload-time = "2026-03-28T17:18:46.286Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/8f/87c56a1a1977d7dddea5b31e12189665a140fdb48a71e9038ff90bb564ec/aiohttp-3.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:014dcc10ec8ab8db681f0d68e939d1e9286a5aa2b993cbbdb0db130853e02144", size = 506381, upload-time = "2026-03-28T17:18:48.74Z" },
+]
+
+[[package]]
+name = "aioitertools"
+version = "0.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/3c/53c4a17a05fb9ea2313ee1777ff53f5e001aefd5cc85aa2f4c2d982e1e38/aioitertools-0.13.0.tar.gz", hash = "sha256:620bd241acc0bbb9ec819f1ab215866871b4bbd1f73836a55f799200ee86950c", size = 19322, upload-time = "2025-11-06T22:17:07.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/a1/510b0a7fadc6f43a6ce50152e69dbd86415240835868bb0bd9b5b88b1e06/aioitertools-0.13.0-py3-none-any.whl", hash = "sha256:0be0292b856f08dfac90e31f4739432f4cb6d7520ab9eb73e143f4f2fa5259be", size = 24182, upload-time = "2025-11-06T22:17:06.502Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[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 = "argon2-cffi"
+version = "25.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "argon2-cffi-bindings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" },
+]
+
+[[package]]
+name = "argon2-cffi-bindings"
+version = "25.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" },
+    { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" },
+    { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" },
+    { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" },
+    { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" },
+    { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" },
+    { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" },
+    { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" },
+]
+
+[[package]]
+name = "arrow"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" },
+]
+
+[[package]]
+name = "asgiref"
+version = "3.11.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/63/40/f03da1264ae8f7cfdbf9146542e5e7e8100a4c66ab48e791df9a03d3f6c0/asgiref-3.11.1.tar.gz", hash = "sha256:5f184dc43b7e763efe848065441eac62229c9f7b0475f41f80e207a114eda4ce", size = 38550, upload-time = "2026-02-03T13:30:14.33Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/0a/a72d10ed65068e115044937873362e6e32fab1b7dce0046aeb224682c989/asgiref-3.11.1-py3-none-any.whl", hash = "sha256:e8667a091e69529631969fd45dc268fa79b99c92c5fcdda727757e52146ec133", size = 24345, upload-time = "2026-02-03T13:30:13.039Z" },
+]
+
+[[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 = "async-lru"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/1f/989ecfef8e64109a489fff357450cb73fa73a865a92bd8c272170a6922c2/async_lru-2.3.0.tar.gz", hash = "sha256:89bdb258a0140d7313cf8f4031d816a042202faa61d0ab310a0a538baa1c24b6", size = 16332, upload-time = "2026-03-19T01:04:32.413Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/e2/c2e3abf398f80732e58b03be77bde9022550d221dd8781bf586bd4d97cc1/async_lru-2.3.0-py3-none-any.whl", hash = "sha256:eea27b01841909316f2cc739807acea1c623df2be8c5cfad7583286397bb8315", size = 8403, upload-time = "2026-03-19T01:04:30.883Z" },
+]
+
+[[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 = "backrefs"
+version = "6.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/a6/e325ec73b638d3ede4421b5445d4a0b8b219481826cc079d510100af356c/backrefs-6.2.tar.gz", hash = "sha256:f44ff4d48808b243b6c0cdc6231e22195c32f77046018141556c66f8bab72a49", size = 7012303, upload-time = "2026-02-16T19:10:15.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/39/3765df263e08a4df37f4f43cb5aa3c6c17a4bdd42ecfe841e04c26037171/backrefs-6.2-py310-none-any.whl", hash = "sha256:0fdc7b012420b6b144410342caeb8adc54c6866cf12064abc9bb211302e496f8", size = 381075, upload-time = "2026-02-16T19:10:04.322Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/f0/35240571e1b67ffb19dafb29ab34150b6f59f93f717b041082cdb1bfceb1/backrefs-6.2-py311-none-any.whl", hash = "sha256:08aa7fae530c6b2361d7bdcbda1a7c454e330cc9dbcd03f5c23205e430e5c3be", size = 392874, upload-time = "2026-02-16T19:10:06.314Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/63/77e8c9745b4d227cce9f5e0a6f68041278c5f9b18588b35905f5f19c1beb/backrefs-6.2-py312-none-any.whl", hash = "sha256:c3f4b9cb2af8cda0d87ab4f57800b57b95428488477be164dd2b47be54db0c90", size = 398787, upload-time = "2026-02-16T19:10:08.274Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/71/c754b1737ad99102e03fa3235acb6cb6d3ac9d6f596cbc3e5f236705abd8/backrefs-6.2-py313-none-any.whl", hash = "sha256:12df81596ab511f783b7d87c043ce26bc5b0288cf3bb03610fe76b8189282b2b", size = 400747, upload-time = "2026-02-16T19:10:09.791Z" },
+    { url = "https://files.pythonhosted.org/packages/af/75/be12ba31a6eb20dccef2320cd8ccb3f7d9013b68ba4c70156259fee9e409/backrefs-6.2-py314-none-any.whl", hash = "sha256:e5f805ae09819caa1aa0623b4a83790e7028604aa2b8c73ba602c4454e665de7", size = 412602, upload-time = "2026-02-16T19:10:12.317Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f8/d02f650c47d05034dcd6f9c8cf94f39598b7a89c00ecda0ecb2911bc27e9/backrefs-6.2-py39-none-any.whl", hash = "sha256:664e33cd88c6840b7625b826ecf2555f32d491800900f5a541f772c485f7cda7", size = 381077, upload-time = "2026-02-16T19:10:13.74Z" },
+]
+
+[[package]]
+name = "beautifulsoup4"
+version = "4.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "soupsieve" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" },
+]
+
+[[package]]
+name = "black"
+version = "26.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "mypy-extensions" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "platformdirs" },
+    { name = "pytokens" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e1/c5/61175d618685d42b005847464b8fb4743a67b1b8fdb75e50e5a96c31a27a/black-26.3.1.tar.gz", hash = "sha256:2c50f5063a9641c7eed7795014ba37b0f5fa227f3d408b968936e24bc0566b07", size = 666155, upload-time = "2026-03-12T03:36:03.593Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/57/5f11c92861f9c92eb9dddf515530bc2d06db843e44bdcf1c83c1427824bc/black-26.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:28ef38aee69e4b12fda8dba75e21f9b4f979b490c8ac0baa7cb505369ac9e1ff", size = 1851987, upload-time = "2026-03-12T03:40:06.248Z" },
+    { url = "https://files.pythonhosted.org/packages/54/aa/340a1463660bf6831f9e39646bf774086dbd8ca7fc3cded9d59bbdf4ad0a/black-26.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bf9bf162ed91a26f1adba8efda0b573bc6924ec1408a52cc6f82cb73ec2b142c", size = 1689499, upload-time = "2026-03-12T03:40:07.642Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/01/b726c93d717d72733da031d2de10b92c9fa4c8d0c67e8a8a372076579279/black-26.3.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:474c27574d6d7037c1bc875a81d9be0a9a4f9ee95e62800dab3cfaadbf75acd5", size = 1754369, upload-time = "2026-03-12T03:40:09.279Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/09/61e91881ca291f150cfc9eb7ba19473c2e59df28859a11a88248b5cbbc4d/black-26.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:5e9d0d86df21f2e1677cc4bd090cd0e446278bcbbe49bf3659c308c3e402843e", size = 1413613, upload-time = "2026-03-12T03:40:10.943Z" },
+    { url = "https://files.pythonhosted.org/packages/16/73/544f23891b22e7efe4d8f812371ab85b57f6a01b2fc45e3ba2e52ba985b8/black-26.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:9a5e9f45e5d5e1c5b5c29b3bd4265dcc90e8b92cf4534520896ed77f791f4da5", size = 1219719, upload-time = "2026-03-12T03:40:12.597Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/f8/da5eae4fc75e78e6dceb60624e1b9662ab00d6b452996046dfa9b8a6025b/black-26.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b5e6f89631eb88a7302d416594a32faeee9fb8fb848290da9d0a5f2903519fc1", size = 1895920, upload-time = "2026-03-12T03:40:13.921Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/9f/04e6f26534da2e1629b2b48255c264cabf5eedc5141d04516d9d68a24111/black-26.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cd2012d35b47d589cb8a16faf8a32ef7a336f56356babd9fcf70939ad1897f", size = 1718499, upload-time = "2026-03-12T03:40:15.239Z" },
+    { url = "https://files.pythonhosted.org/packages/04/91/a5935b2a63e31b331060c4a9fdb5a6c725840858c599032a6f3aac94055f/black-26.3.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f76ff19ec5297dd8e66eb64deda23631e642c9393ab592826fd4bdc97a4bce7", size = 1794994, upload-time = "2026-03-12T03:40:17.124Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0a/86e462cdd311a3c2a8ece708d22aba17d0b2a0d5348ca34b40cdcbea512e/black-26.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:ddb113db38838eb9f043623ba274cfaf7d51d5b0c22ecb30afe58b1bb8322983", size = 1420867, upload-time = "2026-03-12T03:40:18.83Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e5/22515a19cb7eaee3440325a6b0d95d2c0e88dd180cb011b12ae488e031d1/black-26.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:dfdd51fc3e64ea4f35873d1b3fb25326773d55d2329ff8449139ebaad7357efb", size = 1230124, upload-time = "2026-03-12T03:40:20.425Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/77/5728052a3c0450c53d9bb3945c4c46b91baa62b2cafab6801411b6271e45/black-26.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:855822d90f884905362f602880ed8b5df1b7e3ee7d0db2502d4388a954cc8c54", size = 1895034, upload-time = "2026-03-12T03:40:21.813Z" },
+    { url = "https://files.pythonhosted.org/packages/52/73/7cae55fdfdfbe9d19e9a8d25d145018965fe2079fa908101c3733b0c55a0/black-26.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8a33d657f3276328ce00e4d37fe70361e1ec7614da5d7b6e78de5426cb56332f", size = 1718503, upload-time = "2026-03-12T03:40:23.666Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/87/af89ad449e8254fdbc74654e6467e3c9381b61472cc532ee350d28cfdafb/black-26.3.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f1cd08e99d2f9317292a311dfe578fd2a24b15dbce97792f9c4d752275c1fa56", size = 1793557, upload-time = "2026-03-12T03:40:25.497Z" },
+    { url = "https://files.pythonhosted.org/packages/43/10/d6c06a791d8124b843bf325ab4ac7d2f5b98731dff84d6064eafd687ded1/black-26.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:c7e72339f841b5a237ff14f7d3880ddd0fc7f98a1199e8c4327f9a4f478c1839", size = 1422766, upload-time = "2026-03-12T03:40:27.14Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4f/40a582c015f2d841ac24fed6390bd68f0fc896069ff3a886317959c9daf8/black-26.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:afc622538b430aa4c8c853f7f63bc582b3b8030fd8c80b70fb5fa5b834e575c2", size = 1232140, upload-time = "2026-03-12T03:40:28.882Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/da/e36e27c9cebc1311b7579210df6f1c86e50f2d7143ae4fcf8a5017dc8809/black-26.3.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2d6bfaf7fd0993b420bed691f20f9492d53ce9a2bcccea4b797d34e947318a78", size = 1889234, upload-time = "2026-03-12T03:40:30.964Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/7b/9871acf393f64a5fa33668c19350ca87177b181f44bb3d0c33b2d534f22c/black-26.3.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f89f2ab047c76a9c03f78d0d66ca519e389519902fa27e7a91117ef7611c0568", size = 1720522, upload-time = "2026-03-12T03:40:32.346Z" },
+    { url = "https://files.pythonhosted.org/packages/03/87/e766c7f2e90c07fb7586cc787c9ae6462b1eedab390191f2b7fc7f6170a9/black-26.3.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b07fc0dab849d24a80a29cfab8d8a19187d1c4685d8a5e6385a5ce323c1f015f", size = 1787824, upload-time = "2026-03-12T03:40:33.636Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/94/2424338fb2d1875e9e83eed4c8e9c67f6905ec25afd826a911aea2b02535/black-26.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:0126ae5b7c09957da2bdbd91a9ba1207453feada9e9fe51992848658c6c8e01c", size = 1445855, upload-time = "2026-03-12T03:40:35.442Z" },
+    { url = "https://files.pythonhosted.org/packages/86/43/0c3338bd928afb8ee7471f1a4eec3bdbe2245ccb4a646092a222e8669840/black-26.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:92c0ec1f2cc149551a2b7b47efc32c866406b6891b0ee4625e95967c8f4acfb1", size = 1258109, upload-time = "2026-03-12T03:40:36.832Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/0d/52d98722666d6fc6c3dd4c76df339501d6efd40e0ff95e6186a7b7f0befd/black-26.3.1-py3-none-any.whl", hash = "sha256:2bd5aa94fc267d38bb21a70d7410a89f1a1d318841855f698746f8e7f51acd1b", size = 207542, upload-time = "2026-03-12T03:36:01.668Z" },
+]
+
+[[package]]
+name = "bleach"
+version = "6.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "webencodings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/07/18/3c8523962314be6bf4c8989c79ad9531c825210dd13a8669f6b84336e8bd/bleach-6.3.0.tar.gz", hash = "sha256:6f3b91b1c0a02bb9a78b5a454c92506aa0fdf197e1d5e114d2e00c6f64306d22", size = 203533, upload-time = "2025-10-27T17:57:39.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cd/3a/577b549de0cc09d95f11087ee63c739bba856cd3952697eec4c4bb91350a/bleach-6.3.0-py3-none-any.whl", hash = "sha256:fe10ec77c93ddf3d13a73b035abaac7a9f5e436513864ccdad516693213c65d6", size = 164437, upload-time = "2025-10-27T17:57:37.538Z" },
+]
+
+[package.optional-dependencies]
+css = [
+    { name = "tinycss2" },
+]
+
+[[package]]
+name = "boto3"
+version = "1.42.70"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+    { name = "jmespath" },
+    { name = "s3transfer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/7c/d7a533916d1afc9e17f8594203a85799d42f7c5751464fbdb25ead8db9d2/boto3-1.42.70.tar.gz", hash = "sha256:d060b0d83d2832e403671b9a895e73c3b025df8bb5896d89e401b0678705aac4", size = 112808, upload-time = "2026-03-17T19:43:22.445Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/a1/128e3676fb9b4fd965a93554e5e07045975ee6bd6e9fdb536cdffa32e99e/boto3-1.42.70-py3-none-any.whl", hash = "sha256:18a108c4d5df89a200b3949de0d39c0879b100c455e3229ea38275dd392db0f4", size = 140554, upload-time = "2026-03-17T19:43:20.406Z" },
+]
+
+[[package]]
+name = "botocore"
+version = "1.42.70"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jmespath" },
+    { name = "python-dateutil" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/54/b80e1fcee4f732e0e9314bbb8679be9d5690caa1566c4a4cd14e9724d2dd/botocore-1.42.70.tar.gz", hash = "sha256:9ee17553b7febd1a0c1253b3b62ab5d79607eb6163c8fb943470a8893c31d4fa", size = 14997068, upload-time = "2026-03-17T19:43:10.678Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/51/08f32aea872253173f513ba68122f4300966290677c8e59887b4ffd5d957/botocore-1.42.70-py3-none-any.whl", hash = "sha256:54ed9d25f05f810efd22b0dfda0bb9178df3ad8952b2e4359e05156c9321bd3c", size = 14671393, upload-time = "2026-03-17T19:43:06.777Z" },
+]
+
+[[package]]
+name = "branca"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jinja2" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/32/14/9d409124bda3f4ab7af3802aba07181d1fd56aa96cc4b999faea6a27a0d2/branca-0.8.2.tar.gz", hash = "sha256:e5040f4c286e973658c27de9225c1a5a7356dd0702a7c8d84c0f0dfbde388fe7", size = 27890, upload-time = "2025-10-06T10:28:20.305Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/50/fc9680058e63161f2f63165b84c957a0df1415431104c408e8104a3a18ef/branca-0.8.2-py3-none-any.whl", hash = "sha256:2ebaef3983e3312733c1ae2b793b0a8ba3e1c4edeb7598e10328505280cf2f7c", size = 26193, upload-time = "2025-10-06T10:28:19.255Z" },
+]
+
+[[package]]
+name = "brotlipy"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/91/bc79b88590e4f662bd40a55a2b6beb0f15da4726732efec5aa5a3763d856/brotlipy-0.7.0.tar.gz", hash = "sha256:36def0b859beaf21910157b4c33eb3b06d8ce459c942102f16988cca6ea164df", size = 413338, upload-time = "2017-05-30T08:20:34.637Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/98/446b36a3517eb1b3c70d7a32b0523b8946a90db71a95be01a05cf6dd9206/brotlipy-0.7.0-cp35-abi3-macosx_10_9_x86_64.whl", hash = "sha256:382971a641125323e90486244d6266ffb0e1f4dd920fbdcf508d2a19acc7c3b3", size = 390662, upload-time = "2021-09-02T17:51:34.63Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/58/998e70ed426a86f641d49c7a107eaf17de1f7e22d65b1e0b4e33deb172b9/brotlipy-0.7.0-cp35-abi3-manylinux1_i686.whl", hash = "sha256:82f61506d001e626ec3a1ac8a69df11eb3555a4878599befcb672c8178befac8", size = 995723, upload-time = "2021-09-02T17:51:38.043Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/1b/ca5c77fe4a5b99cef24767b48254ea50ffad813407c74aa06d93089d1014/brotlipy-0.7.0-cp35-abi3-manylinux1_x86_64.whl", hash = "sha256:7ff18e42f51ebc9d9d77a0db33f99ad95f01dd431e4491f0eca519b90e9415a9", size = 1094088, upload-time = "2021-09-02T17:51:41.054Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/71/844dc49400ff6c82b169454c03376d3cf68b01543b7e99bd502a9295a5ba/brotlipy-0.7.0-cp35-abi3-manylinux2010_i686.whl", hash = "sha256:8ef230ca9e168ce2b7dc173a48a0cc3d78bcdf0bd0ea7743472a317041a4768e", size = 995726, upload-time = "2021-09-02T17:51:43.446Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2e/372bc34bd5741212ac884b5d88f284ba7369f848bccb9a80b458a9224576/brotlipy-0.7.0-cp35-abi3-manylinux2010_x86_64.whl", hash = "sha256:b7cf5bb69e767a59acc3da0d199d4b5d0c9fed7bef3ffa3efa80c6f39095686b", size = 1094094, upload-time = "2021-09-02T17:51:45.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/19/416936acb7efa79164be7f09a95e26ba03649dcb7799254395ea2f140635/brotlipy-0.7.0-cp35-abi3-manylinux2014_aarch64.whl", hash = "sha256:e5c549ae5928dda952463196180445c24d6fad2d73cb13bd118293aced31b771", size = 1043867, upload-time = "2021-09-02T17:51:48.276Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/db/94a242376511ce71e9758169dd11ca9cf5e8f675e12dede8fbcea644c089/brotlipy-0.7.0-cp35-abi3-win32.whl", hash = "sha256:79ab3bca8dd12c17e092273484f2ac48b906de2b4828dcdf6a7d520f99646ab3", size = 350080, upload-time = "2021-09-02T17:51:50.096Z" },
+    { url = "https://files.pythonhosted.org/packages/03/53/41f17238db696c4c95019174ca5bfd2396ef379c7918ae4f6ff82529ee92/brotlipy-0.7.0-cp35-abi3-win_amd64.whl", hash = "sha256:ac1d66c9774ee62e762750e399a0c95e93b180e96179b645f28b162b55ae8adc", size = 376301, upload-time = "2021-09-02T17:51:51.987Z" },
+]
+
+[[package]]
+name = "cachetools"
+version = "7.0.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/dd/57fe3fdb6e65b25a5987fd2cdc7e22db0aef508b91634d2e57d22928d41b/cachetools-7.0.5.tar.gz", hash = "sha256:0cd042c24377200c1dcd225f8b7b12b0ca53cc2c961b43757e774ebe190fd990", size = 37367, upload-time = "2026-03-09T20:51:29.451Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/f3/39cf3367b8107baa44f861dc802cbf16263c945b62d8265d36034fc07bea/cachetools-7.0.5-py3-none-any.whl", hash = "sha256:46bc8ebefbe485407621d0a4264b23c080cedd913921bad7ac3ed2f26c183114", size = 13918, upload-time = "2026-03-09T20:51:27.33Z" },
+]
+
+[[package]]
+name = "cairocffi"
+version = "1.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/70/c5/1a4dc131459e68a173cbdab5fad6b524f53f9c1ef7861b7698e998b837cc/cairocffi-1.7.1.tar.gz", hash = "sha256:2e48ee864884ec4a3a34bfa8c9ab9999f688286eb714a15a43ec9d068c36557b", size = 88096, upload-time = "2024-06-18T10:56:06.741Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/d8/ba13451aa6b745c49536e87b6bf8f629b950e84bd0e8308f7dc6883b67e2/cairocffi-1.7.1-py3-none-any.whl", hash = "sha256:9803a0e11f6c962f3b0ae2ec8ba6ae45e957a146a004697a1ac1bbf16b073b3f", size = 75611, upload-time = "2024-06-18T10:55:59.489Z" },
+]
+
+[[package]]
+name = "cairosvg"
+version = "2.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cairocffi" },
+    { name = "cssselect2" },
+    { name = "defusedxml" },
+    { name = "pillow" },
+    { name = "tinycss2" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/07/e8412a13019b3f737972dea23a2c61ca42becafc16c9338f4ca7a0caa993/cairosvg-2.9.0.tar.gz", hash = "sha256:1debb00cd2da11350d8b6f5ceb739f1b539196d71d5cf5eb7363dbd1bfbc8dc5", size = 40877, upload-time = "2026-03-13T15:42:00.564Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bf/e0/5011747466414c12cac8a8df77aa235068669a6a5a5df301a96209db6054/cairosvg-2.9.0-py3-none-any.whl", hash = "sha256:4b82d07d145377dffdfc19d9791bd5fb65539bb4da0adecf0bdbd9cd4ffd7c68", size = 45962, upload-time = "2026-03-14T13:56:33.512Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+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/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.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/60/e3bec1881450851b087e301bedc3daa9377a4d45f1c26aa90b0b235e38aa/charset_normalizer-3.4.6.tar.gz", hash = "sha256:1ae6b62897110aa7c79ea2f5dd38d1abca6db663687c0b1ad9aed6f6bae3d9d6", size = 143363, upload-time = "2026-03-15T18:53:25.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/28/ff6f234e628a2de61c458be2779cb182bc03f6eec12200d4a525bbfc9741/charset_normalizer-3.4.6-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:82060f995ab5003a2d6e0f4ad29065b7672b6593c8c63559beefe5b443242c3e", size = 293582, upload-time = "2026-03-15T18:50:25.454Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/b7/b1a117e5385cbdb3205f6055403c2a2a220c5ea80b8716c324eaf75c5c95/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60c74963d8350241a79cb8feea80e54d518f72c26db618862a8f53e5023deaf9", size = 197240, upload-time = "2026-03-15T18:50:27.196Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/5f/2574f0f09f3c3bc1b2f992e20bce6546cb1f17e111c5be07308dc5427956/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6e4333fb15c83f7d1482a76d45a0818897b3d33f00efd215528ff7c51b8e35d", size = 217363, upload-time = "2026-03-15T18:50:28.601Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d1/0ae20ad77bc949ddd39b51bf383b6ca932f2916074c95cad34ae465ab71f/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bc72863f4d9aba2e8fd9085e63548a324ba706d2ea2c83b260da08a59b9482de", size = 212994, upload-time = "2026-03-15T18:50:30.102Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ac/3233d262a310c1b12633536a07cde5ddd16985e6e7e238e9f3f9423d8eb9/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9cc4fc6c196d6a8b76629a70ddfcd4635a6898756e2d9cac5565cf0654605d73", size = 204697, upload-time = "2026-03-15T18:50:31.654Z" },
+    { url = "https://files.pythonhosted.org/packages/25/3c/8a18fc411f085b82303cfb7154eed5bd49c77035eb7608d049468b53f87c/charset_normalizer-3.4.6-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:0c173ce3a681f309f31b87125fecec7a5d1347261ea11ebbb856fa6006b23c8c", size = 191673, upload-time = "2026-03-15T18:50:33.433Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/a7/11cfe61d6c5c5c7438d6ba40919d0306ed83c9ab957f3d4da2277ff67836/charset_normalizer-3.4.6-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c907cdc8109f6c619e6254212e794d6548373cc40e1ec75e6e3823d9135d29cc", size = 201120, upload-time = "2026-03-15T18:50:35.105Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/10/cf491fa1abd47c02f69687046b896c950b92b6cd7337a27e6548adbec8e4/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:404a1e552cf5b675a87f0651f8b79f5f1e6fd100ee88dc612f89aa16abd4486f", size = 200911, upload-time = "2026-03-15T18:50:36.819Z" },
+    { url = "https://files.pythonhosted.org/packages/28/70/039796160b48b18ed466fde0af84c1b090c4e288fae26cd674ad04a2d703/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e3c701e954abf6fc03a49f7c579cc80c2c6cc52525340ca3186c41d3f33482ef", size = 192516, upload-time = "2026-03-15T18:50:38.228Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/34/c56f3223393d6ff3124b9e78f7de738047c2d6bc40a4f16ac0c9d7a1cb3c/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:7a6967aaf043bceabab5412ed6bd6bd26603dae84d5cb75bf8d9a74a4959d398", size = 218795, upload-time = "2026-03-15T18:50:39.664Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/3b/ce2d4f86c5282191a041fdc5a4ce18f1c6bd40a5bd1f74cf8625f08d51c1/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5feb91325bbceade6afab43eb3b508c63ee53579fe896c77137ded51c6b6958e", size = 201833, upload-time = "2026-03-15T18:50:41.552Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/9b/b6a9f76b0fd7c5b5ec58b228ff7e85095370282150f0bd50b3126f5506d6/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f820f24b09e3e779fe84c3c456cb4108a7aa639b0d1f02c28046e11bfcd088ed", size = 213920, upload-time = "2026-03-15T18:50:43.33Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/98/7bc23513a33d8172365ed30ee3a3b3fe1ece14a395e5fc94129541fc6003/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b35b200d6a71b9839a46b9b7fff66b6638bb52fc9658aa58796b0326595d3021", size = 206951, upload-time = "2026-03-15T18:50:44.789Z" },
+    { url = "https://files.pythonhosted.org/packages/32/73/c0b86f3d1458468e11aec870e6b3feac931facbe105a894b552b0e518e79/charset_normalizer-3.4.6-cp311-cp311-win32.whl", hash = "sha256:9ca4c0b502ab399ef89248a2c84c54954f77a070f28e546a85e91da627d1301e", size = 143703, upload-time = "2026-03-15T18:50:46.103Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/e3/76f2facfe8eddee0bbd38d2594e709033338eae44ebf1738bcefe0a06185/charset_normalizer-3.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:a9e68c9d88823b274cf1e72f28cb5dc89c990edf430b0bfd3e2fb0785bfeabf4", size = 153857, upload-time = "2026-03-15T18:50:47.563Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/dc/9abe19c9b27e6cd3636036b9d1b387b78c40dedbf0b47f9366737684b4b0/charset_normalizer-3.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:97d0235baafca5f2b09cf332cc275f021e694e8362c6bb9c96fc9a0eb74fc316", size = 142751, upload-time = "2026-03-15T18:50:49.234Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/62/c0815c992c9545347aeea7859b50dc9044d147e2e7278329c6e02ac9a616/charset_normalizer-3.4.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2ef7fedc7a6ecbe99969cd09632516738a97eeb8bd7258bf8a0f23114c057dab", size = 295154, upload-time = "2026-03-15T18:50:50.88Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/37/bdca6613c2e3c58c7421891d80cc3efa1d32e882f7c4a7ee6039c3fc951a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4ea868bc28109052790eb2b52a9ab33f3aa7adc02f96673526ff47419490e21", size = 199191, upload-time = "2026-03-15T18:50:52.658Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/92/9934d1bbd69f7f398b38c5dae1cbf9cc672e7c34a4adf7b17c0a9c17d15d/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:836ab36280f21fc1a03c99cd05c6b7af70d2697e374c7af0b61ed271401a72a2", size = 218674, upload-time = "2026-03-15T18:50:54.102Z" },
+    { url = "https://files.pythonhosted.org/packages/af/90/25f6ab406659286be929fd89ab0e78e38aa183fc374e03aa3c12d730af8a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f1ce721c8a7dfec21fcbdfe04e8f68174183cf4e8188e0645e92aa23985c57ff", size = 215259, upload-time = "2026-03-15T18:50:55.616Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ef/79a463eb0fff7f96afa04c1d4c51f8fc85426f918db467854bfb6a569ce3/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e28d62a8fc7a1fa411c43bd65e346f3bce9716dc51b897fbe930c5987b402d5", size = 207276, upload-time = "2026-03-15T18:50:57.054Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/72/d0426afec4b71dc159fa6b4e68f868cd5a3ecd918fec5813a15d292a7d10/charset_normalizer-3.4.6-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:530d548084c4a9f7a16ed4a294d459b4f229db50df689bfe92027452452943a0", size = 195161, upload-time = "2026-03-15T18:50:58.686Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/18/c82b06a68bfcb6ce55e508225d210c7e6a4ea122bfc0748892f3dc4e8e11/charset_normalizer-3.4.6-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:30f445ae60aad5e1f8bdbb3108e39f6fbc09f4ea16c815c66578878325f8f15a", size = 203452, upload-time = "2026-03-15T18:51:00.196Z" },
+    { url = "https://files.pythonhosted.org/packages/44/d6/0c25979b92f8adafdbb946160348d8d44aa60ce99afdc27df524379875cb/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ac2393c73378fea4e52aa56285a3d64be50f1a12395afef9cce47772f60334c2", size = 202272, upload-time = "2026-03-15T18:51:01.703Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/3d/7fea3e8fe84136bebbac715dd1221cc25c173c57a699c030ab9b8900cbb7/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:90ca27cd8da8118b18a52d5f547859cc1f8354a00cd1e8e5120df3e30d6279e5", size = 195622, upload-time = "2026-03-15T18:51:03.526Z" },
+    { url = "https://files.pythonhosted.org/packages/57/8a/d6f7fd5cb96c58ef2f681424fbca01264461336d2a7fc875e4446b1f1346/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e5a94886bedca0f9b78fecd6afb6629142fd2605aa70a125d49f4edc6037ee6", size = 220056, upload-time = "2026-03-15T18:51:05.269Z" },
+    { url = "https://files.pythonhosted.org/packages/16/50/478cdda782c8c9c3fb5da3cc72dd7f331f031e7f1363a893cdd6ca0f8de0/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:695f5c2823691a25f17bc5d5ffe79fa90972cc34b002ac6c843bb8a1720e950d", size = 203751, upload-time = "2026-03-15T18:51:06.858Z" },
+    { url = "https://files.pythonhosted.org/packages/75/fc/cc2fcac943939c8e4d8791abfa139f685e5150cae9f94b60f12520feaa9b/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:231d4da14bcd9301310faf492051bee27df11f2bc7549bc0bb41fef11b82daa2", size = 216563, upload-time = "2026-03-15T18:51:08.564Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b7/a4add1d9a5f68f3d037261aecca83abdb0ab15960a3591d340e829b37298/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a056d1ad2633548ca18ffa2f85c202cfb48b68615129143915b8dc72a806a923", size = 209265, upload-time = "2026-03-15T18:51:10.312Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/18/c094561b5d64a24277707698e54b7f67bd17a4f857bbfbb1072bba07c8bf/charset_normalizer-3.4.6-cp312-cp312-win32.whl", hash = "sha256:c2274ca724536f173122f36c98ce188fd24ce3dad886ec2b7af859518ce008a4", size = 144229, upload-time = "2026-03-15T18:51:11.694Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/20/0567efb3a8fd481b8f34f739ebddc098ed062a59fed41a8d193a61939e8f/charset_normalizer-3.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:c8ae56368f8cc97c7e40a7ee18e1cedaf8e780cd8bc5ed5ac8b81f238614facb", size = 154277, upload-time = "2026-03-15T18:51:13.004Z" },
+    { url = "https://files.pythonhosted.org/packages/15/57/28d79b44b51933119e21f65479d0864a8d5893e494cf5daab15df0247c17/charset_normalizer-3.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:899d28f422116b08be5118ef350c292b36fc15ec2daeb9ea987c89281c7bb5c4", size = 142817, upload-time = "2026-03-15T18:51:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/1d/4fdabeef4e231153b6ed7567602f3b68265ec4e5b76d6024cf647d43d981/charset_normalizer-3.4.6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:11afb56037cbc4b1555a34dd69151e8e069bee82e613a73bef6e714ce733585f", size = 294823, upload-time = "2026-03-15T18:51:15.755Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/20e809b89c69d37be748d98e84dce6820bf663cf19cf6b942c951a3e8f41/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:423fb7e748a08f854a08a222b983f4df1912b1daedce51a72bd24fe8f26a1843", size = 198527, upload-time = "2026-03-15T18:51:17.177Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/4f8d27527d59c039dce6f7622593cdcd3d70a8504d87d09eb11e9fdc6062/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d73beaac5e90173ac3deb9928a74763a6d230f494e4bfb422c217a0ad8e629bf", size = 218388, upload-time = "2026-03-15T18:51:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/9b/4770ccb3e491a9bacf1c46cc8b812214fe367c86a96353ccc6daf87b01ec/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d60377dce4511655582e300dc1e5a5f24ba0cb229005a1d5c8d0cb72bb758ab8", size = 214563, upload-time = "2026-03-15T18:51:20.374Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/58/a199d245894b12db0b957d627516c78e055adc3a0d978bc7f65ddaf7c399/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:530e8cebeea0d76bdcf93357aa5e41336f48c3dc709ac52da2bb167c5b8271d9", size = 206587, upload-time = "2026-03-15T18:51:21.807Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/70/3def227f1ec56f5c69dfc8392b8bd63b11a18ca8178d9211d7cc5e5e4f27/charset_normalizer-3.4.6-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:a26611d9987b230566f24a0a125f17fe0de6a6aff9f25c9f564aaa2721a5fb88", size = 194724, upload-time = "2026-03-15T18:51:23.508Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ab/9318352e220c05efd31c2779a23b50969dc94b985a2efa643ed9077bfca5/charset_normalizer-3.4.6-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34315ff4fc374b285ad7f4a0bf7dcbfe769e1b104230d40f49f700d4ab6bbd84", size = 202956, upload-time = "2026-03-15T18:51:25.239Z" },
+    { url = "https://files.pythonhosted.org/packages/75/13/f3550a3ac25b70f87ac98c40d3199a8503676c2f1620efbf8d42095cfc40/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ddd609f9e1af8c7bd6e2aca279c931aefecd148a14402d4e368f3171769fd", size = 201923, upload-time = "2026-03-15T18:51:26.682Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/db/c5c643b912740b45e8eec21de1bbab8e7fc085944d37e1e709d3dcd9d72f/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:80d0a5615143c0b3225e5e3ef22c8d5d51f3f72ce0ea6fb84c943546c7b25b6c", size = 195366, upload-time = "2026-03-15T18:51:28.129Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/67/3b1c62744f9b2448443e0eb160d8b001c849ec3fef591e012eda6484787c/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:92734d4d8d187a354a556626c221cd1a892a4e0802ccb2af432a1d85ec012194", size = 219752, upload-time = "2026-03-15T18:51:29.556Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/98/32ffbaf7f0366ffb0445930b87d103f6b406bc2c271563644bde8a2b1093/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:613f19aa6e082cf96e17e3ffd89383343d0d589abda756b7764cf78361fd41dc", size = 203296, upload-time = "2026-03-15T18:51:30.921Z" },
+    { url = "https://files.pythonhosted.org/packages/41/12/5d308c1bbe60cabb0c5ef511574a647067e2a1f631bc8634fcafaccd8293/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2b1a63e8224e401cafe7739f77efd3f9e7f5f2026bda4aead8e59afab537784f", size = 215956, upload-time = "2026-03-15T18:51:32.399Z" },
+    { url = "https://files.pythonhosted.org/packages/53/e9/5f85f6c5e20669dbe56b165c67b0260547dea97dba7e187938833d791687/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6cceb5473417d28edd20c6c984ab6fee6c6267d38d906823ebfe20b03d607dc2", size = 208652, upload-time = "2026-03-15T18:51:34.214Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/11/897052ea6af56df3eef3ca94edafee410ca699ca0c7b87960ad19932c55e/charset_normalizer-3.4.6-cp313-cp313-win32.whl", hash = "sha256:d7de2637729c67d67cf87614b566626057e95c303bc0a55ffe391f5205e7003d", size = 143940, upload-time = "2026-03-15T18:51:36.15Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/5c/724b6b363603e419829f561c854b87ed7c7e31231a7908708ac086cdf3e2/charset_normalizer-3.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:572d7c822caf521f0525ba1bce1a622a0b85cf47ffbdae6c9c19e3b5ac3c4389", size = 154101, upload-time = "2026-03-15T18:51:37.876Z" },
+    { url = "https://files.pythonhosted.org/packages/01/a5/7abf15b4c0968e47020f9ca0935fb3274deb87cb288cd187cad92e8cdffd/charset_normalizer-3.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a4474d924a47185a06411e0064b803c68be044be2d60e50e8bddcc2649957c1f", size = 143109, upload-time = "2026-03-15T18:51:39.565Z" },
+    { url = "https://files.pythonhosted.org/packages/25/6f/ffe1e1259f384594063ea1869bfb6be5cdb8bc81020fc36c3636bc8302a1/charset_normalizer-3.4.6-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9cc6e6d9e571d2f863fa77700701dae73ed5f78881efc8b3f9a4398772ff53e8", size = 294458, upload-time = "2026-03-15T18:51:41.134Z" },
+    { url = "https://files.pythonhosted.org/packages/56/60/09bb6c13a8c1016c2ed5c6a6488e4ffef506461aa5161662bd7636936fb1/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef5960d965e67165d75b7c7ffc60a83ec5abfc5c11b764ec13ea54fbef8b4421", size = 199277, upload-time = "2026-03-15T18:51:42.953Z" },
+    { url = "https://files.pythonhosted.org/packages/00/50/dcfbb72a5138bbefdc3332e8d81a23494bf67998b4b100703fd15fa52d81/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b3694e3f87f8ac7ce279d4355645b3c878d24d1424581b46282f24b92f5a4ae2", size = 218758, upload-time = "2026-03-15T18:51:44.339Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b3/d79a9a191bb75f5aa81f3aaaa387ef29ce7cb7a9e5074ba8ea095cc073c2/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5d11595abf8dd942a77883a39d81433739b287b6aa71620f15164f8096221b30", size = 215299, upload-time = "2026-03-15T18:51:45.871Z" },
+    { url = "https://files.pythonhosted.org/packages/76/7e/bc8911719f7084f72fd545f647601ea3532363927f807d296a8c88a62c0d/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7bda6eebafd42133efdca535b04ccb338ab29467b3f7bf79569883676fc628db", size = 206811, upload-time = "2026-03-15T18:51:47.308Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/40/c430b969d41dda0c465aa36cc7c2c068afb67177bef50905ac371b28ccc7/charset_normalizer-3.4.6-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:bbc8c8650c6e51041ad1be191742b8b421d05bbd3410f43fa2a00c8db87678e8", size = 193706, upload-time = "2026-03-15T18:51:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/48/15/e35e0590af254f7df984de1323640ef375df5761f615b6225ba8deb9799a/charset_normalizer-3.4.6-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:22c6f0c2fbc31e76c3b8a86fba1a56eda6166e238c29cdd3d14befdb4a4e4815", size = 202706, upload-time = "2026-03-15T18:51:50.257Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/bd/f736f7b9cc5e93a18b794a50346bb16fbfd6b37f99e8f306f7951d27c17c/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7edbed096e4a4798710ed6bc75dcaa2a21b68b6c356553ac4823c3658d53743a", size = 202497, upload-time = "2026-03-15T18:51:52.012Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/ba/2cc9e3e7dfdf7760a6ed8da7446d22536f3d0ce114ac63dee2a5a3599e62/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:7f9019c9cb613f084481bd6a100b12e1547cf2efe362d873c2e31e4035a6fa43", size = 193511, upload-time = "2026-03-15T18:51:53.723Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/cb/5be49b5f776e5613be07298c80e1b02a2d900f7a7de807230595c85a8b2e/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:58c948d0d086229efc484fe2f30c2d382c86720f55cd9bc33591774348ad44e0", size = 220133, upload-time = "2026-03-15T18:51:55.333Z" },
+    { url = "https://files.pythonhosted.org/packages/83/43/99f1b5dad345accb322c80c7821071554f791a95ee50c1c90041c157ae99/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:419a9d91bd238052642a51938af8ac05da5b3343becde08d5cdeab9046df9ee1", size = 203035, upload-time = "2026-03-15T18:51:56.736Z" },
+    { url = "https://files.pythonhosted.org/packages/87/9a/62c2cb6a531483b55dddff1a68b3d891a8b498f3ca555fbcf2978e804d9d/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5273b9f0b5835ff0350c0828faea623c68bfa65b792720c453e22b25cc72930f", size = 216321, upload-time = "2026-03-15T18:51:58.17Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/79/94a010ff81e3aec7c293eb82c28f930918e517bc144c9906a060844462eb/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:0e901eb1049fdb80f5bd11ed5ea1e498ec423102f7a9b9e4645d5b8204ff2815", size = 208973, upload-time = "2026-03-15T18:51:59.998Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/57/4ecff6d4ec8585342f0c71bc03efaa99cb7468f7c91a57b105bcd561cea8/charset_normalizer-3.4.6-cp314-cp314-win32.whl", hash = "sha256:b4ff1d35e8c5bd078be89349b6f3a845128e685e751b6ea1169cf2160b344c4d", size = 144610, upload-time = "2026-03-15T18:52:02.213Z" },
+    { url = "https://files.pythonhosted.org/packages/80/94/8434a02d9d7f168c25767c64671fead8d599744a05d6a6c877144c754246/charset_normalizer-3.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:74119174722c4349af9708993118581686f343adc1c8c9c007d59be90d077f3f", size = 154962, upload-time = "2026-03-15T18:52:03.658Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4c/48f2cdbfd923026503dfd67ccea45c94fd8fe988d9056b468579c66ed62b/charset_normalizer-3.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:e5bcc1a1ae744e0bb59641171ae53743760130600da8db48cbb6e4918e186e4e", size = 143595, upload-time = "2026-03-15T18:52:05.123Z" },
+    { url = "https://files.pythonhosted.org/packages/31/93/8878be7569f87b14f1d52032946131bcb6ebbd8af3e20446bc04053dc3f1/charset_normalizer-3.4.6-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ad8faf8df23f0378c6d527d8b0b15ea4a2e23c89376877c598c4870d1b2c7866", size = 314828, upload-time = "2026-03-15T18:52:06.831Z" },
+    { url = "https://files.pythonhosted.org/packages/06/b6/fae511ca98aac69ecc35cde828b0a3d146325dd03d99655ad38fc2cc3293/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5ea69428fa1b49573eef0cc44a1d43bebd45ad0c611eb7d7eac760c7ae771bc", size = 208138, upload-time = "2026-03-15T18:52:08.239Z" },
+    { url = "https://files.pythonhosted.org/packages/54/57/64caf6e1bf07274a1e0b7c160a55ee9e8c9ec32c46846ce59b9c333f7008/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:06a7e86163334edfc5d20fe104db92fcd666e5a5df0977cb5680a506fe26cc8e", size = 224679, upload-time = "2026-03-15T18:52:10.043Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cb/9ff5a25b9273ef160861b41f6937f86fae18b0792fe0a8e75e06acb08f1d/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e1f6e2f00a6b8edb562826e4632e26d063ac10307e80f7461f7de3ad8ef3f077", size = 223475, upload-time = "2026-03-15T18:52:11.854Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/97/440635fc093b8d7347502a377031f9605a1039c958f3cd18dcacffb37743/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95b52c68d64c1878818687a473a10547b3292e82b6f6fe483808fb1468e2f52f", size = 215230, upload-time = "2026-03-15T18:52:13.325Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/24/afff630feb571a13f07c8539fbb502d2ab494019492aaffc78ef41f1d1d0/charset_normalizer-3.4.6-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:7504e9b7dc05f99a9bbb4525c67a2c155073b44d720470a148b34166a69c054e", size = 199045, upload-time = "2026-03-15T18:52:14.752Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/17/d1399ecdaf7e0498c327433e7eefdd862b41236a7e484355b8e0e5ebd64b/charset_normalizer-3.4.6-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:172985e4ff804a7ad08eebec0a1640ece87ba5041d565fff23c8f99c1f389484", size = 211658, upload-time = "2026-03-15T18:52:16.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/38/16baa0affb957b3d880e5ac2144caf3f9d7de7bc4a91842e447fbb5e8b67/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4be9f4830ba8741527693848403e2c457c16e499100963ec711b1c6f2049b7c7", size = 210769, upload-time = "2026-03-15T18:52:17.782Z" },
+    { url = "https://files.pythonhosted.org/packages/05/34/c531bc6ac4c21da9ddfddb3107be2287188b3ea4b53b70fc58f2a77ac8d8/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:79090741d842f564b1b2827c0b82d846405b744d31e84f18d7a7b41c20e473ff", size = 201328, upload-time = "2026-03-15T18:52:19.553Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/73/a5a1e9ca5f234519c1953608a03fe109c306b97fdfb25f09182babad51a7/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:87725cfb1a4f1f8c2fc9890ae2f42094120f4b44db9360be5d99a4c6b0e03a9e", size = 225302, upload-time = "2026-03-15T18:52:21.043Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/f6/cd782923d112d296294dea4bcc7af5a7ae0f86ab79f8fefbda5526b6cfc0/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:fcce033e4021347d80ed9c66dcf1e7b1546319834b74445f561d2e2221de5659", size = 211127, upload-time = "2026-03-15T18:52:22.491Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c5/0b6898950627af7d6103a449b22320372c24c6feda91aa24e201a478d161/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:ca0276464d148c72defa8bb4390cce01b4a0e425f3b50d1435aa6d7a18107602", size = 222840, upload-time = "2026-03-15T18:52:24.113Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/25/c4bba773bef442cbdc06111d40daa3de5050a676fa26e85090fc54dd12f0/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:197c1a244a274bb016dd8b79204850144ef77fe81c5b797dc389327adb552407", size = 216890, upload-time = "2026-03-15T18:52:25.541Z" },
+    { url = "https://files.pythonhosted.org/packages/35/1a/05dacadb0978da72ee287b0143097db12f2e7e8d3ffc4647da07a383b0b7/charset_normalizer-3.4.6-cp314-cp314t-win32.whl", hash = "sha256:2a24157fa36980478dd1770b585c0f30d19e18f4fb0c47c13aa568f871718579", size = 155379, upload-time = "2026-03-15T18:52:27.05Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/d269d834cb3a76291651256f3b9a5945e81d0a49ab9f4a498964e83c0416/charset_normalizer-3.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:cd5e2801c89992ed8c0a3f0293ae83c159a60d9a5d685005383ef4caca77f2c4", size = 169043, upload-time = "2026-03-15T18:52:28.502Z" },
+    { url = "https://files.pythonhosted.org/packages/23/06/28b29fba521a37a8932c6a84192175c34d49f84a6d4773fa63d05f9aff22/charset_normalizer-3.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:47955475ac79cc504ef2704b192364e51d0d473ad452caedd0002605f780101c", size = 148523, upload-time = "2026-03-15T18:52:29.956Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/68/687187c7e26cb24ccbd88e5069f5ef00eba804d36dde11d99aad0838ab45/charset_normalizer-3.4.6-py3-none-any.whl", hash = "sha256:947cf925bc916d90adba35a64c82aace04fa39b46b52d4630ece166655905a69", size = 61455, upload-time = "2026-03-15T18:53:23.833Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "click-plugins"
+version = "1.1.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/a4/34847b59150da33690a36da3681d6bbc2ec14ee9a846bc30a6746e5984e4/click_plugins-1.1.1.2.tar.gz", hash = "sha256:d7af3984a99d243c131aa1a828331e7630f4a88a9741fd05c927b204bcf92261", size = 8343, upload-time = "2025-06-25T00:47:37.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/9a/2abecb28ae875e39c8cad711eb1186d8d14eab564705325e77e4e6ab9ae5/click_plugins-1.1.1.2-py2.py3-none-any.whl", hash = "sha256:008d65743833ffc1f5417bf0e78e8d2c23aab04d9745ba817bd3e71b0feb6aa6", size = 11051, upload-time = "2025-06-25T00:47:36.731Z" },
+]
+
+[[package]]
+name = "cligj"
+version = "0.7.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ea/0d/837dbd5d8430fd0f01ed72c4cfb2f548180f4c68c635df84ce87956cff32/cligj-0.7.2.tar.gz", hash = "sha256:a4bc13d623356b373c2c27c53dbd9c68cae5d526270bfa71f6c6fa69669c6b27", size = 9803, upload-time = "2021-05-28T21:23:27.935Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/86/43fa9f15c5b9fb6e82620428827cd3c284aa933431405d1bcf5231ae3d3e/cligj-0.7.2-py3-none-any.whl", hash = "sha256:c1ca117dbce1fe20a5809dc96f01e1c2840f6dcc939b3ddbb1111bf330ba82df", size = 7069, upload-time = "2021-05-28T21:23:26.877Z" },
+]
+
+[[package]]
+name = "cogeo-mosaic"
+version = "9.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cachetools" },
+    { name = "click" },
+    { name = "click-plugins" },
+    { name = "cligj" },
+    { name = "httpx" },
+    { name = "morecantile" },
+    { name = "numpy" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "rasterio", version = "1.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "rasterio", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "rio-tiler" },
+    { name = "shapely" },
+    { name = "supermorecado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/48/614f53add12c39c86ac392a365f74c13bcea31d8e8cac4c2ccdb1d9f5cc3/cogeo_mosaic-9.1.0.tar.gz", hash = "sha256:f2102e68d3b1e7ee987ea85137ac198bf2f49d83739e4251a30265f4d5436828", size = 27951, upload-time = "2026-02-02T23:11:36.268Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/1a/be72e2cb8e1f14611d968da99c3689049637de367ed8f8c01132a2c3861e/cogeo_mosaic-9.1.0-py3-none-any.whl", hash = "sha256:b246182f12ae25d562ebc86987d2736617216e94a6a5d202460220faf7afc0d7", size = 39908, upload-time = "2026-02-02T23:11:38.05Z" },
+]
+
+[[package]]
+name = "color-operations"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/d5/8daa1179809f0d8eab39bd83ce8131e84691eb6ba55f19b7b365a822fea3/color_operations-0.2.0.tar.gz", hash = "sha256:f1bff5cff5992ec7d240f1979320a981f2e9f77d983e9298291e02f3ffaac9bf", size = 18042, upload-time = "2025-03-27T08:42:14.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/18/ed195e388f55ef46b89cee994a5dc7c36a6c76fd3c40ed1960b86dcba4ba/color_operations-0.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6fb9b74b9dc33832d08afc8f71ec4161531f48e8bf105d0412e9a718904c5369", size = 86416, upload-time = "2025-03-27T09:18:16.848Z" },
+    { url = "https://files.pythonhosted.org/packages/32/60/a9955ab7077309241d47f0b88d43b993abd49b753ed69449b8f2ced7c30c/color_operations-0.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:05838eee03df5304e014de76bd3ff19974964fc57dad8ce52cf56a9a62f5d572", size = 50869, upload-time = "2025-03-27T09:18:17.761Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/79/3fb8aee10ceb0278bd256eee35dd9fd9607370e4bb75a75a56173fb04394/color_operations-0.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5222cf35ca089637d3424eb42a0c9bfa25aa91dbf771759f6c8003b09b5134cc", size = 49243, upload-time = "2025-03-27T09:18:18.814Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/b5/1783a6834d10960a13c18b6a34f27597052510142ce89125662276184f99/color_operations-0.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2b807de37a40ee1d6fa91d122b0afe1df5f17ee60b9ef1bd38e8c134ffb3070d", size = 189098, upload-time = "2025-03-27T09:18:20.093Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d8/c33469d020f135414a5cd936bd31f4d3d2e3db557df94847ed59cf99a422/color_operations-0.2.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:780685c51e103f378c7bdffbafdd3e24f89b6dcd64079b7d6b3fbab7a23a06bf", size = 195175, upload-time = "2025-03-27T09:18:21.577Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/b6/1dbff90606551f6e802fbabb4e422d3261552a7d8b7a5f4e00f5727e7525/color_operations-0.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:676812cd90ef37e8ca214c376d0a43f223f2717bf37d0b513a4a57c2e1fcfc62", size = 133689, upload-time = "2025-03-27T09:18:22.696Z" },
+    { url = "https://files.pythonhosted.org/packages/50/69/e8c09a930c45cbdf6d3cf84e32a6e53a44a200c447bed8ddf94a75a3f372/color_operations-0.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:98a3348d1dab6c5fdd79a9eeb90cd81bf6f5bf6ca65a24414460d90be76c2c37", size = 86112, upload-time = "2025-03-27T09:18:23.824Z" },
+    { url = "https://files.pythonhosted.org/packages/72/eb/d66611577d721318d5a70dcfcd8d26194cfa14e958bd14a02631c1e712f2/color_operations-0.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:55a10f40ca59505a260e0f8b1ee392a2c049314177d3858ae477e8cc5daff07d", size = 50735, upload-time = "2025-03-27T09:18:24.727Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/57/13dbcc9913967489851f0b7d1c8d27840abe86e02d6e2e133d16db16d0d5/color_operations-0.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3d791eee208f208da9428f38ec9cad80bae4fa55bcde2af1b6d7e939d4f298d7", size = 49066, upload-time = "2025-03-27T09:18:26.084Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/47/b143e2f0ef04cb3e7e4b7236f8a572449ea7340860baf88374ed5ac4f358/color_operations-0.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4061484091fab17f9cd71620ee10ae5902ae643fddd18dc01f1ba85636d9a0e1", size = 198667, upload-time = "2025-03-27T09:18:27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/f4/e754800604d6449d895d7118b346bc2f3c5176cb759934b245aae530138d/color_operations-0.2.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1dfba9c174f3bbd425da388fab22a9670500711d0982e6f82e9999792542d3bf", size = 204259, upload-time = "2025-03-27T09:18:28.096Z" },
+    { url = "https://files.pythonhosted.org/packages/56/45/fbd35c3ebb1a2d85339d70262739502f99447aab76220a7126adcb3722f9/color_operations-0.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7c7fea5d7d0e7dd8d469e93e1bdd29c03afb63cebfcb02747104e482be85ea97", size = 133391, upload-time = "2025-03-27T09:18:29.26Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/93/fdd2e32eb1dd8929d36aabf8703adb9f438cfc79eb563b23140d0dd42475/color_operations-0.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fda310b57befc0aa3a02bf3863ff62adfedf7781ea8aab071887c5e82e5ab6c8", size = 84609, upload-time = "2025-03-27T09:18:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/c4/abdcc64288c8249f5f312dd7b8ff0ccddc31ddf2d776e13796e3464dcc21/color_operations-0.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bf3218834d19e4d195885cb0fbf7b1f98db2f4fc6dd43ca5d035655d7ad3b6f7", size = 50084, upload-time = "2025-03-27T09:18:32.294Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/75/5ce7c78e44f0660713e0b398620baa87d4ef1d98ec8ae42da2153afaf8d0/color_operations-0.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cee7d7da762f04110f15615ebd894820db38ab2aa262a940178a3d41350d2a0d", size = 48205, upload-time = "2025-03-27T09:18:33.22Z" },
+    { url = "https://files.pythonhosted.org/packages/28/54/eeffafffc815a8bb550d4ac1ae5a7bc86df0891e505b78c37a575ca35cb3/color_operations-0.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d2eb9dd747c081a801fc3b831bdf28f5115857934b00c4950c9ceecfb90d91f", size = 193013, upload-time = "2025-03-27T09:18:34.191Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/87/835e83190dd00e2737162f9d66e5a1afcff2b6fb580b6545760749a2e0ec/color_operations-0.2.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fcca6e5593f05cf164d1a302c91c012acab2edf5a4d38c6cc0d4bc7b62388e7", size = 198605, upload-time = "2025-03-27T09:18:35.794Z" },
+    { url = "https://files.pythonhosted.org/packages/60/a4/b1a27ad6490fd316a2e6ba4d05c8dd9f5d867414707d1cd18dcfdb3dbe1f/color_operations-0.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:317d11b425ab802e1c343d8d1356f538e102d6ca57e435b7386593c69f630ac5", size = 132514, upload-time = "2025-03-27T09:18:37.22Z" },
+]
+
+[[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.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+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.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
+    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
+    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
+    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
+    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
+    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
+    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
+    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
+    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
+    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "cramjam"
+version = "2.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/14/12/34bf6e840a79130dfd0da7badfb6f7810b8fcfd60e75b0539372667b41b6/cramjam-2.11.0.tar.gz", hash = "sha256:5c82500ed91605c2d9781380b378397012e25127e89d64f460fea6aeac4389b4", size = 99100, upload-time = "2025-07-27T21:25:07.559Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/89/8001f6a9b6b6e9fa69bec5319789083475d6f26d52aaea209d3ebf939284/cramjam-2.11.0-cp311-cp311-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:04cfa39118570e70e920a9b75c733299784b6d269733dbc791d9aaed6edd2615", size = 3559272, upload-time = "2025-07-27T21:22:01.988Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f3/001d00070ca92e5fbe6aacc768e455568b0cde46b0eb944561a4ea132300/cramjam-2.11.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:66a18f68506290349a256375d7aa2f645b9f7993c10fc4cc211db214e4e61d2b", size = 1861743, upload-time = "2025-07-27T21:22:03.754Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/35/041a3af01bf3f6158f120070f798546d4383b962b63c35cd91dcbf193e17/cramjam-2.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:50e7d65533857736cd56f6509cf2c4866f28ad84dd15b5bdbf2f8a81e77fa28a", size = 1699631, upload-time = "2025-07-27T21:22:05.192Z" },
+    { url = "https://files.pythonhosted.org/packages/17/eb/5358b238808abebd0c949c42635c3751204ca7cf82b29b984abe9f5e33c8/cramjam-2.11.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1f71989668458fc327ac15396db28d92df22f8024bb12963929798b2729d2df5", size = 2025603, upload-time = "2025-07-27T21:22:06.726Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/79/19dba7c03a27408d8d11b5a7a4a7908459cfd4e6f375b73264dc66517bf6/cramjam-2.11.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee77ac543f1e2b22af1e8be3ae589f729491b6090582340aacd77d1d757d9569", size = 1766283, upload-time = "2025-07-27T21:22:08.568Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ad/40e4b3408501d886d082db465c33971655fe82573c535428e52ab905f4d0/cramjam-2.11.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ad52784120e7e4d8a0b5b0517d185b8bf7f74f5e17272857ddc8951a628d9be1", size = 1854407, upload-time = "2025-07-27T21:22:10.518Z" },
+    { url = "https://files.pythonhosted.org/packages/36/6e/c1b60ceb6d7ea6ff8b0bf197520aefe23f878bf2bfb0de65f2b0c2f82cd1/cramjam-2.11.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4b86f8e6d9c1b3f9a75b2af870c93ceee0f1b827cd2507387540e053b35d7459", size = 2035793, upload-time = "2025-07-27T21:22:12.504Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/ad/32a8d5f4b1e3717787945ec6d71bd1c6e6bccba4b7e903fc0d9d4e4b08c3/cramjam-2.11.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:320d61938950d95da2371b46c406ec433e7955fae9f396c8e1bf148ffc187d11", size = 2067499, upload-time = "2025-07-27T21:22:14.067Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/cd/3b5a662736ea62ff7fa4c4a10a85e050bfdaad375cc53dc80427e8afe41c/cramjam-2.11.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41eafc8c1653a35a5c7e75ad48138f9f60085cc05cd99d592e5298552d944e9f", size = 1981853, upload-time = "2025-07-27T21:22:15.908Z" },
+    { url = "https://files.pythonhosted.org/packages/26/8e/1dbcfaaa7a702ee82ee683ec3a81656934dd7e04a7bc4ee854033686f98a/cramjam-2.11.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:03a7316c6bf763dfa34279335b27702321da44c455a64de58112968c0818ec4a", size = 2034514, upload-time = "2025-07-27T21:22:17.352Z" },
+    { url = "https://files.pythonhosted.org/packages/50/62/f11709bfdce74af79a88b410dcb76dedc97612166e759136931bf63cfd7b/cramjam-2.11.0-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:244c2ed8bd7ccbb294a2abe7ca6498db7e89d7eb5e744691dc511a7dc82e65ca", size = 2155343, upload-time = "2025-07-27T21:22:18.854Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/6d/3b98b61841a5376d9a9b8468ae58753a8e6cf22be9534a0fa5af4d8621cc/cramjam-2.11.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:405f8790bad36ce0b4bbdb964ad51507bfc7942c78447f25cb828b870a1d86a0", size = 2169367, upload-time = "2025-07-27T21:22:20.389Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/bd5db5c49dbebc8b002f1c4983101b28d2e7fc9419753db1c31ec22b03ef/cramjam-2.11.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:6b1b751a5411032b08fb3ac556160229ca01c6bbe4757bb3a9a40b951ebaac23", size = 2159334, upload-time = "2025-07-27T21:22:22.254Z" },
+    { url = "https://files.pythonhosted.org/packages/34/32/203c57acdb6eea727e7078b2219984e64ed4ad043c996ed56321301ba167/cramjam-2.11.0-cp311-cp311-win32.whl", hash = "sha256:5251585608778b9ac8effed544933df7ad85b4ba21ee9738b551f17798b215ac", size = 1605313, upload-time = "2025-07-27T21:22:24.126Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/bd/102d6deb87a8524ac11cddcd31a7612b8f20bf9b473c3c645045e3b957c7/cramjam-2.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:dca88bc8b68ce6d35dafd8c4d5d59a238a56c43fa02b74c2ce5f9dfb0d1ccb46", size = 1710991, upload-time = "2025-07-27T21:22:25.661Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/0d/7c84c913a5fae85b773a9dcf8874390f9d68ba0fcc6630efa7ff1541b950/cramjam-2.11.0-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:dba5c14b8b4f73ea1e65720f5a3fe4280c1d27761238378be8274135c60bbc6e", size = 3553368, upload-time = "2025-07-27T21:22:27.162Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/cc/4f6d185d8a744776f53035e72831ff8eefc2354f46ab836f4bd3c4f6c138/cramjam-2.11.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:11eb40722b3fcf3e6890fba46c711bf60f8dc26360a24876c85e52d76c33b25b", size = 1860014, upload-time = "2025-07-27T21:22:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/a8/626c76263085c6d5ded0e71823b411e9522bfc93ba6cc59855a5869296e7/cramjam-2.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aeb26e2898994b6e8319f19a4d37c481512acdcc6d30e1b5ecc9d8ec57e835cb", size = 1693512, upload-time = "2025-07-27T21:22:30.999Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/52/0851a16a62447532e30ba95a80e638926fdea869a34b4b5b9d0a020083ba/cramjam-2.11.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:4f8d82081ed7d8fe52c982bd1f06e4c7631a73fe1fb6d4b3b3f2404f87dc40fe", size = 2025285, upload-time = "2025-07-27T21:22:32.954Z" },
+    { url = "https://files.pythonhosted.org/packages/98/76/122e444f59dbc216451d8e3d8282c9665dc79eaf822f5f1470066be1b695/cramjam-2.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:092a3ec26e0a679305018380e4f652eae1b6dfe3fc3b154ee76aa6b92221a17c", size = 1761327, upload-time = "2025-07-27T21:22:34.484Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/bc/3a0189aef1af2b29632c039c19a7a1b752bc21a4053582a5464183a0ad3d/cramjam-2.11.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:529d6d667c65fd105d10bd83d1cd3f9869f8fd6c66efac9415c1812281196a92", size = 1854075, upload-time = "2025-07-27T21:22:36.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/80/8a6343b13778ce52d94bb8d5365a30c3aa951276b1857201fe79d7e2ad25/cramjam-2.11.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:555eb9c90c450e0f76e27d9ff064e64a8b8c6478ab1a5594c91b7bc5c82fd9f0", size = 2032710, upload-time = "2025-07-27T21:22:38.17Z" },
+    { url = "https://files.pythonhosted.org/packages/df/6b/cd1778a207c29eda10791e3dfa018b588001928086e179fc71254793c625/cramjam-2.11.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5edf4c9e32493035b514cf2ba0c969d81ccb31de63bd05490cc8bfe3b431674e", size = 2068353, upload-time = "2025-07-27T21:22:39.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/f0/5c2a5cd5711032f3b191ca50cb786c17689b4a9255f9f768866e6c9f04d9/cramjam-2.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fa2fe41f48c4d58d923803383b0737f048918b5a0d10390de9628bb6272b107", size = 1978104, upload-time = "2025-07-27T21:22:41.106Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/8b/b363a5fb2c3347504fe9a64f8d0f1e276844f0e532aa7162c061cd1ffee4/cramjam-2.11.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:9ca14cf1cabdb0b77d606db1bb9e9ca593b1dbd421fcaf251ec9a5431ec449f3", size = 2030779, upload-time = "2025-07-27T21:22:42.969Z" },
+    { url = "https://files.pythonhosted.org/packages/78/7b/d83dad46adb6c988a74361f81ad9c5c22642be53ad88616a19baedd06243/cramjam-2.11.0-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:309e95bf898829476bccf4fd2c358ec00e7ff73a12f95a3cdeeba4bb1d3683d5", size = 2155297, upload-time = "2025-07-27T21:22:44.6Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/be/60d9be4cb33d8740a4aa94c7513f2ef3c4eba4fd13536f086facbafade71/cramjam-2.11.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:86dca35d2f15ef22922411496c220f3c9e315d5512f316fe417461971cc1648d", size = 2169255, upload-time = "2025-07-27T21:22:46.534Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b0/4a595f01a243aec8ad272b160b161c44351190c35d98d7787919d962e9e5/cramjam-2.11.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:193c6488bd2f514cbc0bef5c18fad61a5f9c8d059dd56edf773b3b37f0e85496", size = 2155651, upload-time = "2025-07-27T21:22:48.46Z" },
+    { url = "https://files.pythonhosted.org/packages/38/47/7776659aaa677046b77f527106e53ddd47373416d8fcdb1e1a881ec5dc06/cramjam-2.11.0-cp312-cp312-win32.whl", hash = "sha256:514e2c008a8b4fa823122ca3ecab896eac41d9aa0f5fc881bd6264486c204e32", size = 1603568, upload-time = "2025-07-27T21:22:50.084Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b1/d53002729cfd94c5844ddfaf1233c86d29f2dbfc1b764a6562c41c044199/cramjam-2.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:53fed080476d5f6ad7505883ec5d1ec28ba36c2273db3b3e92d7224fe5e463db", size = 1709287, upload-time = "2025-07-27T21:22:51.534Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/8b/406c5dc0f8e82385519d8c299c40fd6a56d97eca3fcd6f5da8dad48de75b/cramjam-2.11.0-cp313-cp313-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:2c289729cc1c04e88bafa48b51082fb462b0a57dbc96494eab2be9b14dca62af", size = 3553330, upload-time = "2025-07-27T21:22:53.124Z" },
+    { url = "https://files.pythonhosted.org/packages/00/ad/4186884083d6e4125b285903e17841827ab0d6d0cffc86216d27ed91e91d/cramjam-2.11.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:045201ee17147e36cf43d8ae2fa4b4836944ac672df5874579b81cf6d40f1a1f", size = 1859756, upload-time = "2025-07-27T21:22:54.821Z" },
+    { url = "https://files.pythonhosted.org/packages/54/01/91b485cf76a7efef638151e8a7d35784dae2c4ff221b1aec2c083e4b106d/cramjam-2.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:619cd195d74c9e1d2a3ad78d63451d35379c84bd851aec552811e30842e1c67a", size = 1693609, upload-time = "2025-07-27T21:22:56.331Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/84/d0c80d279b2976870fc7d10f15dcb90a3c10c06566c6964b37c152694974/cramjam-2.11.0-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6eb3ae5ab72edb2ed68bdc0f5710f0a6cad7fd778a610ec2c31ee15e32d3921e", size = 2024912, upload-time = "2025-07-27T21:22:57.915Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/70/88f2a5cb904281ed5d3c111b8f7d5366639817a5470f059bcd26833fc870/cramjam-2.11.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df7da3f4b19e3078f9635f132d31b0a8196accb2576e3213ddd7a77f93317c20", size = 1760715, upload-time = "2025-07-27T21:22:59.528Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/06/cf5b02081132537d28964fb385fcef9ed9f8a017dd7d8c59d317e53ba50d/cramjam-2.11.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:57286b289cd557ac76c24479d8ecfb6c3d5b854cce54ccc7671f9a2f5e2a2708", size = 1853782, upload-time = "2025-07-27T21:23:01.07Z" },
+    { url = "https://files.pythonhosted.org/packages/57/27/63525087ed40a53d1867021b9c4858b80cc86274ffe7225deed067d88d92/cramjam-2.11.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:28952fbbf8b32c0cb7fa4be9bcccfca734bf0d0989f4b509dc7f2f70ba79ae06", size = 2032354, upload-time = "2025-07-27T21:23:03.021Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/ef/dbba082c6ebfb6410da4dd39a64e654d7194fcfd4567f85991a83fa4ec32/cramjam-2.11.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78ed2e4099812a438b545dfbca1928ec825e743cd253bc820372d6ef8c3adff4", size = 2068007, upload-time = "2025-07-27T21:23:04.526Z" },
+    { url = "https://files.pythonhosted.org/packages/35/ce/d902b9358a46a086938feae83b2251720e030f06e46006f4c1fc0ac9da20/cramjam-2.11.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d9aecd5c3845d415bd6c9957c93de8d93097e269137c2ecb0e5a5256374bdc8", size = 1977485, upload-time = "2025-07-27T21:23:06.058Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/03/982f54553244b0afcbdb2ad2065d460f0ab05a72a96896a969a1ca136a1e/cramjam-2.11.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:362fcf4d6f5e1242a4540812455f5a594949190f6fbc04f2ffbfd7ae0266d788", size = 2030447, upload-time = "2025-07-27T21:23:07.679Z" },
+    { url = "https://files.pythonhosted.org/packages/74/5f/748e54cdb665ec098ec519e23caacc65fc5ae58718183b071e33fc1c45b4/cramjam-2.11.0-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:13240b3dea41b1174456cb9426843b085dc1a2bdcecd9ee2d8f65ac5703374b0", size = 2154949, upload-time = "2025-07-27T21:23:09.366Z" },
+    { url = "https://files.pythonhosted.org/packages/69/81/c4e6cb06ed69db0dc81f9a8b1dc74995ebd4351e7a1877143f7031ff2700/cramjam-2.11.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:c54eed83726269594b9086d827decc7d2015696e31b99bf9b69b12d9063584fe", size = 2168925, upload-time = "2025-07-27T21:23:10.976Z" },
+    { url = "https://files.pythonhosted.org/packages/13/5b/966365523ce8290a08e163e3b489626c5adacdff2b3da9da1b0823dfb14e/cramjam-2.11.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:f8195006fdd0fc0a85b19df3d64a3ef8a240e483ae1dfc7ac6a4316019eb5df2", size = 2154950, upload-time = "2025-07-27T21:23:12.514Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/7d/7f8eb5c534b72b32c6eb79d74585bfee44a9a5647a14040bb65c31c2572d/cramjam-2.11.0-cp313-cp313-win32.whl", hash = "sha256:ccf30e3fe6d770a803dcdf3bb863fa44ba5dc2664d4610ba2746a3c73599f2e4", size = 1603199, upload-time = "2025-07-27T21:23:14.38Z" },
+    { url = "https://files.pythonhosted.org/packages/37/05/47b5e0bf7c41a3b1cdd3b7c2147f880c93226a6bef1f5d85183040cbdece/cramjam-2.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:ee36348a204f0a68b03400f4736224e9f61d1c6a1582d7f875c1ca56f0254268", size = 1708924, upload-time = "2025-07-27T21:23:16.332Z" },
+    { url = "https://files.pythonhosted.org/packages/de/07/a1051cdbbe6d723df16d756b97f09da7c1adb69e29695c58f0392bc12515/cramjam-2.11.0-cp314-cp314-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:7ba5e38c9fbd06f086f4a5a64a1a5b7b417cd3f8fc07a20e5c03651f72f36100", size = 3554141, upload-time = "2025-07-27T21:23:17.938Z" },
+    { url = "https://files.pythonhosted.org/packages/74/66/58487d2e16ef3d04f51a7c7f0e69823e806744b4c21101e89da4873074bc/cramjam-2.11.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8adeee57b41fe08e4520698a4b0bd3cc76dbd81f99424b806d70a5256a391d3", size = 1860353, upload-time = "2025-07-27T21:23:19.593Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b4/67f6254d166ffbcc9d5fa1b56876eaa920c32ebc8e9d3d525b27296b693b/cramjam-2.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b96a74fa03a636c8a7d76f700d50e9a8bc17a516d6a72d28711225d641e30968", size = 1693832, upload-time = "2025-07-27T21:23:21.185Z" },
+    { url = "https://files.pythonhosted.org/packages/55/a3/4e0b31c0d454ae70c04684ed7c13d3c67b4c31790c278c1e788cb804fa4a/cramjam-2.11.0-cp314-cp314-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c3811a56fa32e00b377ef79121c0193311fd7501f0fb378f254c7f083cc1fbe0", size = 2027080, upload-time = "2025-07-27T21:23:23.303Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/c7/5e8eed361d1d3b8be14f38a54852c5370cc0ceb2c2d543b8ba590c34f080/cramjam-2.11.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5d927e87461f8a0d448e4ab5eb2bca9f31ca5d8ea86d70c6f470bb5bc666d7e", size = 1761543, upload-time = "2025-07-27T21:23:24.991Z" },
+    { url = "https://files.pythonhosted.org/packages/09/0c/06b7f8b0ce9fde89470505116a01fc0b6cb92d406c4fb1e46f168b5d3fa5/cramjam-2.11.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f1f5c450121430fd89cb5767e0a9728ecc65997768fd4027d069cb0368af62f9", size = 1854636, upload-time = "2025-07-27T21:23:26.987Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c6/6ebc02c9d5acdf4e5f2b1ec6e1252bd5feee25762246798ae823b3347457/cramjam-2.11.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:724aa7490be50235d97f07e2ca10067927c5d7f336b786ddbc868470e822aa25", size = 2032715, upload-time = "2025-07-27T21:23:28.603Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/77/a122971c23f5ca4b53e4322c647ac7554626c95978f92d19419315dddd05/cramjam-2.11.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:54c4637122e7cfd7aac5c1d3d4c02364f446d6923ea34cf9d0e8816d6e7a4936", size = 2069039, upload-time = "2025-07-27T21:23:30.319Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0f/f6121b90b86b9093c066889274d26a1de3f29969d45c2ed1ecbe2033cb78/cramjam-2.11.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17eb39b1696179fb471eea2de958fa21f40a2cd8bf6b40d428312d5541e19dc4", size = 1979566, upload-time = "2025-07-27T21:23:32.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/f95bc57fd7f4166ce6da816cfa917fb7df4bb80e669eb459d85586498414/cramjam-2.11.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:36aa5a798aa34e11813a80425a30d8e052d8de4a28f27bfc0368cfc454d1b403", size = 2030905, upload-time = "2025-07-27T21:23:33.696Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/52/e429de4e8bc86ee65e090dae0f87f45abd271742c63fb2d03c522ffde28a/cramjam-2.11.0-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:449fca52774dc0199545fbf11f5128933e5a6833946707885cf7be8018017839", size = 2155592, upload-time = "2025-07-27T21:23:35.375Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/6c/65a7a0207787ad39ad804af4da7f06a60149de19481d73d270b540657234/cramjam-2.11.0-cp314-cp314-musllinux_1_1_i686.whl", hash = "sha256:d87d37b3d476f4f7623c56a232045d25bd9b988314702ea01bd9b4a94948a778", size = 2170839, upload-time = "2025-07-27T21:23:37.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/c5/5c5db505ba692bc844246b066e23901d5905a32baf2f33719c620e65887f/cramjam-2.11.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:26cb45c47d71982d76282e303931c6dd4baee1753e5d48f9a89b3a63e690b3a3", size = 2157236, upload-time = "2025-07-27T21:23:38.854Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/22/88e6693e60afe98901e5bbe91b8dea193e3aa7f42e2770f9c3339f5c1065/cramjam-2.11.0-cp314-cp314-win32.whl", hash = "sha256:4efe919d443c2fd112fe25fe636a52f9628250c9a50d9bddb0488d8a6c09acc6", size = 1604136, upload-time = "2025-07-27T21:23:40.56Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/f8/01618801cd59ccedcc99f0f96d20be67d8cfc3497da9ccaaad6b481781dd/cramjam-2.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:ccec3524ea41b9abd5600e3e27001fd774199dbb4f7b9cb248fcee37d4bda84c", size = 1710272, upload-time = "2025-07-27T21:23:42.236Z" },
+    { url = "https://files.pythonhosted.org/packages/40/81/6cdb3ed222d13ae86bda77aafe8d50566e81a1169d49ed195b6263610704/cramjam-2.11.0-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:966ac9358b23d21ecd895c418c048e806fd254e46d09b1ff0cdad2eba195ea3e", size = 3559671, upload-time = "2025-07-27T21:23:44.504Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/43/52b7e54fe5ba1ef0270d9fdc43dabd7971f70ea2d7179be918c997820247/cramjam-2.11.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:387f09d647a0d38dcb4539f8a14281f8eb6bb1d3e023471eb18a5974b2121c86", size = 1867876, upload-time = "2025-07-27T21:23:46.987Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/28/30d5b8d10acd30db3193bc562a313bff722888eaa45cfe32aa09389f2b24/cramjam-2.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:665b0d8fbbb1a7f300265b43926457ec78385200133e41fef19d85790fc1e800", size = 1695562, upload-time = "2025-07-27T21:23:48.644Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/86/ec806f986e01b896a650655024ea52a13e25c3ac8a3a382f493089483cdc/cramjam-2.11.0-cp314-cp314t-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ca905387c7a371531b9622d93471be4d745ef715f2890c3702479cd4fc85aa51", size = 2025056, upload-time = "2025-07-27T21:23:50.404Z" },
+    { url = "https://files.pythonhosted.org/packages/09/43/c2c17586b90848d29d63181f7d14b8bd3a7d00975ad46e3edf2af8af7e1f/cramjam-2.11.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c1aa56aef2c8af55a21ed39040a94a12b53fb23beea290f94d19a76027e2ffb", size = 1764084, upload-time = "2025-07-27T21:23:52.265Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/a9/68bc334fadb434a61df10071dc8606702aa4f5b6cdb2df62474fc21d2845/cramjam-2.11.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e5db59c1cdfaa2ab85cc988e602d6919495f735ca8a5fd7603608eb1e23c26d5", size = 1854859, upload-time = "2025-07-27T21:23:54.085Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4e/b48e67835b5811ec5e9cb2e2bcba9c3fd76dab3e732569fe801b542c6ca9/cramjam-2.11.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b1f893014f00fe5e89a660a032e813bf9f6d91de74cd1490cdb13b2b59d0c9a3", size = 2035970, upload-time = "2025-07-27T21:23:55.758Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/70/d2ac33d572b4d90f7f0f2c8a1d60fb48f06b128fdc2c05f9b49891bb0279/cramjam-2.11.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c26a1eb487947010f5de24943bd7c422dad955b2b0f8650762539778c380ca89", size = 2069320, upload-time = "2025-07-27T21:23:57.494Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/4c/85cec77af4a74308ba5fca8e296c4e2f80ec465c537afc7ab1e0ca2f9a00/cramjam-2.11.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d5c8bfb438d94e7b892d1426da5fc4b4a5370cc360df9b8d9d77c33b896c37e", size = 1982668, upload-time = "2025-07-27T21:23:59.126Z" },
+    { url = "https://files.pythonhosted.org/packages/55/45/938546d1629e008cc3138df7c424ef892719b1796ff408a2ab8550032e5e/cramjam-2.11.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:cb1fb8c9337ab0da25a01c05d69a0463209c347f16512ac43be5986f3d1ebaf4", size = 2034028, upload-time = "2025-07-27T21:24:00.865Z" },
+    { url = "https://files.pythonhosted.org/packages/01/76/b5a53e20505555f1640e66dcf70394bcf51a1a3a072aa18ea35135a0f9ed/cramjam-2.11.0-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:1f6449f6de52dde3e2f1038284910c8765a397a25e2d05083870f3f5e7fc682c", size = 2155513, upload-time = "2025-07-27T21:24:02.92Z" },
+    { url = "https://files.pythonhosted.org/packages/84/12/8d3f6ceefae81bbe45a347fdfa2219d9f3ac75ebc304f92cd5fcb4fbddc5/cramjam-2.11.0-cp314-cp314t-musllinux_1_1_i686.whl", hash = "sha256:382dec4f996be48ed9c6958d4e30c2b89435d7c2c4dbf32480b3b8886293dd65", size = 2170035, upload-time = "2025-07-27T21:24:04.558Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/85/3be6f0a1398f976070672be64f61895f8839857618a2d8cc0d3ab529d3dc/cramjam-2.11.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:d388bd5723732c3afe1dd1d181e4213cc4e1be210b080572e7d5749f6e955656", size = 2160229, upload-time = "2025-07-27T21:24:06.729Z" },
+    { url = "https://files.pythonhosted.org/packages/57/5e/66cfc3635511b20014bbb3f2ecf0095efb3049e9e96a4a9e478e4f3d7b78/cramjam-2.11.0-cp314-cp314t-win32.whl", hash = "sha256:0a70ff17f8e1d13f322df616505550f0f4c39eda62290acb56f069d4857037c8", size = 1610267, upload-time = "2025-07-27T21:24:08.428Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/c6/c71e82e041c95ffe6a92ac707785500aa2a515a4339c2c7dd67e3c449249/cramjam-2.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:028400d699442d40dbda02f74158c73d05cb76587a12490d0bfedd958fd49188", size = 1713108, upload-time = "2025-07-27T21:24:10.147Z" },
+    { url = "https://files.pythonhosted.org/packages/81/da/b3301962ccd6fce9fefa1ecd8ea479edaeaa38fadb1f34d5391d2587216a/cramjam-2.11.0-pp311-pypy311_pp73-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:52d5db3369f95b27b9f3c14d067acb0b183333613363ed34268c9e04560f997f", size = 3573546, upload-time = "2025-07-27T21:24:52.944Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/c2/410ddb8ad4b9dfb129284666293cb6559479645da560f7077dc19d6bee9e/cramjam-2.11.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4820516366d455b549a44d0e2210ee7c4575882dda677564ce79092588321d54", size = 1873654, upload-time = "2025-07-27T21:24:54.958Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/99/f68a443c64f7ce7aff5bed369b0aa5b2fac668fa3dfd441837e316e97a1f/cramjam-2.11.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d9e5db525dc0a950a825202f84ee68d89a072479e07da98795a3469df942d301", size = 1702846, upload-time = "2025-07-27T21:24:57.124Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/02/0ff358ab773def1ee3383587906c453d289953171e9c92db84fdd01bf172/cramjam-2.11.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62ab4971199b2270005359cdc379bc5736071dc7c9a228581c5122d9ffaac50c", size = 1773683, upload-time = "2025-07-27T21:24:59.28Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/31/3298e15f87c9cf2aabdbdd90b153d8644cf989cb42a45d68a1b71e1f7aaf/cramjam-2.11.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24758375cc5414d3035ca967ebb800e8f24604ececcba3c67d6f0218201ebf2d", size = 1994136, upload-time = "2025-07-27T21:25:01.565Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/90/20d1747255f1ee69a412e319da51ea594c18cca195e7a4d4c713f045eff5/cramjam-2.11.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6c2eea545fef1065c7dd4eda991666fd9c783fbc1d226592ccca8d8891c02f23", size = 1714982, upload-time = "2025-07-27T21:25:05.79Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "46.0.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a4/ba/04b1bd4218cbc58dc90ce967106d51582371b898690f3ae0402876cc4f34/cryptography-46.0.6.tar.gz", hash = "sha256:27550628a518c5c6c903d84f637fbecf287f6cb9ced3804838a1295dc1fd0759", size = 750542, upload-time = "2026-03-25T23:34:53.396Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/23/9285e15e3bc57325b0a72e592921983a701efc1ee8f91c06c5f0235d86d9/cryptography-46.0.6-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:64235194bad039a10bb6d2d930ab3323baaec67e2ce36215fd0952fad0930ca8", size = 7176401, upload-time = "2026-03-25T23:33:22.096Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/e61f8f13950ab6195b31913b42d39f0f9afc7d93f76710f299b5ec286ae6/cryptography-46.0.6-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:26031f1e5ca62fcb9d1fcb34b2b60b390d1aacaa15dc8b895a9ed00968b97b30", size = 4275275, upload-time = "2026-03-25T23:33:23.844Z" },
+    { url = "https://files.pythonhosted.org/packages/19/69/732a736d12c2631e140be2348b4ad3d226302df63ef64d30dfdb8db7ad1c/cryptography-46.0.6-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9a693028b9cbe51b5a1136232ee8f2bc242e4e19d456ded3fa7c86e43c713b4a", size = 4425320, upload-time = "2026-03-25T23:33:25.703Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/12/123be7292674abf76b21ac1fc0e1af50661f0e5b8f0ec8285faac18eb99e/cryptography-46.0.6-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:67177e8a9f421aa2d3a170c3e56eca4e0128883cf52a071a7cbf53297f18b175", size = 4278082, upload-time = "2026-03-25T23:33:27.423Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/ba/d5e27f8d68c24951b0a484924a84c7cdaed7502bac9f18601cd357f8b1d2/cryptography-46.0.6-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:d9528b535a6c4f8ff37847144b8986a9a143585f0540fbcb1a98115b543aa463", size = 4926514, upload-time = "2026-03-25T23:33:29.206Z" },
+    { url = "https://files.pythonhosted.org/packages/34/71/1ea5a7352ae516d5512d17babe7e1b87d9db5150b21f794b1377eac1edc0/cryptography-46.0.6-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:22259338084d6ae497a19bae5d4c66b7ca1387d3264d1c2c0e72d9e9b6a77b97", size = 4457766, upload-time = "2026-03-25T23:33:30.834Z" },
+    { url = "https://files.pythonhosted.org/packages/01/59/562be1e653accee4fdad92c7a2e88fced26b3fdfce144047519bbebc299e/cryptography-46.0.6-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:760997a4b950ff00d418398ad73fbc91aa2894b5c1db7ccb45b4f68b42a63b3c", size = 3986535, upload-time = "2026-03-25T23:33:33.02Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/8b/b1ebfeb788bf4624d36e45ed2662b8bd43a05ff62157093c1539c1288a18/cryptography-46.0.6-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:3dfa6567f2e9e4c5dceb8ccb5a708158a2a871052fa75c8b78cb0977063f1507", size = 4277618, upload-time = "2026-03-25T23:33:34.567Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/52/a005f8eabdb28df57c20f84c44d397a755782d6ff6d455f05baa2785bd91/cryptography-46.0.6-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:cdcd3edcbc5d55757e5f5f3d330dd00007ae463a7e7aa5bf132d1f22a4b62b19", size = 4890802, upload-time = "2026-03-25T23:33:37.034Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/4d/8e7d7245c79c617d08724e2efa397737715ca0ec830ecb3c91e547302555/cryptography-46.0.6-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:d4e4aadb7fc1f88687f47ca20bb7227981b03afaae69287029da08096853b738", size = 4457425, upload-time = "2026-03-25T23:33:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/5c/f6c3596a1430cec6f949085f0e1a970638d76f81c3ea56d93d564d04c340/cryptography-46.0.6-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2b417edbe8877cda9022dde3a008e2deb50be9c407eef034aeeb3a8b11d9db3c", size = 4405530, upload-time = "2026-03-25T23:33:40.842Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/c9/9f9cea13ee2dbde070424e0c4f621c091a91ffcc504ffea5e74f0e1daeff/cryptography-46.0.6-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:380343e0653b1c9d7e1f55b52aaa2dbb2fdf2730088d48c43ca1c7c0abb7cc2f", size = 4667896, upload-time = "2026-03-25T23:33:42.781Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/b5/1895bc0821226f129bc74d00eccfc6a5969e2028f8617c09790bf89c185e/cryptography-46.0.6-cp311-abi3-win32.whl", hash = "sha256:bcb87663e1f7b075e48c3be3ecb5f0b46c8fc50b50a97cf264e7f60242dca3f2", size = 3026348, upload-time = "2026-03-25T23:33:45.021Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f8/c9bcbf0d3e6ad288b9d9aa0b1dee04b063d19e8c4f871855a03ab3a297ab/cryptography-46.0.6-cp311-abi3-win_amd64.whl", hash = "sha256:6739d56300662c468fddb0e5e291f9b4d084bead381667b9e654c7dd81705124", size = 3483896, upload-time = "2026-03-25T23:33:46.649Z" },
+    { url = "https://files.pythonhosted.org/packages/01/41/3a578f7fd5c70611c0aacba52cd13cb364a5dee895a5c1d467208a9380b0/cryptography-46.0.6-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:2ef9e69886cbb137c2aef9772c2e7138dc581fad4fcbcf13cc181eb5a3ab6275", size = 7117147, upload-time = "2026-03-25T23:33:48.249Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/87/887f35a6fca9dde90cad08e0de0c89263a8e59b2d2ff904fd9fcd8025b6f/cryptography-46.0.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7f417f034f91dcec1cb6c5c35b07cdbb2ef262557f701b4ecd803ee8cefed4f4", size = 4266221, upload-time = "2026-03-25T23:33:49.874Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/a8/0a90c4f0b0871e0e3d1ed126aed101328a8a57fd9fd17f00fb67e82a51ca/cryptography-46.0.6-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d24c13369e856b94892a89ddf70b332e0b70ad4a5c43cf3e9cb71d6d7ffa1f7b", size = 4408952, upload-time = "2026-03-25T23:33:52.128Z" },
+    { url = "https://files.pythonhosted.org/packages/16/0b/b239701eb946523e4e9f329336e4ff32b1247e109cbab32d1a7b61da8ed7/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:aad75154a7ac9039936d50cf431719a2f8d4ed3d3c277ac03f3339ded1a5e707", size = 4270141, upload-time = "2026-03-25T23:33:54.11Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/a8/976acdd4f0f30df7b25605f4b9d3d89295351665c2091d18224f7ad5cdbf/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:3c21d92ed15e9cfc6eb64c1f5a0326db22ca9c2566ca46d845119b45b4400361", size = 4904178, upload-time = "2026-03-25T23:33:55.725Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/1b/bf0e01a88efd0e59679b69f42d4afd5bced8700bb5e80617b2d63a3741af/cryptography-46.0.6-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:4668298aef7cddeaf5c6ecc244c2302a2b8e40f384255505c22875eebb47888b", size = 4441812, upload-time = "2026-03-25T23:33:57.364Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/8b/11df86de2ea389c65aa1806f331cae145f2ed18011f30234cc10ca253de8/cryptography-46.0.6-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:8ce35b77aaf02f3b59c90b2c8a05c73bac12cea5b4e8f3fbece1f5fddea5f0ca", size = 3963923, upload-time = "2026-03-25T23:33:59.361Z" },
+    { url = "https://files.pythonhosted.org/packages/91/e0/207fb177c3a9ef6a8108f234208c3e9e76a6aa8cf20d51932916bd43bda0/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:c89eb37fae9216985d8734c1afd172ba4927f5a05cfd9bf0e4863c6d5465b013", size = 4269695, upload-time = "2026-03-25T23:34:00.909Z" },
+    { url = "https://files.pythonhosted.org/packages/21/5e/19f3260ed1e95bced52ace7501fabcd266df67077eeb382b79c81729d2d3/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:ed418c37d095aeddf5336898a132fba01091f0ac5844e3e8018506f014b6d2c4", size = 4869785, upload-time = "2026-03-25T23:34:02.796Z" },
+    { url = "https://files.pythonhosted.org/packages/10/38/cd7864d79aa1d92ef6f1a584281433419b955ad5a5ba8d1eb6c872165bcb/cryptography-46.0.6-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:69cf0056d6947edc6e6760e5f17afe4bea06b56a9ac8a06de9d2bd6b532d4f3a", size = 4441404, upload-time = "2026-03-25T23:34:04.35Z" },
+    { url = "https://files.pythonhosted.org/packages/09/0a/4fe7a8d25fed74419f91835cf5829ade6408fd1963c9eae9c4bce390ecbb/cryptography-46.0.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e7304c4f4e9490e11efe56af6713983460ee0780f16c63f219984dab3af9d2d", size = 4397549, upload-time = "2026-03-25T23:34:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/a0/7d738944eac6513cd60a8da98b65951f4a3b279b93479a7e8926d9cd730b/cryptography-46.0.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b928a3ca837c77a10e81a814a693f2295200adb3352395fad024559b7be7a736", size = 4651874, upload-time = "2026-03-25T23:34:07.916Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/f1/c2326781ca05208845efca38bf714f76939ae446cd492d7613808badedf1/cryptography-46.0.6-cp314-cp314t-win32.whl", hash = "sha256:97c8115b27e19e592a05c45d0dd89c57f81f841cc9880e353e0d3bf25b2139ed", size = 3001511, upload-time = "2026-03-25T23:34:09.892Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/57/fe4a23eb549ac9d903bd4698ffda13383808ef0876cc912bcb2838799ece/cryptography-46.0.6-cp314-cp314t-win_amd64.whl", hash = "sha256:c797e2517cb7880f8297e2c0f43bb910e91381339336f75d2c1c2cbf811b70b4", size = 3471692, upload-time = "2026-03-25T23:34:11.613Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/cc/f330e982852403da79008552de9906804568ae9230da8432f7496ce02b71/cryptography-46.0.6-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:12cae594e9473bca1a7aceb90536060643128bb274fcea0fc459ab90f7d1ae7a", size = 7162776, upload-time = "2026-03-25T23:34:13.308Z" },
+    { url = "https://files.pythonhosted.org/packages/49/b3/dc27efd8dcc4bff583b3f01d4a3943cd8b5821777a58b3a6a5f054d61b79/cryptography-46.0.6-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:639301950939d844a9e1c4464d7e07f902fe9a7f6b215bb0d4f28584729935d8", size = 4270529, upload-time = "2026-03-25T23:34:15.019Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/05/e8d0e6eb4f0d83365b3cb0e00eb3c484f7348db0266652ccd84632a3d58d/cryptography-46.0.6-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ed3775295fb91f70b4027aeba878d79b3e55c0b3e97eaa4de71f8f23a9f2eb77", size = 4414827, upload-time = "2026-03-25T23:34:16.604Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/97/daba0f5d2dc6d855e2dcb70733c812558a7977a55dd4a6722756628c44d1/cryptography-46.0.6-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:8927ccfbe967c7df312ade694f987e7e9e22b2425976ddbf28271d7e58845290", size = 4271265, upload-time = "2026-03-25T23:34:18.586Z" },
+    { url = "https://files.pythonhosted.org/packages/89/06/fe1fce39a37ac452e58d04b43b0855261dac320a2ebf8f5260dd55b201a9/cryptography-46.0.6-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:b12c6b1e1651e42ab5de8b1e00dc3b6354fdfd778e7fa60541ddacc27cd21410", size = 4916800, upload-time = "2026-03-25T23:34:20.561Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/8a/b14f3101fe9c3592603339eb5d94046c3ce5f7fc76d6512a2d40efd9724e/cryptography-46.0.6-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:063b67749f338ca9c5a0b7fe438a52c25f9526b851e24e6c9310e7195aad3b4d", size = 4448771, upload-time = "2026-03-25T23:34:22.406Z" },
+    { url = "https://files.pythonhosted.org/packages/01/b3/0796998056a66d1973fd52ee89dc1bb3b6581960a91ad4ac705f182d398f/cryptography-46.0.6-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:02fad249cb0e090b574e30b276a3da6a149e04ee2f049725b1f69e7b8351ec70", size = 3978333, upload-time = "2026-03-25T23:34:24.281Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3d/db200af5a4ffd08918cd55c08399dc6c9c50b0bc72c00a3246e099d3a849/cryptography-46.0.6-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:7e6142674f2a9291463e5e150090b95a8519b2fb6e6aaec8917dd8d094ce750d", size = 4271069, upload-time = "2026-03-25T23:34:25.895Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/18/61acfd5b414309d74ee838be321c636fe71815436f53c9f0334bf19064fa/cryptography-46.0.6-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:456b3215172aeefb9284550b162801d62f5f264a081049a3e94307fe20792cfa", size = 4878358, upload-time = "2026-03-25T23:34:27.67Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/65/5bf43286d566f8171917cae23ac6add941654ccf085d739195a4eacf1674/cryptography-46.0.6-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:341359d6c9e68834e204ceaf25936dffeafea3829ab80e9503860dcc4f4dac58", size = 4448061, upload-time = "2026-03-25T23:34:29.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/25/7e49c0fa7205cf3597e525d156a6bce5b5c9de1fd7e8cb01120e459f205a/cryptography-46.0.6-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9a9c42a2723999a710445bc0d974e345c32adfd8d2fac6d8a251fa829ad31cfb", size = 4399103, upload-time = "2026-03-25T23:34:32.036Z" },
+    { url = "https://files.pythonhosted.org/packages/44/46/466269e833f1c4718d6cd496ffe20c56c9c8d013486ff66b4f69c302a68d/cryptography-46.0.6-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6617f67b1606dfd9fe4dbfa354a9508d4a6d37afe30306fe6c101b7ce3274b72", size = 4659255, upload-time = "2026-03-25T23:34:33.679Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/09/ddc5f630cc32287d2c953fc5d32705e63ec73e37308e5120955316f53827/cryptography-46.0.6-cp38-abi3-win32.whl", hash = "sha256:7f6690b6c55e9c5332c0b59b9c8a3fb232ebf059094c17f9019a51e9827df91c", size = 3010660, upload-time = "2026-03-25T23:34:35.418Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/82/ca4893968aeb2709aacfb57a30dec6fa2ab25b10fa9f064b8882ce33f599/cryptography-46.0.6-cp38-abi3-win_amd64.whl", hash = "sha256:79e865c642cfc5c0b3eb12af83c35c5aeff4fa5c672dc28c43721c2c9fdd2f0f", size = 3471160, upload-time = "2026-03-25T23:34:37.191Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/84/7ccff00ced5bac74b775ce0beb7d1be4e8637536b522b5df9b73ada42da2/cryptography-46.0.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:2ea0f37e9a9cf0df2952893ad145fd9627d326a59daec9b0802480fa3bcd2ead", size = 3475444, upload-time = "2026-03-25T23:34:38.944Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/1f/4c926f50df7749f000f20eede0c896769509895e2648db5da0ed55db711d/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:a3e84d5ec9ba01f8fd03802b2147ba77f0c8f2617b2aff254cedd551844209c8", size = 4218227, upload-time = "2026-03-25T23:34:40.871Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/65/707be3ffbd5f786028665c3223e86e11c4cda86023adbc56bd72b1b6bab5/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:12f0fa16cc247b13c43d56d7b35287ff1569b5b1f4c5e87e92cc4fcc00cd10c0", size = 4381399, upload-time = "2026-03-25T23:34:42.609Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6d/73557ed0ef7d73d04d9aba745d2c8e95218213687ee5e76b7d236a5030fc/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:50575a76e2951fe7dbd1f56d181f8c5ceeeb075e9ff88e7ad997d2f42af06e7b", size = 4217595, upload-time = "2026-03-25T23:34:44.205Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c5/e1594c4eec66a567c3ac4400008108a415808be2ce13dcb9a9045c92f1a0/cryptography-46.0.6-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:90e5f0a7b3be5f40c3a0a0eafb32c681d8d2c181fc2a1bdabe9b3f611d9f6b1a", size = 4380912, upload-time = "2026-03-25T23:34:46.328Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/89/843b53614b47f97fe1abc13f9a86efa5ec9e275292c457af1d4a60dc80e0/cryptography-46.0.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6728c49e3b2c180ef26f8e9f0a883a2c585638db64cf265b49c9ba10652d430e", size = 3409955, upload-time = "2026-03-25T23:34:48.465Z" },
+]
+
+[[package]]
+name = "cssselect2"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tinycss2" },
+    { name = "webencodings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e0/20/92eaa6b0aec7189fa4b75c890640e076e9e793095721db69c5c81142c2e1/cssselect2-0.9.0.tar.gz", hash = "sha256:759aa22c216326356f65e62e791d66160a0f9c91d1424e8d8adc5e74dddfc6fb", size = 35595, upload-time = "2026-02-12T17:16:39.614Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/0e/8459ca4413e1a21a06c97d134bfaf18adfd27cea068813dc0faae06cbf00/cssselect2-0.9.0-py3-none-any.whl", hash = "sha256:6a99e5f91f9a016a304dd929b0966ca464bcfda15177b6fb4a118fc0fb5d9563", size = 15453, upload-time = "2026-02-12T17:16:38.317Z" },
+]
+
+[[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.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/b7/cd8080344452e4874aae67c40d8940e2b4d47b01601a8fd9f44786c757c7/debugpy-1.8.20.tar.gz", hash = "sha256:55bc8701714969f1ab89a6d5f2f3d40c36f91b2cbe2f65d98bf8196f6a6a2c33", size = 1645207, upload-time = "2026-01-29T23:03:28.199Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/56/c3baf5cbe4dd77427fd9aef99fcdade259ad128feeb8a786c246adb838e5/debugpy-1.8.20-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:eada6042ad88fa1571b74bd5402ee8b86eded7a8f7b827849761700aff171f1b", size = 2208318, upload-time = "2026-01-29T23:03:36.481Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/7d/4fa79a57a8e69fe0d9763e98d1110320f9ecd7f1f362572e3aafd7417c9d/debugpy-1.8.20-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:7de0b7dfeedc504421032afba845ae2a7bcc32ddfb07dae2c3ca5442f821c344", size = 3171493, upload-time = "2026-01-29T23:03:37.775Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/f2/1e8f8affe51e12a26f3a8a8a4277d6e60aa89d0a66512f63b1e799d424a4/debugpy-1.8.20-cp311-cp311-win32.whl", hash = "sha256:773e839380cf459caf73cc533ea45ec2737a5cc184cf1b3b796cd4fd98504fec", size = 5209240, upload-time = "2026-01-29T23:03:39.109Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/92/1cb532e88560cbee973396254b21bece8c5d7c2ece958a67afa08c9f10dc/debugpy-1.8.20-cp311-cp311-win_amd64.whl", hash = "sha256:1f7650546e0eded1902d0f6af28f787fa1f1dbdbc97ddabaf1cd963a405930cb", size = 5233481, upload-time = "2026-01-29T23:03:40.659Z" },
+    { url = "https://files.pythonhosted.org/packages/14/57/7f34f4736bfb6e00f2e4c96351b07805d83c9a7b33d28580ae01374430f7/debugpy-1.8.20-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:4ae3135e2089905a916909ef31922b2d733d756f66d87345b3e5e52b7a55f13d", size = 2550686, upload-time = "2026-01-29T23:03:42.023Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/78/b193a3975ca34458f6f0e24aaf5c3e3da72f5401f6054c0dfd004b41726f/debugpy-1.8.20-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:88f47850a4284b88bd2bfee1f26132147d5d504e4e86c22485dfa44b97e19b4b", size = 4310588, upload-time = "2026-01-29T23:03:43.314Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/55/f14deb95eaf4f30f07ef4b90a8590fc05d9e04df85ee379712f6fb6736d7/debugpy-1.8.20-cp312-cp312-win32.whl", hash = "sha256:4057ac68f892064e5f98209ab582abfee3b543fb55d2e87610ddc133a954d390", size = 5331372, upload-time = "2026-01-29T23:03:45.526Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/39/2bef246368bd42f9bd7cba99844542b74b84dacbdbea0833e610f384fee8/debugpy-1.8.20-cp312-cp312-win_amd64.whl", hash = "sha256:a1a8f851e7cf171330679ef6997e9c579ef6dd33c9098458bd9986a0f4ca52e3", size = 5372835, upload-time = "2026-01-29T23:03:47.245Z" },
+    { url = "https://files.pythonhosted.org/packages/15/e2/fc500524cc6f104a9d049abc85a0a8b3f0d14c0a39b9c140511c61e5b40b/debugpy-1.8.20-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:5dff4bb27027821fdfcc9e8f87309a28988231165147c31730128b1c983e282a", size = 2539560, upload-time = "2026-01-29T23:03:48.738Z" },
+    { url = "https://files.pythonhosted.org/packages/90/83/fb33dcea789ed6018f8da20c5a9bc9d82adc65c0c990faed43f7c955da46/debugpy-1.8.20-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:84562982dd7cf5ebebfdea667ca20a064e096099997b175fe204e86817f64eaf", size = 4293272, upload-time = "2026-01-29T23:03:50.169Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/25/b1e4a01bfb824d79a6af24b99ef291e24189080c93576dfd9b1a2815cd0f/debugpy-1.8.20-cp313-cp313-win32.whl", hash = "sha256:da11dea6447b2cadbf8ce2bec59ecea87cc18d2c574980f643f2d2dfe4862393", size = 5331208, upload-time = "2026-01-29T23:03:51.547Z" },
+    { url = "https://files.pythonhosted.org/packages/13/f7/a0b368ce54ffff9e9028c098bd2d28cfc5b54f9f6c186929083d4c60ba58/debugpy-1.8.20-cp313-cp313-win_amd64.whl", hash = "sha256:eb506e45943cab2efb7c6eafdd65b842f3ae779f020c82221f55aca9de135ed7", size = 5372930, upload-time = "2026-01-29T23:03:53.585Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2e/f6cb9a8a13f5058f0a20fe09711a7b726232cd5a78c6a7c05b2ec726cff9/debugpy-1.8.20-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9c74df62fc064cd5e5eaca1353a3ef5a5d50da5eb8058fcef63106f7bebe6173", size = 2538066, upload-time = "2026-01-29T23:03:54.999Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/56/6ddca50b53624e1ca3ce1d1e49ff22db46c47ea5fb4c0cc5c9b90a616364/debugpy-1.8.20-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:077a7447589ee9bc1ff0cdf443566d0ecf540ac8aa7333b775ebcb8ce9f4ecad", size = 4269425, upload-time = "2026-01-29T23:03:56.518Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/d9/d64199c14a0d4c476df46c82470a3ce45c8d183a6796cfb5e66533b3663c/debugpy-1.8.20-cp314-cp314-win32.whl", hash = "sha256:352036a99dd35053b37b7803f748efc456076f929c6a895556932eaf2d23b07f", size = 5331407, upload-time = "2026-01-29T23:03:58.481Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/d9/1f07395b54413432624d61524dfd98c1a7c7827d2abfdb8829ac92638205/debugpy-1.8.20-cp314-cp314-win_amd64.whl", hash = "sha256:a98eec61135465b062846112e5ecf2eebb855305acc1dfbae43b72903b8ab5be", size = 5372521, upload-time = "2026-01-29T23:03:59.864Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/c3/7f67dea8ccf8fdcb9c99033bbe3e90b9e7395415843accb81428c441be2d/debugpy-1.8.20-py2.py3-none-any.whl", hash = "sha256:5be9bed9ae3be00665a06acaa48f8329d2b9632f15fd09f6a9a8c8d9907e54d7", size = 5337658, upload-time = "2026-01-29T23:04:17.404Z" },
+]
+
+[[package]]
+name = "decorator"
+version = "5.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" },
+]
+
+[[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.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
+]
+
+[[package]]
+name = "donfig"
+version = "0.8.1.post1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/25/71/80cc718ff6d7abfbabacb1f57aaa42e9c1552bfdd01e64ddd704e4a03638/donfig-0.8.1.post1.tar.gz", hash = "sha256:3bef3413a4c1c601b585e8d297256d0c1470ea012afa6e8461dc28bfb7c23f52", size = 19506, upload-time = "2024-05-23T14:14:31.513Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/d5/c5db1ea3394c6e1732fb3286b3bd878b59507a8f77d32a2cebda7d7b7cd4/donfig-0.8.1.post1-py3-none-any.whl", hash = "sha256:2a3175ce74a06109ff9307d90a230f81215cbac9a751f4d1c6194644b8204f9d", size = 21592, upload-time = "2024-05-23T14:13:55.283Z" },
+]
+
+[[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 = "fastapi"
+version = "0.135.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/73/5903c4b13beae98618d64eb9870c3fac4f605523dd0312ca5c80dadbd5b9/fastapi-0.135.2.tar.gz", hash = "sha256:88a832095359755527b7f63bb4c6bc9edb8329a026189eed83d6c1afcf419d56", size = 395833, upload-time = "2026-03-23T14:12:41.697Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/ea/18f6d0457f9efb2fc6fa594857f92810cadb03024975726db6546b3d6fcf/fastapi-0.135.2-py3-none-any.whl", hash = "sha256:0af0447d541867e8db2a6a25c23a8c4bd80e2394ac5529bd87501bbb9e240ca5", size = 117407, upload-time = "2026-03-23T14:12:43.284Z" },
+]
+
+[[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.25.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
+]
+
+[[package]]
+name = "folium"
+version = "0.20.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "branca" },
+    { name = "jinja2" },
+    { name = "numpy" },
+    { name = "requests" },
+    { name = "xyzservices" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/76/84a1b1b00ce71f9c0c44af7d80f310c02e2e583591fe7d4cb03baecd0d3f/folium-0.20.0.tar.gz", hash = "sha256:a0d78b9d5a36ba7589ca9aedbd433e84e9fcab79cd6ac213adbcff922e454cb9", size = 109932, upload-time = "2025-06-16T20:22:51.803Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/a8/5f764f333204db0390362a4356d03a43626997f26818a0e9396f1b3bd8c9/folium-0.20.0-py2.py3-none-any.whl", hash = "sha256:f0bc2a92acde20bca56367aa5c1c376c433f450608d058daebab2fc9bf8198bf", size = 113394, upload-time = "2025-06-16T20:22:50.318Z" },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.62.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/08/7012b00a9a5874311b639c3920270c36ee0c445b69d9989a85e5c92ebcb0/fonttools-4.62.1.tar.gz", hash = "sha256:e54c75fd6041f1122476776880f7c3c3295ffa31962dc6ebe2543c00dca58b5d", size = 3580737, upload-time = "2026-03-13T13:54:25.52Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/39/23ff32561ec8d45a4d48578b4d241369d9270dc50926c017570e60893701/fonttools-4.62.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:40975849bac44fb0b9253d77420c6d8b523ac4dcdcefeff6e4d706838a5b80f7", size = 2871039, upload-time = "2026-03-13T13:52:33.127Z" },
+    { url = "https://files.pythonhosted.org/packages/24/7f/66d3f8a9338a9b67fe6e1739f47e1cd5cee78bd3bc1206ef9b0b982289a5/fonttools-4.62.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9dde91633f77fa576879a0c76b1d89de373cae751a98ddf0109d54e173b40f14", size = 2416346, upload-time = "2026-03-13T13:52:35.676Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/53/5276ceba7bff95da7793a07c5284e1da901cf00341ce5e2f3273056c0cca/fonttools-4.62.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6acb4109f8bee00fec985c8c7afb02299e35e9c94b57287f3ea542f28bd0b0a7", size = 5100897, upload-time = "2026-03-13T13:52:38.102Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a1/40a5c4d8e28b0851d53a8eeeb46fbd73c325a2a9a165f290a5ed90e6c597/fonttools-4.62.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1c5c25671ce8805e0d080e2ffdeca7f1e86778c5cbfbeae86d7f866d8830517b", size = 5071078, upload-time = "2026-03-13T13:52:41.305Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/be/d378fca4c65ea1956fee6d90ace6e861776809cbbc5af22388a090c3c092/fonttools-4.62.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a5d8825e1140f04e6c99bb7d37a9e31c172f3bc208afbe02175339e699c710e1", size = 5076908, upload-time = "2026-03-13T13:52:44.122Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d9/ae6a1d0693a4185a84605679c8a1f719a55df87b9c6e8e817bfdd9ef5936/fonttools-4.62.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:268abb1cb221e66c014acc234e872b7870d8b5d4657a83a8f4205094c32d2416", size = 5202275, upload-time = "2026-03-13T13:52:46.591Z" },
+    { url = "https://files.pythonhosted.org/packages/54/6c/af95d9c4efb15cabff22642b608342f2bd67137eea6107202d91b5b03184/fonttools-4.62.1-cp311-cp311-win32.whl", hash = "sha256:942b03094d7edbb99bdf1ae7e9090898cad7bf9030b3d21f33d7072dbcb51a53", size = 2293075, upload-time = "2026-03-13T13:52:48.711Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/97/bf54c5b3f2be34e1f143e6db838dfdc54f2ffa3e68c738934c82f3b2a08d/fonttools-4.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:e8514f4924375f77084e81467e63238b095abda5107620f49421c368a6017ed2", size = 2344593, upload-time = "2026-03-13T13:52:50.725Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d4/dbacced3953544b9a93088cc10ef2b596d348c983d5c67a404fa41ec51ba/fonttools-4.62.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:90365821debbd7db678809c7491ca4acd1e0779b9624cdc6ddaf1f31992bf974", size = 2870219, upload-time = "2026-03-13T13:52:53.664Z" },
+    { url = "https://files.pythonhosted.org/packages/66/9e/a769c8e99b81e5a87ab7e5e7236684de4e96246aae17274e5347d11ebd78/fonttools-4.62.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:12859ff0b47dd20f110804c3e0d0970f7b832f561630cd879969011541a464a9", size = 2414891, upload-time = "2026-03-13T13:52:56.493Z" },
+    { url = "https://files.pythonhosted.org/packages/69/64/f19a9e3911968c37e1e620e14dfc5778299e1474f72f4e57c5ec771d9489/fonttools-4.62.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c125ffa00c3d9003cdaaf7f2c79e6e535628093e14b5de1dccb08859b680936", size = 5033197, upload-time = "2026-03-13T13:52:59.179Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/8a/99c8b3c3888c5c474c08dbfd7c8899786de9604b727fcefb055b42c84bba/fonttools-4.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:149f7d84afca659d1a97e39a4778794a2f83bf344c5ee5134e09995086cc2392", size = 4988768, upload-time = "2026-03-13T13:53:02.761Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/c6/0f904540d3e6ab463c1243a0d803504826a11604c72dd58c2949796a1762/fonttools-4.62.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0aa72c43a601cfa9273bb1ae0518f1acadc01ee181a6fc60cd758d7fdadffc04", size = 4971512, upload-time = "2026-03-13T13:53:05.678Z" },
+    { url = "https://files.pythonhosted.org/packages/29/0b/5cbef6588dc9bd6b5c9ad6a4d5a8ca384d0cea089da31711bbeb4f9654a6/fonttools-4.62.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:19177c8d96c7c36359266e571c5173bcee9157b59cfc8cb0153c5673dc5a3a7d", size = 5122723, upload-time = "2026-03-13T13:53:08.662Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/47/b3a5342d381595ef439adec67848bed561ab7fdb1019fa522e82101b7d9c/fonttools-4.62.1-cp312-cp312-win32.whl", hash = "sha256:a24decd24d60744ee8b4679d38e88b8303d86772053afc29b19d23bb8207803c", size = 2281278, upload-time = "2026-03-13T13:53:10.998Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b1/0c2ab56a16f409c6c8a68816e6af707827ad5d629634691ff60a52879792/fonttools-4.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e7863e10b3de72376280b515d35b14f5eeed639d1aa7824f4cf06779ec65e42", size = 2331414, upload-time = "2026-03-13T13:53:13.992Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/56/6f389de21c49555553d6a5aeed5ac9767631497ac836c4f076273d15bd72/fonttools-4.62.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c22b1014017111c401469e3acc5433e6acf6ebcc6aa9efb538a533c800971c79", size = 2865155, upload-time = "2026-03-13T13:53:16.132Z" },
+    { url = "https://files.pythonhosted.org/packages/03/c5/0e3966edd5ec668d41dfe418787726752bc07e2f5fd8c8f208615e61fa89/fonttools-4.62.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68959f5fc58ed4599b44aad161c2837477d7f35f5f79402d97439974faebfebe", size = 2412802, upload-time = "2026-03-13T13:53:18.878Z" },
+    { url = "https://files.pythonhosted.org/packages/52/94/e6ac4b44026de7786fe46e3bfa0c87e51d5d70a841054065d49cd62bb909/fonttools-4.62.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef46db46c9447103b8f3ff91e8ba009d5fe181b1920a83757a5762551e32bb68", size = 5013926, upload-time = "2026-03-13T13:53:21.379Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/98/8b1e801939839d405f1f122e7d175cebe9aeb4e114f95bfc45e3152af9a7/fonttools-4.62.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6706d1cb1d5e6251a97ad3c1b9347505c5615c112e66047abbef0f8545fa30d1", size = 4964575, upload-time = "2026-03-13T13:53:23.857Z" },
+    { url = "https://files.pythonhosted.org/packages/46/76/7d051671e938b1881670528fec69cc4044315edd71a229c7fd712eaa5119/fonttools-4.62.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2e7abd2b1e11736f58c1de27819e1955a53267c21732e78243fa2fa2e5c1e069", size = 4953693, upload-time = "2026-03-13T13:53:26.569Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/ae/b41f8628ec0be3c1b934fc12b84f4576a5c646119db4d3bdd76a217c90b5/fonttools-4.62.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:403d28ce06ebfc547fbcb0cb8b7f7cc2f7a2d3e1a67ba9a34b14632df9e080f9", size = 5094920, upload-time = "2026-03-13T13:53:29.329Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/f6/53a1e9469331a23dcc400970a27a4caa3d9f6edbf5baab0260285238b884/fonttools-4.62.1-cp313-cp313-win32.whl", hash = "sha256:93c316e0f5301b2adbe6a5f658634307c096fd5aae60a5b3412e4f3e1728ab24", size = 2279928, upload-time = "2026-03-13T13:53:32.352Z" },
+    { url = "https://files.pythonhosted.org/packages/38/60/35186529de1db3c01f5ad625bde07c1f576305eab6d86bbda4c58445f721/fonttools-4.62.1-cp313-cp313-win_amd64.whl", hash = "sha256:7aa21ff53e28a9c2157acbc44e5b401149d3c9178107130e82d74ceb500e5056", size = 2330514, upload-time = "2026-03-13T13:53:34.991Z" },
+    { url = "https://files.pythonhosted.org/packages/36/f0/2888cdac391807d68d90dcb16ef858ddc1b5309bfc6966195a459dd326e2/fonttools-4.62.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fa1d16210b6b10a826d71bed68dd9ec24a9e218d5a5e2797f37c573e7ec215ca", size = 2864442, upload-time = "2026-03-13T13:53:37.509Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/b2/e521803081f8dc35990816b82da6360fa668a21b44da4b53fc9e77efcd62/fonttools-4.62.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:aa69d10ed420d8121118e628ad47d86e4caa79ba37f968597b958f6cceab7eca", size = 2410901, upload-time = "2026-03-13T13:53:40.55Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a4/8c3511ff06e53110039358dbbdc1a65d72157a054638387aa2ada300a8b8/fonttools-4.62.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd13b7999d59c5eb1c2b442eb2d0c427cb517a0b7a1f5798fc5c9e003f5ff782", size = 4999608, upload-time = "2026-03-13T13:53:42.798Z" },
+    { url = "https://files.pythonhosted.org/packages/28/63/cd0c3b26afe60995a5295f37c246a93d454023726c3261cfbb3559969bb9/fonttools-4.62.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8d337fdd49a79b0d51c4da87bc38169d21c3abbf0c1aa9367eff5c6656fb6dae", size = 4912726, upload-time = "2026-03-13T13:53:45.405Z" },
+    { url = "https://files.pythonhosted.org/packages/70/b9/ac677cb07c24c685cf34f64e140617d58789d67a3dd524164b63648c6114/fonttools-4.62.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d241cdc4a67b5431c6d7f115fdf63335222414995e3a1df1a41e1182acd4bcc7", size = 4951422, upload-time = "2026-03-13T13:53:48.326Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/10/11c08419a14b85b7ca9a9faca321accccc8842dd9e0b1c8a72908de05945/fonttools-4.62.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c05557a78f8fa514da0f869556eeda40887a8abc77c76ee3f74cf241778afd5a", size = 5060979, upload-time = "2026-03-13T13:53:51.366Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/3c/12eea4a4cf054e7ab058ed5ceada43b46809fce2bf319017c4d63ae55bb4/fonttools-4.62.1-cp314-cp314-win32.whl", hash = "sha256:49a445d2f544ce4a69338694cad575ba97b9a75fff02720da0882d1a73f12800", size = 2283733, upload-time = "2026-03-13T13:53:53.606Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/67/74b070029043186b5dd13462c958cb7c7f811be0d2e634309d9a1ffb1505/fonttools-4.62.1-cp314-cp314-win_amd64.whl", hash = "sha256:1eecc128c86c552fb963fe846ca4e011b1be053728f798185a1687502f6d398e", size = 2335663, upload-time = "2026-03-13T13:53:56.23Z" },
+    { url = "https://files.pythonhosted.org/packages/42/c5/4d2ed3ca6e33617fc5624467da353337f06e7f637707478903c785bd8e20/fonttools-4.62.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:1596aeaddf7f78e21e68293c011316a25267b3effdaccaf4d59bc9159d681b82", size = 2947288, upload-time = "2026-03-13T13:53:59.397Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/e9/7ab11ddfda48ed0f89b13380e5595ba572619c27077be0b2c447a63ff351/fonttools-4.62.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8f8fca95d3bb3208f59626a4b0ea6e526ee51f5a8ad5d91821c165903e8d9260", size = 2449023, upload-time = "2026-03-13T13:54:01.642Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/10/a800fa090b5e8819942e54e19b55fc7c21fe14a08757c3aa3ca8db358939/fonttools-4.62.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee91628c08e76f77b533d65feb3fbe6d9dad699f95be51cf0d022db94089cdc4", size = 5137599, upload-time = "2026-03-13T13:54:04.495Z" },
+    { url = "https://files.pythonhosted.org/packages/37/dc/8ccd45033fffd74deb6912fa1ca524643f584b94c87a16036855b498a1ed/fonttools-4.62.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5f37df1cac61d906e7b836abe356bc2f34c99d4477467755c216b72aa3dc748b", size = 4920933, upload-time = "2026-03-13T13:54:07.557Z" },
+    { url = "https://files.pythonhosted.org/packages/99/eb/e618adefb839598d25ac8136cd577925d6c513dc0d931d93b8af956210f0/fonttools-4.62.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:92bb00a947e666169c99b43753c4305fc95a890a60ef3aeb2a6963e07902cc87", size = 5016232, upload-time = "2026-03-13T13:54:10.611Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/5f/9b5c9bfaa8ec82def8d8168c4f13615990d6ce5996fe52bd49bfb5e05134/fonttools-4.62.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bdfe592802ef939a0e33106ea4a318eeb17822c7ee168c290273cbd5fabd746c", size = 5042987, upload-time = "2026-03-13T13:54:13.569Z" },
+    { url = "https://files.pythonhosted.org/packages/90/aa/dfbbe24c6a6afc5c203d90cc0343e24bcbb09e76d67c4d6eef8c2558d7ba/fonttools-4.62.1-cp314-cp314t-win32.whl", hash = "sha256:b820fcb92d4655513d8402d5b219f94481c4443d825b4372c75a2072aa4b357a", size = 2348021, upload-time = "2026-03-13T13:54:16.98Z" },
+    { url = "https://files.pythonhosted.org/packages/13/6f/ae9c4e4dd417948407b680855c2c7790efb52add6009aaecff1e3bc50e8e/fonttools-4.62.1-cp314-cp314t-win_amd64.whl", hash = "sha256:59b372b4f0e113d3746b88985f1c796e7bf830dd54b28374cd85c2b8acd7583e", size = 2414147, upload-time = "2026-03-13T13:54:19.416Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ba/56147c165442cc5ba7e82ecf301c9a68353cede498185869e6e02b4c264f/fonttools-4.62.1-py3-none-any.whl", hash = "sha256:7487782e2113861f4ddcc07c3436450659e3caa5e470b27dc2177cade2d8e7fd", size = 1152647, upload-time = "2026-03-13T13:54:22.735Z" },
+]
+
+[[package]]
+name = "fqdn"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" },
+    { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" },
+    { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" },
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/cf/b50ddf667c15276a9ab15a70ef5f257564de271957933ffea49d2cdbcdfb/fsspec-2026.3.0.tar.gz", hash = "sha256:1ee6a0e28677557f8c2f994e3eea77db6392b4de9cd1f5d7a9e87a0ae9d01b41", size = 313547, upload-time = "2026-03-27T19:11:14.892Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/1f/5f4a3cd9e4440e9d9bc78ad0a91a1c8d46b4d429d5239ebe6793c9fe5c41/fsspec-2026.3.0-py3-none-any.whl", hash = "sha256:d2ceafaad1b3457968ed14efa28798162f1638dbb5d2a6868a2db002a5ee39a4", size = 202595, upload-time = "2026-03-27T19:11:13.595Z" },
+]
+
+[[package]]
+name = "gcsfs"
+version = "2026.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "decorator" },
+    { name = "fsspec" },
+    { name = "google-auth" },
+    { name = "google-auth-oauthlib" },
+    { name = "google-cloud-storage" },
+    { name = "google-cloud-storage-control" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/70/63/4340ba024e83315a2fe58e7085a52030d8fe41a96624df34193d6abd7a8d/gcsfs-2026.3.0.tar.gz", hash = "sha256:20008b3c0a7ba9453fff1208dc412ee1c9106efa61a0f8abf500fc7b562ec7de", size = 182664, upload-time = "2026-03-27T20:22:31.581Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/08/678f842a59b544c9f362481fb08015139414da23e01626fb516c26b9ee0a/gcsfs-2026.3.0-py3-none-any.whl", hash = "sha256:af9d271495f7730923fdb660d86b83309b9be70a7c41e7012522c3fc49033141", size = 61705, upload-time = "2026-03-27T20:22:30.576Z" },
+]
+
+[[package]]
+name = "geojson-pydantic"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5c/52/961c8f7c51067f5d853a732cd4abc09b4d15c742384406dda8348b98071e/geojson_pydantic-2.1.0.tar.gz", hash = "sha256:78a52b2a7cd9c113bac4898a81ce00c146c7927dd2804f1c7e9fd05c2515073f", size = 9398, upload-time = "2025-10-08T13:31:12.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/18/8a9dca353e605b344408114f6b045b11d14082d19f4668b073259d3ed1a9/geojson_pydantic-2.1.0-py3-none-any.whl", hash = "sha256:f9091bed334ab9fbb1bef113674edc1212a3737f374a0b13b1aa493f57964c1d", size = 8819, upload-time = "2025-10-08T13:31:11.646Z" },
+]
+
+[[package]]
+name = "ghp-import"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943, upload-time = "2022-05-02T15:47:16.11Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" },
+]
+
+[[package]]
+name = "google-api-core"
+version = "2.30.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "google-auth" },
+    { name = "googleapis-common-protos" },
+    { name = "proto-plus" },
+    { name = "protobuf" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/98/586ec94553b569080caef635f98a3723db36a38eac0e3d7eb3ea9d2e4b9a/google_api_core-2.30.0.tar.gz", hash = "sha256:02edfa9fab31e17fc0befb5f161b3bf93c9096d99aed584625f38065c511ad9b", size = 176959, upload-time = "2026-02-18T20:28:11.926Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/27/09c33d67f7e0dcf06d7ac17d196594e66989299374bfb0d4331d1038e76b/google_api_core-2.30.0-py3-none-any.whl", hash = "sha256:80be49ee937ff9aba0fd79a6eddfde35fe658b9953ab9b79c57dd7061afa8df5", size = 173288, upload-time = "2026-02-18T20:28:10.367Z" },
+]
+
+[package.optional-dependencies]
+grpc = [
+    { name = "grpcio" },
+    { name = "grpcio-status" },
+]
+
+[[package]]
+name = "google-auth"
+version = "2.49.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cryptography" },
+    { name = "pyasn1-modules" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ea/80/6a696a07d3d3b0a92488933532f03dbefa4a24ab80fb231395b9a2a1be77/google_auth-2.49.1.tar.gz", hash = "sha256:16d40da1c3c5a0533f57d268fe72e0ebb0ae1cc3b567024122651c045d879b64", size = 333825, upload-time = "2026-03-12T19:30:58.135Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/eb/c6c2478d8a8d633460be40e2a8a6f8f429171997a35a96f81d3b680dec83/google_auth-2.49.1-py3-none-any.whl", hash = "sha256:195ebe3dca18eddd1b3db5edc5189b76c13e96f29e73043b923ebcf3f1a860f7", size = 240737, upload-time = "2026-03-12T19:30:53.159Z" },
+]
+
+[[package]]
+name = "google-auth-oauthlib"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "google-auth" },
+    { name = "requests-oauthlib" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/b4/1b19567e4c567b796f5c593d89895f3cfae5a38e04f27c6af87618fd0942/google_auth_oauthlib-1.3.0.tar.gz", hash = "sha256:cd39e807ac7229d6b8b9c1e297321d36fcc8a9e4857dff4301870985df51a528", size = 21777, upload-time = "2026-02-27T14:13:01.489Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/56/909fd5632226d3fba31d7aeffd4754410735d49362f5809956fe3e9af344/google_auth_oauthlib-1.3.0-py3-none-any.whl", hash = "sha256:386b3fb85cf4a5b819c6ad23e3128d975216b4cac76324de1d90b128aaf38f29", size = 19308, upload-time = "2026-02-27T14:12:47.865Z" },
+]
+
+[[package]]
+name = "google-cloud-core"
+version = "2.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "google-api-core" },
+    { name = "google-auth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a6/03/ef0bc99d0e0faf4fdbe67ac445e18cdaa74824fd93cd069e7bb6548cb52d/google_cloud_core-2.5.0.tar.gz", hash = "sha256:7c1b7ef5c92311717bd05301aa1a91ffbc565673d3b0b4163a52d8413a186963", size = 36027, upload-time = "2025-10-29T23:17:39.513Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/89/20/bfa472e327c8edee00f04beecc80baeddd2ab33ee0e86fd7654da49d45e9/google_cloud_core-2.5.0-py3-none-any.whl", hash = "sha256:67d977b41ae6c7211ee830c7912e41003ea8194bff15ae7d72fd6f51e57acabc", size = 29469, upload-time = "2025-10-29T23:17:38.548Z" },
+]
+
+[[package]]
+name = "google-cloud-storage"
+version = "3.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "google-api-core" },
+    { name = "google-auth" },
+    { name = "google-cloud-core" },
+    { name = "google-crc32c" },
+    { name = "google-resumable-media" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/47/205eb8e9a1739b5345843e5a425775cbdc472cc38e7eda082ba5b8d02450/google_cloud_storage-3.10.1.tar.gz", hash = "sha256:97db9aa4460727982040edd2bd13ff3d5e2260b5331ad22895802da1fc2a5286", size = 17309950, upload-time = "2026-03-23T09:35:23.409Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/ff/ca9ab2417fa913d75aae38bf40bf856bb2749a604b2e0f701b37cfcd23cc/google_cloud_storage-3.10.1-py3-none-any.whl", hash = "sha256:a72f656759b7b99bda700f901adcb3425a828d4a29f911bc26b3ea79c5b1217f", size = 324453, upload-time = "2026-03-23T09:35:21.368Z" },
+]
+
+[[package]]
+name = "google-cloud-storage-control"
+version = "1.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "google-api-core", extra = ["grpc"] },
+    { name = "google-auth" },
+    { name = "grpc-google-iam-v1" },
+    { name = "grpcio" },
+    { name = "proto-plus" },
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/4d/f36795a1cb37562caaf7fa9367ed34af29a09fd28ccda36f2f62c686de8f/google_cloud_storage_control-1.11.0.tar.gz", hash = "sha256:e97a0f3c99bc5ec5a2a770298ca9e8d5feeaa41bb55f2f2d7b36df2b817ee950", size = 117255, upload-time = "2026-03-26T22:18:32.645Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/aa/4df4066f4883afdae530ad95362f769cd9379fd2fb2d91f819aa7c9bdcc0/google_cloud_storage_control-1.11.0-py3-none-any.whl", hash = "sha256:98d2a3be8ab124ae09c33c1b8e4aadc68597c171c60c33e62666bcc74493f8ee", size = 89728, upload-time = "2026-03-26T22:16:17.2Z" },
+]
+
+[[package]]
+name = "google-crc32c"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/03/41/4b9c02f99e4c5fb477122cd5437403b552873f014616ac1d19ac8221a58d/google_crc32c-1.8.0.tar.gz", hash = "sha256:a428e25fb7691024de47fecfbff7ff957214da51eddded0da0ae0e0f03a2cf79", size = 14192, upload-time = "2025-12-16T00:35:25.142Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/ef/21ccfaab3d5078d41efe8612e0ed0bfc9ce22475de074162a91a25f7980d/google_crc32c-1.8.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:014a7e68d623e9a4222d663931febc3033c5c7c9730785727de2a81f87d5bab8", size = 31298, upload-time = "2025-12-16T00:20:32.241Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/b8/f8413d3f4b676136e965e764ceedec904fe38ae8de0cdc52a12d8eb1096e/google_crc32c-1.8.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:86cfc00fe45a0ac7359e5214a1704e51a99e757d0272554874f419f79838c5f7", size = 30872, upload-time = "2025-12-16T00:33:58.785Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/fd/33aa4ec62b290477181c55bb1c9302c9698c58c0ce9a6ab4874abc8b0d60/google_crc32c-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:19b40d637a54cb71e0829179f6cb41835f0fbd9e8eb60552152a8b52c36cbe15", size = 33243, upload-time = "2025-12-16T00:40:21.46Z" },
+    { url = "https://files.pythonhosted.org/packages/71/03/4820b3bd99c9653d1a5210cb32f9ba4da9681619b4d35b6a052432df4773/google_crc32c-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:17446feb05abddc187e5441a45971b8394ea4c1b6efd88ab0af393fd9e0a156a", size = 33608, upload-time = "2025-12-16T00:40:22.204Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/43/acf61476a11437bf9733fb2f70599b1ced11ec7ed9ea760fdd9a77d0c619/google_crc32c-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:71734788a88f551fbd6a97be9668a0020698e07b2bf5b3aa26a36c10cdfb27b2", size = 34439, upload-time = "2025-12-16T00:35:20.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5f/7307325b1198b59324c0fa9807cafb551afb65e831699f2ce211ad5c8240/google_crc32c-1.8.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:4b8286b659c1335172e39563ab0a768b8015e88e08329fa5321f774275fc3113", size = 31300, upload-time = "2025-12-16T00:21:56.723Z" },
+    { url = "https://files.pythonhosted.org/packages/21/8e/58c0d5d86e2220e6a37befe7e6a94dd2f6006044b1a33edf1ff6d9f7e319/google_crc32c-1.8.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:2a3dc3318507de089c5384cc74d54318401410f82aa65b2d9cdde9d297aca7cb", size = 30867, upload-time = "2025-12-16T00:38:31.302Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/a9/a780cc66f86335a6019f557a8aaca8fbb970728f0efd2430d15ff1beae0e/google_crc32c-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14f87e04d613dfa218d6135e81b78272c3b904e2a7053b841481b38a7d901411", size = 33364, upload-time = "2025-12-16T00:40:22.96Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/3457ea803db0198c9aaca2dd373750972ce28a26f00544b6b85088811939/google_crc32c-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb5c869c2923d56cb0c8e6bcdd73c009c36ae39b652dbe46a05eb4ef0ad01454", size = 33740, upload-time = "2025-12-16T00:40:23.96Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c0/87c2073e0c72515bb8733d4eef7b21548e8d189f094b5dad20b0ecaf64f6/google_crc32c-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:3cc0c8912038065eafa603b238abf252e204accab2a704c63b9e14837a854962", size = 34437, upload-time = "2025-12-16T00:35:21.395Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/db/000f15b41724589b0e7bc24bc7a8967898d8d3bc8caf64c513d91ef1f6c0/google_crc32c-1.8.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:3ebb04528e83b2634857f43f9bb8ef5b2bbe7f10f140daeb01b58f972d04736b", size = 31297, upload-time = "2025-12-16T00:23:20.709Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/8ebed0c39c53a7e838e2a486da8abb0e52de135f1b376ae2f0b160eb4c1a/google_crc32c-1.8.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:450dc98429d3e33ed2926fc99ee81001928d63460f8538f21a5d6060912a8e27", size = 30867, upload-time = "2025-12-16T00:43:14.628Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/42/b468aec74a0354b34c8cbf748db20d6e350a68a2b0912e128cabee49806c/google_crc32c-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3b9776774b24ba76831609ffbabce8cdf6fa2bd5e9df37b594221c7e333a81fa", size = 33344, upload-time = "2025-12-16T00:40:24.742Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/e8/b33784d6fc77fb5062a8a7854e43e1e618b87d5ddf610a88025e4de6226e/google_crc32c-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:89c17d53d75562edfff86679244830599ee0a48efc216200691de8b02ab6b2b8", size = 33694, upload-time = "2025-12-16T00:40:25.505Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b1/d3cbd4d988afb3d8e4db94ca953df429ed6db7282ed0e700d25e6c7bfc8d/google_crc32c-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:57a50a9035b75643996fbf224d6661e386c7162d1dfdab9bc4ca790947d1007f", size = 34435, upload-time = "2025-12-16T00:35:22.107Z" },
+    { url = "https://files.pythonhosted.org/packages/21/88/8ecf3c2b864a490b9e7010c84fd203ec8cf3b280651106a3a74dd1b0ca72/google_crc32c-1.8.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:e6584b12cb06796d285d09e33f63309a09368b9d806a551d8036a4207ea43697", size = 31301, upload-time = "2025-12-16T00:24:48.527Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c6/f7ff6c11f5ca215d9f43d3629163727a272eabc356e5c9b2853df2bfe965/google_crc32c-1.8.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:f4b51844ef67d6cf2e9425983274da75f18b1597bb2c998e1c0a0e8d46f8f651", size = 30868, upload-time = "2025-12-16T00:48:12.163Z" },
+    { url = "https://files.pythonhosted.org/packages/56/15/c25671c7aad70f8179d858c55a6ae8404902abe0cdcf32a29d581792b491/google_crc32c-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b0d1a7afc6e8e4635564ba8aa5c0548e3173e41b6384d7711a9123165f582de2", size = 33381, upload-time = "2025-12-16T00:40:26.268Z" },
+    { url = "https://files.pythonhosted.org/packages/42/fa/f50f51260d7b0ef5d4898af122d8a7ec5a84e2984f676f746445f783705f/google_crc32c-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3f68782f3cbd1bce027e48768293072813469af6a61a86f6bb4977a4380f21", size = 33734, upload-time = "2025-12-16T00:40:27.028Z" },
+    { url = "https://files.pythonhosted.org/packages/08/a5/7b059810934a09fb3ccb657e0843813c1fee1183d3bc2c8041800374aa2c/google_crc32c-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:d511b3153e7011a27ab6ee6bb3a5404a55b994dc1a7322c0b87b29606d9790e2", size = 34878, upload-time = "2025-12-16T00:35:23.142Z" },
+    { url = "https://files.pythonhosted.org/packages/52/c5/c171e4d8c44fec1422d801a6d2e5d7ddabd733eeda505c79730ee9607f07/google_crc32c-1.8.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:87fa445064e7db928226b2e6f0d5304ab4cd0339e664a4e9a25029f384d9bb93", size = 28615, upload-time = "2025-12-16T00:40:29.298Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/97/7d75fe37a7a6ed171a2cf17117177e7aab7e6e0d115858741b41e9dd4254/google_crc32c-1.8.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f639065ea2042d5c034bf258a9f085eaa7af0cd250667c0635a3118e8f92c69c", size = 28800, upload-time = "2025-12-16T00:40:30.322Z" },
+]
+
+[[package]]
+name = "google-resumable-media"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "google-crc32c" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/64/d7/520b62a35b23038ff005e334dba3ffc75fcf583bee26723f1fd8fd4b6919/google_resumable_media-2.8.0.tar.gz", hash = "sha256:f1157ed8b46994d60a1bc432544db62352043113684d4e030ee02e77ebe9a1ae", size = 2163265, upload-time = "2025-11-17T15:38:06.659Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/0b/93afde9cfe012260e9fe1522f35c9b72d6ee222f316586b1f23ecf44d518/google_resumable_media-2.8.0-py3-none-any.whl", hash = "sha256:dd14a116af303845a8d932ddae161a26e86cc229645bc98b39f026f9b1717582", size = 81340, upload-time = "2025-11-17T15:38:05.594Z" },
+]
+
+[[package]]
+name = "googleapis-common-protos"
+version = "1.73.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/c0/4a54c386282c13449eca8bbe2ddb518181dc113e78d240458a68856b4d69/googleapis_common_protos-1.73.1.tar.gz", hash = "sha256:13114f0e9d2391756a0194c3a8131974ed7bffb06086569ba193364af59163b6", size = 147506, upload-time = "2026-03-26T22:17:38.451Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/82/fcb6520612bec0c39b973a6c0954b6a0d948aadfe8f7e9487f60ceb8bfa6/googleapis_common_protos-1.73.1-py3-none-any.whl", hash = "sha256:e51f09eb0a43a8602f5a915870972e6b4a394088415c79d79605a46d8e826ee8", size = 297556, upload-time = "2026-03-26T22:15:58.455Z" },
+]
+
+[package.optional-dependencies]
+grpc = [
+    { name = "grpcio" },
+]
+
+[[package]]
+name = "griffe-inherited-docstrings"
+version = "1.1.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "griffelib" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/da/fd002dc5f215cd896bfccaebe8b4aa1cdeed8ea1d9d60633685bd61ff933/griffe_inherited_docstrings-1.1.3.tar.gz", hash = "sha256:cd1f937ec9336a790e5425e7f9b92f5a5ab17f292ba86917f1c681c0704cb64e", size = 26738, upload-time = "2026-02-21T09:38:44.312Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/20/4bc15f242181daad1c104e0a7d33be49e712461ea89e548152be0365b9ea/griffe_inherited_docstrings-1.1.3-py3-none-any.whl", hash = "sha256:aa7f6e624515c50d9325a5cfdf4b2acac547f1889aca89092d5da7278f739695", size = 6710, upload-time = "2026-02-20T11:06:38.75Z" },
+]
+
+[[package]]
+name = "griffelib"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/82/74f4a3310cdabfbb10da554c3a672847f1ed33c6f61dd472681ce7f1fe67/griffelib-2.0.2.tar.gz", hash = "sha256:3cf20b3bc470e83763ffbf236e0076b1211bac1bc67de13daf494640f2de707e", size = 166461, upload-time = "2026-03-27T11:34:51.091Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/8c/c9138d881c79aa0ea9ed83cbd58d5ca75624378b38cee225dcf5c42cc91f/griffelib-2.0.2-py3-none-any.whl", hash = "sha256:925c857658fb1ba40c0772c37acbc2ab650bd794d9c1b9726922e36ea4117ea1", size = 142357, upload-time = "2026-03-27T11:34:46.275Z" },
+]
+
+[[package]]
+name = "grpc-google-iam-v1"
+version = "0.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "googleapis-common-protos", extra = ["grpc"] },
+    { name = "grpcio" },
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/1e/1011451679a983f2f5c6771a1682542ecb027776762ad031fd0d7129164b/grpc_google_iam_v1-0.14.3.tar.gz", hash = "sha256:879ac4ef33136c5491a6300e27575a9ec760f6cdf9a2518798c1b8977a5dc389", size = 23745, upload-time = "2025-10-15T21:14:53.318Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/bd/330a1bbdb1afe0b96311249e699b6dc9cfc17916394fd4503ac5aca2514b/grpc_google_iam_v1-0.14.3-py3-none-any.whl", hash = "sha256:7a7f697e017a067206a3dfef44e4c634a34d3dee135fe7d7a4613fe3e59217e6", size = 32690, upload-time = "2025-10-15T21:14:51.72Z" },
+]
+
+[[package]]
+name = "grpcio"
+version = "1.80.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/db/1d56e5f5823257b291962d6c0ce106146c6447f405b60b234c4f222a7cde/grpcio-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:dfab85db094068ff42e2a3563f60ab3dddcc9d6488a35abf0132daec13209c8a", size = 6055009, upload-time = "2026-03-30T08:46:46.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/18/c83f3cad64c5ca63bca7e91e5e46b0d026afc5af9d0a9972472ceba294b3/grpcio-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5c07e82e822e1161354e32da2662f741a4944ea955f9f580ec8fb409dd6f6060", size = 12035295, upload-time = "2026-03-30T08:46:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/8e/e14966b435be2dda99fbe89db9525ea436edc79780431a1c2875a3582644/grpcio-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba0915d51fd4ced2db5ff719f84e270afe0e2d4c45a7bdb1e8d036e4502928c2", size = 6610297, upload-time = "2026-03-30T08:46:52.123Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/26/d5eb38f42ce0e3fdc8174ea4d52036ef8d58cc4426cb800f2610f625dd75/grpcio-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3cb8130ba457d2aa09fa6b7c3ed6b6e4e6a2685fce63cb803d479576c4d80e21", size = 7300208, upload-time = "2026-03-30T08:46:54.859Z" },
+    { url = "https://files.pythonhosted.org/packages/25/51/bd267c989f85a17a5b3eea65a6feb4ff672af41ca614e5a0279cc0ea381c/grpcio-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09e5e478b3d14afd23f12e49e8b44c8684ac3c5f08561c43a5b9691c54d136ab", size = 6813442, upload-time = "2026-03-30T08:46:57.056Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d9/d80eef735b19e9169e30164bbf889b46f9df9127598a83d174eb13a48b26/grpcio-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:00168469238b022500e486c1c33916acf2f2a9b2c022202cf8a1885d2e3073c1", size = 7414743, upload-time = "2026-03-30T08:46:59.682Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f2/567f5bd5054398ed6b0509b9a30900376dcf2786bd936812098808b49d8d/grpcio-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8502122a3cc1714038e39a0b071acb1207ca7844208d5ea0d091317555ee7106", size = 8426046, upload-time = "2026-03-30T08:47:02.474Z" },
+    { url = "https://files.pythonhosted.org/packages/62/29/73ef0141b4732ff5eacd68430ff2512a65c004696997f70476a83e548e7e/grpcio-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce1794f4ea6cc3ca29463f42d665c32ba1b964b48958a66497917fe9069f26e6", size = 7851641, upload-time = "2026-03-30T08:47:05.462Z" },
+    { url = "https://files.pythonhosted.org/packages/46/69/abbfa360eb229a8623bab5f5a4f8105e445bd38ce81a89514ba55d281ad0/grpcio-1.80.0-cp311-cp311-win32.whl", hash = "sha256:51b4a7189b0bef2aa30adce3c78f09c83526cf3dddb24c6a96555e3b97340440", size = 4154368, upload-time = "2026-03-30T08:47:08.027Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d4/ae92206d01183b08613e846076115f5ac5991bae358d2a749fa864da5699/grpcio-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:02e64bb0bb2da14d947a49e6f120a75e947250aebe65f9629b62bb1f5c14e6e9", size = 4894235, upload-time = "2026-03-30T08:47:10.839Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e8/a2b749265eb3415abc94f2e619bbd9e9707bebdda787e61c593004ec927a/grpcio-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:c624cc9f1008361014378c9d776de7182b11fe8b2e5a81bc69f23a295f2a1ad0", size = 6015616, upload-time = "2026-03-30T08:47:13.428Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/97/b1282161a15d699d1e90c360df18d19165a045ce1c343c7f313f5e8a0b77/grpcio-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:f49eddcac43c3bf350c0385366a58f36bed8cc2c0ec35ef7b74b49e56552c0c2", size = 12014204, upload-time = "2026-03-30T08:47:15.873Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/5e/d319c6e997b50c155ac5a8cb12f5173d5b42677510e886d250d50264949d/grpcio-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d334591df610ab94714048e0d5b4f3dd5ad1bee74dfec11eee344220077a79de", size = 6563866, upload-time = "2026-03-30T08:47:18.588Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f6/fdd975a2cb4d78eb67769a7b3b3830970bfa2e919f1decf724ae4445f42c/grpcio-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0cb517eb1d0d0aaf1d87af7cc5b801d686557c1d88b2619f5e31fab3c2315921", size = 7273060, upload-time = "2026-03-30T08:47:21.113Z" },
+    { url = "https://files.pythonhosted.org/packages/db/f0/a3deb5feba60d9538a962913e37bd2e69a195f1c3376a3dd44fe0427e996/grpcio-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4e78c4ac0d97dc2e569b2f4bcbbb447491167cb358d1a389fc4af71ab6f70411", size = 6782121, upload-time = "2026-03-30T08:47:23.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/84/36c6dcfddc093e108141f757c407902a05085e0c328007cb090d56646cdf/grpcio-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ed770b4c06984f3b47eb0517b1c69ad0b84ef3f40128f51448433be904634cd", size = 7383811, upload-time = "2026-03-30T08:47:26.517Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ef/f3a77e3dc5b471a0ec86c564c98d6adfa3510d38f8ee99010410858d591e/grpcio-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:256507e2f524092f1473071a05e65a5b10d84b82e3ff24c5b571513cfaa61e2f", size = 8393860, upload-time = "2026-03-30T08:47:29.439Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/8d/9d4d27ed7f33d109c50d6b5ce578a9914aa68edab75d65869a17e630a8d1/grpcio-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a6284a5d907c37db53350645567c522be314bac859a64a7a5ca63b77bb7958f", size = 7830132, upload-time = "2026-03-30T08:47:33.254Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e4/9990b41c6d7a44e1e9dee8ac11d7a9802ba1378b40d77468a7761d1ad288/grpcio-1.80.0-cp312-cp312-win32.whl", hash = "sha256:c71309cfce2f22be26aa4a847357c502db6c621f1a49825ae98aa0907595b193", size = 4140904, upload-time = "2026-03-30T08:47:35.319Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/2c/296f6138caca1f4b92a31ace4ae1b87dab692fc16a7a3417af3bb3c805bf/grpcio-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe648599c0e37594c4809d81a9e77bd138cc82eb8baa71b6a86af65426723ff", size = 4880944, upload-time = "2026-03-30T08:47:37.831Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/7c3c25789e3f069e581dc342e03613c5b1cb012c4e8c7d9d5cf960a75856/grpcio-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e9e408fc016dffd20661f0126c53d8a31c2821b5c13c5d67a0f5ed5de93319ad", size = 6017243, upload-time = "2026-03-30T08:47:40.075Z" },
+    { url = "https://files.pythonhosted.org/packages/04/19/21a9806eb8240e174fd1ab0cd5b9aa948bb0e05c2f2f55f9d5d7405e6d08/grpcio-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:92d787312e613754d4d8b9ca6d3297e69994a7912a32fa38c4c4e01c272974b0", size = 12010840, upload-time = "2026-03-30T08:47:43.11Z" },
+    { url = "https://files.pythonhosted.org/packages/18/3a/23347d35f76f639e807fb7a36fad3068aed100996849a33809591f26eca6/grpcio-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac393b58aa16991a2f1144ec578084d544038c12242da3a215966b512904d0f", size = 6567644, upload-time = "2026-03-30T08:47:46.806Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/40/96e07ecb604a6a67ae6ab151e3e35b132875d98bc68ec65f3e5ab3e781d7/grpcio-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:68e5851ac4b9afe07e7f84483803ad167852570d65326b34d54ca560bfa53fb6", size = 7277830, upload-time = "2026-03-30T08:47:49.643Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/e2/da1506ecea1f34a5e365964644b35edef53803052b763ca214ba3870c856/grpcio-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:873ff5d17d68992ef6605330127425d2fc4e77e612fa3c3e0ed4e668685e3140", size = 6783216, upload-time = "2026-03-30T08:47:52.817Z" },
+    { url = "https://files.pythonhosted.org/packages/44/83/3b20ff58d0c3b7f6caaa3af9a4174d4023701df40a3f39f7f1c8e7c48f9d/grpcio-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2bea16af2750fd0a899bf1abd9022244418b55d1f37da2202249ba4ba673838d", size = 7385866, upload-time = "2026-03-30T08:47:55.687Z" },
+    { url = "https://files.pythonhosted.org/packages/47/45/55c507599c5520416de5eefecc927d6a0d7af55e91cfffb2e410607e5744/grpcio-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba0db34f7e1d803a878284cd70e4c63cb6ae2510ba51937bf8f45ba997cefcf7", size = 8391602, upload-time = "2026-03-30T08:47:58.303Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bb/dd06f4c24c01db9cf11341b547d0a016b2c90ed7dbbb086a5710df7dd1d7/grpcio-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8eb613f02d34721f1acf3626dfdb3545bd3c8505b0e52bf8b5710a28d02e8aa7", size = 7826752, upload-time = "2026-03-30T08:48:01.311Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/1e/9d67992ba23371fd63d4527096eb8c6b76d74d52b500df992a3343fd7251/grpcio-1.80.0-cp313-cp313-win32.whl", hash = "sha256:93b6f823810720912fd131f561f91f5fed0fda372b6b7028a2681b8194d5d294", size = 4142310, upload-time = "2026-03-30T08:48:04.594Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e6/283326a27da9e2c3038bc93eeea36fb118ce0b2d03922a9cda6688f53c5b/grpcio-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:e172cf795a3ba5246d3529e4d34c53db70e888fa582a8ffebd2e6e48bc0cba50", size = 4882833, upload-time = "2026-03-30T08:48:07.363Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/6d/e65307ce20f5a09244ba9e9d8476e99fb039de7154f37fb85f26978b59c3/grpcio-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:3d4147a97c8344d065d01bbf8b6acec2cf86fb0400d40696c8bdad34a64ffc0e", size = 6017376, upload-time = "2026-03-30T08:48:10.005Z" },
+    { url = "https://files.pythonhosted.org/packages/69/10/9cef5d9650c72625a699c549940f0abb3c4bfdb5ed45a5ce431f92f31806/grpcio-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8e11f167935b3eb089ac9038e1a063e6d7dbe995c0bb4a661e614583352e76f", size = 12018133, upload-time = "2026-03-30T08:48:12.927Z" },
+    { url = "https://files.pythonhosted.org/packages/04/82/983aabaad82ba26113caceeb9091706a0696b25da004fe3defb5b346e15b/grpcio-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f14b618fc30de822681ee986cfdcc2d9327229dc4c98aed16896761cacd468b9", size = 6574748, upload-time = "2026-03-30T08:48:16.386Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d7/031666ef155aa0bf399ed7e19439656c38bbd143779ae0861b038ce82abd/grpcio-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4ed39fbdcf9b87370f6e8df4e39ca7b38b3e5e9d1b0013c7b6be9639d6578d14", size = 7277711, upload-time = "2026-03-30T08:48:19.627Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/f437a78f7f4f1d311804189e8f11fb311a01049b2e08557c1068d470cb2e/grpcio-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2dcc70e9f0ba987526e8e8603a610fb4f460e42899e74e7a518bf3c68fe1bf05", size = 6785372, upload-time = "2026-03-30T08:48:22.373Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3d/f6558e9c6296cb4227faa5c43c54a34c68d32654b829f53288313d16a86e/grpcio-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:448c884b668b868562b1bda833c5fce6272d26e1926ec46747cda05741d302c1", size = 7395268, upload-time = "2026-03-30T08:48:25.638Z" },
+    { url = "https://files.pythonhosted.org/packages/06/21/0fdd77e84720b08843c371a2efa6f2e19dbebf56adc72df73d891f5506f0/grpcio-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a1dc80fe55685b4a543555e6eef975303b36c8db1023b1599b094b92aa77965f", size = 8392000, upload-time = "2026-03-30T08:48:28.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/68/67f4947ed55d2e69f2cc199ab9fd85e0a0034d813bbeef84df6d2ba4d4b7/grpcio-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:31b9ac4ad1aa28ffee5503821fafd09e4da0a261ce1c1281c6c8da0423c83b6e", size = 7828477, upload-time = "2026-03-30T08:48:32.054Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b6/8d4096691b2e385e8271911a0de4f35f0a6c7d05aff7098e296c3de86939/grpcio-1.80.0-cp314-cp314-win32.whl", hash = "sha256:367ce30ba67d05e0592470428f0ec1c31714cab9ef19b8f2e37be1f4c7d32fae", size = 4218563, upload-time = "2026-03-30T08:48:34.538Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/8c/bbe6baf2557262834f2070cf668515fa308b2d38a4bbf771f8f7872a7036/grpcio-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:3b01e1f5464c583d2f567b2e46ff0d516ef979978f72091fd81f5ab7fa6e2e7f", size = 5019457, upload-time = "2026-03-30T08:48:37.308Z" },
+]
+
+[[package]]
+name = "grpcio-status"
+version = "1.80.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "googleapis-common-protos" },
+    { name = "grpcio" },
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/ed/105f619bdd00cb47a49aa2feea6232ea2bbb04199d52a22cc6a7d603b5cb/grpcio_status-1.80.0.tar.gz", hash = "sha256:df73802a4c89a3ea88aa2aff971e886fccce162bc2e6511408b3d67a144381cd", size = 13901, upload-time = "2026-03-30T08:54:34.784Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/80/58cd2dfc19a07d022abe44bde7c365627f6c7cb6f692ada6c65ca437d09a/grpcio_status-1.80.0-py3-none-any.whl", hash = "sha256:4b56990363af50dbf2c2ebb80f1967185c07d87aa25aa2bea45ddb75fc181dbe", size = 14638, upload-time = "2026-03-30T08:54:01.569Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "h5netcdf"
+version = "1.8.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ef/03/92d6cc02c0055158167255980461155d6e17f1c4143c03f8bcc18d3e3f3a/h5netcdf-1.8.1.tar.gz", hash = "sha256:9b396a4cc346050fc1a4df8523bc1853681ec3544e0449027ae397cb953c7a16", size = 78679, upload-time = "2026-01-23T07:35:31.233Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b1/8b/88f16936a8e8070a83d36239555227ecd91728f9ef222c5382cda07e0fd6/h5netcdf-1.8.1-py3-none-any.whl", hash = "sha256:a76ed7cfc9b8a8908ea7057c4e57e27307acff1049b7f5ed52db6c2247636879", size = 62915, upload-time = "2026-01-23T07:35:30.195Z" },
+]
+
+[[package]]
+name = "h5py"
+version = "3.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/db/33/acd0ce6863b6c0d7735007df01815403f5589a21ff8c2e1ee2587a38f548/h5py-3.16.0.tar.gz", hash = "sha256:a0dbaad796840ccaa67a4c144a0d0c8080073c34c76d5a6941d6818678ef2738", size = 446526, upload-time = "2026-03-06T13:49:08.07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/95/a825894f3e45cbac7554c4e97314ce886b233a20033787eda755ca8fecc7/h5py-3.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:719439d14b83f74eeb080e9650a6c7aa6d0d9ea0ca7f804347b05fac6fbf18af", size = 3721663, upload-time = "2026-03-06T13:47:49.599Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/3b/38ff88b347c3e346cda1d3fc1b65a7aa75d40632228d8b8a5d7b58508c24/h5py-3.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c3f0a0e136f2e95dd0b67146abb6668af4f1a69c81ef8651a2d316e8e01de447", size = 3087630, upload-time = "2026-03-06T13:47:51.249Z" },
+    { url = "https://files.pythonhosted.org/packages/98/a8/2594cef906aee761601eff842c7dc598bea2b394a3e1c00966832b8eeb7c/h5py-3.16.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a6fbc5367d4046801f9b7db9191b31895f22f1c6df1f9987d667854cac493538", size = 4823472, upload-time = "2026-03-06T13:47:53.085Z" },
+    { url = "https://files.pythonhosted.org/packages/52/a0/c1f604538ff6db22a0690be2dc44ab59178e115f63c917794e529356ab23/h5py-3.16.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:fb1720028d99040792bb2fb31facb8da44a6f29df7697e0b84f0d79aff2e9bd3", size = 5027150, upload-time = "2026-03-06T13:47:55.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/fd/301739083c2fc4fd89950f9bcfce75d6e14b40b0ca3d40e48a8993d1722c/h5py-3.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:314b6054fe0b1051c2b0cb2df5cbdab15622fb05e80f202e3b6a5eee0d6fe365", size = 4814544, upload-time = "2026-03-06T13:47:56.893Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/42/2193ed41ccee78baba8fcc0cff2c925b8b9ee3793305b23e1f22c20bf4c7/h5py-3.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ffbab2fedd6581f6aa31cf1639ca2cb86e02779de525667892ebf4cc9fd26434", size = 5034013, upload-time = "2026-03-06T13:47:59.01Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/20/e6c0ff62ca2ad1a396a34f4380bafccaaf8791ff8fccf3d995a1fc12d417/h5py-3.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:17d1f1630f92ad74494a9a7392ab25982ce2b469fc62da6074c0ce48366a2999", size = 3191673, upload-time = "2026-03-06T13:48:00.626Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/48/239cbe352ac4f2b8243a8e620fa1a2034635f633731493a7ff1ed71e8658/h5py-3.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:85b9c49dd58dc44cf70af944784e2c2038b6f799665d0dcbbc812a26e0faa859", size = 2673834, upload-time = "2026-03-06T13:48:02.579Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/c0/5d4119dba94093bbafede500d3defd2f5eab7897732998c04b54021e530b/h5py-3.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5313566f4643121a78503a473f0fb1e6dcc541d5115c44f05e037609c565c4d", size = 3685604, upload-time = "2026-03-06T13:48:04.198Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/42/c84efcc1d4caebafb1ecd8be4643f39c85c47a80fe254d92b8b43b1eadaf/h5py-3.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:42b012933a83e1a558c673176676a10ce2fd3759976a0fedee1e672d1e04fc9d", size = 3061940, upload-time = "2026-03-06T13:48:05.783Z" },
+    { url = "https://files.pythonhosted.org/packages/89/84/06281c82d4d1686fde1ac6b0f307c50918f1c0151062445ab3b6fa5a921d/h5py-3.16.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:ff24039e2573297787c3063df64b60aab0591980ac898329a08b0320e0cf2527", size = 5198852, upload-time = "2026-03-06T13:48:07.482Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e9/1a19e42cd43cc1365e127db6aae85e1c671da1d9a5d746f4d34a50edb577/h5py-3.16.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:dfc21898ff025f1e8e67e194965a95a8d4754f452f83454538f98f8a3fcb207e", size = 5405250, upload-time = "2026-03-06T13:48:09.628Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8e/9790c1655eabeb85b92b1ecab7d7e62a2069e53baefd58c98f0909c7a948/h5py-3.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:698dd69291272642ffda44a0ecd6cd3bda5faf9621452d255f57ce91487b9794", size = 5190108, upload-time = "2026-03-06T13:48:11.26Z" },
+    { url = "https://files.pythonhosted.org/packages/51/d7/ab693274f1bd7e8c5f9fdd6c7003a88d59bedeaf8752716a55f532924fbb/h5py-3.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2b2c02b0a160faed5fb33f1ba8a264a37ee240b22e049ecc827345d0d9043074", size = 5419216, upload-time = "2026-03-06T13:48:13.322Z" },
+    { url = "https://files.pythonhosted.org/packages/03/c1/0976b235cf29ead553e22f2fb6385a8252b533715e00d0ae52ed7b900582/h5py-3.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:96b422019a1c8975c2d5dadcf61d4ba6f01c31f92bbde6e4649607885fe502d6", size = 3182868, upload-time = "2026-03-06T13:48:15.759Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d9/866b7e570b39070f92d47b0ff1800f0f8239b6f9e45f02363d7112336c1f/h5py-3.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:39c2838fb1e8d97bcf1755e60ad1f3dd76a7b2a475928dc321672752678b96db", size = 2653286, upload-time = "2026-03-06T13:48:17.279Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/9e/6142ebfda0cb6e9349c091eae73c2e01a770b7659255248d637bec54a88b/h5py-3.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:370a845f432c2c9619db8eed334d1e610c6015796122b0e57aa46312c22617d9", size = 3671808, upload-time = "2026-03-06T13:48:19.737Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/65/5e088a45d0f43cd814bc5bec521c051d42005a472e804b1a36c48dada09b/h5py-3.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42108e93326c50c2810025aade9eac9d6827524cdccc7d4b75a546e5ab308edb", size = 3045837, upload-time = "2026-03-06T13:48:21.854Z" },
+    { url = "https://files.pythonhosted.org/packages/da/1e/6172269e18cc5a484e2913ced33339aad588e02ba407fafd00d369e22ef3/h5py-3.16.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:099f2525c9dcf28de366970a5fb34879aab20491589fa89ce2863a84218bb524", size = 5193860, upload-time = "2026-03-06T13:48:24.071Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/98/ef2b6fe2903e377cbe870c3b2800d62552f1e3dbe81ce49e1923c53d1c5c/h5py-3.16.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:9300ad32dea9dfc5171f94d5f6948e159ed93e4701280b0f508773b3f582f402", size = 5400417, upload-time = "2026-03-06T13:48:25.728Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/81/5b62d760039eed64348c98129d17061fdfc7839fc9c04eaaad6dee1004e4/h5py-3.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:171038f23bccddfc23f344cadabdfc9917ff554db6a0d417180d2747fe4c75a7", size = 5185214, upload-time = "2026-03-06T13:48:27.436Z" },
+    { url = "https://files.pythonhosted.org/packages/28/c4/532123bcd9080e250696779c927f2cb906c8bf3447df98f5ceb8dcded539/h5py-3.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7e420b539fb6023a259a1b14d4c9f6df8cf50d7268f48e161169987a57b737ff", size = 5414598, upload-time = "2026-03-06T13:48:29.49Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d9/a27997f84341fc0dfcdd1fe4179b6ba6c32a7aa880fdb8c514d4dad6fba3/h5py-3.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:18f2bbcd545e6991412253b98727374c356d67caa920e68dc79eab36bf5fedad", size = 3175509, upload-time = "2026-03-06T13:48:31.131Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/23/bb8647521d4fd770c30a76cfc6cb6a2f5495868904054e92f2394c5a78ff/h5py-3.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:656f00e4d903199a1d58df06b711cf3ca632b874b4207b7dbec86185b5c8c7d4", size = 2647362, upload-time = "2026-03-06T13:48:33.411Z" },
+    { url = "https://files.pythonhosted.org/packages/48/3c/7fcd9b4c9eed82e91fb15568992561019ae7a829d1f696b2c844355d95dd/h5py-3.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9c9d307c0ef862d1cd5714f72ecfafe0a5d7529c44845afa8de9f46e5ba8bd65", size = 3678608, upload-time = "2026-03-06T13:48:35.183Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b7/9366ed44ced9b7ef357ab48c94205280276db9d7f064aa3012a97227e966/h5py-3.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8c1eff849cdd53cbc73c214c30ebdb6f1bb8b64790b4b4fc36acdb5e43570210", size = 3054773, upload-time = "2026-03-06T13:48:37.139Z" },
+    { url = "https://files.pythonhosted.org/packages/58/a5/4964bc0e91e86340c2bbda83420225b2f770dcf1eb8a39464871ad769436/h5py-3.16.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:e2c04d129f180019e216ee5f9c40b78a418634091c8782e1f723a6ca3658b965", size = 5198886, upload-time = "2026-03-06T13:48:38.879Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/16/d905e7f53e661ce2c24686c38048d8e2b750ffc4350009d41c4e6c6c9826/h5py-3.16.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:e4360f15875a532bc7b98196c7592ed4fc92672a57c0a621355961cafb17a6dd", size = 5404883, upload-time = "2026-03-06T13:48:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f2/58f34cb74af46d39f4cd18ea20909a8514960c5a3e5b92fd06a28161e0a8/h5py-3.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3fae9197390c325e62e0a1aa977f2f62d994aa87aab182abbea85479b791197c", size = 5192039, upload-time = "2026-03-06T13:48:43.117Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/ca/934a39c24ce2e2db017268c08da0537c20fa0be7e1549be3e977313fc8f5/h5py-3.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:43259303989ac8adacc9986695b31e35dba6fd1e297ff9c6a04b7da5542139cc", size = 5421526, upload-time = "2026-03-06T13:48:44.838Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/14/615a450205e1b56d16c6783f5ccd116cde05550faad70ae077c955654a75/h5py-3.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:fa48993a0b799737ba7fd21e2350fa0a60701e58180fae9f2de834bc39a147ab", size = 3183263, upload-time = "2026-03-06T13:48:47.117Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/48/a6faef5ed632cae0c65ac6b214a6614a0b510c3183532c521bdb0055e117/h5py-3.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:1897a771a7f40d05c262fc8f37376ec37873218544b70216872876c627640f63", size = 2663450, upload-time = "2026-03-06T13:48:48.707Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/32/0c8bb8aedb62c772cf7c1d427c7d1951477e8c2835f872bc0a13d1f85f86/h5py-3.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:15922e485844f77c0b9d275396d435db3baa58292a9c2176a386e072e0cf2491", size = 3760693, upload-time = "2026-03-06T13:48:50.453Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/1f/fcc5977d32d6387c5c9a694afee716a5e20658ac08b3ff24fdec79fb05f2/h5py-3.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:df02dd29bd247f98674634dfe41f89fd7c16ba3d7de8695ec958f58404a4e618", size = 3181305, upload-time = "2026-03-06T13:48:52.221Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/a1/af87f64b9f986889884243643621ebbd4ac72472ba8ec8cec891ac8e2ca1/h5py-3.16.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:0f456f556e4e2cebeebd9d66adf8dc321770a42593494a0b6f0af54a7567b242", size = 5074061, upload-time = "2026-03-06T13:48:54.089Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/d0/146f5eaff3dc246a9c7f6e5e4f42bd45cc613bce16693bcd4d1f7c958bf5/h5py-3.16.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:3e6cb3387c756de6a9492d601553dffea3fe11b5f22b443aac708c69f3f55e16", size = 5279216, upload-time = "2026-03-06T13:48:56.75Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/9d/12a13424f1e604fc7df9497b73c0356fb78c2fb206abd7465ce47226e8fd/h5py-3.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8389e13a1fd745ad2856873e8187fd10268b2d9677877bb667b41aebd771d8b7", size = 5070068, upload-time = "2026-03-06T13:48:59.169Z" },
+    { url = "https://files.pythonhosted.org/packages/41/8c/bbe98f813722b4873818a8db3e15aa3e625b59278566905ac439725e8070/h5py-3.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:346df559a0f7dcb31cf8e44805319e2ab24b8957c45e7708ce503b2ec79ba725", size = 5300253, upload-time = "2026-03-06T13:49:02.033Z" },
+    { url = "https://files.pythonhosted.org/packages/32/9e/87e6705b4d6890e7cecdf876e2a7d3e40654a2ae37482d79a6f1b87f7b92/h5py-3.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4c6ab014ab704b4feaa719ae783b86522ed0bf1f82184704ed3c9e4e3228796e", size = 3381671, upload-time = "2026-03-06T13:49:04.351Z" },
+    { url = "https://files.pythonhosted.org/packages/96/91/9fad90cfc5f9b2489c7c26ad897157bce82f0e9534a986a221b99760b23b/h5py-3.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:faca8fb4e4319c09d83337adc80b2ca7d5c5a343c2d6f1b6388f32cfecca13c1", size = 2740706, upload-time = "2026-03-06T13:49:06.347Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httptools"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/08/17e07e8d89ab8f343c134616d72eebfe03798835058e2ab579dcc8353c06/httptools-0.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:474d3b7ab469fefcca3697a10d11a32ee2b9573250206ba1e50d5980910da657", size = 206521, upload-time = "2025-10-10T03:54:31.002Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/06/c9c1b41ff52f16aee526fd10fbda99fa4787938aa776858ddc4a1ea825ec/httptools-0.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3c3b7366bb6c7b96bd72d0dbe7f7d5eead261361f013be5f6d9590465ea1c70", size = 110375, upload-time = "2025-10-10T03:54:31.941Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/cc/10935db22fda0ee34c76f047590ca0a8bd9de531406a3ccb10a90e12ea21/httptools-0.7.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:379b479408b8747f47f3b253326183d7c009a3936518cdb70db58cffd369d9df", size = 456621, upload-time = "2025-10-10T03:54:33.176Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/84/875382b10d271b0c11aa5d414b44f92f8dd53e9b658aec338a79164fa548/httptools-0.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cad6b591a682dcc6cf1397c3900527f9affef1e55a06c4547264796bbd17cf5e", size = 454954, upload-time = "2025-10-10T03:54:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e1/44f89b280f7e46c0b1b2ccee5737d46b3bb13136383958f20b580a821ca0/httptools-0.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eb844698d11433d2139bbeeb56499102143beb582bd6c194e3ba69c22f25c274", size = 440175, upload-time = "2025-10-10T03:54:35.942Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/7e/b9287763159e700e335028bc1824359dc736fa9b829dacedace91a39b37e/httptools-0.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f65744d7a8bdb4bda5e1fa23e4ba16832860606fcc09d674d56e425e991539ec", size = 440310, upload-time = "2025-10-10T03:54:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/07/5b614f592868e07f5c94b1f301b5e14a21df4e8076215a3bccb830a687d8/httptools-0.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:135fbe974b3718eada677229312e97f3b31f8a9c8ffa3ae6f565bf808d5b6bcb", size = 86875, upload-time = "2025-10-10T03:54:38.421Z" },
+    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" },
+    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" },
+    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694, upload-time = "2025-10-10T03:54:45.923Z" },
+    { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889, upload-time = "2025-10-10T03:54:47.089Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180, upload-time = "2025-10-10T03:54:48.052Z" },
+    { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596, upload-time = "2025-10-10T03:54:48.919Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268, upload-time = "2025-10-10T03:54:49.993Z" },
+    { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517, upload-time = "2025-10-10T03:54:51.066Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337, upload-time = "2025-10-10T03:54:52.196Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743, upload-time = "2025-10-10T03:54:53.448Z" },
+    { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619, upload-time = "2025-10-10T03:54:54.321Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714, upload-time = "2025-10-10T03:54:55.163Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909, upload-time = "2025-10-10T03:54:56.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831, upload-time = "2025-10-10T03:54:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631, upload-time = "2025-10-10T03:54:58.219Z" },
+    { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910, upload-time = "2025-10-10T03:54:59.366Z" },
+    { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205, upload-time = "2025-10-10T03:55:00.389Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/c4/7fb4db12296cdb11893d61c92048fe617ee853f8523b9b296ac03b43757e/identify-2.6.18.tar.gz", hash = "sha256:873ac56a5e3fd63e7438a7ecbc4d91aca692eb3fefa4534db2b7913f3fc352fd", size = 99580, upload-time = "2026-03-15T18:39:50.319Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/33/92ef41c6fad0233e41d3d84ba8e8ad18d1780f1e5d99b3c683e6d7f98b63/identify-2.6.18-py2.py3-none-any.whl", hash = "sha256:8db9d3c8ea9079db92cafb0ebf97abdc09d52e97f4dcf773a2e694048b7cd737", size = 99394, upload-time = "2026-03-15T18:39:48.915Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[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 = "7.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "appnope", marker = "sys_platform == 'darwin'" },
+    { name = "comm" },
+    { name = "debugpy" },
+    { name = "ipython", version = "9.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "ipython", version = "9.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { 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/ca/8d/b68b728e2d06b9e0051019640a40a9eb7a88fcd82c2e1b5ce70bef5ff044/ipykernel-7.2.0.tar.gz", hash = "sha256:18ed160b6dee2cbb16e5f3575858bc19d8f1fe6046a9a680c708494ce31d909e", size = 176046, upload-time = "2026-02-06T16:43:27.403Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/b9/e73d5d9f405cba7706c539aa8b311b49d4c2f3d698d9c12f815231169c71/ipykernel-7.2.0-py3-none-any.whl", hash = "sha256:3bbd4420d2b3cc105cbdf3756bfc04500b1e52f090a90716851f3916c62e1661", size = 118788, upload-time = "2026-02-06T16:43:25.149Z" },
+]
+
+[[package]]
+name = "ipython"
+version = "9.10.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.12' and sys_platform == 'win32'",
+    "python_full_version < '3.12' and sys_platform == 'emscripten'",
+    "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "colorama", marker = "python_full_version < '3.12' and sys_platform == 'win32'" },
+    { name = "decorator", marker = "python_full_version < '3.12'" },
+    { name = "ipython-pygments-lexers", marker = "python_full_version < '3.12'" },
+    { name = "jedi", marker = "python_full_version < '3.12'" },
+    { name = "matplotlib-inline", marker = "python_full_version < '3.12'" },
+    { name = "pexpect", marker = "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "prompt-toolkit", marker = "python_full_version < '3.12'" },
+    { name = "pygments", marker = "python_full_version < '3.12'" },
+    { name = "stack-data", marker = "python_full_version < '3.12'" },
+    { name = "traitlets", marker = "python_full_version < '3.12'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c5/25/daae0e764047b0a2480c7bbb25d48f4f509b5818636562eeac145d06dfee/ipython-9.10.1.tar.gz", hash = "sha256:e170e9b2a44312484415bdb750492699bf329233b03f2557a9692cce6466ada4", size = 4426663, upload-time = "2026-03-27T09:53:26.244Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/09/ba70f8d662d5671687da55ad2cc0064cf795b15e1eea70907532202e7c97/ipython-9.10.1-py3-none-any.whl", hash = "sha256:82d18ae9fb9164ded080c71ef92a182ee35ee7db2395f67616034bebb020a232", size = 622827, upload-time = "2026-03-27T09:53:24.566Z" },
+]
+
+[[package]]
+name = "ipython"
+version = "9.12.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "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.13.*' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.12.*' and sys_platform == 'win32'",
+    "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "colorama", marker = "python_full_version >= '3.12' and sys_platform == 'win32'" },
+    { name = "decorator", marker = "python_full_version >= '3.12'" },
+    { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.12'" },
+    { name = "jedi", marker = "python_full_version >= '3.12'" },
+    { name = "matplotlib-inline", marker = "python_full_version >= '3.12'" },
+    { name = "pexpect", marker = "python_full_version >= '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "prompt-toolkit", marker = "python_full_version >= '3.12'" },
+    { name = "pygments", marker = "python_full_version >= '3.12'" },
+    { name = "stack-data", marker = "python_full_version >= '3.12'" },
+    { name = "traitlets", marker = "python_full_version >= '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3a/73/7114f80a8f9cabdb13c27732dce24af945b2923dcab80723602f7c8bc2d8/ipython-9.12.0.tar.gz", hash = "sha256:01daa83f504b693ba523b5a407246cabde4eb4513285a3c6acaff11a66735ee4", size = 4428879, upload-time = "2026-03-27T09:42:45.312Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/22/906c8108974c673ebef6356c506cebb6870d48cedea3c41e949e2dd556bb/ipython-9.12.0-py3-none-any.whl", hash = "sha256:0f2701e8ee86e117e37f50563205d36feaa259d2e08d4a6bc6b6d74b18ce128d", size = 625661, upload-time = "2026-03-27T09:42:42.831Z" },
+]
+
+[[package]]
+name = "ipython-pygments-lexers"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pygments" },
+]
+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 = "ipywidgets"
+version = "8.1.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "comm" },
+    { name = "ipython", version = "9.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "ipython", version = "9.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "jupyterlab-widgets" },
+    { name = "traitlets" },
+    { name = "widgetsnbextension" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/ae/c5ce1edc1afe042eadb445e95b0671b03cee61895264357956e61c0d2ac0/ipywidgets-8.1.8.tar.gz", hash = "sha256:61f969306b95f85fba6b6986b7fe45d73124d1d9e3023a8068710d47a22ea668", size = 116739, upload-time = "2025-11-01T21:18:12.393Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/6d/0d9848617b9f753b87f214f1c682592f7ca42de085f564352f10f0843026/ipywidgets-8.1.8-py3-none-any.whl", hash = "sha256:ecaca67aed704a338f88f67b1181b58f821ab5dc89c1f0f5ef99db43c1c2921e", size = 139808, upload-time = "2025-11-01T21:18:10.956Z" },
+]
+
+[[package]]
+name = "isoduration"
+version = "20.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "arrow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" },
+]
+
+[[package]]
+name = "jedi"
+version = "0.19.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "parso" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" },
+]
+
+[[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 = "jmespath"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+]
+
+[[package]]
+name = "json5"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9c/4b/6f8906aaf67d501e259b0adab4d312945bb7211e8b8d4dcc77c92320edaa/json5-0.14.0.tar.gz", hash = "sha256:b3f492fad9f6cdbced8b7d40b28b9b1c9701c5f561bef0d33b81c2ff433fefcb", size = 52656, upload-time = "2026-03-27T22:50:48.108Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/42/cf027b4ac873b076189d935b135397675dac80cb29acb13e1ab86ad6c631/json5-0.14.0-py3-none-any.whl", hash = "sha256:56cf861bab076b1178eb8c92e1311d273a9b9acea2ccc82c276abf839ebaef3a", size = 36271, upload-time = "2026-03-27T22:50:47.073Z" },
+]
+
+[[package]]
+name = "jsonpointer"
+version = "3.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", hash = "sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900", size = 9068, upload-time = "2026-03-23T22:32:32.458Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", hash = "sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca", size = 7659, upload-time = "2026-03-23T22:32:31.568Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+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.optional-dependencies]
+format-nongpl = [
+    { name = "fqdn" },
+    { name = "idna" },
+    { name = "isoduration" },
+    { name = "jsonpointer" },
+    { name = "rfc3339-validator" },
+    { name = "rfc3986-validator" },
+    { name = "rfc3987-syntax" },
+    { name = "uri-template" },
+    { name = "webcolors" },
+]
+
+[[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"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ipykernel" },
+    { name = "ipywidgets" },
+    { name = "jupyter-console" },
+    { name = "jupyterlab" },
+    { name = "nbconvert" },
+    { name = "notebook" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657, upload-time = "2024-08-30T07:15:47.045Z" },
+]
+
+[[package]]
+name = "jupyter-client"
+version = "8.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-core" },
+    { name = "python-dateutil" },
+    { name = "pyzmq" },
+    { name = "tornado" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/0b/ceb7694d864abc0a047649aec263878acb9f792e1fec3e676f22dc9015e3/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a", size = 107371, upload-time = "2026-01-08T13:55:45.562Z" },
+]
+
+[[package]]
+name = "jupyter-console"
+version = "6.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ipykernel" },
+    { name = "ipython", version = "9.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "ipython", version = "9.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "prompt-toolkit" },
+    { name = "pygments" },
+    { name = "pyzmq" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510, upload-time = "2023-03-06T14:13:28.229Z" },
+]
+
+[[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 = "jupyter-events"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonschema", extra = ["format-nongpl"] },
+    { name = "packaging" },
+    { name = "python-json-logger" },
+    { name = "pyyaml" },
+    { name = "referencing" },
+    { name = "rfc3339-validator" },
+    { name = "rfc3986-validator" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9d/c3/306d090461e4cf3cd91eceaff84bede12a8e52cd821c2d20c9a4fd728385/jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b", size = 62196, upload-time = "2025-02-03T17:23:41.485Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/48/577993f1f99c552f18a0428731a755e06171f9902fa118c379eb7c04ea22/jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb", size = 19430, upload-time = "2025-02-03T17:23:38.643Z" },
+]
+
+[[package]]
+name = "jupyter-lsp"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-server" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/5a/9066c9f8e94ee517133cd98dba393459a16cd48bba71a82f16a65415206c/jupyter_lsp-2.3.0.tar.gz", hash = "sha256:458aa59339dc868fb784d73364f17dbce8836e906cd75fd471a325cba02e0245", size = 54823, upload-time = "2025-08-27T17:47:34.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/60/1f6cee0c46263de1173894f0fafcb3475ded276c472c14d25e0280c18d6d/jupyter_lsp-2.3.0-py3-none-any.whl", hash = "sha256:e914a3cb2addf48b1c7710914771aaf1819d46b2e5a79b0f917b5478ec93f34f", size = 76687, upload-time = "2025-08-27T17:47:33.15Z" },
+]
+
+[[package]]
+name = "jupyter-server"
+version = "2.17.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "argon2-cffi" },
+    { name = "jinja2" },
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "jupyter-events" },
+    { name = "jupyter-server-terminals" },
+    { name = "nbconvert" },
+    { name = "nbformat" },
+    { name = "overrides", marker = "python_full_version < '3.12'" },
+    { name = "packaging" },
+    { name = "prometheus-client" },
+    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "pyzmq" },
+    { name = "send2trash" },
+    { name = "terminado" },
+    { name = "tornado" },
+    { name = "traitlets" },
+    { name = "websocket-client" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/ac/e040ec363d7b6b1f11304cc9f209dac4517ece5d5e01821366b924a64a50/jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5", size = 731949, upload-time = "2025-08-21T14:42:54.042Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/80/a24767e6ca280f5a49525d987bf3e4d7552bf67c8be07e8ccf20271f8568/jupyter_server-2.17.0-py3-none-any.whl", hash = "sha256:e8cb9c7db4251f51ed307e329b81b72ccf2056ff82d50524debde1ee1870e13f", size = 388221, upload-time = "2025-08-21T14:42:52.034Z" },
+]
+
+[[package]]
+name = "jupyter-server-terminals"
+version = "0.5.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "terminado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", hash = "sha256:55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14", size = 13704, upload-time = "2026-01-14T16:53:18.738Z" },
+]
+
+[[package]]
+name = "jupyterlab"
+version = "4.5.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "async-lru" },
+    { name = "httpx" },
+    { name = "ipykernel" },
+    { name = "jinja2" },
+    { name = "jupyter-core" },
+    { name = "jupyter-lsp" },
+    { name = "jupyter-server" },
+    { name = "jupyterlab-server" },
+    { name = "notebook-shim" },
+    { name = "packaging" },
+    { name = "setuptools" },
+    { name = "tornado" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/d5/730628e03fff2e8a8e8ccdaedde1489ab1309f9a4fa2536248884e30b7c7/jupyterlab-4.5.6.tar.gz", hash = "sha256:642fe2cfe7f0f5922a8a558ba7a0d246c7bc133b708dfe43f7b3a826d163cf42", size = 23970670, upload-time = "2026-03-11T14:17:04.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/1b/dad6fdcc658ed7af26fdf3841e7394072c9549a8b896c381ab49dd11e2d9/jupyterlab-4.5.6-py3-none-any.whl", hash = "sha256:d6b3dac883aa4d9993348e0f8e95b24624f75099aed64eab6a4351a9cdd1e580", size = 12447124, upload-time = "2026-03-11T14:17:00.229Z" },
+]
+
+[[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 = "jupyterlab-server"
+version = "2.28.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "babel" },
+    { name = "jinja2" },
+    { name = "json5" },
+    { name = "jsonschema" },
+    { name = "jupyter-server" },
+    { name = "packaging" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" },
+]
+
+[[package]]
+name = "jupyterlab-widgets"
+version = "3.0.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/2d/ef58fed122b268c69c0aa099da20bc67657cdfb2e222688d5731bd5b971d/jupyterlab_widgets-3.0.16.tar.gz", hash = "sha256:423da05071d55cf27a9e602216d35a3a65a3e41cdf9c5d3b643b814ce38c19e0", size = 897423, upload-time = "2025-11-01T21:11:29.724Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl", hash = "sha256:45fa36d9c6422cf2559198e4db481aa243c7a32d9926b500781c830c80f7ecf8", size = 914926, upload-time = "2025-11-01T21:11:28.008Z" },
+]
+
+[[package]]
+name = "jupytext"
+version = "1.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "mdit-py-plugins" },
+    { name = "nbformat" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/13/a5/80c02f307c8ce863cb33e27daf049315e9d96979e14eead700923b5ec9cc/jupytext-1.19.1.tar.gz", hash = "sha256:82587c07e299173c70ed5e8ec7e75183edf1be289ed518bab49ad0d4e3d5f433", size = 4307829, upload-time = "2026-01-25T21:35:13.276Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/5a/736dd2f4535dbf3bf26523f9158c011389ef88dd06ec2eef67fd744f1c7b/jupytext-1.19.1-py3-none-any.whl", hash = "sha256:d8975035155d034bdfde5c0c37891425314b7ea8d3a6c4b5d18c294348714cd9", size = 170478, upload-time = "2026-01-25T21:35:11.17Z" },
+]
+
+[[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/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/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 = "lark"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" },
+]
+
+[[package]]
+name = "lxml"
+version = "6.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/88/262177de60548e5a2bfc46ad28232c9e9cbde697bd94132aeb80364675cb/lxml-6.0.2.tar.gz", hash = "sha256:cd79f3367bd74b317dda655dc8fcfa304d9eb6e4fb06b7168c5cf27f96e0cd62", size = 4073426, upload-time = "2025-09-22T04:04:59.287Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/d5/becbe1e2569b474a23f0c672ead8a29ac50b2dc1d5b9de184831bda8d14c/lxml-6.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:13e35cbc684aadf05d8711a5d1b5857c92e5e580efa9a0d2be197199c8def607", size = 8634365, upload-time = "2025-09-22T04:00:45.672Z" },
+    { url = "https://files.pythonhosted.org/packages/28/66/1ced58f12e804644426b85d0bb8a4478ca77bc1761455da310505f1a3526/lxml-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b1675e096e17c6fe9c0e8c81434f5736c0739ff9ac6123c87c2d452f48fc938", size = 4650793, upload-time = "2025-09-22T04:00:47.783Z" },
+    { url = "https://files.pythonhosted.org/packages/11/84/549098ffea39dfd167e3f174b4ce983d0eed61f9d8d25b7bf2a57c3247fc/lxml-6.0.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac6e5811ae2870953390452e3476694196f98d447573234592d30488147404d", size = 4944362, upload-time = "2025-09-22T04:00:49.845Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/bd/f207f16abf9749d2037453d56b643a7471d8fde855a231a12d1e095c4f01/lxml-6.0.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5aa0fc67ae19d7a64c3fe725dc9a1bb11f80e01f78289d05c6f62545affec438", size = 5083152, upload-time = "2025-09-22T04:00:51.709Z" },
+    { url = "https://files.pythonhosted.org/packages/15/ae/bd813e87d8941d52ad5b65071b1affb48da01c4ed3c9c99e40abb266fbff/lxml-6.0.2-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de496365750cc472b4e7902a485d3f152ecf57bd3ba03ddd5578ed8ceb4c5964", size = 5023539, upload-time = "2025-09-22T04:00:53.593Z" },
+    { url = "https://files.pythonhosted.org/packages/02/cd/9bfef16bd1d874fbe0cb51afb00329540f30a3283beb9f0780adbb7eec03/lxml-6.0.2-cp311-cp311-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:200069a593c5e40b8f6fc0d84d86d970ba43138c3e68619ffa234bc9bb806a4d", size = 5344853, upload-time = "2025-09-22T04:00:55.524Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/89/ea8f91594bc5dbb879734d35a6f2b0ad50605d7fb419de2b63d4211765cc/lxml-6.0.2-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d2de809c2ee3b888b59f995625385f74629707c9355e0ff856445cdcae682b7", size = 5225133, upload-time = "2025-09-22T04:00:57.269Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/37/9c735274f5dbec726b2db99b98a43950395ba3d4a1043083dba2ad814170/lxml-6.0.2-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:b2c3da8d93cf5db60e8858c17684c47d01fee6405e554fb55018dd85fc23b178", size = 4677944, upload-time = "2025-09-22T04:00:59.052Z" },
+    { url = "https://files.pythonhosted.org/packages/20/28/7dfe1ba3475d8bfca3878365075abe002e05d40dfaaeb7ec01b4c587d533/lxml-6.0.2-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:442de7530296ef5e188373a1ea5789a46ce90c4847e597856570439621d9c553", size = 5284535, upload-time = "2025-09-22T04:01:01.335Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/cf/5f14bc0de763498fc29510e3532bf2b4b3a1c1d5d0dff2e900c16ba021ef/lxml-6.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2593c77efde7bfea7f6389f1ab249b15ed4aa5bc5cb5131faa3b843c429fbedb", size = 5067343, upload-time = "2025-09-22T04:01:03.13Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/b0/bb8275ab5472f32b28cfbbcc6db7c9d092482d3439ca279d8d6fa02f7025/lxml-6.0.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:3e3cb08855967a20f553ff32d147e14329b3ae70ced6edc2f282b94afbc74b2a", size = 4725419, upload-time = "2025-09-22T04:01:05.013Z" },
+    { url = "https://files.pythonhosted.org/packages/25/4c/7c222753bc72edca3b99dbadba1b064209bc8ed4ad448af990e60dcce462/lxml-6.0.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2ed6c667fcbb8c19c6791bbf40b7268ef8ddf5a96940ba9404b9f9a304832f6c", size = 5275008, upload-time = "2025-09-22T04:01:07.327Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/8c/478a0dc6b6ed661451379447cdbec77c05741a75736d97e5b2b729687828/lxml-6.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b8f18914faec94132e5b91e69d76a5c1d7b0c73e2489ea8929c4aaa10b76bbf7", size = 5248906, upload-time = "2025-09-22T04:01:09.452Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/d9/5be3a6ab2784cdf9accb0703b65e1b64fcdd9311c9f007630c7db0cfcce1/lxml-6.0.2-cp311-cp311-win32.whl", hash = "sha256:6605c604e6daa9e0d7f0a2137bdc47a2e93b59c60a65466353e37f8272f47c46", size = 3610357, upload-time = "2025-09-22T04:01:11.102Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/7d/ca6fb13349b473d5732fb0ee3eec8f6c80fc0688e76b7d79c1008481bf1f/lxml-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e5867f2651016a3afd8dd2c8238baa66f1e2802f44bc17e236f547ace6647078", size = 4036583, upload-time = "2025-09-22T04:01:12.766Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a2/51363b5ecd3eab46563645f3a2c3836a2fc67d01a1b87c5017040f39f567/lxml-6.0.2-cp311-cp311-win_arm64.whl", hash = "sha256:4197fb2534ee05fd3e7afaab5d8bfd6c2e186f65ea7f9cd6a82809c887bd1285", size = 3680591, upload-time = "2025-09-22T04:01:14.874Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c8/8ff2bc6b920c84355146cd1ab7d181bc543b89241cfb1ebee824a7c81457/lxml-6.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a59f5448ba2ceccd06995c95ea59a7674a10de0810f2ce90c9006f3cbc044456", size = 8661887, upload-time = "2025-09-22T04:01:17.265Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/9aae1008083bb501ef63284220ce81638332f9ccbfa53765b2b7502203cf/lxml-6.0.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e8113639f3296706fbac34a30813929e29247718e88173ad849f57ca59754924", size = 4667818, upload-time = "2025-09-22T04:01:19.688Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ca/31fb37f99f37f1536c133476674c10b577e409c0a624384147653e38baf2/lxml-6.0.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a8bef9b9825fa8bc816a6e641bb67219489229ebc648be422af695f6e7a4fa7f", size = 4950807, upload-time = "2025-09-22T04:01:21.487Z" },
+    { url = "https://files.pythonhosted.org/packages/da/87/f6cb9442e4bada8aab5ae7e1046264f62fdbeaa6e3f6211b93f4c0dd97f1/lxml-6.0.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:65ea18d710fd14e0186c2f973dc60bb52039a275f82d3c44a0e42b43440ea534", size = 5109179, upload-time = "2025-09-22T04:01:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/20/a7760713e65888db79bbae4f6146a6ae5c04e4a204a3c48896c408cd6ed2/lxml-6.0.2-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c371aa98126a0d4c739ca93ceffa0fd7a5d732e3ac66a46e74339acd4d334564", size = 5023044, upload-time = "2025-09-22T04:01:25.118Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/b0/7e64e0460fcb36471899f75831509098f3fd7cd02a3833ac517433cb4f8f/lxml-6.0.2-cp312-cp312-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:700efd30c0fa1a3581d80a748157397559396090a51d306ea59a70020223d16f", size = 5359685, upload-time = "2025-09-22T04:01:27.398Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/e1/e5df362e9ca4e2f48ed6411bd4b3a0ae737cc842e96877f5bf9428055ab4/lxml-6.0.2-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c33e66d44fe60e72397b487ee92e01da0d09ba2d66df8eae42d77b6d06e5eba0", size = 5654127, upload-time = "2025-09-22T04:01:29.629Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d1/232b3309a02d60f11e71857778bfcd4acbdb86c07db8260caf7d008b08f8/lxml-6.0.2-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90a345bbeaf9d0587a3aaffb7006aa39ccb6ff0e96a57286c0cb2fd1520ea192", size = 5253958, upload-time = "2025-09-22T04:01:31.535Z" },
+    { url = "https://files.pythonhosted.org/packages/35/35/d955a070994725c4f7d80583a96cab9c107c57a125b20bb5f708fe941011/lxml-6.0.2-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:064fdadaf7a21af3ed1dcaa106b854077fbeada827c18f72aec9346847cd65d0", size = 4711541, upload-time = "2025-09-22T04:01:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/be/667d17363b38a78c4bd63cfd4b4632029fd68d2c2dc81f25ce9eb5224dd5/lxml-6.0.2-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fbc74f42c3525ac4ffa4b89cbdd00057b6196bcefe8bce794abd42d33a018092", size = 5267426, upload-time = "2025-09-22T04:01:35.639Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/62c70aa4a1c26569bc958c9ca86af2bb4e1f614e8c04fb2989833874f7ae/lxml-6.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6ddff43f702905a4e32bc24f3f2e2edfe0f8fde3277d481bffb709a4cced7a1f", size = 5064917, upload-time = "2025-09-22T04:01:37.448Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/55/6ceddaca353ebd0f1908ef712c597f8570cc9c58130dbb89903198e441fd/lxml-6.0.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6da5185951d72e6f5352166e3da7b0dc27aa70bd1090b0eb3f7f7212b53f1bb8", size = 4788795, upload-time = "2025-09-22T04:01:39.165Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e8/fd63e15da5e3fd4c2146f8bbb3c14e94ab850589beab88e547b2dbce22e1/lxml-6.0.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:57a86e1ebb4020a38d295c04fc79603c7899e0df71588043eb218722dabc087f", size = 5676759, upload-time = "2025-09-22T04:01:41.506Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/b3ec58dc5c374697f5ba37412cd2728f427d056315d124dd4b61da381877/lxml-6.0.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2047d8234fe735ab77802ce5f2297e410ff40f5238aec569ad7c8e163d7b19a6", size = 5255666, upload-time = "2025-09-22T04:01:43.363Z" },
+    { url = "https://files.pythonhosted.org/packages/19/93/03ba725df4c3d72afd9596eef4a37a837ce8e4806010569bedfcd2cb68fd/lxml-6.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6f91fd2b2ea15a6800c8e24418c0775a1694eefc011392da73bc6cef2623b322", size = 5277989, upload-time = "2025-09-22T04:01:45.215Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/80/c06de80bfce881d0ad738576f243911fccf992687ae09fd80b734712b39c/lxml-6.0.2-cp312-cp312-win32.whl", hash = "sha256:3ae2ce7d6fedfb3414a2b6c5e20b249c4c607f72cb8d2bb7cc9c6ec7c6f4e849", size = 3611456, upload-time = "2025-09-22T04:01:48.243Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/d7/0cdfb6c3e30893463fb3d1e52bc5f5f99684a03c29a0b6b605cfae879cd5/lxml-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:72c87e5ee4e58a8354fb9c7c84cbf95a1c8236c127a5d1b7683f04bed8361e1f", size = 4011793, upload-time = "2025-09-22T04:01:50.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/7b/93c73c67db235931527301ed3785f849c78991e2e34f3fd9a6663ffda4c5/lxml-6.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:61cb10eeb95570153e0c0e554f58df92ecf5109f75eacad4a95baa709e26c3d6", size = 3672836, upload-time = "2025-09-22T04:01:52.145Z" },
+    { url = "https://files.pythonhosted.org/packages/53/fd/4e8f0540608977aea078bf6d79f128e0e2c2bba8af1acf775c30baa70460/lxml-6.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9b33d21594afab46f37ae58dfadd06636f154923c4e8a4d754b0127554eb2e77", size = 8648494, upload-time = "2025-09-22T04:01:54.242Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/f4/2a94a3d3dfd6c6b433501b8d470a1960a20ecce93245cf2db1706adf6c19/lxml-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c8963287d7a4c5c9a432ff487c52e9c5618667179c18a204bdedb27310f022f", size = 4661146, upload-time = "2025-09-22T04:01:56.282Z" },
+    { url = "https://files.pythonhosted.org/packages/25/2e/4efa677fa6b322013035d38016f6ae859d06cac67437ca7dc708a6af7028/lxml-6.0.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1941354d92699fb5ffe6ed7b32f9649e43c2feb4b97205f75866f7d21aa91452", size = 4946932, upload-time = "2025-09-22T04:01:58.989Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/0f/526e78a6d38d109fdbaa5049c62e1d32fdd70c75fb61c4eadf3045d3d124/lxml-6.0.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb2f6ca0ae2d983ded09357b84af659c954722bbf04dea98030064996d156048", size = 5100060, upload-time = "2025-09-22T04:02:00.812Z" },
+    { url = "https://files.pythonhosted.org/packages/81/76/99de58d81fa702cc0ea7edae4f4640416c2062813a00ff24bd70ac1d9c9b/lxml-6.0.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb2a12d704f180a902d7fa778c6d71f36ceb7b0d317f34cdc76a5d05aa1dd1df", size = 5019000, upload-time = "2025-09-22T04:02:02.671Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/9e57d25482bc9a9882cb0037fdb9cc18f4b79d85df94fa9d2a89562f1d25/lxml-6.0.2-cp313-cp313-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:6ec0e3f745021bfed19c456647f0298d60a24c9ff86d9d051f52b509663feeb1", size = 5348496, upload-time = "2025-09-22T04:02:04.904Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/8e/cb99bd0b83ccc3e8f0f528e9aa1f7a9965dfec08c617070c5db8d63a87ce/lxml-6.0.2-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:846ae9a12d54e368933b9759052d6206a9e8b250291109c48e350c1f1f49d916", size = 5643779, upload-time = "2025-09-22T04:02:06.689Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/34/9e591954939276bb679b73773836c6684c22e56d05980e31d52a9a8deb18/lxml-6.0.2-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef9266d2aa545d7374938fb5c484531ef5a2ec7f2d573e62f8ce722c735685fd", size = 5244072, upload-time = "2025-09-22T04:02:08.587Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/27/b29ff065f9aaca443ee377aff699714fcbffb371b4fce5ac4ca759e436d5/lxml-6.0.2-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:4077b7c79f31755df33b795dc12119cb557a0106bfdab0d2c2d97bd3cf3dffa6", size = 4718675, upload-time = "2025-09-22T04:02:10.783Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f756f9c2cd27caa1a6ef8c32ae47aadea697f5c2c6d07b0dae133c244fbe/lxml-6.0.2-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a7c5d5e5f1081955358533be077166ee97ed2571d6a66bdba6ec2f609a715d1a", size = 5255171, upload-time = "2025-09-22T04:02:12.631Z" },
+    { url = "https://files.pythonhosted.org/packages/61/46/bb85ea42d2cb1bd8395484fd72f38e3389611aa496ac7772da9205bbda0e/lxml-6.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8f8d0cbd0674ee89863a523e6994ac25fd5be9c8486acfc3e5ccea679bad2679", size = 5057175, upload-time = "2025-09-22T04:02:14.718Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/443fc476dcc8e41577f0af70458c50fe299a97bb6b7505bb1ae09aa7f9ac/lxml-6.0.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:2cbcbf6d6e924c28f04a43f3b6f6e272312a090f269eff68a2982e13e5d57659", size = 4785688, upload-time = "2025-09-22T04:02:16.957Z" },
+    { url = "https://files.pythonhosted.org/packages/48/78/6ef0b359d45bb9697bc5a626e1992fa5d27aa3f8004b137b2314793b50a0/lxml-6.0.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:dfb874cfa53340009af6bdd7e54ebc0d21012a60a4e65d927c2e477112e63484", size = 5660655, upload-time = "2025-09-22T04:02:18.815Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/ea/e1d33808f386bc1339d08c0dcada6e4712d4ed8e93fcad5f057070b7988a/lxml-6.0.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fb8dae0b6b8b7f9e96c26fdd8121522ce5de9bb5538010870bd538683d30e9a2", size = 5247695, upload-time = "2025-09-22T04:02:20.593Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/47/eba75dfd8183673725255247a603b4ad606f4ae657b60c6c145b381697da/lxml-6.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:358d9adae670b63e95bc59747c72f4dc97c9ec58881d4627fe0120da0f90d314", size = 5269841, upload-time = "2025-09-22T04:02:22.489Z" },
+    { url = "https://files.pythonhosted.org/packages/76/04/5c5e2b8577bc936e219becb2e98cdb1aca14a4921a12995b9d0c523502ae/lxml-6.0.2-cp313-cp313-win32.whl", hash = "sha256:e8cd2415f372e7e5a789d743d133ae474290a90b9023197fd78f32e2dc6873e2", size = 3610700, upload-time = "2025-09-22T04:02:24.465Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/0a/4643ccc6bb8b143e9f9640aa54e38255f9d3b45feb2cbe7ae2ca47e8782e/lxml-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:b30d46379644fbfc3ab81f8f82ae4de55179414651f110a1514f0b1f8f6cb2d7", size = 4010347, upload-time = "2025-09-22T04:02:26.286Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ef/dcf1d29c3f530577f61e5fe2f1bd72929acf779953668a8a47a479ae6f26/lxml-6.0.2-cp313-cp313-win_arm64.whl", hash = "sha256:13dcecc9946dca97b11b7c40d29fba63b55ab4170d3c0cf8c0c164343b9bfdcf", size = 3671248, upload-time = "2025-09-22T04:02:27.918Z" },
+    { url = "https://files.pythonhosted.org/packages/03/15/d4a377b385ab693ce97b472fe0c77c2b16ec79590e688b3ccc71fba19884/lxml-6.0.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:b0c732aa23de8f8aec23f4b580d1e52905ef468afb4abeafd3fec77042abb6fe", size = 8659801, upload-time = "2025-09-22T04:02:30.113Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/e8/c128e37589463668794d503afaeb003987373c5f94d667124ffd8078bbd9/lxml-6.0.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4468e3b83e10e0317a89a33d28f7aeba1caa4d1a6fd457d115dd4ffe90c5931d", size = 4659403, upload-time = "2025-09-22T04:02:32.119Z" },
+    { url = "https://files.pythonhosted.org/packages/00/ce/74903904339decdf7da7847bb5741fc98a5451b42fc419a86c0c13d26fe2/lxml-6.0.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:abd44571493973bad4598a3be7e1d807ed45aa2adaf7ab92ab7c62609569b17d", size = 4966974, upload-time = "2025-09-22T04:02:34.155Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/d3/131dec79ce61c5567fecf82515bd9bc36395df42501b50f7f7f3bd065df0/lxml-6.0.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:370cd78d5855cfbffd57c422851f7d3864e6ae72d0da615fca4dad8c45d375a5", size = 5102953, upload-time = "2025-09-22T04:02:36.054Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ea/a43ba9bb750d4ffdd885f2cd333572f5bb900cd2408b67fdda07e85978a0/lxml-6.0.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:901e3b4219fa04ef766885fb40fa516a71662a4c61b80c94d25336b4934b71c0", size = 5055054, upload-time = "2025-09-22T04:02:38.154Z" },
+    { url = "https://files.pythonhosted.org/packages/60/23/6885b451636ae286c34628f70a7ed1fcc759f8d9ad382d132e1c8d3d9bfd/lxml-6.0.2-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:a4bf42d2e4cf52c28cc1812d62426b9503cdb0c87a6de81442626aa7d69707ba", size = 5352421, upload-time = "2025-09-22T04:02:40.413Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5b/fc2ddfc94ddbe3eebb8e9af6e3fd65e2feba4967f6a4e9683875c394c2d8/lxml-6.0.2-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2c7fdaa4d7c3d886a42534adec7cfac73860b89b4e5298752f60aa5984641a0", size = 5673684, upload-time = "2025-09-22T04:02:42.288Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/47293c58cc91769130fbf85531280e8cc7868f7fbb6d92f4670071b9cb3e/lxml-6.0.2-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98a5e1660dc7de2200b00d53fa00bcd3c35a3608c305d45a7bbcaf29fa16e83d", size = 5252463, upload-time = "2025-09-22T04:02:44.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/da/ba6eceb830c762b48e711ded880d7e3e89fc6c7323e587c36540b6b23c6b/lxml-6.0.2-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:dc051506c30b609238d79eda75ee9cab3e520570ec8219844a72a46020901e37", size = 4698437, upload-time = "2025-09-22T04:02:46.524Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/24/7be3f82cb7990b89118d944b619e53c656c97dc89c28cfb143fdb7cd6f4d/lxml-6.0.2-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8799481bbdd212470d17513a54d568f44416db01250f49449647b5ab5b5dccb9", size = 5269890, upload-time = "2025-09-22T04:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bd/dcfb9ea1e16c665efd7538fc5d5c34071276ce9220e234217682e7d2c4a5/lxml-6.0.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9261bb77c2dab42f3ecd9103951aeca2c40277701eb7e912c545c1b16e0e4917", size = 5097185, upload-time = "2025-09-22T04:02:50.746Z" },
+    { url = "https://files.pythonhosted.org/packages/21/04/a60b0ff9314736316f28316b694bccbbabe100f8483ad83852d77fc7468e/lxml-6.0.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:65ac4a01aba353cfa6d5725b95d7aed6356ddc0a3cd734de00124d285b04b64f", size = 4745895, upload-time = "2025-09-22T04:02:52.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/bd/7d54bd1846e5a310d9c715921c5faa71cf5c0853372adf78aee70c8d7aa2/lxml-6.0.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b22a07cbb82fea98f8a2fd814f3d1811ff9ed76d0fc6abc84eb21527596e7cc8", size = 5695246, upload-time = "2025-09-22T04:02:54.798Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/5643d6ab947bc371da21323acb2a6e603cedbe71cb4c99c8254289ab6f4e/lxml-6.0.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d759cdd7f3e055d6bc8d9bec3ad905227b2e4c785dc16c372eb5b5e83123f48a", size = 5260797, upload-time = "2025-09-22T04:02:57.058Z" },
+    { url = "https://files.pythonhosted.org/packages/33/da/34c1ec4cff1eea7d0b4cd44af8411806ed943141804ac9c5d565302afb78/lxml-6.0.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:945da35a48d193d27c188037a05fec5492937f66fb1958c24fc761fb9d40d43c", size = 5277404, upload-time = "2025-09-22T04:02:58.966Z" },
+    { url = "https://files.pythonhosted.org/packages/82/57/4eca3e31e54dc89e2c3507e1cd411074a17565fa5ffc437c4ae0a00d439e/lxml-6.0.2-cp314-cp314-win32.whl", hash = "sha256:be3aaa60da67e6153eb15715cc2e19091af5dc75faef8b8a585aea372507384b", size = 3670072, upload-time = "2025-09-22T04:03:38.05Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/e0/c96cf13eccd20c9421ba910304dae0f619724dcf1702864fd59dd386404d/lxml-6.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:fa25afbadead523f7001caf0c2382afd272c315a033a7b06336da2637d92d6ed", size = 4080617, upload-time = "2025-09-22T04:03:39.835Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/5d/b3f03e22b3d38d6f188ef044900a9b29b2fe0aebb94625ce9fe244011d34/lxml-6.0.2-cp314-cp314-win_arm64.whl", hash = "sha256:063eccf89df5b24e361b123e257e437f9e9878f425ee9aae3144c77faf6da6d8", size = 3754930, upload-time = "2025-09-22T04:03:41.565Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/5c/42c2c4c03554580708fc738d13414801f340c04c3eff90d8d2d227145275/lxml-6.0.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6162a86d86893d63084faaf4ff937b3daea233e3682fb4474db07395794fa80d", size = 8910380, upload-time = "2025-09-22T04:03:01.645Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/4f/12df843e3e10d18d468a7557058f8d3733e8b6e12401f30b1ef29360740f/lxml-6.0.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:414aaa94e974e23a3e92e7ca5b97d10c0cf37b6481f50911032c69eeb3991bba", size = 4775632, upload-time = "2025-09-22T04:03:03.814Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0c/9dc31e6c2d0d418483cbcb469d1f5a582a1cd00a1f4081953d44051f3c50/lxml-6.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48461bd21625458dd01e14e2c38dd0aea69addc3c4f960c30d9f59d7f93be601", size = 4975171, upload-time = "2025-09-22T04:03:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2b/9b870c6ca24c841bdd887504808f0417aa9d8d564114689266f19ddf29c8/lxml-6.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:25fcc59afc57d527cfc78a58f40ab4c9b8fd096a9a3f964d2781ffb6eb33f4ed", size = 5110109, upload-time = "2025-09-22T04:03:07.452Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/0c/4f5f2a4dd319a178912751564471355d9019e220c20d7db3fb8307ed8582/lxml-6.0.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5179c60288204e6ddde3f774a93350177e08876eaf3ab78aa3a3649d43eb7d37", size = 5041061, upload-time = "2025-09-22T04:03:09.297Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/554eed290365267671fe001a20d72d14f468ae4e6acef1e179b039436967/lxml-6.0.2-cp314-cp314t-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:967aab75434de148ec80597b75062d8123cadf2943fb4281f385141e18b21338", size = 5306233, upload-time = "2025-09-22T04:03:11.651Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/31/1d748aa275e71802ad9722df32a7a35034246b42c0ecdd8235412c3396ef/lxml-6.0.2-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d100fcc8930d697c6561156c6810ab4a508fb264c8b6779e6e61e2ed5e7558f9", size = 5604739, upload-time = "2025-09-22T04:03:13.592Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/41/2c11916bcac09ed561adccacceaedd2bf0e0b25b297ea92aab99fd03d0fa/lxml-6.0.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ca59e7e13e5981175b8b3e4ab84d7da57993eeff53c07764dcebda0d0e64ecd", size = 5225119, upload-time = "2025-09-22T04:03:15.408Z" },
+    { url = "https://files.pythonhosted.org/packages/99/05/4e5c2873d8f17aa018e6afde417c80cc5d0c33be4854cce3ef5670c49367/lxml-6.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:957448ac63a42e2e49531b9d6c0fa449a1970dbc32467aaad46f11545be9af1d", size = 4633665, upload-time = "2025-09-22T04:03:17.262Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c9/dcc2da1bebd6275cdc723b515f93edf548b82f36a5458cca3578bc899332/lxml-6.0.2-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b7fc49c37f1786284b12af63152fe1d0990722497e2d5817acfe7a877522f9a9", size = 5234997, upload-time = "2025-09-22T04:03:19.14Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e2/5172e4e7468afca64a37b81dba152fc5d90e30f9c83c7c3213d6a02a5ce4/lxml-6.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e19e0643cc936a22e837f79d01a550678da8377d7d801a14487c10c34ee49c7e", size = 5090957, upload-time = "2025-09-22T04:03:21.436Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/b3/15461fd3e5cd4ddcb7938b87fc20b14ab113b92312fc97afe65cd7c85de1/lxml-6.0.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:1db01e5cf14345628e0cbe71067204db658e2fb8e51e7f33631f5f4735fefd8d", size = 4764372, upload-time = "2025-09-22T04:03:23.27Z" },
+    { url = "https://files.pythonhosted.org/packages/05/33/f310b987c8bf9e61c4dd8e8035c416bd3230098f5e3cfa69fc4232de7059/lxml-6.0.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:875c6b5ab39ad5291588aed6925fac99d0097af0dd62f33c7b43736043d4a2ec", size = 5634653, upload-time = "2025-09-22T04:03:25.767Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ff/51c80e75e0bc9382158133bdcf4e339b5886c6ee2418b5199b3f1a61ed6d/lxml-6.0.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:cdcbed9ad19da81c480dfd6dd161886db6096083c9938ead313d94b30aadf272", size = 5233795, upload-time = "2025-09-22T04:03:27.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/4d/4856e897df0d588789dd844dbed9d91782c4ef0b327f96ce53c807e13128/lxml-6.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:80dadc234ebc532e09be1975ff538d154a7fa61ea5031c03d25178855544728f", size = 5257023, upload-time = "2025-09-22T04:03:30.056Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/85/86766dfebfa87bea0ab78e9ff7a4b4b45225df4b4d3b8cc3c03c5cd68464/lxml-6.0.2-cp314-cp314t-win32.whl", hash = "sha256:da08e7bb297b04e893d91087df19638dc7a6bb858a954b0cc2b9f5053c922312", size = 3911420, upload-time = "2025-09-22T04:03:32.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/1a/b248b355834c8e32614650b8008c69ffeb0ceb149c793961dd8c0b991bb3/lxml-6.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:252a22982dca42f6155125ac76d3432e548a7625d56f5a273ee78a5057216eca", size = 4406837, upload-time = "2025-09-22T04:03:34.027Z" },
+    { url = "https://files.pythonhosted.org/packages/92/aa/df863bcc39c5e0946263454aba394de8a9084dbaff8ad143846b0d844739/lxml-6.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:bb4c1847b303835d89d785a18801a883436cdfd5dc3d62947f9c49e24f0f5a2c", size = 3822205, upload-time = "2025-09-22T04:03:36.249Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/11/29d08bc103a62c0eba8016e7ed5aeebbf1e4312e83b0b1648dd203b0e87d/lxml-6.0.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1c06035eafa8404b5cf475bb37a9f6088b0aca288d4ccc9d69389750d5543700", size = 3949829, upload-time = "2025-09-22T04:04:45.608Z" },
+    { url = "https://files.pythonhosted.org/packages/12/b3/52ab9a3b31e5ab8238da241baa19eec44d2ab426532441ee607165aebb52/lxml-6.0.2-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c7d13103045de1bdd6fe5d61802565f1a3537d70cd3abf596aa0af62761921ee", size = 4226277, upload-time = "2025-09-22T04:04:47.754Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/33/1eaf780c1baad88224611df13b1c2a9dfa460b526cacfe769103ff50d845/lxml-6.0.2-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a3c150a95fbe5ac91de323aa756219ef9cf7fde5a3f00e2281e30f33fa5fa4f", size = 4330433, upload-time = "2025-09-22T04:04:49.907Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/c1/27428a2ff348e994ab4f8777d3a0ad510b6b92d37718e5887d2da99952a2/lxml-6.0.2-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60fa43be34f78bebb27812ed90f1925ec99560b0fa1decdb7d12b84d857d31e9", size = 4272119, upload-time = "2025-09-22T04:04:51.801Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d0/3020fa12bcec4ab62f97aab026d57c2f0cfd480a558758d9ca233bb6a79d/lxml-6.0.2-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21c73b476d3cfe836be731225ec3421fa2f048d84f6df6a8e70433dff1376d5a", size = 4417314, upload-time = "2025-09-22T04:04:55.024Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/77/d7f491cbc05303ac6801651aabeb262d43f319288c1ea96c66b1d2692ff3/lxml-6.0.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:27220da5be049e936c3aca06f174e8827ca6445a4353a1995584311487fc4e3e", size = 3518768, upload-time = "2025-09-22T04:04:57.097Z" },
+]
+
+[[package]]
+name = "markdown"
+version = "3.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2b/f4/69fa6ed85ae003c2378ffa8f6d2e3234662abd02c10d216c0ba96081a238/markdown-3.10.2.tar.gz", hash = "sha256:994d51325d25ad8aa7ce4ebaec003febcce822c3f8c911e3b17c52f7f589f950", size = 368805, upload-time = "2026-02-09T14:57:26.942Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/1f/77fa3081e4f66ca3576c896ae5d31c3002ac6607f9747d2e3aa49227e464/markdown-3.10.2-py3-none-any.whl", hash = "sha256:e91464b71ae3ee7afd3017d9f358ef0baf158fd9a298db92f1d4761133824c36", size = 108180, upload-time = "2026-02-09T14:57:25.787Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[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/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.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "contourpy" },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/86/de7e3a1cdcfc941483af70609edc06b83e7c8a0e0dc9ac325200a3f4d220/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160", size = 8251215, upload-time = "2025-12-10T22:55:16.175Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/14/baad3222f424b19ce6ad243c71de1ad9ec6b2e4eb1e458a48fdc6d120401/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78", size = 8139625, upload-time = "2025-12-10T22:55:17.712Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/a0/7024215e95d456de5883e6732e708d8187d9753a21d32f8ddb3befc0c445/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4", size = 8712614, upload-time = "2025-12-10T22:55:20.8Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f4/b8347351da9a5b3f41e26cf547252d861f685c6867d179a7c9d60ad50189/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2", size = 9540997, upload-time = "2025-12-10T22:55:23.258Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/c7b914e297efe0bc36917bf216b2acb91044b91e930e878ae12981e461e5/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6", size = 9596825, upload-time = "2025-12-10T22:55:25.217Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d3/a4bbc01c237ab710a1f22b4da72f4ff6d77eb4c7735ea9811a94ae239067/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9", size = 8135090, upload-time = "2025-12-10T22:55:27.162Z" },
+    { url = "https://files.pythonhosted.org/packages/89/dd/a0b6588f102beab33ca6f5218b31725216577b2a24172f327eaf6417d5c9/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2", size = 8012377, upload-time = "2025-12-10T22:55:29.185Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/67/f997cdcbb514012eb0d10cd2b4b332667997fb5ebe26b8d41d04962fa0e6/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a", size = 8260453, upload-time = "2025-12-10T22:55:30.709Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58", size = 8148321, upload-time = "2025-12-10T22:55:33.265Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04", size = 8716944, upload-time = "2025-12-10T22:55:34.922Z" },
+    { url = "https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f", size = 9550099, upload-time = "2025-12-10T22:55:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/57/61/78cd5920d35b29fd2a0fe894de8adf672ff52939d2e9b43cb83cd5ce1bc7/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466", size = 9613040, upload-time = "2025-12-10T22:55:38.715Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/c10f171b6e2f44d9e3a2b96efa38b1677439d79c99357600a62cc1e9594e/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf", size = 8142717, upload-time = "2025-12-10T22:55:41.103Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/76/934db220026b5fef85f45d51a738b91dea7d70207581063cd9bd8fafcf74/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b", size = 8012751, upload-time = "2025-12-10T22:55:42.684Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b9/15fd5541ef4f5b9a17eefd379356cf12175fe577424e7b1d80676516031a/matplotlib-3.10.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3f2e409836d7f5ac2f1c013110a4d50b9f7edc26328c108915f9075d7d7a91b6", size = 8261076, upload-time = "2025-12-10T22:55:44.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a0/2ba3473c1b66b9c74dc7107c67e9008cb1782edbe896d4c899d39ae9cf78/matplotlib-3.10.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56271f3dac49a88d7fca5060f004d9d22b865f743a12a23b1e937a0be4818ee1", size = 8148794, upload-time = "2025-12-10T22:55:46.252Z" },
+    { url = "https://files.pythonhosted.org/packages/75/97/a471f1c3eb1fd6f6c24a31a5858f443891d5127e63a7788678d14e249aea/matplotlib-3.10.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0a7f52498f72f13d4a25ea70f35f4cb60642b466cbb0a9be951b5bc3f45a486", size = 8718474, upload-time = "2025-12-10T22:55:47.864Z" },
+    { url = "https://files.pythonhosted.org/packages/01/be/cd478f4b66f48256f42927d0acbcd63a26a893136456cd079c0cc24fbabf/matplotlib-3.10.8-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:646d95230efb9ca614a7a594d4fcacde0ac61d25e37dd51710b36477594963ce", size = 9549637, upload-time = "2025-12-10T22:55:50.048Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7c/8dc289776eae5109e268c4fb92baf870678dc048a25d4ac903683b86d5bf/matplotlib-3.10.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f89c151aab2e2e23cb3fe0acad1e8b82841fd265379c4cecd0f3fcb34c15e0f6", size = 9613678, upload-time = "2025-12-10T22:55:52.21Z" },
+    { url = "https://files.pythonhosted.org/packages/64/40/37612487cc8a437d4dd261b32ca21fe2d79510fe74af74e1f42becb1bdb8/matplotlib-3.10.8-cp313-cp313-win_amd64.whl", hash = "sha256:e8ea3e2d4066083e264e75c829078f9e149fa119d27e19acd503de65e0b13149", size = 8142686, upload-time = "2025-12-10T22:55:54.253Z" },
+    { url = "https://files.pythonhosted.org/packages/66/52/8d8a8730e968185514680c2a6625943f70269509c3dcfc0dcf7d75928cb8/matplotlib-3.10.8-cp313-cp313-win_arm64.whl", hash = "sha256:c108a1d6fa78a50646029cb6d49808ff0fc1330fda87fa6f6250c6b5369b6645", size = 8012917, upload-time = "2025-12-10T22:55:56.268Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/27/51fe26e1062f298af5ef66343d8ef460e090a27fea73036c76c35821df04/matplotlib-3.10.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ad3d9833a64cf48cc4300f2b406c3d0f4f4724a91c0bd5640678a6ba7c102077", size = 8305679, upload-time = "2025-12-10T22:55:57.856Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/1e/4de865bc591ac8e3062e835f42dd7fe7a93168d519557837f0e37513f629/matplotlib-3.10.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:eb3823f11823deade26ce3b9f40dcb4a213da7a670013929f31d5f5ed1055b22", size = 8198336, upload-time = "2025-12-10T22:55:59.371Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cb/2f7b6e75fb4dce87ef91f60cac4f6e34f4c145ab036a22318ec837971300/matplotlib-3.10.8-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d9050fee89a89ed57b4fb2c1bfac9a3d0c57a0d55aed95949eedbc42070fea39", size = 8731653, upload-time = "2025-12-10T22:56:01.032Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b3/bd9c57d6ba670a37ab31fb87ec3e8691b947134b201f881665b28cc039ff/matplotlib-3.10.8-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b44d07310e404ba95f8c25aa5536f154c0a8ec473303535949e52eb71d0a1565", size = 9561356, upload-time = "2025-12-10T22:56:02.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3d/8b94a481456dfc9dfe6e39e93b5ab376e50998cddfd23f4ae3b431708f16/matplotlib-3.10.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0a33deb84c15ede243aead39f77e990469fff93ad1521163305095b77b72ce4a", size = 9614000, upload-time = "2025-12-10T22:56:05.411Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/cd/bc06149fe5585ba800b189a6a654a75f1f127e8aab02fd2be10df7fa500c/matplotlib-3.10.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3a48a78d2786784cc2413e57397981fb45c79e968d99656706018d6e62e57958", size = 8220043, upload-time = "2025-12-10T22:56:07.551Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/de/b22cf255abec916562cc04eef457c13e58a1990048de0c0c3604d082355e/matplotlib-3.10.8-cp313-cp313t-win_arm64.whl", hash = "sha256:15d30132718972c2c074cd14638c7f4592bd98719e2308bccea40e0538bc0cb5", size = 8062075, upload-time = "2025-12-10T22:56:09.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/43/9c0ff7a2f11615e516c3b058e1e6e8f9614ddeca53faca06da267c48345d/matplotlib-3.10.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b53285e65d4fa4c86399979e956235deb900be5baa7fc1218ea67fbfaeaadd6f", size = 8262481, upload-time = "2025-12-10T22:56:10.885Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ca/e8ae28649fcdf039fda5ef554b40a95f50592a3c47e6f7270c9561c12b07/matplotlib-3.10.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32f8dce744be5569bebe789e46727946041199030db8aeb2954d26013a0eb26b", size = 8151473, upload-time = "2025-12-10T22:56:12.377Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/6f/009d129ae70b75e88cbe7e503a12a4c0670e08ed748a902c2568909e9eb5/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cf267add95b1c88300d96ca837833d4112756045364f5c734a2276038dae27d", size = 9553896, upload-time = "2025-12-10T22:56:14.432Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/26/4221a741eb97967bc1fd5e4c52b9aa5a91b2f4ec05b59f6def4d820f9df9/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2cf5bd12cecf46908f286d7838b2abc6c91cda506c0445b8223a7c19a00df008", size = 9824193, upload-time = "2025-12-10T22:56:16.29Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/3abf75f38605772cf48a9daf5821cd4f563472f38b4b828c6fba6fa6d06e/matplotlib-3.10.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:41703cc95688f2516b480f7f339d8851a6035f18e100ee6a32bc0b8536a12a9c", size = 9615444, upload-time = "2025-12-10T22:56:18.155Z" },
+    { url = "https://files.pythonhosted.org/packages/93/a5/de89ac80f10b8dc615807ee1133cd99ac74082581196d4d9590bea10690d/matplotlib-3.10.8-cp314-cp314-win_amd64.whl", hash = "sha256:83d282364ea9f3e52363da262ce32a09dfe241e4080dcedda3c0db059d3c1f11", size = 8272719, upload-time = "2025-12-10T22:56:20.366Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ce/b006495c19ccc0a137b48083168a37bd056392dee02f87dba0472f2797fe/matplotlib-3.10.8-cp314-cp314-win_arm64.whl", hash = "sha256:2c1998e92cd5999e295a731bcb2911c75f597d937341f3030cc24ef2733d78a8", size = 8144205, upload-time = "2025-12-10T22:56:22.239Z" },
+    { url = "https://files.pythonhosted.org/packages/68/d9/b31116a3a855bd313c6fcdb7226926d59b041f26061c6c5b1be66a08c826/matplotlib-3.10.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b5a2b97dbdc7d4f353ebf343744f1d1f1cca8aa8bfddb4262fcf4306c3761d50", size = 8305785, upload-time = "2025-12-10T22:56:24.218Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/90/6effe8103f0272685767ba5f094f453784057072f49b393e3ea178fe70a5/matplotlib-3.10.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3f5c3e4da343bba819f0234186b9004faba952cc420fbc522dc4e103c1985908", size = 8198361, upload-time = "2025-12-10T22:56:26.787Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/65/a73188711bea603615fc0baecca1061429ac16940e2385433cc778a9d8e7/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f62550b9a30afde8c1c3ae450e5eb547d579dd69b25c2fc7a1c67f934c1717a", size = 9561357, upload-time = "2025-12-10T22:56:28.953Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/3d/b5c5d5d5be8ce63292567f0e2c43dde9953d3ed86ac2de0a72e93c8f07a1/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:495672de149445ec1b772ff2c9ede9b769e3cb4f0d0aa7fa730d7f59e2d4e1c1", size = 9823610, upload-time = "2025-12-10T22:56:31.455Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/4b/e7beb6bbd49f6bae727a12b270a2654d13c397576d25bd6786e47033300f/matplotlib-3.10.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:595ba4d8fe983b88f0eec8c26a241e16d6376fe1979086232f481f8f3f67494c", size = 9614011, upload-time = "2025-12-10T22:56:33.85Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/e6/76f2813d31f032e65f6f797e3f2f6e4aab95b65015924b1c51370395c28a/matplotlib-3.10.8-cp314-cp314t-win_amd64.whl", hash = "sha256:25d380fe8b1dc32cf8f0b1b448470a77afb195438bafdf1d858bfb876f3edf7b", size = 8362801, upload-time = "2025-12-10T22:56:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/49/d651878698a0b67f23aa28e17f45a6d6dd3d3f933fa29087fa4ce5947b5a/matplotlib-3.10.8-cp314-cp314t-win_arm64.whl", hash = "sha256:113bb52413ea508ce954a02c10ffd0d565f9c3bc7f2eddc27dfe1731e71c7b5f", size = 8192560, upload-time = "2025-12-10T22:56:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/04/30/3afaa31c757f34b7725ab9d2ba8b48b5e89c2019c003e7d0ead143aabc5a/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1", size = 8249198, upload-time = "2025-12-10T22:56:45.584Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2f/6334aec331f57485a642a7c8be03cb286f29111ae71c46c38b363230063c/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a", size = 8136817, upload-time = "2025-12-10T22:56:47.339Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" },
+]
+
+[[package]]
+name = "matplotlib-inline"
+version = "0.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" },
+]
+
+[[package]]
+name = "mdit-py-plugins"
+version = "0.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" },
+]
+
+[[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 = "mergedeep"
+version = "1.3.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661, upload-time = "2021-02-05T18:55:30.623Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" },
+]
+
+[[package]]
+name = "mistune"
+version = "3.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/55/d01f0c4b45ade6536c51170b9043db8b2ec6ddf4a35c7ea3f5f559ac935b/mistune-3.2.0.tar.gz", hash = "sha256:708487c8a8cdd99c9d90eb3ed4c3ed961246ff78ac82f03418f5183ab70e398a", size = 95467, upload-time = "2025-12-23T11:36:34.994Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/f7/4a5e785ec9fbd65146a27b6b70b6cdc161a66f2024e4b04ac06a67f5578b/mistune-3.2.0-py3-none-any.whl", hash = "sha256:febdc629a3c78616b94393c6580551e0e34cc289987ec6c35ed3f4be42d0eee1", size = 53598, upload-time = "2025-12-23T11:36:33.211Z" },
+]
+
+[[package]]
+name = "mkdocs"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "ghp-import" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mergedeep" },
+    { name = "mkdocs-get-deps" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "pyyaml" },
+    { name = "pyyaml-env-tag" },
+    { name = "watchdog" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159, upload-time = "2024-08-30T12:24:06.899Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" },
+]
+
+[[package]]
+name = "mkdocs-autorefs"
+version = "1.4.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mkdocs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/c0/f641843de3f612a6b48253f39244165acff36657a91cc903633d456ae1ac/mkdocs_autorefs-1.4.4.tar.gz", hash = "sha256:d54a284f27a7346b9c38f1f852177940c222da508e66edc816a0fa55fc6da197", size = 56588, upload-time = "2026-02-10T15:23:55.105Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/de/a3e710469772c6a89595fc52816da05c1e164b4c866a89e3cb82fb1b67c5/mkdocs_autorefs-1.4.4-py3-none-any.whl", hash = "sha256:834ef5408d827071ad1bc69e0f39704fa34c7fc05bc8e1c72b227dfdc5c76089", size = 25530, upload-time = "2026-02-10T15:23:53.817Z" },
+]
+
+[[package]]
+name = "mkdocs-get-deps"
+version = "0.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mergedeep" },
+    { name = "platformdirs" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/25/b3cccb187655b9393572bde9b09261d267c3bf2f2cdabe347673be5976a6/mkdocs_get_deps-0.2.2.tar.gz", hash = "sha256:8ee8d5f316cdbbb2834bc1df6e69c08fe769a83e040060de26d3c19fad3599a1", size = 11047, upload-time = "2026-03-10T02:46:33.632Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/29/744136411e785c4b0b744d5413e56555265939ab3a104c6a4b719dad33fd/mkdocs_get_deps-0.2.2-py3-none-any.whl", hash = "sha256:e7878cbeac04860b8b5e0ca31d3abad3df9411a75a32cde82f8e44b6c16ff650", size = 9555, upload-time = "2026-03-10T02:46:32.256Z" },
+]
+
+[[package]]
+name = "mkdocs-jupyter"
+version = "0.26.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ipykernel" },
+    { name = "jupytext" },
+    { name = "mkdocs" },
+    { name = "mkdocs-material" },
+    { name = "nbconvert" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7f/d8/c146ea8cc36c3e812dd4c154513aa308614f35d2b4becec4b449165088f5/mkdocs_jupyter-0.26.1.tar.gz", hash = "sha256:7c80c0d3953de91e5b40a0d3209233795c8f800243ab298e4ec38e0504eda630", size = 1628270, upload-time = "2026-03-24T15:32:47.944Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/89/eb601278b12c471235860992f5973cf3c55ca3f77d1d6127389eb045a021/mkdocs_jupyter-0.26.1-py3-none-any.whl", hash = "sha256:527242c2c8f1d30970764bbab752de41243e5703f458d8bc05336ec53828192e", size = 1459618, upload-time = "2026-03-24T15:32:46.25Z" },
+]
+
+[[package]]
+name = "mkdocs-material"
+version = "9.7.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "babel" },
+    { name = "backrefs" },
+    { name = "colorama" },
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "mkdocs" },
+    { name = "mkdocs-material-extensions" },
+    { name = "paginate" },
+    { name = "pygments" },
+    { name = "pymdown-extensions" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/29/6d2bcf41ae40802c4beda2432396fff97b8456fb496371d1bc7aad6512ec/mkdocs_material-9.7.6.tar.gz", hash = "sha256:00bdde50574f776d328b1862fe65daeaf581ec309bd150f7bff345a098c64a69", size = 4097959, upload-time = "2026-03-19T15:41:58.161Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/01/bc663630c510822c95c47a66af9fa7a443c295b47d5f041e5e6ae62ef659/mkdocs_material-9.7.6-py3-none-any.whl", hash = "sha256:71b84353921b8ea1ba84fe11c50912cc512da8fe0881038fcc9a0761c0e635ba", size = 9305470, upload-time = "2026-03-19T15:41:55.217Z" },
+]
+
+[package.optional-dependencies]
+imaging = [
+    { name = "cairosvg" },
+    { name = "pillow" },
+]
+
+[[package]]
+name = "mkdocs-material-extensions"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847, upload-time = "2023-11-22T19:09:45.208Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" },
+]
+
+[[package]]
+name = "mkdocstrings"
+version = "1.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jinja2" },
+    { name = "markdown" },
+    { name = "markupsafe" },
+    { name = "mkdocs" },
+    { name = "mkdocs-autorefs" },
+    { name = "pymdown-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/62/0dfc5719514115bf1781f44b1d7f2a0923fcc01e9c5d7990e48a05c9ae5d/mkdocstrings-1.0.3.tar.gz", hash = "sha256:ab670f55040722b49bb45865b2e93b824450fb4aef638b00d7acb493a9020434", size = 100946, upload-time = "2026-02-07T14:31:40.973Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/41/1cf02e3df279d2dd846a1bf235a928254eba9006dd22b4a14caa71aed0f7/mkdocstrings-1.0.3-py3-none-any.whl", hash = "sha256:0d66d18430c2201dc7fe85134277382baaa15e6b30979f3f3bdbabd6dbdb6046", size = 35523, upload-time = "2026-02-07T14:31:39.27Z" },
+]
+
+[package.optional-dependencies]
+python = [
+    { name = "mkdocstrings-python" },
+]
+
+[[package]]
+name = "mkdocstrings-python"
+version = "2.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "griffelib" },
+    { name = "mkdocs-autorefs" },
+    { name = "mkdocstrings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/29/33/c225eaf898634bdda489a6766fc35d1683c640bffe0e0acd10646b13536d/mkdocstrings_python-2.0.3.tar.gz", hash = "sha256:c518632751cc869439b31c9d3177678ad2bfa5c21b79b863956ad68fc92c13b8", size = 199083, upload-time = "2026-02-20T10:38:36.368Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/28/79f0f8de97cce916d5ae88a7bee1ad724855e83e6019c0b4d5b3fabc80f3/mkdocstrings_python-2.0.3-py3-none-any.whl", hash = "sha256:0b83513478bdfd803ff05aa43e9b1fca9dd22bcd9471f09ca6257f009bc5ee12", size = 104779, upload-time = "2026-02-20T10:38:34.517Z" },
+]
+
+[[package]]
+name = "morecantile"
+version = "7.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "click" },
+    { name = "pydantic" },
+    { name = "pyproj" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ab/44/fa4f0685481b51e5ce33089ca84e821453593d34f306738515a937934751/morecantile-7.0.3.tar.gz", hash = "sha256:b44419c83f310b411b1f547df2d07c115dc6d194ab7c8a4c318a154490e938c1", size = 43104, upload-time = "2026-02-04T23:03:26.423Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/1a/f9edb1c167bd8ad214dc87e9ae17fb208d08f7a05e724f74ce29e375c8de/morecantile-7.0.3-py3-none-any.whl", hash = "sha256:747c6b8f3a8029ddaadb04d96c834f10d2796d1898ad893bed47c896a058ddc7", size = 50885, upload-time = "2026-02-04T23:03:27.463Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" },
+    { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" },
+    { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+    { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+    { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+    { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+    { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[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 = "nbclient"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-client" },
+    { name = "jupyter-core" },
+    { name = "nbformat" },
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/56/91/1c1d5a4b9a9ebba2b4e32b8c852c2975c872aec1fe42ab5e516b2cecd193/nbclient-0.10.4.tar.gz", hash = "sha256:1e54091b16e6da39e297b0ece3e10f6f29f4ac4e8ee515d29f8a7099bd6553c9", size = 62554, upload-time = "2025-12-23T07:45:46.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/a0/5b0c2f11142ed1dddec842457d3f65eaf71a0080894eb6f018755b319c3a/nbclient-0.10.4-py3-none-any.whl", hash = "sha256:9162df5a7373d70d606527300a95a975a47c137776cd942e52d9c7e29ff83440", size = 25465, upload-time = "2025-12-23T07:45:44.51Z" },
+]
+
+[[package]]
+name = "nbconvert"
+version = "7.17.0"
+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/38/47/81f886b699450d0569f7bc551df2b1673d18df7ff25cc0c21ca36ed8a5ff/nbconvert-7.17.0.tar.gz", hash = "sha256:1b2696f1b5be12309f6c7d707c24af604b87dfaf6d950794c7b07acab96dda78", size = 862855, upload-time = "2026-01-29T16:37:48.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0d/4b/8d5f796a792f8a25f6925a96032f098789f448571eb92011df1ae59e8ea8/nbconvert-7.17.0-py3-none-any.whl", hash = "sha256:4f99a63b337b9a23504347afdab24a11faa7d86b405e5c8f9881cd313336d518", size = 261510, upload-time = "2026-01-29T16:37:46.322Z" },
+]
+
+[[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 = "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 = "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 = "notebook"
+version = "7.5.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-server" },
+    { name = "jupyterlab" },
+    { name = "jupyterlab-server" },
+    { name = "notebook-shim" },
+    { name = "tornado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/6d/41052c48d6f6349ca0a7c4d1f6a78464de135e6d18f5829ba2510e62184c/notebook-7.5.5.tar.gz", hash = "sha256:dc0bfab0f2372c8278c457423d3256c34154ac2cc76bf20e9925260c461013c3", size = 14169167, upload-time = "2026-03-11T16:32:51.922Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/aa/cbd1deb9f07446241e88f8d5fecccd95b249bca0b4e5482214a4d1714c49/notebook-7.5.5-py3-none-any.whl", hash = "sha256:a7c14dbeefa6592e87f72290ca982e0c10f5bbf3786be2a600fda9da2764a2b8", size = 14578929, upload-time = "2026-03-11T16:32:48.021Z" },
+]
+
+[[package]]
+name = "notebook-shim"
+version = "0.2.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jupyter-server" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" },
+]
+
+[[package]]
+name = "numcodecs"
+version = "0.16.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/44/bd/8a391e7c356366224734efd24da929cc4796fff468bfb179fe1af6548535/numcodecs-0.16.5.tar.gz", hash = "sha256:0d0fb60852f84c0bd9543cc4d2ab9eefd37fc8efcc410acd4777e62a1d300318", size = 6276387, upload-time = "2025-11-21T02:49:48.986Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/85/1ac101a40ead81eaa1c7dc49a8827a30e2e436211b43ebdc63c590eb1347/numcodecs-0.16.5-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:78382dcea50622f2ef1e6e7a71dbe7f861d8fe376b27b7c297c26907304fef1e", size = 1621795, upload-time = "2025-11-21T02:49:17.418Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/cc/0d97ef55dda48cb0f93d7b92d761208e7a99bd2eea6b0e859426e6a99a21/numcodecs-0.16.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2d04a19cb57a3c519b4127ac377cca6471aee1990d7c18f5b1e3a4fe1306689", size = 1153030, upload-time = "2025-11-21T02:49:19.089Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/41/e120ee1b390730ac5987cde2afd82e2b8442cec315ab40b94b0373e93e73/numcodecs-0.16.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c043af648eb280cd61785c99c22ff5c3c3460f906eb51a8511327c4f5111b283", size = 8510503, upload-time = "2025-11-21T02:49:20.324Z" },
+    { url = "https://files.pythonhosted.org/packages/54/4b/195ac84cc8f6077b4f0f421e8daee21b7f1bd88cb7716414234379fe68ec/numcodecs-0.16.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c398919ef2eb0e56b8e97456f622640bfd3deed06de3acc976989cbcb22628a3", size = 9123428, upload-time = "2025-11-21T02:49:22.328Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/5b/af02c417954f46e5c7bd5163ac251f535877d909fce54861c99ae197f6f6/numcodecs-0.16.5-cp311-cp311-win_amd64.whl", hash = "sha256:3820860ed302d4d84a1c66e70981ff959d5eb712555be4e7d8ced49888594773", size = 801542, upload-time = "2025-11-21T02:49:24.265Z" },
+    { url = "https://files.pythonhosted.org/packages/75/cc/55420f3641a67f78392dc0bc5d02cb9eb0a9dcebf2848d1ac77253ca61fa/numcodecs-0.16.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:24e675dc8d1550cd976a99479b87d872cb142632c75cc402fea04c08c4898523", size = 1656287, upload-time = "2025-11-21T02:49:25.755Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/6c/86644987505dcb90ba6d627d6989c27bafb0699f9fd00187e06d05ea8594/numcodecs-0.16.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:94ddfa4341d1a3ab99989d13b01b5134abb687d3dab2ead54b450aefe4ad5bd6", size = 1148899, upload-time = "2025-11-21T02:49:26.87Z" },
+    { url = "https://files.pythonhosted.org/packages/97/1e/98aaddf272552d9fef1f0296a9939d1487914a239e98678f6b20f8b0a5c8/numcodecs-0.16.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b554ab9ecf69de7ca2b6b5e8bc696bd9747559cb4dd5127bd08d7a28bec59c3a", size = 8534814, upload-time = "2025-11-21T02:49:28.547Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/53/78c98ef5c8b2b784453487f3e4d6c017b20747c58b470393e230c78d18e8/numcodecs-0.16.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ad1a379a45bd3491deab8ae6548313946744f868c21d5340116977ea3be5b1d6", size = 9173471, upload-time = "2025-11-21T02:49:30.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/20/2fdec87fc7f8cec950d2b0bea603c12dc9f05b4966dc5924ba5a36a61bf6/numcodecs-0.16.5-cp312-cp312-win_amd64.whl", hash = "sha256:845a9857886ffe4a3172ba1c537ae5bcc01e65068c31cf1fce1a844bd1da050f", size = 801412, upload-time = "2025-11-21T02:49:32.123Z" },
+    { url = "https://files.pythonhosted.org/packages/38/38/071ced5a5fd1c85ba0e14ba721b66b053823e5176298c2f707e50bed11d9/numcodecs-0.16.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:25be3a516ab677dad890760d357cfe081a371d9c0a2e9a204562318ac5969de3", size = 1654359, upload-time = "2025-11-21T02:49:33.673Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/c0/5f84ba7525577c1b9909fc2d06ef11314825fc4ad4378f61d0e4c9883b4a/numcodecs-0.16.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0107e839ef75b854e969cb577e140b1aadb9847893937636582d23a2a4c6ce50", size = 1144237, upload-time = "2025-11-21T02:49:35.294Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/00/787ea5f237b8ea7bc67140c99155f9c00b5baf11c49afc5f3bfefa298f95/numcodecs-0.16.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:015a7c859ecc2a06e2a548f64008c0ec3aaecabc26456c2c62f4278d8fc20597", size = 8483064, upload-time = "2025-11-21T02:49:36.454Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/e6/d359fdd37498e74d26a167f7a51e54542e642ea47181eb4e643a69a066c3/numcodecs-0.16.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:84230b4b9dad2392f2a84242bd6e3e659ac137b5a1ce3571d6965fca673e0903", size = 9126063, upload-time = "2025-11-21T02:49:38.018Z" },
+    { url = "https://files.pythonhosted.org/packages/27/72/6663cc0382ddbb866136c255c837bcb96cc7ce5e83562efec55e1b995941/numcodecs-0.16.5-cp313-cp313-win_amd64.whl", hash = "sha256:5088145502ad1ebf677ec47d00eb6f0fd600658217db3e0c070c321c85d6cf3d", size = 799275, upload-time = "2025-11-21T02:49:39.558Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/9e/38e7ca8184c958b51f45d56a4aeceb1134ecde2d8bd157efadc98502cc42/numcodecs-0.16.5-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b05647b8b769e6bc8016e9fd4843c823ce5c9f2337c089fb5c9c4da05e5275de", size = 1654721, upload-time = "2025-11-21T02:49:40.602Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/37/260fa42e7b2b08e6e00ad632f8dd620961a60a459426c26cea390f8c68d0/numcodecs-0.16.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3832bd1b5af8bb3e413076b7d93318c8e7d7b68935006b9fa36ca057d1725a8f", size = 1146887, upload-time = "2025-11-21T02:49:41.721Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/15/e2e1151b5a8b14a15dfd4bb4abccce7fff7580f39bc34092780088835f3a/numcodecs-0.16.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49f7b7d24f103187f53135bed28bb9f0ed6b2e14c604664726487bb6d7c882e1", size = 8476987, upload-time = "2025-11-21T02:49:43.363Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/30/16a57fc4d9fb0ba06c600408bd6634f2f1753c54a7a351c99c5e09b51ee2/numcodecs-0.16.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aec9736d81b70f337d89c4070ee3ffeff113f386fd789492fa152d26a15043e4", size = 9102377, upload-time = "2025-11-21T02:49:45.508Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a5/a0425af36c20d55a3ea884db4b4efca25a43bea9214ba69ca7932dd997b4/numcodecs-0.16.5-cp314-cp314-win_amd64.whl", hash = "sha256:b16a14303800e9fb88abc39463ab4706c037647ac17e49e297faa5f7d7dbbf1d", size = 819022, upload-time = "2025-11-21T02:49:47.39Z" },
+]
+
+[[package]]
+name = "numexpr"
+version = "2.14.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/2f/fdba158c9dbe5caca9c3eca3eaffffb251f2fb8674bf8e2d0aed5f38d319/numexpr-2.14.1.tar.gz", hash = "sha256:4be00b1086c7b7a5c32e31558122b7b80243fe098579b170967da83f3152b48b", size = 119400, upload-time = "2025-10-13T16:17:27.351Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/a3/67999bdd1ed1f938d38f3fedd4969632f2f197b090e50505f7cc1fa82510/numexpr-2.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2d03fcb4644a12f70a14d74006f72662824da5b6128bf1bcd10cc3ed80e64c34", size = 163195, upload-time = "2025-10-13T16:16:31.212Z" },
+    { url = "https://files.pythonhosted.org/packages/25/95/d64f680ea1fc56d165457287e0851d6708800f9fcea346fc1b9957942ee6/numexpr-2.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2773ee1133f77009a1fc2f34fe236f3d9823779f5f75450e183137d49f00499f", size = 152088, upload-time = "2025-10-13T16:16:33.186Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/7f/3bae417cb13ae08afd86d08bb0301c32440fe0cae4e6262b530e0819aeda/numexpr-2.14.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ebe4980f9494b9f94d10d2e526edc29e72516698d3bf95670ba79415492212a4", size = 451126, upload-time = "2025-10-13T16:13:22.248Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/1a/edbe839109518364ac0bd9e918cf874c755bb2c128040e920f198c494263/numexpr-2.14.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a381e5e919a745c9503bcefffc1c7f98c972c04ec58fc8e999ed1a929e01ba6", size = 442012, upload-time = "2025-10-13T16:14:51.416Z" },
+    { url = "https://files.pythonhosted.org/packages/66/b1/be4ce99bff769a5003baddac103f34681997b31d4640d5a75c0e8ed59c78/numexpr-2.14.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d08856cfc1b440eb1caaa60515235369654321995dd68eb9377577392020f6cb", size = 1415975, upload-time = "2025-10-13T16:13:26.088Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/33/b33b8fdc032a05d9ebb44a51bfcd4b92c178a2572cd3e6c1b03d8a4b45b2/numexpr-2.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:03130afa04edf83a7b590d207444f05a00363c9b9ea5d81c0f53b1ea13fad55a", size = 1464683, upload-time = "2025-10-13T16:14:58.87Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/b2/ddcf0ac6cf0a1d605e5aecd4281507fd79a9628a67896795ab2e975de5df/numexpr-2.14.1-cp311-cp311-win32.whl", hash = "sha256:db78fa0c9fcbaded3ae7453faf060bd7a18b0dc10299d7fcd02d9362be1213ed", size = 166838, upload-time = "2025-10-13T16:17:06.765Z" },
+    { url = "https://files.pythonhosted.org/packages/64/72/4ca9bd97b2eb6dce9f5e70a3b6acec1a93e1fb9b079cb4cba2cdfbbf295d/numexpr-2.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:e9b2f957798c67a2428be96b04bce85439bed05efe78eb78e4c2ca43737578e7", size = 160069, upload-time = "2025-10-13T16:17:08.752Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/20/c473fc04a371f5e2f8c5749e04505c13e7a8ede27c09e9f099b2ad6f43d6/numexpr-2.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:91ebae0ab18c799b0e6b8c5a8d11e1fa3848eb4011271d99848b297468a39430", size = 162790, upload-time = "2025-10-13T16:16:34.903Z" },
+    { url = "https://files.pythonhosted.org/packages/45/93/b6760dd1904c2a498e5f43d1bb436f59383c3ddea3815f1461dfaa259373/numexpr-2.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:47041f2f7b9e69498fb311af672ba914a60e6e6d804011caacb17d66f639e659", size = 152196, upload-time = "2025-10-13T16:16:36.593Z" },
+    { url = "https://files.pythonhosted.org/packages/72/94/cc921e35593b820521e464cbbeaf8212bbdb07f16dc79fe283168df38195/numexpr-2.14.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d686dfb2c1382d9e6e0ee0b7647f943c1886dba3adbf606c625479f35f1956c1", size = 452468, upload-time = "2025-10-13T16:13:29.531Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/43/560e9ba23c02c904b5934496486d061bcb14cd3ebba2e3cf0e2dccb6c22b/numexpr-2.14.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eee6d4fbbbc368e6cdd0772734d6249128d957b3b8ad47a100789009f4de7083", size = 443631, upload-time = "2025-10-13T16:15:02.473Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/6c/78f83b6219f61c2c22d71ab6e6c2d4e5d7381334c6c29b77204e59edb039/numexpr-2.14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3a2839efa25f3c8d4133252ea7342d8f81226c7c4dda81f97a57e090b9d87a48", size = 1417670, upload-time = "2025-10-13T16:13:33.464Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/bb/1ccc9dcaf46281568ce769888bf16294c40e98a5158e4b16c241de31d0d3/numexpr-2.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9f9137f1351b310436662b5dc6f4082a245efa8950c3b0d9008028df92fefb9b", size = 1466212, upload-time = "2025-10-13T16:15:12.828Z" },
+    { url = "https://files.pythonhosted.org/packages/31/9f/203d82b9e39dadd91d64bca55b3c8ca432e981b822468dcef41a4418626b/numexpr-2.14.1-cp312-cp312-win32.whl", hash = "sha256:36f8d5c1bd1355df93b43d766790f9046cccfc1e32b7c6163f75bcde682cda07", size = 166996, upload-time = "2025-10-13T16:17:10.369Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/ffe750b5452eb66de788c34e7d21ec6d886abb4d7c43ad1dc88ceb3d998f/numexpr-2.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:fdd886f4b7dbaf167633ee396478f0d0aa58ea2f9e7ccc3c6431019623e8d68f", size = 160187, upload-time = "2025-10-13T16:17:11.974Z" },
+    { url = "https://files.pythonhosted.org/packages/73/b4/9f6d637fd79df42be1be29ee7ba1f050fab63b7182cb922a0e08adc12320/numexpr-2.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:09078ba73cffe94745abfbcc2d81ab8b4b4e9d7bfbbde6cac2ee5dbf38eee222", size = 162794, upload-time = "2025-10-13T16:16:38.291Z" },
+    { url = "https://files.pythonhosted.org/packages/35/ae/d58558d8043de0c49f385ea2fa789e3cfe4d436c96be80200c5292f45f15/numexpr-2.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dce0b5a0447baa7b44bc218ec2d7dcd175b8eee6083605293349c0c1d9b82fb6", size = 152203, upload-time = "2025-10-13T16:16:39.907Z" },
+    { url = "https://files.pythonhosted.org/packages/13/65/72b065f9c75baf8f474fd5d2b768350935989d4917db1c6c75b866d4067c/numexpr-2.14.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:06855053de7a3a8425429bd996e8ae3c50b57637ad3e757e0fa0602a7874be30", size = 455860, upload-time = "2025-10-13T16:13:35.811Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f9/c9457652dfe28e2eb898372da2fe786c6db81af9540c0f853ee04a0699cc/numexpr-2.14.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f9366d23a2e991fd5a8b5e61a17558f028ba86158a4552f8f239b005cdf83c", size = 446574, upload-time = "2025-10-13T16:15:17.367Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/99/8d3879c4d67d3db5560cf2de65ce1778b80b75f6fa415eb5c3e7bd37ba27/numexpr-2.14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c5f1b1605695778896534dfc6e130d54a65cd52be7ed2cd0cfee3981fd676bf5", size = 1417306, upload-time = "2025-10-13T16:13:42.813Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/05/6bddac9f18598ba94281e27a6943093f7d0976544b0cb5d92272c64719bd/numexpr-2.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a4ba71db47ea99c659d88ee6233fa77b6dc83392f1d324e0c90ddf617ae3f421", size = 1466145, upload-time = "2025-10-13T16:15:27.464Z" },
+    { url = "https://files.pythonhosted.org/packages/24/5d/cbeb67aca0c5a76ead13df7e8bd8dd5e0d49145f90da697ba1d9f07005b0/numexpr-2.14.1-cp313-cp313-win32.whl", hash = "sha256:638dce8320f4a1483d5ca4fda69f60a70ed7e66be6e68bc23fb9f1a6b78a9e3b", size = 166996, upload-time = "2025-10-13T16:17:13.803Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/23/9281bceaeb282cead95f0aa5f7f222ffc895670ea689cc1398355f6e3001/numexpr-2.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:9fdcd4735121658a313f878fd31136d1bfc6a5b913219e7274e9fca9f8dac3bb", size = 160189, upload-time = "2025-10-13T16:17:15.417Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/76/7aac965fd93a56803cbe502aee2adcad667253ae34b0badf6c5af7908b6c/numexpr-2.14.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:557887ad7f5d3c2a40fd7310e50597045a68e66b20a77b3f44d7bc7608523b4b", size = 163524, upload-time = "2025-10-13T16:16:42.213Z" },
+    { url = "https://files.pythonhosted.org/packages/58/65/79d592d5e63fbfab3b59a60c386853d9186a44a3fa3c87ba26bdc25b6195/numexpr-2.14.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:af111c8fe6fc55d15e4c7cab11920fc50740d913636d486545b080192cd0ad73", size = 152919, upload-time = "2025-10-13T16:16:44.229Z" },
+    { url = "https://files.pythonhosted.org/packages/84/78/3c8335f713d4aeb99fa758d7c62f0be1482d4947ce5b508e2052bb7aeee9/numexpr-2.14.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33265294376e7e2ae4d264d75b798a915d2acf37b9dd2b9405e8b04f84d05cfc", size = 465972, upload-time = "2025-10-13T16:13:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/35/81/9ee5f69b811e8f18746c12d6f71848617684edd3161927f95eee7a305631/numexpr-2.14.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:83647d846d3eeeb9a9255311236135286728b398d0d41d35dedb532dca807fe9", size = 456953, upload-time = "2025-10-13T16:15:31.186Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/39/9b8bc6e294d85cbb54a634e47b833e9f3276a8bdf7ce92aa808718a0212d/numexpr-2.14.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6e575fd3ad41ddf3355d0c7ef6bd0168619dc1779a98fe46693cad5e95d25e6e", size = 1426199, upload-time = "2025-10-13T16:13:48.231Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/ce/0d4fcd31ab49319740d934fba1734d7dad13aa485532ca754e555ca16c8b/numexpr-2.14.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:67ea4771029ce818573b1998f5ca416bd255156feea017841b86176a938f7d19", size = 1474214, upload-time = "2025-10-13T16:15:38.893Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/47/b2a93cbdb3ba4e009728ad1b9ef1550e2655ea2c86958ebaf03b9615f275/numexpr-2.14.1-cp313-cp313t-win32.whl", hash = "sha256:15015d47d3d1487072d58c0e7682ef2eb608321e14099c39d52e2dd689483611", size = 167676, upload-time = "2025-10-13T16:17:17.351Z" },
+    { url = "https://files.pythonhosted.org/packages/86/99/ee3accc589ed032eea68e12172515ed96a5568534c213ad109e1f4411df1/numexpr-2.14.1-cp313-cp313t-win_amd64.whl", hash = "sha256:94c711f6d8f17dfb4606842b403699603aa591ab9f6bf23038b488ea9cfb0f09", size = 161096, upload-time = "2025-10-13T16:17:19.174Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/36/9db78dfbfdfa1f8bf0872993f1a334cdd8fca5a5b6567e47dcb128bcb7c2/numexpr-2.14.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ede79f7ff06629f599081de644546ce7324f1581c09b0ac174da88a470d39c21", size = 162848, upload-time = "2025-10-13T16:16:46.216Z" },
+    { url = "https://files.pythonhosted.org/packages/13/c1/a5c78ae637402c5550e2e0ba175275d2515d432ec28af0cdc23c9b476e65/numexpr-2.14.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2eac7a5a2f70b3768c67056445d1ceb4ecd9b853c8eda9563823b551aeaa5082", size = 152270, upload-time = "2025-10-13T16:16:47.92Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/ed/aabd8678077848dd9a751c5558c2057839f5a09e2a176d8dfcd0850ee00e/numexpr-2.14.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5aedf38d4c0c19d3cecfe0334c3f4099fb496f54c146223d30fa930084bc8574", size = 455918, upload-time = "2025-10-13T16:13:50.338Z" },
+    { url = "https://files.pythonhosted.org/packages/88/e1/3db65117f02cdefb0e5e4c440daf1c30beb45051b7f47aded25b7f4f2f34/numexpr-2.14.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439ec4d57b853792ebe5456e3160312281c3a7071ecac5532ded3278ede614de", size = 446512, upload-time = "2025-10-13T16:15:42.313Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/fb/7ceb9ee55b5f67e4a3e4d73d5af4c7e37e3c9f37f54bee90361b64b17e3f/numexpr-2.14.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e23b87f744e04e302d82ac5e2189ae20a533566aec76a46885376e20b0645bf8", size = 1417845, upload-time = "2025-10-13T16:13:53.836Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2d/9b5764d0eafbbb2889288f80de773791358acf6fad1a55767538d8b79599/numexpr-2.14.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:44f84e0e5af219dbb62a081606156420815890e041b87252fbcea5df55214c4c", size = 1466211, upload-time = "2025-10-13T16:15:48.985Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/21/204db708eccd71aa8bc55bcad55bc0fc6c5a4e01ad78e14ee5714a749386/numexpr-2.14.1-cp314-cp314-win32.whl", hash = "sha256:1f1a5e817c534539351aa75d26088e9e1e0ef1b3a6ab484047618a652ccc4fc3", size = 168835, upload-time = "2025-10-13T16:17:20.82Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/3e/d83e9401a1c3449a124f7d4b3fb44084798e0d30f7c11e60712d9b94cf11/numexpr-2.14.1-cp314-cp314-win_amd64.whl", hash = "sha256:587c41509bc373dfb1fe6086ba55a73147297247bedb6d588cda69169fc412f2", size = 162608, upload-time = "2025-10-13T16:17:22.228Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/d6/ec947806bb57836d6379a8c8a253c2aeaa602b12fef2336bfd2462bb4ed5/numexpr-2.14.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ec368819502b64f190c3f71be14a304780b5935c42aae5bf22c27cc2cbba70b5", size = 163525, upload-time = "2025-10-13T16:16:50.133Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/77/048f30dcf661a3d52963a88c29b52b6d5ce996d38e9313a56a922451c1e0/numexpr-2.14.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7e87f6d203ac57239de32261c941e9748f9309cbc0da6295eabd0c438b920d3a", size = 152917, upload-time = "2025-10-13T16:16:52.055Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/956a13e628d722d649fbf2fded615134a308c082e122a48bad0e90a99ce9/numexpr-2.14.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dd72d8c2a165fe45ea7650b16eb8cc1792a94a722022006bb97c86fe51fd2091", size = 466242, upload-time = "2025-10-13T16:13:55.795Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/dd/abe848678d82486940892f2cacf39e82eec790e8930d4d713d3f9191063b/numexpr-2.14.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70d80fcb418a54ca208e9a38e58ddc425c07f66485176b261d9a67c7f2864f73", size = 457149, upload-time = "2025-10-13T16:15:52.036Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/bb/797b583b5fb9da5700a5708ca6eb4f889c94d81abb28de4d642c0f4b3258/numexpr-2.14.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:edea2f20c2040df8b54ee8ca8ebda63de9545b2112872466118e9df4d0ae99f3", size = 1426493, upload-time = "2025-10-13T16:13:59.244Z" },
+    { url = "https://files.pythonhosted.org/packages/77/c4/0519ab028fdc35e3e7ee700def7f2b4631b175cd9e1202bd7966c1695c33/numexpr-2.14.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:790447be6879a6c51b9545f79612d24c9ea0a41d537a84e15e6a8ddef0b6268e", size = 1474413, upload-time = "2025-10-13T16:15:59.211Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/4a/33044878c8f4a75213cfe9c11d4c02058bb710a7a063fe14f362e8de1077/numexpr-2.14.1-cp314-cp314t-win32.whl", hash = "sha256:538961096c2300ea44240209181e31fae82759d26b51713b589332b9f2a4117e", size = 169502, upload-time = "2025-10-13T16:17:23.829Z" },
+    { url = "https://files.pythonhosted.org/packages/41/a2/5a1a2c72528b429337f49911b18c302ecd36eeab00f409147e1aa4ae4519/numexpr-2.14.1-cp314-cp314t-win_amd64.whl", hash = "sha256:a40b350cd45b4446076fa11843fa32bbe07024747aeddf6d467290bf9011b392", size = 163589, upload-time = "2025-10-13T16:17:25.696Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", hash = "sha256:2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0", size = 20731587, upload-time = "2026-03-29T13:22:01.298Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/c6/4218570d8c8ecc9704b5157a3348e486e84ef4be0ed3e38218ab473c83d2/numpy-2.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f983334aea213c99992053ede6168500e5f086ce74fbc4acc3f2b00f5762e9db", size = 16976799, upload-time = "2026-03-29T13:18:15.438Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/92/b4d922c4a5f5dab9ed44e6153908a5c665b71acf183a83b93b690996e39b/numpy-2.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:72944b19f2324114e9dc86a159787333b77874143efcf89a5167ef83cfee8af0", size = 14971552, upload-time = "2026-03-29T13:18:18.606Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/dc/df98c095978fa6ee7b9a9387d1d58cbb3d232d0e69ad169a4ce784bde4fd/numpy-2.4.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:86b6f55f5a352b48d7fbfd2dbc3d5b780b2d79f4d3c121f33eb6efb22e9a2015", size = 5476566, upload-time = "2026-03-29T13:18:21.532Z" },
+    { url = "https://files.pythonhosted.org/packages/28/34/b3fdcec6e725409223dd27356bdf5a3c2cc2282e428218ecc9cb7acc9763/numpy-2.4.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:ba1f4fc670ed79f876f70082eff4f9583c15fb9a4b89d6188412de4d18ae2f40", size = 6806482, upload-time = "2026-03-29T13:18:23.634Z" },
+    { url = "https://files.pythonhosted.org/packages/68/62/63417c13aa35d57bee1337c67446761dc25ea6543130cf868eace6e8157b/numpy-2.4.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a87ec22c87be071b6bdbd27920b129b94f2fc964358ce38f3822635a3e2e03d", size = 15973376, upload-time = "2026-03-29T13:18:26.677Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/c5/9fcb7e0e69cef59cf10c746b84f7d58b08bc66a6b7d459783c5a4f6101a6/numpy-2.4.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df3775294accfdd75f32c74ae39fcba920c9a378a2fc18a12b6820aa8c1fb502", size = 16925137, upload-time = "2026-03-29T13:18:30.14Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/43/80020edacb3f84b9efdd1591120a4296462c23fd8db0dde1666f6ef66f13/numpy-2.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0d4e437e295f18ec29bc79daf55e8a47a9113df44d66f702f02a293d93a2d6dd", size = 17329414, upload-time = "2026-03-29T13:18:33.733Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/06/af0658593b18a5f73532d377188b964f239eb0894e664a6c12f484472f97/numpy-2.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6aa3236c78803afbcb255045fbef97a9e25a1f6c9888357d205ddc42f4d6eba5", size = 18658397, upload-time = "2026-03-29T13:18:37.511Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ce/13a09ed65f5d0ce5c7dd0669250374c6e379910f97af2c08c57b0608eee4/numpy-2.4.4-cp311-cp311-win32.whl", hash = "sha256:30caa73029a225b2d40d9fae193e008e24b2026b7ee1a867b7ee8d96ca1a448e", size = 6239499, upload-time = "2026-03-29T13:18:40.372Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/63/05d193dbb4b5eec1eca73822d80da98b511f8328ad4ae3ca4caf0f4db91d/numpy-2.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:6bbe4eb67390b0a0265a2c25458f6b90a409d5d069f1041e6aff1e27e3d9a79e", size = 12614257, upload-time = "2026-03-29T13:18:42.95Z" },
+    { url = "https://files.pythonhosted.org/packages/87/c5/8168052f080c26fa984c413305012be54741c9d0d74abd7fbeeccae3889f/numpy-2.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:fcfe2045fd2e8f3cb0ce9d4ba6dba6333b8fa05bb8a4939c908cd43322d14c7e", size = 10486775, upload-time = "2026-03-29T13:18:45.835Z" },
+    { url = "https://files.pythonhosted.org/packages/28/05/32396bec30fb2263770ee910142f49c1476d08e8ad41abf8403806b520ce/numpy-2.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15716cfef24d3a9762e3acdf87e27f58dc823d1348f765bbea6bef8c639bfa1b", size = 16689272, upload-time = "2026-03-29T13:18:49.223Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/f3/a983d28637bfcd763a9c7aafdb6d5c0ebf3d487d1e1459ffdb57e2f01117/numpy-2.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23cbfd4c17357c81021f21540da84ee282b9c8fba38a03b7b9d09ba6b951421e", size = 14699573, upload-time = "2026-03-29T13:18:52.629Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/fd/e5ecca1e78c05106d98028114f5c00d3eddb41207686b2b7de3e477b0e22/numpy-2.4.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8b3b60bb7cba2c8c81837661c488637eee696f59a877788a396d33150c35d842", size = 5204782, upload-time = "2026-03-29T13:18:55.579Z" },
+    { url = "https://files.pythonhosted.org/packages/de/2f/702a4594413c1a8632092beae8aba00f1d67947389369b3777aed783fdca/numpy-2.4.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e4a010c27ff6f210ff4c6ef34394cd61470d01014439b192ec22552ee867f2a8", size = 6552038, upload-time = "2026-03-29T13:18:57.769Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121", size = 15670666, upload-time = "2026-03-29T13:19:00.341Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e", size = 16645480, upload-time = "2026-03-29T13:19:03.63Z" },
+    { url = "https://files.pythonhosted.org/packages/34/49/f2312c154b82a286758ee2f1743336d50651f8b5195db18cdb63675ff649/numpy-2.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:62d6b0f03b694173f9fcb1fb317f7222fd0b0b103e784c6549f5e53a27718c44", size = 17020036, upload-time = "2026-03-29T13:19:07.428Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/e9/736d17bd77f1b0ec4f9901aaec129c00d59f5d84d5e79bba540ef12c2330/numpy-2.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fbc356aae7adf9e6336d336b9c8111d390a05df88f1805573ebb0807bd06fd1d", size = 18368643, upload-time = "2026-03-29T13:19:10.775Z" },
+    { url = "https://files.pythonhosted.org/packages/63/f6/d417977c5f519b17c8a5c3bc9e8304b0908b0e21136fe43bf628a1343914/numpy-2.4.4-cp312-cp312-win32.whl", hash = "sha256:0d35aea54ad1d420c812bfa0385c71cd7cc5bcf7c65fed95fc2cd02fe8c79827", size = 5961117, upload-time = "2026-03-29T13:19:13.464Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/5b/e1deebf88ff431b01b7406ca3583ab2bbb90972bbe1c568732e49c844f7e/numpy-2.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:b5f0362dc928a6ecd9db58868fca5e48485205e3855957bdedea308f8672ea4a", size = 12320584, upload-time = "2026-03-29T13:19:16.155Z" },
+    { url = "https://files.pythonhosted.org/packages/58/89/e4e856ac82a68c3ed64486a544977d0e7bdd18b8da75b78a577ca31c4395/numpy-2.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:846300f379b5b12cc769334464656bc882e0735d27d9726568bc932fdc49d5ec", size = 10221450, upload-time = "2026-03-29T13:19:18.994Z" },
+    { url = "https://files.pythonhosted.org/packages/14/1d/d0a583ce4fefcc3308806a749a536c201ed6b5ad6e1322e227ee4848979d/numpy-2.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:08f2e31ed5e6f04b118e49821397f12767934cfdd12a1ce86a058f91e004ee50", size = 16684933, upload-time = "2026-03-29T13:19:22.47Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/62/2b7a48fbb745d344742c0277f01286dead15f3f68e4f359fbfcf7b48f70f/numpy-2.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e823b8b6edc81e747526f70f71a9c0a07ac4e7ad13020aa736bb7c9d67196115", size = 14694532, upload-time = "2026-03-29T13:19:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/87/499737bfba066b4a3bebff24a8f1c5b2dee410b209bc6668c9be692580f0/numpy-2.4.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:4a19d9dba1a76618dd86b164d608566f393f8ec6ac7c44f0cc879011c45e65af", size = 5199661, upload-time = "2026-03-29T13:19:28.31Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/da/464d551604320d1491bc345efed99b4b7034143a85787aab78d5691d5a0e/numpy-2.4.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d2a8490669bfe99a233298348acc2d824d496dee0e66e31b66a6022c2ad74a5c", size = 6547539, upload-time = "2026-03-29T13:19:30.97Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/90/8d23e3b0dafd024bf31bdec225b3bb5c2dbfa6912f8a53b8659f21216cbf/numpy-2.4.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45dbed2ab436a9e826e302fcdcbe9133f9b0006e5af7168afb8963a6520da103", size = 15668806, upload-time = "2026-03-29T13:19:33.887Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/73/a9d864e42a01896bb5974475438f16086be9ba1f0d19d0bb7a07427c4a8b/numpy-2.4.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c901b15172510173f5cb310eae652908340f8dede90fff9e3bf6c0d8dfd92f83", size = 16632682, upload-time = "2026-03-29T13:19:37.336Z" },
+    { url = "https://files.pythonhosted.org/packages/34/fb/14570d65c3bde4e202a031210475ae9cde9b7686a2e7dc97ee67d2833b35/numpy-2.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:99d838547ace2c4aace6c4f76e879ddfe02bb58a80c1549928477862b7a6d6ed", size = 17019810, upload-time = "2026-03-29T13:19:40.963Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/77/2ba9d87081fd41f6d640c83f26fb7351e536b7ce6dd9061b6af5904e8e46/numpy-2.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0aec54fd785890ecca25a6003fd9a5aed47ad607bbac5cd64f836ad8666f4959", size = 18357394, upload-time = "2026-03-29T13:19:44.859Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/23/52666c9a41708b0853fa3b1a12c90da38c507a3074883823126d4e9d5b30/numpy-2.4.4-cp313-cp313-win32.whl", hash = "sha256:07077278157d02f65c43b1b26a3886bce886f95d20aabd11f87932750dfb14ed", size = 5959556, upload-time = "2026-03-29T13:19:47.661Z" },
+    { url = "https://files.pythonhosted.org/packages/57/fb/48649b4971cde70d817cf97a2a2fdc0b4d8308569f1dd2f2611959d2e0cf/numpy-2.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:5c70f1cc1c4efbe316a572e2d8b9b9cc44e89b95f79ca3331553fbb63716e2bf", size = 12317311, upload-time = "2026-03-29T13:19:50.67Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/d8/11490cddd564eb4de97b4579ef6bfe6a736cc07e94c1598590ae25415e01/numpy-2.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:ef4059d6e5152fa1a39f888e344c73fdc926e1b2dd58c771d67b0acfbf2aa67d", size = 10222060, upload-time = "2026-03-29T13:19:54.229Z" },
+    { url = "https://files.pythonhosted.org/packages/99/5d/dab4339177a905aad3e2221c915b35202f1ec30d750dd2e5e9d9a72b804b/numpy-2.4.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4bbc7f303d125971f60ec0aaad5e12c62d0d2c925f0ab1273debd0e4ba37aba5", size = 14822302, upload-time = "2026-03-29T13:19:57.585Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/e4/0564a65e7d3d97562ed6f9b0fd0fb0a6f559ee444092f105938b50043876/numpy-2.4.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:4d6d57903571f86180eb98f8f0c839fa9ebbfb031356d87f1361be91e433f5b7", size = 5327407, upload-time = "2026-03-29T13:20:00.601Z" },
+    { url = "https://files.pythonhosted.org/packages/29/8d/35a3a6ce5ad371afa58b4700f1c820f8f279948cca32524e0a695b0ded83/numpy-2.4.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:4636de7fd195197b7535f231b5de9e4b36d2c440b6e566d2e4e4746e6af0ca93", size = 6647631, upload-time = "2026-03-29T13:20:02.855Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/da/477731acbd5a58a946c736edfdabb2ac5b34c3d08d1ba1a7b437fa0884df/numpy-2.4.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ad2e2ef14e0b04e544ea2fa0a36463f847f113d314aa02e5b402fdf910ef309e", size = 15727691, upload-time = "2026-03-29T13:20:06.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/db/338535d9b152beabeb511579598418ba0212ce77cf9718edd70262cc4370/numpy-2.4.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a285b3b96f951841799528cd1f4f01cd70e7e0204b4abebac9463eecfcf2a40", size = 16681241, upload-time = "2026-03-29T13:20:09.417Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a9/ad248e8f58beb7a0219b413c9c7d8151c5d285f7f946c3e26695bdbbe2df/numpy-2.4.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f8474c4241bc18b750be2abea9d7a9ec84f46ef861dbacf86a4f6e043401f79e", size = 17085767, upload-time = "2026-03-29T13:20:13.126Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/1a/3b88ccd3694681356f70da841630e4725a7264d6a885c8d442a697e1146b/numpy-2.4.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4e874c976154687c1f71715b034739b45c7711bec81db01914770373d125e392", size = 18403169, upload-time = "2026-03-29T13:20:17.096Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c9/fcfd5d0639222c6eac7f304829b04892ef51c96a75d479214d77e3ce6e33/numpy-2.4.4-cp313-cp313t-win32.whl", hash = "sha256:9c585a1790d5436a5374bac930dad6ed244c046ed91b2b2a3634eb2971d21008", size = 6083477, upload-time = "2026-03-29T13:20:20.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e3/3938a61d1c538aaec8ed6fd6323f57b0c2d2d2219512434c5c878db76553/numpy-2.4.4-cp313-cp313t-win_amd64.whl", hash = "sha256:93e15038125dc1e5345d9b5b68aa7f996ec33b98118d18c6ca0d0b7d6198b7e8", size = 12457487, upload-time = "2026-03-29T13:20:22.946Z" },
+    { url = "https://files.pythonhosted.org/packages/97/6a/7e345032cc60501721ef94e0e30b60f6b0bd601f9174ebd36389a2b86d40/numpy-2.4.4-cp313-cp313t-win_arm64.whl", hash = "sha256:0dfd3f9d3adbe2920b68b5cd3d51444e13a10792ec7154cd0a2f6e74d4ab3233", size = 10292002, upload-time = "2026-03-29T13:20:25.909Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/06/c54062f85f673dd5c04cbe2f14c3acb8c8b95e3384869bb8cc9bff8cb9df/numpy-2.4.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f169b9a863d34f5d11b8698ead99febeaa17a13ca044961aa8e2662a6c7766a0", size = 16684353, upload-time = "2026-03-29T13:20:29.504Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/39/8a320264a84404c74cc7e79715de85d6130fa07a0898f67fb5cd5bd79908/numpy-2.4.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2483e4584a1cb3092da4470b38866634bafb223cbcd551ee047633fd2584599a", size = 14704914, upload-time = "2026-03-29T13:20:33.547Z" },
+    { url = "https://files.pythonhosted.org/packages/91/fb/287076b2614e1d1044235f50f03748f31fa287e3dbe6abeb35cdfa351eca/numpy-2.4.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:2d19e6e2095506d1736b7d80595e0f252d76b89f5e715c35e06e937679ea7d7a", size = 5210005, upload-time = "2026-03-29T13:20:36.45Z" },
+    { url = "https://files.pythonhosted.org/packages/63/eb/fcc338595309910de6ecabfcef2419a9ce24399680bfb149421fa2df1280/numpy-2.4.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:6a246d5914aa1c820c9443ddcee9c02bec3e203b0c080349533fae17727dfd1b", size = 6544974, upload-time = "2026-03-29T13:20:39.014Z" },
+    { url = "https://files.pythonhosted.org/packages/44/5d/e7e9044032a716cdfaa3fba27a8e874bf1c5f1912a1ddd4ed071bf8a14a6/numpy-2.4.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:989824e9faf85f96ec9c7761cd8d29c531ad857bfa1daa930cba85baaecf1a9a", size = 15684591, upload-time = "2026-03-29T13:20:42.146Z" },
+    { url = "https://files.pythonhosted.org/packages/98/7c/21252050676612625449b4807d6b695b9ce8a7c9e1c197ee6216c8a65c7c/numpy-2.4.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27a8d92cd10f1382a67d7cf4db7ce18341b66438bdd9f691d7b0e48d104c2a9d", size = 16637700, upload-time = "2026-03-29T13:20:46.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/29/56d2bbef9465db24ef25393383d761a1af4f446a1df9b8cded4fe3a5a5d7/numpy-2.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e44319a2953c738205bf3354537979eaa3998ed673395b964c1176083dd46252", size = 17035781, upload-time = "2026-03-29T13:20:50.242Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/2b/a35a6d7589d21f44cea7d0a98de5ddcbb3d421b2622a5c96b1edf18707c3/numpy-2.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e892aff75639bbef0d2a2cfd55535510df26ff92f63c92cd84ef8d4ba5a5557f", size = 18362959, upload-time = "2026-03-29T13:20:54.019Z" },
+    { url = "https://files.pythonhosted.org/packages/64/c9/d52ec581f2390e0f5f85cbfd80fb83d965fc15e9f0e1aec2195faa142cde/numpy-2.4.4-cp314-cp314-win32.whl", hash = "sha256:1378871da56ca8943c2ba674530924bb8ca40cd228358a3b5f302ad60cf875fc", size = 6008768, upload-time = "2026-03-29T13:20:56.912Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/22/4cc31a62a6c7b74a8730e31a4274c5dc80e005751e277a2ce38e675e4923/numpy-2.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:715d1c092715954784bc79e1174fc2a90093dc4dc84ea15eb14dad8abdcdeb74", size = 12449181, upload-time = "2026-03-29T13:20:59.548Z" },
+    { url = "https://files.pythonhosted.org/packages/70/2e/14cda6f4d8e396c612d1bf97f22958e92148801d7e4f110cabebdc0eef4b/numpy-2.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:2c194dd721e54ecad9ad387c1d35e63dce5c4450c6dc7dd5611283dda239aabb", size = 10496035, upload-time = "2026-03-29T13:21:02.524Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/e8/8fed8c8d848d7ecea092dc3469643f9d10bc3a134a815a3b033da1d2039b/numpy-2.4.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2aa0613a5177c264ff5921051a5719d20095ea586ca88cc802c5c218d1c67d3e", size = 14824958, upload-time = "2026-03-29T13:21:05.671Z" },
+    { url = "https://files.pythonhosted.org/packages/05/1a/d8007a5138c179c2bf33ef44503e83d70434d2642877ee8fbb230e7c0548/numpy-2.4.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:42c16925aa5a02362f986765f9ebabf20de75cdefdca827d14315c568dcab113", size = 5330020, upload-time = "2026-03-29T13:21:08.635Z" },
+    { url = "https://files.pythonhosted.org/packages/99/64/ffb99ac6ae93faf117bcbd5c7ba48a7f45364a33e8e458545d3633615dda/numpy-2.4.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:874f200b2a981c647340f841730fc3a2b54c9d940566a3c4149099591e2c4c3d", size = 6650758, upload-time = "2026-03-29T13:21:10.949Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6e/795cc078b78a384052e73b2f6281ff7a700e9bf53bcce2ee579d4f6dd879/numpy-2.4.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9b39d38a9bd2ae1becd7eac1303d031c5c110ad31f2b319c6e7d98b135c934d", size = 15729948, upload-time = "2026-03-29T13:21:14.047Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/86/2acbda8cc2af5f3d7bfc791192863b9e3e19674da7b5e533fded124d1299/numpy-2.4.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b268594bccac7d7cf5844c7732e3f20c50921d94e36d7ec9b79e9857694b1b2f", size = 16679325, upload-time = "2026-03-29T13:21:17.561Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/59/cafd83018f4aa55e0ac6fa92aa066c0a1877b77a615ceff1711c260ffae8/numpy-2.4.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ac6b31e35612a26483e20750126d30d0941f949426974cace8e6b5c58a3657b0", size = 17084883, upload-time = "2026-03-29T13:21:21.106Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/85/a42548db84e65ece46ab2caea3d3f78b416a47af387fcbb47ec28e660dc2/numpy-2.4.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8e3ed142f2728df44263aaf5fb1f5b0b99f4070c553a0d7f033be65338329150", size = 18403474, upload-time = "2026-03-29T13:21:24.828Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/ad/483d9e262f4b831000062e5d8a45e342166ec8aaa1195264982bca267e62/numpy-2.4.4-cp314-cp314t-win32.whl", hash = "sha256:dddbbd259598d7240b18c9d87c56a9d2fb3b02fe266f49a7c101532e78c1d871", size = 6155500, upload-time = "2026-03-29T13:21:28.205Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/03/2fc4e14c7bd4ff2964b74ba90ecb8552540b6315f201df70f137faa5c589/numpy-2.4.4-cp314-cp314t-win_amd64.whl", hash = "sha256:a7164afb23be6e37ad90b2f10426149fd75aee07ca55653d2aa41e66c4ef697e", size = 12637755, upload-time = "2026-03-29T13:21:31.107Z" },
+    { url = "https://files.pythonhosted.org/packages/58/78/548fb8e07b1a341746bfbecb32f2c268470f45fa028aacdbd10d9bc73aab/numpy-2.4.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ba203255017337d39f89bdd58417f03c4426f12beed0440cfd933cb15f8669c7", size = 10566643, upload-time = "2026-03-29T13:21:34.339Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/33/8fae8f964a4f63ed528264ddf25d2b683d0b663e3cba26961eb838a7c1bd/numpy-2.4.4-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:58c8b5929fcb8287cbd6f0a3fae19c6e03a5c48402ae792962ac465224a629a4", size = 16854491, upload-time = "2026-03-29T13:21:38.03Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d0/1aabee441380b981cf8cdda3ae7a46aa827d1b5a8cce84d14598bc94d6d9/numpy-2.4.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:eea7ac5d2dce4189771cedb559c738a71512768210dc4e4753b107a2048b3d0e", size = 14895830, upload-time = "2026-03-29T13:21:41.509Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/b8/aafb0d1065416894fccf4df6b49ef22b8db045187949545bced89c034b8e/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:51fc224f7ca4d92656d5a5eb315f12eb5fe2c97a66249aa7b5f562528a3be38c", size = 5400927, upload-time = "2026-03-29T13:21:44.747Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/77/063baa20b08b431038c7f9ff5435540c7b7265c78cf56012a483019ca72d/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:28a650663f7314afc3e6ec620f44f333c386aad9f6fc472030865dc0ebb26ee3", size = 6715557, upload-time = "2026-03-29T13:21:47.406Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/a8/379542d45a14f149444c5c4c4e7714707239ce9cc1de8c2803958889da14/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:19710a9ca9992d7174e9c52f643d4272dcd1558c5f7af7f6f8190f633bd651a7", size = 15804253, upload-time = "2026-03-29T13:21:50.753Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/c8/f0a45426d6d21e7ea3310a15cf90c43a14d9232c31a837702dba437f3373/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b2aec6af35c113b05695ebb5749a787acd63cafc83086a05771d1e1cd1e555f", size = 16753552, upload-time = "2026-03-29T13:21:54.344Z" },
+    { url = "https://files.pythonhosted.org/packages/04/74/f4c001f4714c3ad9ce037e18cf2b9c64871a84951eaa0baf683a9ca9301c/numpy-2.4.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f2cf083b324a467e1ab358c105f6cad5ea950f50524668a80c486ff1db24e119", size = 12509075, upload-time = "2026-03-29T13:21:57.644Z" },
+]
+
+[[package]]
+name = "oauthlib"
+version = "3.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/5f/19930f824ffeb0ad4372da4812c50edbd1434f678c90c2733e1188edfc63/oauthlib-3.3.1.tar.gz", hash = "sha256:0f0f8aa759826a193cf66c12ea1af1637f87b9b4622d46e866952bb022e538c9", size = 185918, upload-time = "2025-06-19T22:48:08.269Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065, upload-time = "2025-06-19T22:48:06.508Z" },
+]
+
+[[package]]
+name = "obstore"
+version = "0.9.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/24/18/cab734edaeb495a861cfbdced9fecdc0866ed1a85aa5a9202ec77cf4723e/obstore-0.9.2.tar.gz", hash = "sha256:7ef94323127a971c9dea2484109d6c706eb2b2594a2df13c2dd0a6d21a9a69ae", size = 123731, upload-time = "2026-03-11T19:10:18.19Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/d2/b98058a552849719df56d59a53f7d97e6507b37fca0399a866534800f9fa/obstore-0.9.2-cp311-abi3-macosx_10_12_x86_64.whl", hash = "sha256:50d9c9d6de601ad4805a5a76a1a3d731f7b899383f96ef57276f97bc35202f95", size = 4105494, upload-time = "2026-03-11T19:09:06.573Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/55/4386622b94fd028cb2298b4780d5a8e2d959fc4c71e599fb63be869aa83d/obstore-0.9.2-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:4c6dcd9b76b802a2278e1cd88ad7305caf3c3c16f800b2bf5f86a606e9e83d96", size = 3878429, upload-time = "2026-03-11T19:09:07.962Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/0bfad11f1ee5fb1fbdb7833607212ad2586dbd1824b30cf328af63fe92fc/obstore-0.9.2-cp311-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8d46e629beb47565fa67b6ef05919434258d72ef848efa340f911af5de2536da", size = 4041157, upload-time = "2026-03-11T19:09:09.278Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/98/bfde825f61a8b2541be9185cd6a4ddbb820de94c79750edc32f9f9dfb795/obstore-0.9.2-cp311-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:350d8cc1cd9564369291396e160ebfa133d705ec349d8c0d444a39158d6ef3e7", size = 4144757, upload-time = "2026-03-11T19:09:10.938Z" },
+    { url = "https://files.pythonhosted.org/packages/19/35/1c101f6660ef91e5280c824677d8b5ab11ee25ed52e59b075cd795a86e69/obstore-0.9.2-cp311-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dddd38c9f98fd8eaf11a9805464f0bec7e57d8e04a5e0b0cb17582ec58d2fe41", size = 4427897, upload-time = "2026-03-11T19:09:12.137Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/eb/a9bdb64474d4e0ab4e4c0105c959090d6bd7ce38d4a945cae3679ead8c52/obstore-0.9.2-cp311-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ca872e88e5c719faf1581632e348a6b01331b4f838d7ac29aff226107088dc35", size = 4336227, upload-time = "2026-03-11T19:09:13.822Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/ec/e6d39aa311afec2241adb6f2067d7d6ca2eb4e0aab5a95c47796edadd524/obstore-0.9.2-cp311-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ee61ac2af5c32c5282fc13b9eba7ffa332f268cb65bc29134ad8ac45e069871", size = 4229010, upload-time = "2026-03-11T19:09:15.503Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/fb/a24fd972b66b2d83829e2e89ccf236a759a82f881f909bf4fbe0b6c398ae/obstore-0.9.2-cp311-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:2f430cf8af76985e7ebb8d5f20c8ccef858c608103af6ea95c870f5380cd62f7", size = 4103835, upload-time = "2026-03-11T19:09:16.729Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d4/c8cc60c8afc597712bf6c5059d629e050de521d901dad0f554b268c2d77f/obstore-0.9.2-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1df403f80feef7ac483ed66a2a5a964a469f3756ded533935640c4baf986dd49", size = 4292174, upload-time = "2026-03-11T19:09:18.461Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/80/dcf8f31814f25c390aa5501a95b78b9f6456d30cd4625109c2a6a5105ad1/obstore-0.9.2-cp311-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:c20f62b7c2f57c6f449215c36af4a8d502082ced2185c0b28f07a5e7c9698181", size = 4276266, upload-time = "2026-03-11T19:09:19.787Z" },
+    { url = "https://files.pythonhosted.org/packages/16/71/5f5369fba652c5f83b44381d9e7a3cfe00793301d01802059b52b8663f2c/obstore-0.9.2-cp311-abi3-musllinux_1_2_i686.whl", hash = "sha256:c296e7d60ee132babb7fd01eab946396fa28eb0d88264b9e60320922174e6010", size = 4264118, upload-time = "2026-03-11T19:09:21.081Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/50/a5bd1948f2b2efb1039852542829a33a198be0586da7d4247996d3f15d26/obstore-0.9.2-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:76f274a170731a4461d0fe3eefde38f3bdaf346011ae020c94a0bd18bfd3c4bc", size = 4446876, upload-time = "2026-03-11T19:09:22.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d6/bcc266e391403163ed12dd8cab53012f4db8f5020fb49e3b0a505d7a1bba/obstore-0.9.2-cp311-abi3-win_amd64.whl", hash = "sha256:f644fef2a91973b6c055623692524baf830abb1f8bb3ad348611f0e25224e160", size = 4190639, upload-time = "2026-03-11T19:09:23.637Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/da/ea7c5095cf15c026819958f74d3ab7b69aff7ce5bf74188e5df5bba4c252/obstore-0.9.2-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:7161a977e94a94dfd2c4ef66846371bdff46bb8b5f9b91dc29c912deb88a5bb2", size = 4087051, upload-time = "2026-03-11T19:09:24.944Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/9f/16d6f41ab87e75a6400959a4708343eaca782b78a5f9de7846c70e2b1381/obstore-0.9.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e3a31fbd68bbe7e061272420337d5ccaf2df7927c2b44ff768531dda02196746", size = 3869338, upload-time = "2026-03-11T19:09:26.404Z" },
+    { url = "https://files.pythonhosted.org/packages/99/61/5f13cc91b054d8c93db77e9113ca4924c4320e988284840c8a98238709e6/obstore-0.9.2-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:928da0d131ea33d0b88aa8c3a0dd3f7423261e0c9495444cc14ce0cf62808558", size = 4037703, upload-time = "2026-03-11T19:09:27.743Z" },
+    { url = "https://files.pythonhosted.org/packages/58/a2/669620821881559819b8911c4820defa3ffc30a9e49e9d5aca05bd57da45/obstore-0.9.2-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:79667de1f0c7eed64b658b3e696bb0565fba4069f6134db502bf4f5f5835aeee", size = 4135488, upload-time = "2026-03-11T19:09:29.232Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/12/019e523e97415b4fcfc35b230b270d452fdf5578a7612034c8043c8f2cbf/obstore-0.9.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7318253bc8d03b64473150dad31e611f5bd70a3cc945e3e1d6ac59a901f397c0", size = 4412922, upload-time = "2026-03-11T19:09:30.462Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/52/d4a8c1bf588a10bfd17a5a11ebc6af834850fe174a0369648d534a2acb81/obstore-0.9.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:133507229632fde08bc202ca2c81119b2314662dab7a96f8348e97f8e97ae36a", size = 4337193, upload-time = "2026-03-11T19:09:31.773Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/59/46c1bdaeae2904bb1edddbfc78e35cb0521ab7c58fe92b147a981873fcdc/obstore-0.9.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1c73f208abcddcd3edb7a739d5cac777bdb6fac12a358c9b251654ec7df7866", size = 4221641, upload-time = "2026-03-11T19:09:33.067Z" },
+    { url = "https://files.pythonhosted.org/packages/44/9c/b0203594666d11da31e4a7f25ace0718cb1591792e3c1de5225fbd7c8246/obstore-0.9.2-cp313-cp313t-manylinux_2_24_aarch64.whl", hash = "sha256:857b2e7d78c8fb36dcb7c6f1fa89401429667195186ced746a500e54a6aaecdb", size = 4103500, upload-time = "2026-03-11T19:09:34.687Z" },
+    { url = "https://files.pythonhosted.org/packages/95/bc/b215712ef24a21247d6e8a4049a76d95e2dca517b8b24efb496600c333c7/obstore-0.9.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:24c24fdba5080524ce79b36782a11563ea40d9ae5aa26bb6b81a6d089184e4eb", size = 4290492, upload-time = "2026-03-11T19:09:35.936Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/28/5aa0ecdc6c01b6e020f1ff8efcca35493e0c6091a0b72ec1bbb16b5b18a8/obstore-0.9.2-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:778785266aaaf3a73d44ee15e33b72c7ecf0585efeaf8745a1889cc02930ae59", size = 4272220, upload-time = "2026-03-11T19:09:37.223Z" },
+    { url = "https://files.pythonhosted.org/packages/06/65/c47b0f972bc7acd64385a964dfbc2efc7361207f490b4d16da789da26fd5/obstore-0.9.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:305c415fdb2230a1e096f6f290cf524d030329ad5c5e1c9c41f121e7d2fb27d7", size = 4256524, upload-time = "2026-03-11T19:09:38.592Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/1d/9f826fd49cd17cdbc8d2a7a75698d1cc9d731ca98d645f1ca9366ac93781/obstore-0.9.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1a544aad84ae774fac339c686f8a4d7b187c4927b6e33ebb9758c58991d4f27f", size = 4440986, upload-time = "2026-03-11T19:09:40.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/24/0af1af62239c539975b6c9095428f7597e8f5f9617e897e58dbf7b63f1c5/obstore-0.9.2-cp313-cp313t-win_amd64.whl", hash = "sha256:52da6bd719c4962fdfb3c7504e790a89a9b5d27703ee872db01e2075162706fd", size = 4175182, upload-time = "2026-03-11T19:09:41.617Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/63/02ca0378938efd1111aa5d689b527c6f3f0c59f4ee440a7b0bf36c528f46/obstore-0.9.2-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:1bd4790eaa2bb384b58e1c430b2c8816edd7e60216e813c8120014f742e5d280", size = 4087916, upload-time = "2026-03-11T19:09:43.162Z" },
+    { url = "https://files.pythonhosted.org/packages/86/9b/604bfb0ec9f117dbb8e936d64e45d95cd9a1fcb63640453566fb3dc66e9d/obstore-0.9.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e6417ac0b5cb32498490ceb7034ea357ea2ea965c855590496d64b2d7808a621", size = 3869703, upload-time = "2026-03-11T19:09:44.673Z" },
+    { url = "https://files.pythonhosted.org/packages/44/6a/04bcb394f2a6bb12c4325e6ff3f7ead24592582a593c70669d9cdb5b4e9c/obstore-0.9.2-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dc07d71e2f9cd30d2db6ac15c2b162d5b14f6a0e7f575ad66676335c256b1a80", size = 4038164, upload-time = "2026-03-11T19:09:45.922Z" },
+    { url = "https://files.pythonhosted.org/packages/34/39/2cc1c2c2a7027dd32ae010ac2ae4491b5f653f86c499e6ec20a6a54e799d/obstore-0.9.2-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7606d5f5c682cc8be9f55d3b07d282dfc0e0262ddfd31b8a26b0a6a3787e5b78", size = 4135199, upload-time = "2026-03-11T19:09:47.242Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/4c/defabe9c19bddf44f22591bcf0fffbc3b2b3202eb5ab99a0d894562f56de/obstore-0.9.2-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80e870ab402ac0f93799049a6680faacbfc2995c60fa87fd683807ce1366e544", size = 4413291, upload-time = "2026-03-11T19:09:48.934Z" },
+    { url = "https://files.pythonhosted.org/packages/10/ce/fcfd0436834657a6617d06f07de7630889036c722d35ed9df7913e6caac7/obstore-0.9.2-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:534049c4b970e1e49c33b47a3e2a051fdc9727f844c3d4737aac4e4c89939fe4", size = 4337512, upload-time = "2026-03-11T19:09:50.13Z" },
+    { url = "https://files.pythonhosted.org/packages/70/12/565d0cd60f7ae6bb65bde745e182f745a0520f314b32cb802d5f445ad10a/obstore-0.9.2-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c903949b9994003bda82b57f938ab88f458e75fd27eed809547533bffad99a77", size = 4221955, upload-time = "2026-03-11T19:09:51.499Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/27/3fb7f28277fbc929168ff7e02a36a64a56e1288936ac10fce49420c343f4/obstore-0.9.2-cp314-cp314t-manylinux_2_24_aarch64.whl", hash = "sha256:3f07a060702c8b1af51ca15a92658a34bb3ff2e38625173c5592c5aae7fdbfcd", size = 4103438, upload-time = "2026-03-11T19:09:52.748Z" },
+    { url = "https://files.pythonhosted.org/packages/67/8f/53ed223ee069da797b09f45e9dbf4a1ed24743081be1ec1411ab6baf8ce9/obstore-0.9.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:462a864782a8d7a1a60c55ac19ce4ad53668a39e35d16b98b787fe97d3fec193", size = 4290842, upload-time = "2026-03-11T19:09:54.3Z" },
+    { url = "https://files.pythonhosted.org/packages/05/cd/fc94afca13776c4eb8b7a2f27ecb9ee964156d20d699100b719c6c8b6246/obstore-0.9.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:afe36e0452e753c2fece5e6849dd13f209400d5feca668514c0cca2242b0eee8", size = 4273457, upload-time = "2026-03-11T19:09:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/8e/fb02a7a8d4f966af5e069315075bc4388eb63d9cff1c2f3283f3c5781919/obstore-0.9.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3bfae2c634bca903141ef09d6d65e343402de0470e595799881a47ac7c08b2bd", size = 4256979, upload-time = "2026-03-11T19:09:56.983Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/87/5621ea304d39b4099d36bfa50dce901eb37b3861e2592d76baa26031d407/obstore-0.9.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:71d4059b5e948fe6e8cfc2b77da9c2fc944dfe0ee98090d985e60dd6ebecd7f6", size = 4441545, upload-time = "2026-03-11T19:09:58.59Z" },
+    { url = "https://files.pythonhosted.org/packages/30/44/5a7b98d5d92a2267df7a9a905b3cc4f0ca98fbf207b9fae5179a6838a80b/obstore-0.9.2-cp314-cp314t-win_amd64.whl", hash = "sha256:e75295c9c522dde5020d4ff763315af75a165a8a6b8d7f9ed247ce17b7d7f7b0", size = 4175247, upload-time = "2026-03-11T19:10:00.111Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/b0/958df4459af032a589a96657eb896949c7077f1c6b97fbd12dcbb2b31163/obstore-0.9.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:034071b5d54fc5e945cd9a15e0a7c3128cd3bc1b97bfffe153e09d940bfbf390", size = 4101577, upload-time = "2026-03-11T19:10:01.51Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/78/cb10d54e988506c26bcf0a3d1e9d4c896fa42f40640cffde91f6c28c0e12/obstore-0.9.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:fc62c77dd29f2642b9ac0338de16b105701445c0baf04f9a665250aa490ecfaf", size = 3881592, upload-time = "2026-03-11T19:10:02.803Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/d8/f87684bf91af83da63963170d4ec40afa72615f6af66bb9820a1d00c1ac4/obstore-0.9.2-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9fd12afd030a3867879e62a20aa294e89bf8d744e958cf889b462004edbdeca6", size = 4038571, upload-time = "2026-03-11T19:10:04Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/ad/d71cad9086935b7f9e9f7c8f6a6e36e8946f888b83c46f1bd4c45567f00e/obstore-0.9.2-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:490606e6a0d52c846b36c85a4cd772fe14776821e50a4bff1680e8643c4a9d73", size = 4141769, upload-time = "2026-03-11T19:10:05.422Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/b0/c789b07c56b4e88fd904a7e684dc78b0b179a7fc84afd5a9039efe37cc19/obstore-0.9.2-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ca53037bcc6a061cc02652ff0652c4313b75e9f66a0a147701459c65192a72d", size = 4422333, upload-time = "2026-03-11T19:10:06.795Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/80/956254c0dfffe2b795849987b14afbc8ebfe79e6bf4993e3dd5969c1f9d8/obstore-0.9.2-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:56138a4546fb5b46cb576b2b5951582fbc613cba97f51aab4a03fc305f66758b", size = 4345863, upload-time = "2026-03-11T19:10:08.156Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/6a/d07a8f5b63d6bb259eb349958882638268624af5da5eda4731a510aa3dbe/obstore-0.9.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:08280bb90ccd19350cca352348eef4c44ea34be34893819cb35f29ac578c01f9", size = 4226798, upload-time = "2026-03-11T19:10:09.792Z" },
+    { url = "https://files.pythonhosted.org/packages/71/a4/8a6db6db5a2218de47a7cdecdf1d37185280a4ed364e1c27bdce813372da/obstore-0.9.2-pp311-pypy311_pp73-manylinux_2_24_aarch64.whl", hash = "sha256:a98c5da06ee34c285b0bdc32be03ab453af1fbf51c9a02fce36b195f2e404c03", size = 4108402, upload-time = "2026-03-11T19:10:11.125Z" },
+    { url = "https://files.pythonhosted.org/packages/55/a9/3af105f9e8769840b9d7fa16f13ee3413e4ae40d5ef4b233a01c20faabb8/obstore-0.9.2-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:845b77a65add7449efc74994f02c62df87390a28d4a07a9296a065c88206d4fd", size = 4296537, upload-time = "2026-03-11T19:10:12.519Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/d7/ba263d6bdd7f7fe61143233fead0b0fdf4907092eb2cf8f1d1db1e8e4bb6/obstore-0.9.2-pp311-pypy311_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:50bc1f25ad3881bcd74142f143ab41a26c1b7a7c0b14a72ecbf6fddc34f5a36e", size = 4273106, upload-time = "2026-03-11T19:10:14.184Z" },
+    { url = "https://files.pythonhosted.org/packages/05/22/179117970abd49d8fe53e014c9326363b8ce20f4635a4389e7d1215529bb/obstore-0.9.2-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:cada36b244361a25df6a943f374110034cb75c4bd284375df53bc1826c4b3bb6", size = 4262228, upload-time = "2026-03-11T19:10:15.463Z" },
+    { url = "https://files.pythonhosted.org/packages/24/80/2de1995c1c195f5ce7d54184a01868741445333c751153f9d979b77de9e5/obstore-0.9.2-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:66ad31b4630c2cd41b1369529b6e9a472c84a7a8df045dc62b0bfea6d922110c", size = 4445675, upload-time = "2026-03-11T19:10:16.805Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-exporter-otlp-proto-grpc" },
+    { name = "opentelemetry-exporter-otlp-proto-http" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/37/b6708e0eff5c5fb9aba2e0ea09f7f3bcbfd12a592d2a780241b5f6014df7/opentelemetry_exporter_otlp-1.40.0.tar.gz", hash = "sha256:7caa0870b95e2fcb59d64e16e2b639ecffb07771b6cd0000b5d12e5e4fef765a", size = 6152, upload-time = "2026-03-04T14:17:23.235Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/fc/aea77c28d9f3ffef2fdafdc3f4a235aee4091d262ddabd25882f47ce5c5f/opentelemetry_exporter_otlp-1.40.0-py3-none-any.whl", hash = "sha256:48c87e539ec9afb30dc443775a1334cc5487de2f72a770a4c00b1610bf6c697d", size = 7023, upload-time = "2026-03-04T14:17:03.612Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-proto-common"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-proto" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-proto-grpc"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "googleapis-common-protos" },
+    { name = "grpcio" },
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp-proto-common" },
+    { name = "opentelemetry-proto" },
+    { name = "opentelemetry-sdk" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8f/7f/b9e60435cfcc7590fa87436edad6822240dddbc184643a2a005301cc31f4/opentelemetry_exporter_otlp_proto_grpc-1.40.0.tar.gz", hash = "sha256:bd4015183e40b635b3dab8da528b27161ba83bf4ef545776b196f0fb4ec47740", size = 25759, upload-time = "2026-03-04T14:17:24.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/6f/7ee0980afcbdcd2d40362da16f7f9796bd083bf7f0b8e038abfbc0300f5d/opentelemetry_exporter_otlp_proto_grpc-1.40.0-py3-none-any.whl", hash = "sha256:2aa0ca53483fe0cf6405087a7491472b70335bc5c7944378a0a8e72e86995c52", size = 20304, upload-time = "2026-03-04T14:17:05.942Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-proto-http"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "googleapis-common-protos" },
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp-proto-common" },
+    { name = "opentelemetry-proto" },
+    { name = "opentelemetry-sdk" },
+    { name = "requests" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-asgi"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "asgiref" },
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/00/3e/143cf5c034e58037307e6a24f06e0dd64b2c49ae60a965fc580027581931/opentelemetry_instrumentation_asgi-0.61b0.tar.gz", hash = "sha256:9d08e127244361dc33976d39dd4ca8f128b5aa5a7ae425208400a80a095019b5", size = 26691, upload-time = "2026-03-04T14:20:21.038Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/78/154470cf9d741a7487fbb5067357b87386475bbb77948a6707cae982e158/opentelemetry_instrumentation_asgi-0.61b0-py3-none-any.whl", hash = "sha256:e4b3ce6b66074e525e717efff20745434e5efd5d9df6557710856fba356da7a4", size = 16980, upload-time = "2026-03-04T14:19:10.894Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-fastapi"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-instrumentation-asgi" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/37/35/aa727bb6e6ef930dcdc96a617b83748fece57b43c47d83ba8d83fbeca657/opentelemetry_instrumentation_fastapi-0.61b0.tar.gz", hash = "sha256:3a24f35b07c557ae1bbc483bf8412221f25d79a405f8b047de8b670722e2fa9f", size = 24800, upload-time = "2026-03-04T14:20:32.759Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/05/acfeb2cccd434242a0a7d0ea29afaf077e04b42b35b485d89aee4e0d9340/opentelemetry_instrumentation_fastapi-0.61b0-py3-none-any.whl", hash = "sha256:a1a844d846540d687d377516b2ff698b51d87c781b59f47c214359c4a241047c", size = 13485, upload-time = "2026-03-04T14:19:30.351Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-logging"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ae/e0/69473f925acfe2d4edf5c23bcced36906ac3627aa7c5722a8e3f60825f3b/opentelemetry_instrumentation_logging-0.61b0.tar.gz", hash = "sha256:feaa30b700acd2a37cc81db5f562ab0c3a5b6cc2453595e98b72c01dcf649584", size = 17906, upload-time = "2026-03-04T14:20:37.398Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/0e/2137db5239cc5e564495549a4d11488a7af9b48fc76520a0eea20e69ddae/opentelemetry_instrumentation_logging-0.61b0-py3-none-any.whl", hash = "sha256:6d87e5ded6a0128d775d41511f8380910a1b610671081d16efb05ac3711c0074", size = 17076, upload-time = "2026-03-04T14:19:36.765Z" },
+]
+
+[[package]]
+name = "opentelemetry-proto"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+]
+
+[[package]]
+name = "opentelemetry-util-http"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/3c/f0196223efc5c4ca19f8fad3d5462b171ac6333013335ce540c01af419e9/opentelemetry_util_http-0.61b0.tar.gz", hash = "sha256:1039cb891334ad2731affdf034d8fb8b48c239af9b6dd295e5fabd07f1c95572", size = 11361, upload-time = "2026-03-04T14:20:57.01Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0d/e5/c08aaaf2f64288d2b6ef65741d2de5454e64af3e050f34285fb1907492fe/opentelemetry_util_http-0.61b0-py3-none-any.whl", hash = "sha256:8e715e848233e9527ea47e275659ea60a57a75edf5206a3b937e236a6da5fc33", size = 9281, upload-time = "2026-03-04T14:20:08.364Z" },
+]
+
+[[package]]
+name = "overrides"
+version = "7.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/36/86/b585f53236dec60aba864e050778b25045f857e17f6e5ea0ae95fe80edd2/overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a", size = 22812, upload-time = "2024-01-27T21:01:33.423Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/ab/fc8290c6a4c722e5514d80f62b2dc4c4df1a68a41d1364e625c35990fcf3/overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49", size = 17832, upload-time = "2024-01-27T21:01:31.393Z" },
+]
+
+[[package]]
+name = "owslib"
+version = "0.35.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lxml" },
+    { name = "python-dateutil" },
+    { name = "pyyaml" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bf/03/5df0b995a3a6eefc24cc2320e3fe830d95e76ee6b0b1c6c9d0f1d4040bbe/owslib-0.35.0.tar.gz", hash = "sha256:0182f377bb30d25b78284bbaf82a12dece97902ed844cee88791ff38665b9b00", size = 194282, upload-time = "2025-10-28T15:13:42.594Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cd/12/74c145b9e273b2b479f1ea578c7778d96d0c34f2d112fd0ec96c905bb792/owslib-0.35.0-py3-none-any.whl", hash = "sha256:01648ea9b2b86502f456ad68a8dd07131d336416c5637f34adb358aafc0ad380", size = 240487, upload-time = "2025-10-28T15:13:41.399Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "paginate"
+version = "0.5.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252, upload-time = "2024-08-25T14:17:24.139Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746, upload-time = "2024-08-25T14:17:22.55Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/0c/b28ed414f080ee0ad153f848586d61d1878f91689950f037f976ce15f6c8/pandas-3.0.1.tar.gz", hash = "sha256:4186a699674af418f655dbd420ed87f50d56b4cd6603784279d9eef6627823c8", size = 4641901, upload-time = "2026-02-17T22:20:16.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/07/c7087e003ceee9b9a82539b40414ec557aa795b584a1a346e89180853d79/pandas-3.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de09668c1bf3b925c07e5762291602f0d789eca1b3a781f99c1c78f6cac0e7ea", size = 10323380, upload-time = "2026-02-17T22:18:16.133Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/27/90683c7122febeefe84a56f2cde86a9f05f68d53885cebcc473298dfc33e/pandas-3.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:24ba315ba3d6e5806063ac6eb717504e499ce30bd8c236d8693a5fd3f084c796", size = 9923455, upload-time = "2026-02-17T22:18:19.13Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/f1/ed17d927f9950643bc7631aa4c99ff0cc83a37864470bc419345b656a41f/pandas-3.0.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:406ce835c55bac912f2a0dcfaf27c06d73c6b04a5dde45f1fd3169ce31337389", size = 10753464, upload-time = "2026-02-17T22:18:21.134Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/7c/870c7e7daec2a6c7ff2ac9e33b23317230d4e4e954b35112759ea4a924a7/pandas-3.0.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:830994d7e1f31dd7e790045235605ab61cff6c94defc774547e8b7fdfbff3dc7", size = 11255234, upload-time = "2026-02-17T22:18:24.175Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/39/3653fe59af68606282b989c23d1a543ceba6e8099cbcc5f1d506a7bae2aa/pandas-3.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a64ce8b0f2de1d2efd2ae40b0abe7f8ae6b29fbfb3812098ed5a6f8e235ad9bf", size = 11767299, upload-time = "2026-02-17T22:18:26.824Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/31/1daf3c0c94a849c7a8dab8a69697b36d313b229918002ba3e409265c7888/pandas-3.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9832c2c69da24b602c32e0c7b1b508a03949c18ba08d4d9f1c1033426685b447", size = 12333292, upload-time = "2026-02-17T22:18:28.996Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/67/af63f83cd6ca603a00fe8530c10a60f0879265b8be00b5930e8e78c5b30b/pandas-3.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:84f0904a69e7365f79a0c77d3cdfccbfb05bf87847e3a51a41e1426b0edb9c79", size = 9892176, upload-time = "2026-02-17T22:18:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/79/ab/9c776b14ac4b7b4140788eca18468ea39894bc7340a408f1d1e379856a6b/pandas-3.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:4a68773d5a778afb31d12e34f7dd4612ab90de8c6fb1d8ffe5d4a03b955082a1", size = 9151328, upload-time = "2026-02-17T22:18:35.721Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/b467209c08dae2c624873d7491ea47d2b47336e5403309d433ea79c38571/pandas-3.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:476f84f8c20c9f5bc47252b66b4bb25e1a9fc2fa98cead96744d8116cb85771d", size = 10344357, upload-time = "2026-02-17T22:18:38.262Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f1/e2567ffc8951ab371db2e40b2fe068e36b81d8cf3260f06ae508700e5504/pandas-3.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0ab749dfba921edf641d4036c4c21c0b3ea70fea478165cb98a998fb2a261955", size = 9884543, upload-time = "2026-02-17T22:18:41.476Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/39/327802e0b6d693182403c144edacbc27eb82907b57062f23ef5a4c4a5ea7/pandas-3.0.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8e36891080b87823aff3640c78649b91b8ff6eea3c0d70aeabd72ea43ab069b", size = 10396030, upload-time = "2026-02-17T22:18:43.822Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/fe/89d77e424365280b79d99b3e1e7d606f5165af2f2ecfaf0c6d24c799d607/pandas-3.0.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:532527a701281b9dd371e2f582ed9094f4c12dd9ffb82c0c54ee28d8ac9520c4", size = 10876435, upload-time = "2026-02-17T22:18:45.954Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/a6/2a75320849dd154a793f69c951db759aedb8d1dd3939eeacda9bdcfa1629/pandas-3.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:356e5c055ed9b0da1580d465657bc7d00635af4fd47f30afb23025352ba764d1", size = 11405133, upload-time = "2026-02-17T22:18:48.533Z" },
+    { url = "https://files.pythonhosted.org/packages/58/53/1d68fafb2e02d7881df66aa53be4cd748d25cbe311f3b3c85c93ea5d30ca/pandas-3.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9d810036895f9ad6345b8f2a338dd6998a74e8483847403582cab67745bff821", size = 11932065, upload-time = "2026-02-17T22:18:50.837Z" },
+    { url = "https://files.pythonhosted.org/packages/75/08/67cc404b3a966b6df27b38370ddd96b3b023030b572283d035181854aac5/pandas-3.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:536232a5fe26dd989bd633e7a0c450705fdc86a207fec7254a55e9a22950fe43", size = 9741627, upload-time = "2026-02-17T22:18:53.905Z" },
+    { url = "https://files.pythonhosted.org/packages/86/4f/caf9952948fb00d23795f09b893d11f1cacb384e666854d87249530f7cbe/pandas-3.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f463ebfd8de7f326d38037c7363c6dacb857c5881ab8961fb387804d6daf2f7", size = 9052483, upload-time = "2026-02-17T22:18:57.31Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/48/aad6ec4f8d007534c091e9a7172b3ec1b1ee6d99a9cbb936b5eab6c6cf58/pandas-3.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5272627187b5d9c20e55d27caf5f2cd23e286aba25cadf73c8590e432e2b7262", size = 10317509, upload-time = "2026-02-17T22:18:59.498Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/14/5990826f779f79148ae9d3a2c39593dc04d61d5d90541e71b5749f35af95/pandas-3.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:661e0f665932af88c7877f31da0dc743fe9c8f2524bdffe23d24fdcb67ef9d56", size = 9860561, upload-time = "2026-02-17T22:19:02.265Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/80/f01ff54664b6d70fed71475543d108a9b7c888e923ad210795bef04ffb7d/pandas-3.0.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75e6e292ff898679e47a2199172593d9f6107fd2dd3617c22c2946e97d5df46e", size = 10365506, upload-time = "2026-02-17T22:19:05.017Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/85/ab6d04733a7d6ff32bfc8382bf1b07078228f5d6ebec5266b91bfc5c4ff7/pandas-3.0.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ff8cf1d2896e34343197685f432450ec99a85ba8d90cce2030c5eee2ef98791", size = 10873196, upload-time = "2026-02-17T22:19:07.204Z" },
+    { url = "https://files.pythonhosted.org/packages/48/a9/9301c83d0b47c23ac5deab91c6b39fd98d5b5db4d93b25df8d381451828f/pandas-3.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eca8b4510f6763f3d37359c2105df03a7a221a508f30e396a51d0713d462e68a", size = 11370859, upload-time = "2026-02-17T22:19:09.436Z" },
+    { url = "https://files.pythonhosted.org/packages/59/fe/0c1fc5bd2d29c7db2ab372330063ad555fb83e08422829c785f5ec2176ca/pandas-3.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:06aff2ad6f0b94a17822cf8b83bbb563b090ed82ff4fe7712db2ce57cd50d9b8", size = 11924584, upload-time = "2026-02-17T22:19:11.562Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/7d/216a1588b65a7aa5f4535570418a599d943c85afb1d95b0876fc00aa1468/pandas-3.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:9fea306c783e28884c29057a1d9baa11a349bbf99538ec1da44c8476563d1b25", size = 9742769, upload-time = "2026-02-17T22:19:13.926Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/cb/810a22a6af9a4e97c8ab1c946b47f3489c5bca5adc483ce0ffc84c9cc768/pandas-3.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:a8d37a43c52917427e897cb2e429f67a449327394396a81034a4449b99afda59", size = 9043855, upload-time = "2026-02-17T22:19:16.09Z" },
+    { url = "https://files.pythonhosted.org/packages/92/fa/423c89086cca1f039cf1253c3ff5b90f157b5b3757314aa635f6bf3e30aa/pandas-3.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d54855f04f8246ed7b6fc96b05d4871591143c46c0b6f4af874764ed0d2d6f06", size = 10752673, upload-time = "2026-02-17T22:19:18.304Z" },
+    { url = "https://files.pythonhosted.org/packages/22/23/b5a08ec1f40020397f0faba72f1e2c11f7596a6169c7b3e800abff0e433f/pandas-3.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e1b677accee34a09e0dc2ce5624e4a58a1870ffe56fc021e9caf7f23cd7668f", size = 10404967, upload-time = "2026-02-17T22:19:20.726Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/81/94841f1bb4afdc2b52a99daa895ac2c61600bb72e26525ecc9543d453ebc/pandas-3.0.1-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a9cabbdcd03f1b6cd254d6dda8ae09b0252524be1592594c00b7895916cb1324", size = 10320575, upload-time = "2026-02-17T22:19:24.919Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/8b/2ae37d66a5342a83adadfd0cb0b4bf9c3c7925424dd5f40d15d6cfaa35ee/pandas-3.0.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ae2ab1f166668b41e770650101e7090824fd34d17915dd9cd479f5c5e0065e9", size = 10710921, upload-time = "2026-02-17T22:19:27.181Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/61/772b2e2757855e232b7ccf7cb8079a5711becb3a97f291c953def15a833f/pandas-3.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6bf0603c2e30e2cafac32807b06435f28741135cb8697eae8b28c7d492fc7d76", size = 11334191, upload-time = "2026-02-17T22:19:29.411Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/08/b16c6df3ef555d8495d1d265a7963b65be166785d28f06a350913a4fac78/pandas-3.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6c426422973973cae1f4a23e51d4ae85974f44871b24844e4f7de752dd877098", size = 11782256, upload-time = "2026-02-17T22:19:32.34Z" },
+    { url = "https://files.pythonhosted.org/packages/55/80/178af0594890dee17e239fca96d3d8670ba0f5ff59b7d0439850924a9c09/pandas-3.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b03f91ae8c10a85c1613102c7bef5229b5379f343030a3ccefeca8a33414cf35", size = 10485047, upload-time = "2026-02-17T22:19:34.605Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/8b/4bb774a998b97e6c2fd62a9e6cfdaae133b636fd1c468f92afb4ae9a447a/pandas-3.0.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:99d0f92ed92d3083d140bf6b97774f9f13863924cf3f52a70711f4e7588f9d0a", size = 10322465, upload-time = "2026-02-17T22:19:36.803Z" },
+    { url = "https://files.pythonhosted.org/packages/72/3a/5b39b51c64159f470f1ca3b1c2a87da290657ca022f7cd11442606f607d1/pandas-3.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3b66857e983208654294bb6477b8a63dee26b37bdd0eb34d010556e91261784f", size = 9910632, upload-time = "2026-02-17T22:19:39.001Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f7/b449ffb3f68c11da12fc06fbf6d2fa3a41c41e17d0284d23a79e1c13a7e4/pandas-3.0.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56cf59638bf24dc9bdf2154c81e248b3289f9a09a6d04e63608c159022352749", size = 10440535, upload-time = "2026-02-17T22:19:41.157Z" },
+    { url = "https://files.pythonhosted.org/packages/55/77/6ea82043db22cb0f2bbfe7198da3544000ddaadb12d26be36e19b03a2dc5/pandas-3.0.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1a9f55e0f46951874b863d1f3906dcb57df2d9be5c5847ba4dfb55b2c815249", size = 10893940, upload-time = "2026-02-17T22:19:43.493Z" },
+    { url = "https://files.pythonhosted.org/packages/03/30/f1b502a72468c89412c1b882a08f6eed8a4ee9dc033f35f65d0663df6081/pandas-3.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1849f0bba9c8a2fb0f691d492b834cc8dadf617e29015c66e989448d58d011ee", size = 11442711, upload-time = "2026-02-17T22:19:46.074Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f0/ebb6ddd8fc049e98cabac5c2924d14d1dda26a20adb70d41ea2e428d3ec4/pandas-3.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c3d288439e11b5325b02ae6e9cc83e6805a62c40c5a6220bea9beb899c073b1c", size = 11963918, upload-time = "2026-02-17T22:19:48.838Z" },
+    { url = "https://files.pythonhosted.org/packages/09/f8/8ce132104074f977f907442790eaae24e27bce3b3b454e82faa3237ff098/pandas-3.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:93325b0fe372d192965f4cca88d97667f49557398bbf94abdda3bf1b591dbe66", size = 9862099, upload-time = "2026-02-17T22:19:51.081Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/b7/6af9aac41ef2456b768ef0ae60acf8abcebb450a52043d030a65b4b7c9bd/pandas-3.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:97ca08674e3287c7148f4858b01136f8bdfe7202ad25ad04fec602dd1d29d132", size = 9185333, upload-time = "2026-02-17T22:19:53.266Z" },
+    { url = "https://files.pythonhosted.org/packages/66/fc/848bb6710bc6061cb0c5badd65b92ff75c81302e0e31e496d00029fe4953/pandas-3.0.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:58eeb1b2e0fb322befcf2bbc9ba0af41e616abadb3d3414a6bc7167f6cbfce32", size = 10772664, upload-time = "2026-02-17T22:19:55.806Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5c/866a9bbd0f79263b4b0db6ec1a341be13a1473323f05c122388e0f15b21d/pandas-3.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cd9af1276b5ca9e298bd79a26bda32fa9cc87ed095b2a9a60978d2ca058eaf87", size = 10421286, upload-time = "2026-02-17T22:19:58.091Z" },
+    { url = "https://files.pythonhosted.org/packages/51/a4/2058fb84fb1cfbfb2d4a6d485e1940bb4ad5716e539d779852494479c580/pandas-3.0.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f87a04984d6b63788327cd9f79dda62b7f9043909d2440ceccf709249ca988", size = 10342050, upload-time = "2026-02-17T22:20:01.376Z" },
+    { url = "https://files.pythonhosted.org/packages/22/1b/674e89996cc4be74db3c4eb09240c4bb549865c9c3f5d9b086ff8fcfbf00/pandas-3.0.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85fe4c4df62e1e20f9db6ebfb88c844b092c22cd5324bdcf94bfa2fc1b391221", size = 10740055, upload-time = "2026-02-17T22:20:04.328Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/f8/e954b750764298c22fa4614376531fe63c521ef517e7059a51f062b87dca/pandas-3.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:331ca75a2f8672c365ae25c0b29e46f5ac0c6551fdace8eec4cd65e4fac271ff", size = 11357632, upload-time = "2026-02-17T22:20:06.647Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/02/c6e04b694ffd68568297abd03588b6d30295265176a5c01b7459d3bc35a3/pandas-3.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:15860b1fdb1973fffade772fdb931ccf9b2f400a3f5665aef94a00445d7d8dd5", size = 11810974, upload-time = "2026-02-17T22:20:08.946Z" },
+    { url = "https://files.pythonhosted.org/packages/89/41/d7dfb63d2407f12055215070c42fc6ac41b66e90a2946cdc5e759058398b/pandas-3.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:44f1364411d5670efa692b146c748f4ed013df91ee91e9bec5677fb1fd58b937", size = 10884622, upload-time = "2026-02-17T22:20:11.711Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b0/34937815889fa982613775e4b97fddd13250f11012d769949c5465af2150/pandas-3.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:108dd1790337a494aa80e38def654ca3f0968cf4f362c85f44c15e471667102d", size = 9452085, upload-time = "2026-02-17T22:20:14.331Z" },
+]
+
+[[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.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621, upload-time = "2026-02-09T15:45:24.425Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894, upload-time = "2026-02-09T15:45:21.391Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+]
+
+[[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.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2b/46/5da1ec4a5171ee7bf1a0efa064aba70ba3d6e0788ce3f5acd1375d23c8c0/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32", size = 5304084, upload-time = "2026-02-11T04:20:27.501Z" },
+    { url = "https://files.pythonhosted.org/packages/78/93/a29e9bc02d1cf557a834da780ceccd54e02421627200696fcf805ebdc3fb/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38", size = 4657866, upload-time = "2026-02-11T04:20:29.827Z" },
+    { url = "https://files.pythonhosted.org/packages/13/84/583a4558d492a179d31e4aae32eadce94b9acf49c0337c4ce0b70e0a01f2/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5", size = 6232148, upload-time = "2026-02-11T04:20:31.329Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e2/53c43334bbbb2d3b938978532fbda8e62bb6e0b23a26ce8592f36bcc4987/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090", size = 8038007, upload-time = "2026-02-11T04:20:34.225Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/a6/3d0e79c8a9d58150dd98e199d7c1c56861027f3829a3a60b3c2784190180/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af", size = 6345418, upload-time = "2026-02-11T04:20:35.858Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/c8/46dfeac5825e600579157eea177be43e2f7ff4a99da9d0d0a49533509ac5/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b", size = 7034590, upload-time = "2026-02-11T04:20:37.91Z" },
+    { url = "https://files.pythonhosted.org/packages/af/bf/e6f65d3db8a8bbfeaf9e13cc0417813f6319863a73de934f14b2229ada18/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5", size = 6458655, upload-time = "2026-02-11T04:20:39.496Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c2/66091f3f34a25894ca129362e510b956ef26f8fb67a0e6417bc5744e56f1/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d", size = 7159286, upload-time = "2026-02-11T04:20:41.139Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5a/24bc8eb526a22f957d0cec6243146744966d40857e3d8deb68f7902ca6c1/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c", size = 6328663, upload-time = "2026-02-11T04:20:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/31/03/bef822e4f2d8f9d7448c133d0a18185d3cce3e70472774fffefe8b0ed562/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563", size = 7031448, upload-time = "2026-02-11T04:20:44.696Z" },
+    { url = "https://files.pythonhosted.org/packages/49/70/f76296f53610bd17b2e7d31728b8b7825e3ac3b5b3688b51f52eab7c0818/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80", size = 2453651, upload-time = "2026-02-11T04:20:46.243Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },
+    { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },
+    { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" },
+    { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" },
+    { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" },
+    { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" },
+    { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" },
+    { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" },
+    { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" },
+    { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" },
+    { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" },
+    { url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" },
+    { url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" },
+    { url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" },
+    { url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" },
+    { url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" },
+    { url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" },
+    { url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" },
+    { url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" },
+    { url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" },
+    { url = "https://files.pythonhosted.org/packages/56/11/5d43209aa4cb58e0cc80127956ff1796a68b928e6324bbf06ef4db34367b/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f", size = 5228606, upload-time = "2026-02-11T04:22:52.106Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/d5/3b005b4e4fda6698b371fa6c21b097d4707585d7db99e98d9b0b87ac612a/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9", size = 4622321, upload-time = "2026-02-11T04:22:53.827Z" },
+    { url = "https://files.pythonhosted.org/packages/df/36/ed3ea2d594356fd8037e5a01f6156c74bc8d92dbb0fa60746cc96cabb6e8/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e", size = 5247579, upload-time = "2026-02-11T04:22:56.094Z" },
+    { url = "https://files.pythonhosted.org/packages/54/9a/9cc3e029683cf6d20ae5085da0dafc63148e3252c2f13328e553aaa13cfb/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9", size = 6989094, upload-time = "2026-02-11T04:22:58.288Z" },
+    { url = "https://files.pythonhosted.org/packages/00/98/fc53ab36da80b88df0967896b6c4b4cd948a0dc5aa40a754266aa3ae48b3/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3", size = 5313850, upload-time = "2026-02-11T04:23:00.554Z" },
+    { url = "https://files.pythonhosted.org/packages/30/02/00fa585abfd9fe9d73e5f6e554dc36cc2b842898cbfc46d70353dae227f8/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735", size = 5963343, upload-time = "2026-02-11T04:23:02.934Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.9.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" },
+]
+
+[[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.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
+]
+
+[[package]]
+name = "prometheus-client"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/58/a794d23feb6b00fc0c72787d7e87d872a6730dd9ed7c7b3e954637d8f280/prometheus_client-0.24.1.tar.gz", hash = "sha256:7e0ced7fbbd40f7b84962d5d2ab6f17ef88a72504dcf7c0b40737b43b2a461f9", size = 85616, upload-time = "2026-01-14T15:26:26.965Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/c3/24a2f845e3917201628ecaba4f18bab4d18a337834c1df2a159ee9d22a42/prometheus_client-0.24.1-py3-none-any.whl", hash = "sha256:150db128af71a5c2482b36e588fc8a6b95e498750da4b17065947c16070f4055", size = 64057, upload-time = "2026-01-14T15:26:24.42Z" },
+]
+
+[[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 = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" },
+    { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" },
+    { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" },
+    { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" },
+    { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "proto-plus"
+version = "1.27.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/0d/94dfe80193e79d55258345901acd2917523d56e8381bc4dee7fd38e3868a/proto_plus-1.27.2.tar.gz", hash = "sha256:b2adde53adadf75737c44d3dcb0104fde65250dfc83ad59168b4aa3e574b6a24", size = 57204, upload-time = "2026-03-26T22:18:57.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/f3/1fba73eeffafc998a25d59703b63f8be4fe8a5cb12eaff7386a0ba0f7125/proto_plus-1.27.2-py3-none-any.whl", hash = "sha256:6432f75893d3b9e70b9c412f1d2f03f65b11fb164b793d14ae2ca01821d22718", size = 50450, upload-time = "2026-03-26T22:13:42.927Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "6.33.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" },
+    { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" },
+    { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },
+]
+
+[[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 = "pyasn1"
+version = "0.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/5f/6583902b6f79b399c9c40674ac384fd9cd77805f9e6205075f828ef11fb2/pyasn1-0.6.3.tar.gz", hash = "sha256:697a8ecd6d98891189184ca1fa05d1bb00e2f84b5977c481452050549c8a72cf", size = 148685, upload-time = "2026-03-17T01:06:53.382Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/a0/7d793dce3fa811fe047d6ae2431c672364b462850c6235ae306c0efd025f/pyasn1-0.6.3-py3-none-any.whl", hash = "sha256:a80184d120f0864a52a073acc6fc642847d0be408e7c7252f31390c0f4eadcde", size = 83997, upload-time = "2026-03-17T01:06:52.036Z" },
+]
+
+[[package]]
+name = "pyasn1-modules"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyasn1" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload-time = "2025-03-28T02:41:19.028Z" },
+]
+
+[[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 = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" },
+]
+
+[[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 = "pymdown-extensions"
+version = "10.21.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/08/f1c908c581fd11913da4711ea7ba32c0eee40b0190000996bb863b0c9349/pymdown_extensions-10.21.2.tar.gz", hash = "sha256:c3f55a5b8a1d0edf6699e35dcbea71d978d34ff3fa79f3d807b8a5b3fa90fbdc", size = 853922, upload-time = "2026-03-29T15:01:55.233Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/27/a2fc51a4a122dfd1015e921ae9d22fee3d20b0b8080d9a704578bf9deece/pymdown_extensions-10.21.2-py3-none-any.whl", hash = "sha256:5c0fd2a2bea14eb39af8ff284f1066d898ab2187d81b889b75d46d4348c01638", size = 268901, upload-time = "2026-03-29T15:01:53.244Z" },
+]
+
+[[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 = "pyproj"
+version = "3.7.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/90/67bd7260b4ea9b8b20b4f58afef6c223ecb3abf368eb4ec5bc2cdef81b49/pyproj-3.7.2.tar.gz", hash = "sha256:39a0cf1ecc7e282d1d30f36594ebd55c9fae1fda8a2622cee5d100430628f88c", size = 226279, upload-time = "2025-08-14T12:05:42.18Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/bd/f205552cd1713b08f93b09e39a3ec99edef0b3ebbbca67b486fdf1abe2de/pyproj-3.7.2-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:2514d61f24c4e0bb9913e2c51487ecdaeca5f8748d8313c933693416ca41d4d5", size = 6227022, upload-time = "2025-08-14T12:03:51.474Z" },
+    { url = "https://files.pythonhosted.org/packages/75/4c/9a937e659b8b418ab573c6d340d27e68716928953273e0837e7922fcac34/pyproj-3.7.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:8693ca3892d82e70de077701ee76dd13d7bca4ae1c9d1e739d72004df015923a", size = 4625810, upload-time = "2025-08-14T12:03:53.808Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/7d/a9f41e814dc4d1dc54e95b2ccaf0b3ebe3eb18b1740df05fe334724c3d89/pyproj-3.7.2-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:5e26484d80fea56273ed1555abaea161e9661d81a6c07815d54b8e883d4ceb25", size = 9638694, upload-time = "2025-08-14T12:03:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/ab/9bdb4a6216b712a1f9aab1c0fcbee5d3726f34a366f29c3e8c08a78d6b70/pyproj-3.7.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:281cb92847814e8018010c48b4069ff858a30236638631c1a91dd7bfa68f8a8a", size = 9493977, upload-time = "2025-08-14T12:03:57.937Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/db/2db75b1b6190f1137b1c4e8ef6a22e1c338e46320f6329bfac819143e063/pyproj-3.7.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9c8577f0b7bb09118ec2e57e3babdc977127dd66326d6c5d755c76b063e6d9dc", size = 10841151, upload-time = "2025-08-14T12:04:00.271Z" },
+    { url = "https://files.pythonhosted.org/packages/89/f7/989643394ba23a286e9b7b3f09981496172f9e0d4512457ffea7dc47ffc7/pyproj-3.7.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a23f59904fac3a5e7364b3aa44d288234af267ca041adb2c2b14a903cd5d3ac5", size = 10751585, upload-time = "2025-08-14T12:04:02.228Z" },
+    { url = "https://files.pythonhosted.org/packages/53/6d/ad928fe975a6c14a093c92e6a319ca18f479f3336bb353a740bdba335681/pyproj-3.7.2-cp311-cp311-win32.whl", hash = "sha256:f2af4ed34b2cf3e031a2d85b067a3ecbd38df073c567e04b52fa7a0202afde8a", size = 5908533, upload-time = "2025-08-14T12:04:04.821Z" },
+    { url = "https://files.pythonhosted.org/packages/79/e0/b95584605cec9ed50b7ebaf7975d1c4ddeec5a86b7a20554ed8b60042bd7/pyproj-3.7.2-cp311-cp311-win_amd64.whl", hash = "sha256:0b7cb633565129677b2a183c4d807c727d1c736fcb0568a12299383056e67433", size = 6320742, upload-time = "2025-08-14T12:04:06.357Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4d/536e8f93bca808175c2d0a5ac9fdf69b960d8ab6b14f25030dccb07464d7/pyproj-3.7.2-cp311-cp311-win_arm64.whl", hash = "sha256:38b08d85e3a38e455625b80e9eb9f78027c8e2649a21dec4df1f9c3525460c71", size = 6245772, upload-time = "2025-08-14T12:04:08.365Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/ab/9893ea9fb066be70ed9074ae543914a618c131ed8dff2da1e08b3a4df4db/pyproj-3.7.2-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:0a9bb26a6356fb5b033433a6d1b4542158fb71e3c51de49b4c318a1dff3aeaab", size = 6219832, upload-time = "2025-08-14T12:04:10.264Z" },
+    { url = "https://files.pythonhosted.org/packages/53/78/4c64199146eed7184eb0e85bedec60a4aa8853b6ffe1ab1f3a8b962e70a0/pyproj-3.7.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:567caa03021178861fad27fabde87500ec6d2ee173dd32f3e2d9871e40eebd68", size = 4620650, upload-time = "2025-08-14T12:04:11.978Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ac/14a78d17943898a93ef4f8c6a9d4169911c994e3161e54a7cedeba9d8dde/pyproj-3.7.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:c203101d1dc3c038a56cff0447acc515dd29d6e14811406ac539c21eed422b2a", size = 9667087, upload-time = "2025-08-14T12:04:13.964Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/be/212882c450bba74fc8d7d35cbd57e4af84792f0a56194819d98106b075af/pyproj-3.7.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:1edc34266c0c23ced85f95a1ee8b47c9035eae6aca5b6b340327250e8e281630", size = 9552797, upload-time = "2025-08-14T12:04:16.624Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/c0/c0f25c87b5d2a8686341c53c1792a222a480d6c9caf60311fec12c99ec26/pyproj-3.7.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aa9f26c21bc0e2dc3d224cb1eb4020cf23e76af179a7c66fea49b828611e4260", size = 10837036, upload-time = "2025-08-14T12:04:18.733Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/37/5cbd6772addde2090c91113332623a86e8c7d583eccb2ad02ea634c4a89f/pyproj-3.7.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f9428b318530625cb389b9ddc9c51251e172808a4af79b82809376daaeabe5e9", size = 10775952, upload-time = "2025-08-14T12:04:20.709Z" },
+    { url = "https://files.pythonhosted.org/packages/69/a1/dc250e3cf83eb4b3b9a2cf86fdb5e25288bd40037ae449695550f9e96b2f/pyproj-3.7.2-cp312-cp312-win32.whl", hash = "sha256:b3d99ed57d319da042f175f4554fc7038aa4bcecc4ac89e217e350346b742c9d", size = 5898872, upload-time = "2025-08-14T12:04:22.485Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/a6/6fe724b72b70f2b00152d77282e14964d60ab092ec225e67c196c9b463e5/pyproj-3.7.2-cp312-cp312-win_amd64.whl", hash = "sha256:11614a054cd86a2ed968a657d00987a86eeb91fdcbd9ad3310478685dc14a128", size = 6312176, upload-time = "2025-08-14T12:04:24.736Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/68/915cc32c02a91e76d02c8f55d5a138d6ef9e47a0d96d259df98f4842e558/pyproj-3.7.2-cp312-cp312-win_arm64.whl", hash = "sha256:509a146d1398bafe4f53273398c3bb0b4732535065fa995270e52a9d3676bca3", size = 6233452, upload-time = "2025-08-14T12:04:27.287Z" },
+    { url = "https://files.pythonhosted.org/packages/be/14/faf1b90d267cea68d7e70662e7f88cefdb1bc890bd596c74b959e0517a72/pyproj-3.7.2-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:19466e529b1b15eeefdf8ff26b06fa745856c044f2f77bf0edbae94078c1dfa1", size = 6214580, upload-time = "2025-08-14T12:04:28.804Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/da9a45b184d375f62667f62eba0ca68569b0bd980a0bb7ffcc1d50440520/pyproj-3.7.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:c79b9b84c4a626c5dc324c0d666be0bfcebd99f7538d66e8898c2444221b3da7", size = 4615388, upload-time = "2025-08-14T12:04:30.553Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/e7/d2b459a4a64bca328b712c1b544e109df88e5c800f7c143cfbc404d39bfb/pyproj-3.7.2-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ceecf374cacca317bc09e165db38ac548ee3cad07c3609442bd70311c59c21aa", size = 9628455, upload-time = "2025-08-14T12:04:32.435Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/85/c2b1706e51942de19076eff082f8495e57d5151364e78b5bef4af4a1d94a/pyproj-3.7.2-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5141a538ffdbe4bfd157421828bb2e07123a90a7a2d6f30fa1462abcfb5ce681", size = 9514269, upload-time = "2025-08-14T12:04:34.599Z" },
+    { url = "https://files.pythonhosted.org/packages/34/38/07a9b89ae7467872f9a476883a5bad9e4f4d1219d31060f0f2b282276cbe/pyproj-3.7.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f000841e98ea99acbb7b8ca168d67773b0191de95187228a16110245c5d954d5", size = 10808437, upload-time = "2025-08-14T12:04:36.485Z" },
+    { url = "https://files.pythonhosted.org/packages/12/56/fda1daeabbd39dec5b07f67233d09f31facb762587b498e6fc4572be9837/pyproj-3.7.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8115faf2597f281a42ab608ceac346b4eb1383d3b45ab474fd37341c4bf82a67", size = 10745540, upload-time = "2025-08-14T12:04:38.568Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/90/c793182cbba65a39a11db2ac6b479fe76c59e6509ae75e5744c344a0da9d/pyproj-3.7.2-cp313-cp313-win32.whl", hash = "sha256:f18c0579dd6be00b970cb1a6719197fceecc407515bab37da0066f0184aafdf3", size = 5896506, upload-time = "2025-08-14T12:04:41.059Z" },
+    { url = "https://files.pythonhosted.org/packages/be/0f/747974129cf0d800906f81cd25efd098c96509026e454d4b66868779ab04/pyproj-3.7.2-cp313-cp313-win_amd64.whl", hash = "sha256:bb41c29d5f60854b1075853fe80c58950b398d4ebb404eb532536ac8d2834ed7", size = 6310195, upload-time = "2025-08-14T12:04:42.974Z" },
+    { url = "https://files.pythonhosted.org/packages/82/64/fc7598a53172c4931ec6edf5228280663063150625d3f6423b4c20f9daff/pyproj-3.7.2-cp313-cp313-win_arm64.whl", hash = "sha256:2b617d573be4118c11cd96b8891a0b7f65778fa7733ed8ecdb297a447d439100", size = 6230748, upload-time = "2025-08-14T12:04:44.491Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/f0/611dd5cddb0d277f94b7af12981f56e1441bf8d22695065d4f0df5218498/pyproj-3.7.2-cp313-cp313t-macosx_13_0_x86_64.whl", hash = "sha256:d27b48f0e81beeaa2b4d60c516c3a1cfbb0c7ff6ef71256d8e9c07792f735279", size = 6241729, upload-time = "2025-08-14T12:04:46.274Z" },
+    { url = "https://files.pythonhosted.org/packages/15/93/40bd4a6c523ff9965e480870611aed7eda5aa2c6128c6537345a2b77b542/pyproj-3.7.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:55a3610d75023c7b1c6e583e48ef8f62918e85a2ae81300569d9f104d6684bb6", size = 4652497, upload-time = "2025-08-14T12:04:48.203Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/ae/7150ead53c117880b35e0d37960d3138fe640a235feb9605cb9386f50bb0/pyproj-3.7.2-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:8d7349182fa622696787cc9e195508d2a41a64765da9b8a6bee846702b9e6220", size = 9942610, upload-time = "2025-08-14T12:04:49.652Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/17/7a4a7eafecf2b46ab64e5c08176c20ceb5844b503eaa551bf12ccac77322/pyproj-3.7.2-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:d230b186eb876ed4f29a7c5ee310144c3a0e44e89e55f65fb3607e13f6db337c", size = 9692390, upload-time = "2025-08-14T12:04:51.731Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/55/ae18f040f6410f0ea547a21ada7ef3e26e6c82befa125b303b02759c0e9d/pyproj-3.7.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:237499c7862c578d0369e2b8ac56eec550e391a025ff70e2af8417139dabb41c", size = 11047596, upload-time = "2025-08-14T12:04:53.748Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/2e/d3fff4d2909473f26ae799f9dda04caa322c417a51ff3b25763f7d03b233/pyproj-3.7.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8c225f5978abd506fd9a78eaaf794435e823c9156091cabaab5374efb29d7f69", size = 10896975, upload-time = "2025-08-14T12:04:55.875Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/bc/8fc7d3963d87057b7b51ebe68c1e7c51c23129eee5072ba6b86558544a46/pyproj-3.7.2-cp313-cp313t-win32.whl", hash = "sha256:2da731876d27639ff9d2d81c151f6ab90a1546455fabd93368e753047be344a2", size = 5953057, upload-time = "2025-08-14T12:04:58.466Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/27/ea9809966cc47d2d51e6d5ae631ea895f7c7c7b9b3c29718f900a8f7d197/pyproj-3.7.2-cp313-cp313t-win_amd64.whl", hash = "sha256:f54d91ae18dd23b6c0ab48126d446820e725419da10617d86a1b69ada6d881d3", size = 6375414, upload-time = "2025-08-14T12:04:59.861Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/f8/1ef0129fba9a555c658e22af68989f35e7ba7b9136f25758809efec0cd6e/pyproj-3.7.2-cp313-cp313t-win_arm64.whl", hash = "sha256:fc52ba896cfc3214dc9f9ca3c0677a623e8fdd096b257c14a31e719d21ff3fdd", size = 6262501, upload-time = "2025-08-14T12:05:01.39Z" },
+    { url = "https://files.pythonhosted.org/packages/42/17/c2b050d3f5b71b6edd0d96ae16c990fdc42a5f1366464a5c2772146de33a/pyproj-3.7.2-cp314-cp314-macosx_13_0_x86_64.whl", hash = "sha256:2aaa328605ace41db050d06bac1adc11f01b71fe95c18661497763116c3a0f02", size = 6214541, upload-time = "2025-08-14T12:05:03.166Z" },
+    { url = "https://files.pythonhosted.org/packages/03/68/68ada9c8aea96ded09a66cfd9bf87aa6db8c2edebe93f5bf9b66b0143fbc/pyproj-3.7.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:35dccbce8201313c596a970fde90e33605248b66272595c061b511c8100ccc08", size = 4617456, upload-time = "2025-08-14T12:05:04.563Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e4/4c50ceca7d0e937977866b02cb64e6ccf4df979a5871e521f9e255df6073/pyproj-3.7.2-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:25b0b7cb0042444c29a164b993c45c1b8013d6c48baa61dc1160d834a277e83b", size = 9615590, upload-time = "2025-08-14T12:05:06.094Z" },
+    { url = "https://files.pythonhosted.org/packages/05/1e/ada6fb15a1d75b5bd9b554355a69a798c55a7dcc93b8d41596265c1772e3/pyproj-3.7.2-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:85def3a6388e9ba51f964619aa002a9d2098e77c6454ff47773bb68871024281", size = 9474960, upload-time = "2025-08-14T12:05:07.973Z" },
+    { url = "https://files.pythonhosted.org/packages/51/07/9d48ad0a8db36e16f842f2c8a694c1d9d7dcf9137264846bef77585a71f3/pyproj-3.7.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b1bccefec3875ab81eabf49059e2b2ea77362c178b66fd3528c3e4df242f1516", size = 10799478, upload-time = "2025-08-14T12:05:14.102Z" },
+    { url = "https://files.pythonhosted.org/packages/85/cf/2f812b529079f72f51ff2d6456b7fef06c01735e5cfd62d54ffb2b548028/pyproj-3.7.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d5371ca114d6990b675247355a801925814eca53e6c4b2f1b5c0a956336ee36e", size = 10710030, upload-time = "2025-08-14T12:05:16.317Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9b/4626a19e1f03eba4c0e77b91a6cf0f73aa9cb5d51a22ee385c22812bcc2c/pyproj-3.7.2-cp314-cp314-win32.whl", hash = "sha256:77f066626030f41be543274f5ac79f2a511fe89860ecd0914f22131b40a0ec25", size = 5991181, upload-time = "2025-08-14T12:05:19.492Z" },
+    { url = "https://files.pythonhosted.org/packages/04/b2/5a6610554306a83a563080c2cf2c57565563eadd280e15388efa00fb5b33/pyproj-3.7.2-cp314-cp314-win_amd64.whl", hash = "sha256:5a964da1696b8522806f4276ab04ccfff8f9eb95133a92a25900697609d40112", size = 6434721, upload-time = "2025-08-14T12:05:21.022Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/ce/6c910ea2e1c74ef673c5d48c482564b8a7824a44c4e35cca2e765b68cfcc/pyproj-3.7.2-cp314-cp314-win_arm64.whl", hash = "sha256:e258ab4dbd3cf627809067c0ba8f9884ea76c8e5999d039fb37a1619c6c3e1f6", size = 6363821, upload-time = "2025-08-14T12:05:22.627Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e4/5532f6f7491812ba782a2177fe9de73fd8e2912b59f46a1d056b84b9b8f2/pyproj-3.7.2-cp314-cp314t-macosx_13_0_x86_64.whl", hash = "sha256:bbbac2f930c6d266f70ec75df35ef851d96fdb3701c674f42fd23a9314573b37", size = 6241773, upload-time = "2025-08-14T12:05:24.577Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/0938c3f2bbbef1789132d1726d9b0e662f10cfc22522743937f421ad664e/pyproj-3.7.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:b7544e0a3d6339dc9151e9c8f3ea62a936ab7cc446a806ec448bbe86aebb979b", size = 4652537, upload-time = "2025-08-14T12:05:26.391Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/a8/488b1ed47d25972f33874f91f09ca8f2227902f05f63a2b80dc73e7b1c97/pyproj-3.7.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:f7f5133dca4c703e8acadf6f30bc567d39a42c6af321e7f81975c2518f3ed357", size = 9940864, upload-time = "2025-08-14T12:05:27.985Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/cc/7f4c895d0cb98e47b6a85a6d79eaca03eb266129eed2f845125c09cf31ff/pyproj-3.7.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:5aff3343038d7426aa5076f07feb88065f50e0502d1b0d7c22ddfdd2c75a3f81", size = 9688868, upload-time = "2025-08-14T12:05:30.425Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/b7/c7e306b8bb0f071d9825b753ee4920f066c40fbfcce9372c4f3cfb2fc4ed/pyproj-3.7.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b0552178c61f2ac1c820d087e8ba6e62b29442debddbb09d51c4bf8acc84d888", size = 11045910, upload-time = "2025-08-14T12:05:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/42/fb/538a4d2df695980e2dde5c04d965fbdd1fe8c20a3194dc4aaa3952a4d1be/pyproj-3.7.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:47d87db2d2c436c5fd0409b34d70bb6cdb875cca2ebe7a9d1c442367b0ab8d59", size = 10895724, upload-time = "2025-08-14T12:05:35.465Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/8b/a3f0618b03957de9db5489a04558a8826f43906628bb0b766033aa3b5548/pyproj-3.7.2-cp314-cp314t-win32.whl", hash = "sha256:c9b6f1d8ad3e80a0ee0903a778b6ece7dca1d1d40f6d114ae01bc8ddbad971aa", size = 6056848, upload-time = "2025-08-14T12:05:37.553Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/56/413240dd5149dd3291eda55aa55a659da4431244a2fd1319d0ae89407cfb/pyproj-3.7.2-cp314-cp314t-win_amd64.whl", hash = "sha256:1914e29e27933ba6f9822663ee0600f169014a2859f851c054c88cf5ea8a333c", size = 6517676, upload-time = "2025-08-14T12:05:39.126Z" },
+    { url = "https://files.pythonhosted.org/packages/15/73/a7141a1a0559bf1a7aa42a11c879ceb19f02f5c6c371c6d57fd86cefd4d1/pyproj-3.7.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d9d25bae416a24397e0d85739f84d323b55f6511e45a522dd7d7eae70d10c7e4", size = 6391844, upload-time = "2025-08-14T12:05:40.745Z" },
+]
+
+[[package]]
+name = "pystac"
+version = "1.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/31/e6/efbc20dbc94ad7ed18fe11a4208103a509384ffcccd9bdc27953b725e686/pystac-1.14.3.tar.gz", hash = "sha256:24f92d6f301371859aa0abc1bbe7b1523a603e1184a6d139ecb323967c2c9bb3", size = 164205, upload-time = "2026-01-09T12:38:42.456Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/b4/a9430e72bfc3c458e1fcf8363890994e483052ab052ed93912be4e5b32c8/pystac-1.14.3-py3-none-any.whl", hash = "sha256:2f60005f521d541fb801428307098f223c14697b3faf4d2f0209afb6a43f39e5", size = 208506, upload-time = "2026-01-09T12:38:40.721Z" },
+]
+
+[package.optional-dependencies]
+validation = [
+    { name = "jsonschema" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
+]
+
+[[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.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b9/88/815e53084c5079a59df912825a279f41dd2e0df82281770eadc732f5352c/python_discovery-1.2.1.tar.gz", hash = "sha256:180c4d114bff1c32462537eac5d6a332b768242b76b69c0259c7d14b1b680c9e", size = 58457, upload-time = "2026-03-26T22:30:44.496Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/0f/019d3949a40280f6193b62bc010177d4ce702d0fce424322286488569cd3/python_discovery-1.2.1-py3-none-any.whl", hash = "sha256:b6a957b24c1cd79252484d3566d1b49527581d46e789aaf43181005e56201502", size = 31674, upload-time = "2026-03-26T22:30:43.396Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-json-logger"
+version = "4.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/ff/3cc9165fd44106973cd7ac9facb674a65ed853494592541d339bdc9a30eb/python_json_logger-4.1.0.tar.gz", hash = "sha256:b396b9e3ed782b09ff9d6e4f1683d46c83ad0d35d2e407c09a9ebbf038f88195", size = 17573, upload-time = "2026-03-29T04:39:56.805Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/be/0631a861af4d1c875f096c07d34e9a63639560a717130e7a87cbc82b7e3f/python_json_logger-4.1.0-py3-none-any.whl", hash = "sha256:132994765cf75bf44554be9aa49b06ef2345d23661a96720262716438141b6b2", size = 15021, upload-time = "2026-03-29T04:39:55.266Z" },
+]
+
+[[package]]
+name = "pytokens"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b6/34/b4e015b99031667a7b960f888889c5bd34ef585c85e1cb56a594b92836ac/pytokens-0.4.1.tar.gz", hash = "sha256:292052fe80923aae2260c073f822ceba21f3872ced9a68bb7953b348e561179a", size = 23015, upload-time = "2026-01-30T01:03:45.924Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/92/790ebe03f07b57e53b10884c329b9a1a308648fc083a6d4a39a10a28c8fc/pytokens-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d70e77c55ae8380c91c0c18dea05951482e263982911fc7410b1ffd1dadd3440", size = 160864, upload-time = "2026-01-30T01:02:57.882Z" },
+    { url = "https://files.pythonhosted.org/packages/13/25/a4f555281d975bfdd1eba731450e2fe3a95870274da73fb12c40aeae7625/pytokens-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a58d057208cb9075c144950d789511220b07636dd2e4708d5645d24de666bdc", size = 248565, upload-time = "2026-01-30T01:02:59.912Z" },
+    { url = "https://files.pythonhosted.org/packages/17/50/bc0394b4ad5b1601be22fa43652173d47e4c9efbf0044c62e9a59b747c56/pytokens-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b49750419d300e2b5a3813cf229d4e5a4c728dae470bcc89867a9ad6f25a722d", size = 260824, upload-time = "2026-01-30T01:03:01.471Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/54/3e04f9d92a4be4fc6c80016bc396b923d2a6933ae94b5f557c939c460ee0/pytokens-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d9907d61f15bf7261d7e775bd5d7ee4d2930e04424bab1972591918497623a16", size = 264075, upload-time = "2026-01-30T01:03:04.143Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/1b/44b0326cb5470a4375f37988aea5d61b5cc52407143303015ebee94abfd6/pytokens-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:ee44d0f85b803321710f9239f335aafe16553b39106384cef8e6de40cb4ef2f6", size = 103323, upload-time = "2026-01-30T01:03:05.412Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5d/e44573011401fb82e9d51e97f1290ceb377800fb4eed650b96f4753b499c/pytokens-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:140709331e846b728475786df8aeb27d24f48cbcf7bcd449f8de75cae7a45083", size = 160663, upload-time = "2026-01-30T01:03:06.473Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/e6/5bbc3019f8e6f21d09c41f8b8654536117e5e211a85d89212d59cbdab381/pytokens-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d6c4268598f762bc8e91f5dbf2ab2f61f7b95bdc07953b602db879b3c8c18e1", size = 255626, upload-time = "2026-01-30T01:03:08.177Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/3c/2d5297d82286f6f3d92770289fd439956b201c0a4fc7e72efb9b2293758e/pytokens-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24afde1f53d95348b5a0eb19488661147285ca4dd7ed752bbc3e1c6242a304d1", size = 269779, upload-time = "2026-01-30T01:03:09.756Z" },
+    { url = "https://files.pythonhosted.org/packages/20/01/7436e9ad693cebda0551203e0bf28f7669976c60ad07d6402098208476de/pytokens-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5ad948d085ed6c16413eb5fec6b3e02fa00dc29a2534f088d3302c47eb59adf9", size = 268076, upload-time = "2026-01-30T01:03:10.957Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/df/533c82a3c752ba13ae7ef238b7f8cdd272cf1475f03c63ac6cf3fcfb00b6/pytokens-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:3f901fe783e06e48e8cbdc82d631fca8f118333798193e026a50ce1b3757ea68", size = 103552, upload-time = "2026-01-30T01:03:12.066Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/dc/08b1a080372afda3cceb4f3c0a7ba2bde9d6a5241f1edb02a22a019ee147/pytokens-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8bdb9d0ce90cbf99c525e75a2fa415144fd570a1ba987380190e8b786bc6ef9b", size = 160720, upload-time = "2026-01-30T01:03:13.843Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0c/41ea22205da480837a700e395507e6a24425151dfb7ead73343d6e2d7ffe/pytokens-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5502408cab1cb18e128570f8d598981c68a50d0cbd7c61312a90507cd3a1276f", size = 254204, upload-time = "2026-01-30T01:03:14.886Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/d2/afe5c7f8607018beb99971489dbb846508f1b8f351fcefc225fcf4b2adc0/pytokens-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29d1d8fb1030af4d231789959f21821ab6325e463f0503a61d204343c9b355d1", size = 268423, upload-time = "2026-01-30T01:03:15.936Z" },
+    { url = "https://files.pythonhosted.org/packages/68/d4/00ffdbd370410c04e9591da9220a68dc1693ef7499173eb3e30d06e05ed1/pytokens-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b08dd6b86058b6dc07efe9e98414f5102974716232d10f32ff39701e841c4", size = 266859, upload-time = "2026-01-30T01:03:17.458Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/c9/c3161313b4ca0c601eeefabd3d3b576edaa9afdefd32da97210700e47652/pytokens-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:9bd7d7f544d362576be74f9d5901a22f317efc20046efe2034dced238cbbfe78", size = 103520, upload-time = "2026-01-30T01:03:18.652Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/a7/b470f672e6fc5fee0a01d9e75005a0e617e162381974213a945fcd274843/pytokens-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4a14d5f5fc78ce85e426aa159489e2d5961acf0e47575e08f35584009178e321", size = 160821, upload-time = "2026-01-30T01:03:19.684Z" },
+    { url = "https://files.pythonhosted.org/packages/80/98/e83a36fe8d170c911f864bfded690d2542bfcfacb9c649d11a9e6eb9dc41/pytokens-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f50fd18543be72da51dd505e2ed20d2228c74e0464e4262e4899797803d7fa", size = 254263, upload-time = "2026-01-30T01:03:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/95/70d7041273890f9f97a24234c00b746e8da86df462620194cef1d411ddeb/pytokens-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc74c035f9bfca0255c1af77ddd2d6ae8419012805453e4b0e7513e17904545d", size = 268071, upload-time = "2026-01-30T01:03:21.888Z" },
+    { url = "https://files.pythonhosted.org/packages/da/79/76e6d09ae19c99404656d7db9c35dfd20f2086f3eb6ecb496b5b31163bad/pytokens-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f66a6bbe741bd431f6d741e617e0f39ec7257ca1f89089593479347cc4d13324", size = 271716, upload-time = "2026-01-30T01:03:23.633Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/482e55fa1602e0a7ff012661d8c946bafdc05e480ea5a32f4f7e336d4aa9/pytokens-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:b35d7e5ad269804f6697727702da3c517bb8a5228afa450ab0fa787732055fc9", size = 104539, upload-time = "2026-01-30T01:03:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e8/20e7db907c23f3d63b0be3b8a4fd1927f6da2395f5bcc7f72242bb963dfe/pytokens-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8fcb9ba3709ff77e77f1c7022ff11d13553f3c30299a9fe246a166903e9091eb", size = 168474, upload-time = "2026-01-30T01:03:26.428Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/81/88a95ee9fafdd8f5f3452107748fd04c24930d500b9aba9738f3ade642cc/pytokens-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79fc6b8699564e1f9b521582c35435f1bd32dd06822322ec44afdeba666d8cb3", size = 290473, upload-time = "2026-01-30T01:03:27.415Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/35/3aa899645e29b6375b4aed9f8d21df219e7c958c4c186b465e42ee0a06bf/pytokens-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d31b97b3de0f61571a124a00ffe9a81fb9939146c122c11060725bd5aea79975", size = 303485, upload-time = "2026-01-30T01:03:28.558Z" },
+    { url = "https://files.pythonhosted.org/packages/52/a0/07907b6ff512674d9b201859f7d212298c44933633c946703a20c25e9d81/pytokens-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:967cf6e3fd4adf7de8fc73cd3043754ae79c36475c1c11d514fc72cf5490094a", size = 306698, upload-time = "2026-01-30T01:03:29.653Z" },
+    { url = "https://files.pythonhosted.org/packages/39/2a/cbbf9250020a4a8dd53ba83a46c097b69e5eb49dd14e708f496f548c6612/pytokens-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:584c80c24b078eec1e227079d56dc22ff755e0ba8654d8383b2c549107528918", size = 116287, upload-time = "2026-01-30T01:03:30.912Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/78/397db326746f0a342855b81216ae1f0a32965deccfd7c830a2dbc66d2483/pytokens-0.4.1-py3-none-any.whl", hash = "sha256:26cef14744a8385f35d0e095dc8b3a7583f6c953c2e3d269c7f82484bf5ad2de", size = 13729, upload-time = "2026-01-30T01:03:45.029Z" },
+]
+
+[[package]]
+name = "pywinpty"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/54/37c7370ba91f579235049dc26cd2c5e657d2a943e01820844ffc81f32176/pywinpty-3.0.3.tar.gz", hash = "sha256:523441dc34d231fb361b4b00f8c99d3f16de02f5005fd544a0183112bcc22412", size = 31309, upload-time = "2026-02-04T21:51:09.524Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/c3/3e75075c7f71735f22b66fab0481f2c98e3a4d58cba55cb50ba29114bcf6/pywinpty-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:dff25a9a6435f527d7c65608a7e62783fc12076e7d44487a4911ee91be5a8ac8", size = 2114430, upload-time = "2026-02-04T21:54:19.485Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/1e/8a54166a8c5e4f5cb516514bdf4090be4d51a71e8d9f6d98c0aa00fe45d4/pywinpty-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:fbc1e230e5b193eef4431cba3f39996a288f9958f9c9f092c8a961d930ee8f68", size = 236191, upload-time = "2026-02-04T21:50:36.239Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/d4/aeb5e1784d2c5bff6e189138a9ca91a090117459cea0c30378e1f2db3d54/pywinpty-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:c9081df0e49ffa86d15db4a6ba61530630e48707f987df42c9d3313537e81fc0", size = 2113098, upload-time = "2026-02-04T21:54:37.711Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/53/7278223c493ccfe4883239cf06c823c56460a8010e0fc778eef67858dc14/pywinpty-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:15e79d870e18b678fb8a5a6105fd38496b55697c66e6fc0378236026bc4d59e9", size = 234901, upload-time = "2026-02-04T21:53:31.35Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/cb/58d6ed3fd429c96a90ef01ac9a617af10a6d41469219c25e7dc162abbb71/pywinpty-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9c91dbb026050c77bdcef964e63a4f10f01a639113c4d3658332614544c467ab", size = 2112686, upload-time = "2026-02-04T21:52:03.035Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/50/724ed5c38c504d4e58a88a072776a1e880d970789deaeb2b9f7bd9a5141a/pywinpty-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:fe1f7911805127c94cf51f89ab14096c6f91ffdcacf993d2da6082b2142a2523", size = 234591, upload-time = "2026-02-04T21:52:29.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ad/90a110538696b12b39fd8758a06d70ded899308198ad2305ac68e361126e/pywinpty-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:3f07a6cf1c1d470d284e614733c3d0f726d2c85e78508ea10a403140c3c0c18a", size = 2112360, upload-time = "2026-02-04T21:55:33.397Z" },
+    { url = "https://files.pythonhosted.org/packages/44/0f/7ffa221757a220402bc79fda44044c3f2cc57338d878ab7d622add6f4581/pywinpty-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:15c7c0b6f8e9d87aabbaff76468dabf6e6121332c40fc1d83548d02a9d6a3759", size = 233107, upload-time = "2026-02-04T21:51:45.455Z" },
+    { url = "https://files.pythonhosted.org/packages/28/88/2ff917caff61e55f38bcdb27de06ee30597881b2cae44fbba7627be015c4/pywinpty-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:d4b6b7b0fe0cdcd02e956bd57cfe9f4e5a06514eecf3b5ae174da4f951b58be9", size = 2113282, upload-time = "2026-02-04T21:52:08.188Z" },
+    { url = "https://files.pythonhosted.org/packages/63/32/40a775343ace542cc43ece3f1d1fce454021521ecac41c4c4573081c2336/pywinpty-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:34789d685fc0d547ce0c8a65e5a70e56f77d732fa6e03c8f74fefb8cbb252019", size = 234207, upload-time = "2026-02-04T21:51:58.687Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/54/5d5e52f4cb75028104ca6faf36c10f9692389b1986d34471663b4ebebd6d/pywinpty-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:0c37e224a47a971d1a6e08649a1714dac4f63c11920780977829ed5c8cadead1", size = 2112910, upload-time = "2026-02-04T21:52:30.976Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/44/dcd184824e21d4620b06c7db9fbb15c3ad0a0f1fa2e6de79969fb82647ec/pywinpty-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:c4e9c3dff7d86ba81937438d5819f19f385a39d8f592d4e8af67148ceb4f6ab5", size = 233425, upload-time = "2026-02-04T21:51:56.754Z" },
+]
+
+[[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/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 = "pyyaml-env-tag"
+version = "1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/2e/79c822141bfd05a853236b504869ebc6b70159afc570e1d5a20641782eaa/pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff", size = 5737, upload-time = "2025-05-13T15:24:01.64Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" },
+]
+
+[[package]]
+name = "pyzmq"
+version = "27.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "implementation_name == 'pypy'" },
+]
+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/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/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 = "rasterio"
+version = "1.4.4"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.12' and sys_platform == 'win32'",
+    "python_full_version < '3.12' and sys_platform == 'emscripten'",
+    "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "affine", marker = "python_full_version < '3.12'" },
+    { name = "attrs", marker = "python_full_version < '3.12'" },
+    { name = "certifi", marker = "python_full_version < '3.12'" },
+    { name = "click", marker = "python_full_version < '3.12'" },
+    { name = "click-plugins", marker = "python_full_version < '3.12'" },
+    { name = "cligj", marker = "python_full_version < '3.12'" },
+    { name = "numpy", marker = "python_full_version < '3.12'" },
+    { name = "pyparsing", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ec/fa/fce8dc9f09e5bc6520b6fc1b4ecfa510af9ca06eb42ad7bdff9c9b8989d0/rasterio-1.4.4.tar.gz", hash = "sha256:c95424e2c7f009b8f7df1095d645c52895cd332c0c2e1b4c2e073ea28b930320", size = 445004, upload-time = "2025-12-12T18:01:08.971Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/0d/d3859e49ab94464de2623fec82c6798d8d7c8bea2473cd2696fc5e09f717/rasterio-1.4.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:b8eea428b5f0c78a963f6003a19b60777df83a0aba8c28231d65431e32ac160e", size = 21144125, upload-time = "2025-12-12T17:58:59.511Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/3c/97ba4b146309cdc0e36f289b02ac69465b026a21afc828e4e4e1dc39466a/rasterio-1.4.4-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:1cc0ea5aa0d22f5f349aa221674481de689b7b3a99607ce6bb58a29e5be54d17", size = 25746406, upload-time = "2025-12-12T17:59:02.902Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/33/75f81bd837ac2336b24456fdb249597a4b9af2a212b7151f64d09022be36/rasterio-1.4.4-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:7eb25b23666b29dadfc49a59206cead62c99190584b61771bba0e95f7da06801", size = 34587242, upload-time = "2025-12-12T17:59:05.848Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/77/3869a426f6e752dde13f3868cdf16253ca0214f92107db79c1583c9aa07b/rasterio-1.4.4-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:e24b7b8c2df801dde2a1dffb44c58902bd76b5cab740dc11de4ff9963992a71a", size = 35881871, upload-time = "2025-12-12T17:59:09.779Z" },
+    { url = "https://files.pythonhosted.org/packages/66/d0/3818859ddbd3750d0ef5a6580a3272e81764286d943c689dd41e49b8b786/rasterio-1.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:0718630f607be2f5742d8e4b34b434746fd788a192d77eefc9bb924399fea802", size = 25716477, upload-time = "2025-12-12T17:59:13.519Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/02/039eb4970c93aaef4c9eb1ee159abad18e6e7f932c2eed575c95f78d94f6/rasterio-1.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:0308ff4762ae9eb40a991f12d758626b59af4376b13675480391dd7295d17bbf", size = 24075993, upload-time = "2025-12-12T17:59:16.407Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/fc/63d89ddfcb4643730553683ee322566b9b15fe56d026e4c21c4f4f5d9d26/rasterio-1.4.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f3c4f0cbd188f893011f2a0a6dc2852b3892799b3a0d79eddf92f2b115ec7ed7", size = 21120715, upload-time = "2025-12-12T17:59:19.35Z" },
+    { url = "https://files.pythonhosted.org/packages/43/70/2c003f76a23dbb078fdee35c8e2ec490d2ad8982f4dc956ba08b56027b87/rasterio-1.4.4-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:6fce26090b9f509eab337228420145947c491a13628965410f25bc3e6e05cf75", size = 25732944, upload-time = "2025-12-12T17:59:22.533Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/cc/4a8e92362c0ff496dd1007c3dcba66e9ededf1a45eca8ad1db302b071c49/rasterio-1.4.4-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:c1c722da390dc264aeccdc0dc200ca37923875d910ca4cd5bec0fec351bb818e", size = 34295209, upload-time = "2025-12-12T17:59:26.035Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/6d/717d2dec47fbefad33ca0d27bd5f0d543b1d1bc9fcab5ef82a13adaaf38d/rasterio-1.4.4-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:98b6dfb8282b2a54b9d75c3dc8d2520a69bbc66916c7d43de8e0bbf6e0240ca1", size = 35661866, upload-time = "2025-12-12T17:59:29.928Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/60/ae3351fba2726ec0976974ce2eb030c159edd3363b8771e832b8db571c24/rasterio-1.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:9513f4c7a6d93b45098f8dff2421fa9516604e3bfbf35aa144484a88d36a321f", size = 25682853, upload-time = "2025-12-12T17:59:35.869Z" },
+    { url = "https://files.pythonhosted.org/packages/38/ee/35387296bbacfc5cbbb4273228b1b959793d3ce38b0402a07f11a248420b/rasterio-1.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:60b49a482e0f12f12ce9d2cc3090add02f89f3d422e85f2cffaa9207adb83c04", size = 24043249, upload-time = "2025-12-12T17:59:39.915Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/fe/e3e37041c49956f4f4cbe473c3fe290aaba96ed20e9c07da304e0cad2015/rasterio-1.4.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:df26c96aa81ffbd0b33189680859211eadf9950123c21579f84de73bb0f91d81", size = 21107336, upload-time = "2025-12-12T17:59:43.585Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/02/c217fdcc8e80a4b7d1b1bc4529d78f98452816e9add53ff8742049a77ae7/rasterio-1.4.4-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:b3af0ecc922a80f3755516629f7948e37bade9077b5f5c12a3869a5e7f01619b", size = 25719929, upload-time = "2025-12-12T17:59:47.64Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/d0/7f177f37bc9595d809dabb0073abd0c42358469f6b10875192b46331c652/rasterio-1.4.4-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:7ce3b0f9a22e95a27790087908753973644d7c3877d495ec9bd6e04a25233ca4", size = 34198845, upload-time = "2025-12-12T17:59:52.405Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/84/66c0d9cca2a09074ec2ce6fffa87709ca51b0d197ae742d835e841bac660/rasterio-1.4.4-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c072450caa96428b1218b030500bb908fd6f09bc013a88969ff81a124b6a112a", size = 35576074, upload-time = "2025-12-12T17:59:56.392Z" },
+    { url = "https://files.pythonhosted.org/packages/32/68/f7df5478458ace2fa50be43e9fab1a39957a0e71afaa3e6147ec289e0fc8/rasterio-1.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:16ee92ef10c0ba89f45f9c2b40fca9f971f357385f04ee9b716fb09cbd9ce20c", size = 25680573, upload-time = "2025-12-12T18:00:00.45Z" },
+    { url = "https://files.pythonhosted.org/packages/34/e5/1bdaccb658430dfd391ad4a63d206546f36639d7e4130bf31f125c6525b4/rasterio-1.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:65c10afe64b5e488185aaff0b659e08eda22c89285b54a3e433b80e6c6621770", size = 24040367, upload-time = "2025-12-12T18:00:04.443Z" },
+    { url = "https://files.pythonhosted.org/packages/32/76/54643a7d1d650fd7f1acea9093c298603e4c01bba6f90be2254310b48507/rasterio-1.4.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:18c2c1130e789dc2771d0aa5ec4b56d5b8a0097c648ccb94882d5ff3ab55c928", size = 21247203, upload-time = "2025-12-12T18:00:07.547Z" },
+    { url = "https://files.pythonhosted.org/packages/76/ef/434b4849ccd6a3e03a0b1ac37c963c1771564945745613d15c5d96ce768d/rasterio-1.4.4-cp313-cp313t-macosx_15_0_x86_64.whl", hash = "sha256:2d1654b7ffa6f3dde42c5fd27159ae45148c11e352de26f12fe7313a3236aeed", size = 25822050, upload-time = "2025-12-12T18:00:11.081Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/fa/fe9a478aa0cde246da58baeb0df3248c7ca174e4d9c9b27e81b504e40a76/rasterio-1.4.4-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c4022cbddb659856e120603b12233cec8913ae760fff220657ce888c3c6b9f9d", size = 34833783, upload-time = "2025-12-12T18:00:14.525Z" },
+    { url = "https://files.pythonhosted.org/packages/04/cd/ed4716590dbcd4b8ae633417d758564e510bee4d6aaac5050a0f6d5179c5/rasterio-1.4.4-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:96b88880551a07b7a3b50439483cefbd9af91a09e19ff2b736815994e5671314", size = 35738114, upload-time = "2025-12-12T18:00:17.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/29/da7050d11ba1d041e0333ac14768e6e9ca1aa2b9fa8416f317d2650ed276/rasterio-1.4.4-cp313-cp313t-win_amd64.whl", hash = "sha256:def75d486d0ab8f306f918a913c425ed57159495518c54efe8e18d5164d37d90", size = 25896835, upload-time = "2025-12-12T18:00:21.411Z" },
+    { url = "https://files.pythonhosted.org/packages/88/80/304dbe5434c4aa8dfaf90480c16d770161796a6a61fa88e72e8a402153df/rasterio-1.4.4-cp313-cp313t-win_arm64.whl", hash = "sha256:770b7e86f6c565e6f9cf30f6fa4479a5a2bab4e10ff44fe7acfd518ca4a71d1b", size = 24128074, upload-time = "2025-12-12T18:00:24.653Z" },
+    { url = "https://files.pythonhosted.org/packages/03/01/d5a3dc51cd5fef62b76ecc77d33c1ca20de305fed7e16c71bcdf4858e466/rasterio-1.4.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:019693f14a83ae9225cb57c16e466901d0e6284962dcf13a9f4bb1175b979011", size = 21120237, upload-time = "2025-12-12T18:00:27.723Z" },
+    { url = "https://files.pythonhosted.org/packages/50/da/db18362602b17327c0e00c9e9c0847c1c4ac657c1a289169ca06a26faccb/rasterio-1.4.4-cp314-cp314-macosx_15_0_x86_64.whl", hash = "sha256:87d7c3e97e3b40c9041d1602e2dcb4fc2d88abe6c645fccb4939dec297a91cf8", size = 25720506, upload-time = "2025-12-12T18:00:30.592Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/8f/a15d66c9c05bffb176c9707ef1f2bfcf9c0b835272937c80ac7207a20b5c/rasterio-1.4.4-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:a2401e4c43a31c7382154d4042b60a63b9bca5886802983c5c9362cdc5b09548", size = 34153931, upload-time = "2025-12-12T18:00:33.852Z" },
+    { url = "https://files.pythonhosted.org/packages/05/2d/cd778286b910db7a3f0bc1743ca362173f1fbb7365137e4982ca857b6d26/rasterio-1.4.4-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6c4287d8934d953f7870b8e2a1df1096fbf47eba39ad0f777a31ea500f4e5010", size = 35421139, upload-time = "2025-12-12T18:00:37.482Z" },
+    { url = "https://files.pythonhosted.org/packages/70/97/13a2e33aede8d7a42178c696a6a93868d1f9560f73de05033a1675f0806a/rasterio-1.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:c3ba1871549221140661227dd4fa1f9a472ded4a6d2f2c2e367b0648bb15b99d", size = 26419132, upload-time = "2025-12-12T18:00:40.871Z" },
+    { url = "https://files.pythonhosted.org/packages/27/d8/2dcfcb362d6a2fd07c14cfb803a345a7926d4d9fb6243e196df105671e97/rasterio-1.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:7c9d7dc824cb8d222808be153643cd4e65ea3e1f66019ada1ccd630221edfe30", size = 24800998, upload-time = "2025-12-12T18:00:45.332Z" },
+    { url = "https://files.pythonhosted.org/packages/13/f8/16e9b648e7f16cadb41df7c0116dbab26b4a2ba02c85cbe3f744065bdf56/rasterio-1.4.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:98e17bded830a59992d9f8f8d9f227ce1c4be0694930afcc4360358f5cb1a5db", size = 21247046, upload-time = "2025-12-12T18:00:49.429Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ea/f3dc3a25d7591821d488f5c5eb89f6abcd1f5c8e2ef4bd2792f965cbc9c8/rasterio-1.4.4-cp314-cp314t-macosx_15_0_x86_64.whl", hash = "sha256:56134ca203f952855e60774b06672033cf65057eb9810fcc5c1a75f1921053a3", size = 25821677, upload-time = "2025-12-12T18:00:52.458Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/d3/1e038350218e852f904c8dc4ab751aa023a2e82e68998767b7b42e33832c/rasterio-1.4.4-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:52edde65515b33fe4314c8a44a9ee2fc00b550deed6d56e1a8d085d42bbca3e6", size = 34829572, upload-time = "2025-12-12T18:00:56.294Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/ce/28abf7a5f5d9cb014c2e14cc396bebe953b3deefbf604d49f4322e73fa35/rasterio-1.4.4-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:d61d3f2c171c64050bd75e54a5d964ff7f165b3f5d2b92c9ee09b9716aa1b8bf", size = 35735171, upload-time = "2025-12-12T18:00:59.531Z" },
+    { url = "https://files.pythonhosted.org/packages/54/91/1ce35cfda2d56dacd6395faf20a5290268bd9009c53393ac42b5f9bb2c4c/rasterio-1.4.4-cp314-cp314t-win_amd64.whl", hash = "sha256:40137fe512c0d6e96c0167a0ae4e56d82c488f244163c45494b7392e51c844de", size = 26700712, upload-time = "2025-12-12T18:01:03.023Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/33/4d13f48a8f01d782ffc1eece20821586518f3f515dca7cf152bca9fd22d4/rasterio-1.4.4-cp314-cp314t-win_arm64.whl", hash = "sha256:29ec3a794454b5bb255c9c0374cc380030a8a1e295c81eee7feb036802d2a9e3", size = 24875933, upload-time = "2025-12-12T18:01:06.134Z" },
+]
+
+[[package]]
+name = "rasterio"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "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.13.*' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.12.*' and sys_platform == 'win32'",
+    "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "affine", marker = "python_full_version >= '3.12'" },
+    { name = "attrs", marker = "python_full_version >= '3.12'" },
+    { name = "certifi", marker = "python_full_version >= '3.12'" },
+    { name = "click", marker = "python_full_version >= '3.12'" },
+    { name = "cligj", marker = "python_full_version >= '3.12'" },
+    { name = "numpy", marker = "python_full_version >= '3.12'" },
+    { name = "pyparsing", marker = "python_full_version >= '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f6/88/edb4b66b6cb2c13f123af5a3896bf70c0cbe73ab3cd4243cb4eb0212a0f6/rasterio-1.5.0.tar.gz", hash = "sha256:1e0ea56b02eea4989b36edf8e58a5a3ef40e1b7edcb04def2603accd5ab3ee7b", size = 452184, upload-time = "2026-01-05T16:06:47.169Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ac/de/ba1cd11d7d1182bfb26e758bf07016d04e5442f4f5fea35b0d7279b72399/rasterio-1.5.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:420656074897a460f5ef46f657b3061d2e004f9d99e613914b0671643e69d92c", size = 22787192, upload-time = "2026-01-05T16:05:19.779Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/42/efaeb6dc531dbcd02fec01c791a853bb5a139a5126ecec579ac0f735eeb9/rasterio-1.5.0-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:c5c3597a783857e760550e8f26365d928b0377ac5ffc3e12ba447ac65ca5406d", size = 24412221, upload-time = "2026-01-05T16:05:22.526Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/14/89645988424c40cbcb8334f94305ffe094dd28d85c643341d9690704c9f0/rasterio-1.5.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:e14d07a09833b6df6024ce7a57aee1e1977b3aec682e30b1e58ce773462f2382", size = 36128020, upload-time = "2026-01-05T16:05:25.556Z" },
+    { url = "https://files.pythonhosted.org/packages/85/23/5a52319a98451ff910f42e5f7f4804bfb39f9327933a89daab685d1ce2dd/rasterio-1.5.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:26dbcffcf0d01fc121cbb92186bc1cb78e16efe62b17be45ad7494446b325cf8", size = 37634010, upload-time = "2026-01-05T16:05:28.673Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d6/fe8826f813c98b046d8d4c3bc83053c89c71f367f89257d211fe5dd0b0ba/rasterio-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:ac8d04eee66ca8060763ead607800e5611d857dd005905d920365e24a16ba20a", size = 30142328, upload-time = "2026-01-05T16:05:31.357Z" },
+    { url = "https://files.pythonhosted.org/packages/af/62/6397379271d5628ed65ef781bf2d3a8f56094a86e6d8479c6ca506a1b960/rasterio-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:31f1edc45c781ebd087e60cc00a4fc37028dd3fe25cff4098e4139fc9d0565be", size = 28500710, upload-time = "2026-01-05T16:05:33.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/87/42865a77cebf2e524d27b6afc71db48984799ecd1dbe6a213d4713f42f5f/rasterio-1.5.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e7b25b0a19975ccd511e507e6de45b0a2d8fb6802abe49bb726cf48588e34833", size = 22776107, upload-time = "2026-01-05T16:05:36.967Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/53/e81683fbbfdf04e019e68b042d9cff8524b0571aa80e4f4d81c373c31a49/rasterio-1.5.0-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:1162c18eaece9f6d2aa1c2ff6b373b99651d93f113f24120a991eaebf28aa4f4", size = 24401477, upload-time = "2026-01-05T16:05:39.702Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/3c/6aa6e0690b18eea02a61739cb362a47c5df66138f0a02cc69e1181b964e5/rasterio-1.5.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:8eb87fd6f843eea109f3df9bef83f741b053b716b0465932276e2c0577dfb929", size = 36018214, upload-time = "2026-01-05T16:05:42.741Z" },
+    { url = "https://files.pythonhosted.org/packages/48/4a/1af9aa9810fb30668568f2c4dd3eec2412c8e9762b69201d971c509b295e/rasterio-1.5.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:08a7580cbb9b3bd320bdf827e10c9b2424d0df066d8eef6f2feb37e154ce0c17", size = 37544972, upload-time = "2026-01-05T16:05:45.815Z" },
+    { url = "https://files.pythonhosted.org/packages/01/62/bfe3408743c9837919ff232474a09ece9eaa88d4ee8c040711fa3dff6dad/rasterio-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:d7d6729c0739b5ec48c33686668a30e27f5bdb361093f180ee7818ff19665547", size = 30140141, upload-time = "2026-01-05T16:05:48.751Z" },
+    { url = "https://files.pythonhosted.org/packages/63/ca/e90e19a6d065a718cc3d468a12b9f015289ad17017656dea8c76f7318d1f/rasterio-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:8af7c368c22f0a99d1259ccc5a5cd96c432c2bde6f132c1ac78508cd7445a745", size = 28498556, upload-time = "2026-01-05T16:05:51.334Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/ba/e37462d8c33bbbd6c152a0390ec6911a3d9614ded3d2bc6f6a48e147e833/rasterio-1.5.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:b4ccfcc8ed9400e4f14efdf2005533fcf72048748b727f85ff89b9291ecdf98a", size = 22920107, upload-time = "2026-01-05T16:05:53.773Z" },
+    { url = "https://files.pythonhosted.org/packages/66/dc/7bfa9cf96ac39b451b2f94dfc584c223ec584c52c148df2e4bab60c3341b/rasterio-1.5.0-cp313-cp313t-macosx_15_0_x86_64.whl", hash = "sha256:2f57c36ca4d3c896f7024226bd71eeb5cd10c8183c2a94508534d78cc05ff9e7", size = 24508993, upload-time = "2026-01-05T16:05:57.062Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/55/7293743f3b69de4b726c67b8dc9da01fc194070b6becc51add4ca8a20a27/rasterio-1.5.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cc1395475e4bb7032cd81dda4d5558061c4c7d5a50b1b5e146bdf9716d0b9353", size = 36565784, upload-time = "2026-01-05T16:06:00.019Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/ef/5354c47de16c6e289728c3a3d6961ffcf7a9ad6313aef7e8db5d6a40c46e/rasterio-1.5.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:592a485e2057b1aaeab4f843c9897628e60e3ff45e2509325c3e1479116599cb", size = 37686456, upload-time = "2026-01-05T16:06:02.772Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fc/fe1f034b1acd1900d9fbd616826d001a3d5811f1d0c97c785f88f525853e/rasterio-1.5.0-cp313-cp313t-win_amd64.whl", hash = "sha256:0c739e70a72fb080f039ee1570c5d02b974dde32ded1a3216e1f13fe38ac4844", size = 30355842, upload-time = "2026-01-05T16:06:06.359Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/cb/4dee9697891c9c6474b240d00e27688e03ecd882d3c83cc97eb25c2266ff/rasterio-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:a3539a2f401a7b4b2e94ff2db334878c0e15a2d1c9fe90bb0879c52f89367ae5", size = 28589538, upload-time = "2026-01-05T16:06:09.662Z" },
+    { url = "https://files.pythonhosted.org/packages/77/9f/f84dfa54110c1c82f9f4fd929465d12519569b6f5d015273aa0957013b2e/rasterio-1.5.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:597be8df418d5ba7b6a927b6b9febfcb42b192882448a8d5b2e2e75a1296631f", size = 22788832, upload-time = "2026-01-05T16:06:12.247Z" },
+    { url = "https://files.pythonhosted.org/packages/20/f1/de55255c918b17afd7292f793a3500c4aea7e9530b2b3f5b3a57836c7d49/rasterio-1.5.0-cp314-cp314-macosx_15_0_x86_64.whl", hash = "sha256:dd292030d39d685c0b35eddef233e7f1cb8b43052578a3ec97a2da57799693be", size = 24405917, upload-time = "2026-01-05T16:06:14.603Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/57/054087a9d5011ad5dfa799277ba8814e41775e1967d37a59ab7b8e2f1876/rasterio-1.5.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:62c3f97a3c72643c74f2d0f310621a09c35c0c412229c327ae6bcc1ee4b9c3bc", size = 35987536, upload-time = "2026-01-05T16:06:17.707Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/72/5fbe5f67ae75d7e89ffb718c500d5fecbaa84f6ba354db306de689faf961/rasterio-1.5.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:19577f0f0c5f1158af47b57f73356961cbd1782a5f6ae6f3adf6f2650f4eb369", size = 37408048, upload-time = "2026-01-05T16:06:20.82Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/3e/0c4ef19980204bdcbc8f9e084056adebc97916ff4edcc718750ef34e5bf9/rasterio-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:015c1ab6e5453312c5e29692752e7ad73568fe4d13567cbd448d7893128cbd2d", size = 30949590, upload-time = "2026-01-05T16:06:23.425Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/d8/2e6b81505408926c00e629d7d3d73fd0454213201bd9907450e0fe82f3dd/rasterio-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:ff677c0a9d3ba667c067227ef2b76872488b37ff29b061bc3e576fad9baa3286", size = 29337287, upload-time = "2026-01-05T16:06:26.599Z" },
+    { url = "https://files.pythonhosted.org/packages/19/49/7b6e6afb28d4e3f69f2229f990ed87dfdc21a3e15ca63b96b2fd9ba17d89/rasterio-1.5.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:508251b9c746d8d008771a30c2160ff321bfc3b41f6a1aa8e8ef1dd4a00d97ba", size = 22926149, upload-time = "2026-01-05T16:06:29.617Z" },
+    { url = "https://files.pythonhosted.org/packages/24/30/19345d8bc7d2b96c1172594026b9009702e9ab9f0baf07079d3612aaadae/rasterio-1.5.0-cp314-cp314t-macosx_15_0_x86_64.whl", hash = "sha256:742841ed48bc70f6ef517b8fa3521f231780bf408fde0aa6d73770337a36374e", size = 24516040, upload-time = "2026-01-05T16:06:32.964Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/43/dc7a4518fa78904bc41952cbf346c3c2a88a20e61b479154058392914c0b/rasterio-1.5.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c9a9eee49ce9410c2f352b34c370bb3a96bb518b6a7f97b3a72ee4c835fd4b5c", size = 36589519, upload-time = "2026-01-05T16:06:35.922Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/f2/8f706083c6c163054d12c7ed6d5ac4e4ed02252b761288d74e6158871b34/rasterio-1.5.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:b9fd87a0b63ab5c6267dfb0bc96f54fdf49d000651b9ee85ed37798141cff046", size = 37714599, upload-time = "2026-01-05T16:06:38.818Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/d5/bbca726d5fea5864f7e4bcf3ee893095369e93ad51120495e8c40e2aa1a0/rasterio-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f459db8953ba30ca04fcef2b5e1260eeeff0eae8158bd9c3d6adbe56289765cc", size = 31233931, upload-time = "2026-01-05T16:06:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/d1/8b017856e63ccaff3cbd0e82490dbb01363a42f3a462a41b1d8a391e1443/rasterio-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:f4b9c2c3b5f10469eb9588f105086e68f0279e62cc9095c4edd245e3f9b88c8a", size = 29418321, upload-time = "2026-01-05T16:06:44.758Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+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.33.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/64/8860370b167a9721e8956ae116825caff829224fbca0ca6e7bf8ddef8430/requests-2.33.0.tar.gz", hash = "sha256:c7ebc5e8b0f21837386ad0e1c8fe8b829fa5f544d8df3b2253bff14ef29d7652", size = 134232, upload-time = "2026-03-25T15:10:41.586Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/5d/c814546c2333ceea4ba42262d8c4d55763003e767fa169adc693bd524478/requests-2.33.0-py3-none-any.whl", hash = "sha256:3324635456fa185245e24865e810cecec7b4caf933d7eb133dcde67d48cee69b", size = 65017, upload-time = "2026-03-25T15:10:40.382Z" },
+]
+
+[[package]]
+name = "requests-oauthlib"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "oauthlib" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/f2/05f29bc3913aea15eb670be136045bf5c5bbf4b99ecb839da9b422bb2c85/requests-oauthlib-2.0.0.tar.gz", hash = "sha256:b3dffaebd884d8cd778494369603a9e7b58d29111bf6b41bdc2dcd87203af4e9", size = 55650, upload-time = "2024-03-22T20:32:29.939Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/5d/63d4ae3b9daea098d5d6f5da83984853c1bbacd5dc826764b249fe119d24/requests_oauthlib-2.0.0-py2.py3-none-any.whl", hash = "sha256:7dd8a5c40426b779b0868c404bdef9768deccf22749cde15852df527e6269b36", size = 24179, upload-time = "2024-03-22T20:32:28.055Z" },
+]
+
+[[package]]
+name = "rfc3339-validator"
+version = "0.1.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" },
+]
+
+[[package]]
+name = "rfc3986-validator"
+version = "0.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" },
+]
+
+[[package]]
+name = "rfc3987-syntax"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lark" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" },
+]
+
+[[package]]
+name = "rio-cogeo"
+version = "7.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "morecantile" },
+    { name = "pydantic" },
+    { name = "rasterio", version = "1.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "rasterio", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4a/01/3b88154233db4cb29cc54df64006537fadb8d7c2ace872af985dac972fd3/rio_cogeo-7.0.2.tar.gz", hash = "sha256:1454ff94dca8652db68862d667bf47e54ecabfe8872c939f2c16ebb62d432f69", size = 19282, upload-time = "2026-03-27T08:25:27.554Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/da/835b573b1a8ba0fcdb3fa6c26fee0c8fa7549f79cf882894ea2238f19f1c/rio_cogeo-7.0.2-py3-none-any.whl", hash = "sha256:1426faea08ae0970707d3534119164d99969ee15181b06d94c5f84645f82537f", size = 21827, upload-time = "2026-03-27T08:25:26.18Z" },
+]
+
+[[package]]
+name = "rio-stac"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pystac" },
+    { name = "rasterio", version = "1.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "rasterio", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/32/fdb3dc918fdb3d4385190e47950f6accb82a6c75dca5d6e939f83234070d/rio_stac-0.12.0.tar.gz", hash = "sha256:02cf7ff4e2228752277cfd08cca26d4f4f7253ded3b49fb1db3ea207050d7cda", size = 13972, upload-time = "2025-09-17T08:35:05.526Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/57/3c/0219fc20bd63ebce3ad4ea4cc4764d31aa2ad94677cd3b0fa660f40c77da/rio_stac-0.12.0-py3-none-any.whl", hash = "sha256:4453281c30a3a644f45fd71281b49a48aa8bc29daa185a50854ce1822df9a8a3", size = 11765, upload-time = "2025-09-17T08:35:04.451Z" },
+]
+
+[[package]]
+name = "rio-tiler"
+version = "9.0.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cachetools" },
+    { name = "color-operations" },
+    { name = "httpx" },
+    { name = "morecantile" },
+    { name = "numexpr" },
+    { name = "numpy" },
+    { name = "pydantic" },
+    { name = "pystac" },
+    { name = "rasterio", version = "1.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "rasterio", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ca/d7/6a1e16f0bd5608c24a93be830d760437f6a0b4673e13a45e4bbe1b9dfd47/rio_tiler-9.0.4.tar.gz", hash = "sha256:5769e533f07c6d8cafafe84614b4fc9086cfefb7265eeda7849f0f927d299c2a", size = 190915, upload-time = "2026-03-24T17:12:20.39Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/03/7812700200411866c02ce1e4e06ff3c7c7ee78eebfa838a76cba9b026e73/rio_tiler-9.0.4-py3-none-any.whl", hash = "sha256:4877844d5fd339496d94cd130737376403b09aa33563bf21aa048925f7b49dd1", size = 287499, upload-time = "2026-03-24T17:12:18.336Z" },
+]
+
+[[package]]
+name = "rioxarray"
+version = "0.19.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.12' and sys_platform == 'win32'",
+    "python_full_version < '3.12' and sys_platform == 'emscripten'",
+    "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "numpy", marker = "python_full_version < '3.12'" },
+    { name = "packaging", marker = "python_full_version < '3.12'" },
+    { name = "pyproj", marker = "python_full_version < '3.12'" },
+    { name = "rasterio", version = "1.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "xarray", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/8e/fe4e87460f8c62d8d5c683e09f19fbde5d9cfcfd0342d02df1f452999b5d/rioxarray-0.19.0.tar.gz", hash = "sha256:7819a0036fd874c8c8e280447cbbe43d8dc72fc4a14ac7852a665b1bdb7d4b04", size = 54600, upload-time = "2025-04-21T17:46:54.183Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/2f/63d2cacc0e525f8e3398bcf32bd3620385f22cd1600834ec49d7f3597a7b/rioxarray-0.19.0-py3-none-any.whl", hash = "sha256:494ee4fff1781072d55ee5276f5d07b63d93b05093cb33b926a12186ba5bb8ef", size = 62151, upload-time = "2025-04-21T17:46:52.801Z" },
+]
+
+[[package]]
+name = "rioxarray"
+version = "0.22.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "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.13.*' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.12.*' and sys_platform == 'win32'",
+    "python_full_version == '3.12.*' and sys_platform == 'emscripten'",
+    "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+dependencies = [
+    { name = "numpy", marker = "python_full_version >= '3.12'" },
+    { name = "packaging", marker = "python_full_version >= '3.12'" },
+    { name = "pyproj", marker = "python_full_version >= '3.12'" },
+    { name = "rasterio", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "xarray", marker = "python_full_version >= '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4b/04/9e43477ab0fce7c4c949e1131bfae55ec5228da4ba30f55760660db224b2/rioxarray-0.22.0.tar.gz", hash = "sha256:3f55f23a632ffd9eff13463634227f4afbbcf298947536e161f6cf2ce88d4373", size = 61337, upload-time = "2026-03-06T17:11:00.16Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/dd/0b2c68495331ba36af783139baaa94693ef310d484d458c11dfa1357287d/rioxarray-0.22.0-py3-none-any.whl", hash = "sha256:db0aa55cd36a95060968f2e6574107829def29d43a563560b90bc642d0bd6a3b", size = 72018, upload-time = "2026-03-06T17:10:58.965Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+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/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 = "s3fs"
+version = "2026.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiobotocore" },
+    { name = "aiohttp" },
+    { name = "fsspec" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0b/93/093972862fb9c2fdc24ecf8d6d2212853df1945eddf26ba2625e8eaeee66/s3fs-2026.3.0.tar.gz", hash = "sha256:ce8b30a9dc5e01c5127c96cb7377290243a689a251ef9257336ac29d72d7b0d8", size = 85986, upload-time = "2026-03-27T19:28:20.963Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/52/5ccdc01f7a8a61357d15a66b5d8a6580aa8529cb33f32e6cbb71c52622c5/s3fs-2026.3.0-py3-none-any.whl", hash = "sha256:2fa40a64c03003cfa5ae0e352788d97aa78ae8f9e25ea98b28ce9d21ba10c1b8", size = 32399, upload-time = "2026-03-27T19:28:19.702Z" },
+]
+
+[[package]]
+name = "s3transfer"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/04/74127fc843314818edfa81b5540e26dd537353b123a4edc563109d8f17dd/s3transfer-0.16.0.tar.gz", hash = "sha256:8e990f13268025792229cd52fa10cb7163744bf56e719e0b9cb925ab79abf920", size = 153827, upload-time = "2025-12-01T02:30:59.114Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/51/727abb13f44c1fcf6d145979e1535a35794db0f6e450a0cb46aa24732fe2/s3transfer-0.16.0-py3-none-any.whl", hash = "sha256:18e25d66fed509e3868dc1572b3f427ff947dd2c56f844a5bf09481ad3f3b2fe", size = 86830, upload-time = "2025-12-01T02:30:57.729Z" },
+]
+
+[[package]]
+name = "send2trash"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", hash = "sha256:1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459", size = 17255, upload-time = "2026-01-14T06:27:36.056Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" },
+]
+
+[[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 = "shapely"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/8d/1ff672dea9ec6a7b5d422eb6d095ed886e2e523733329f75fdcb14ee1149/shapely-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:91121757b0a36c9aac3427a651a7e6567110a4a67c97edf04f8d55d4765f6618", size = 1820038, upload-time = "2025-09-24T13:50:15.628Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/ce/28fab8c772ce5db23a0d86bf0adaee0c4c79d5ad1db766055fa3dab442e2/shapely-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:16a9c722ba774cf50b5d4541242b4cce05aafd44a015290c82ba8a16931ff63d", size = 1626039, upload-time = "2025-09-24T13:50:16.881Z" },
+    { url = "https://files.pythonhosted.org/packages/70/8b/868b7e3f4982f5006e9395c1e12343c66a8155c0374fdc07c0e6a1ab547d/shapely-2.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cc4f7397459b12c0b196c9efe1f9d7e92463cbba142632b4cc6d8bbbbd3e2b09", size = 3001519, upload-time = "2025-09-24T13:50:18.606Z" },
+    { url = "https://files.pythonhosted.org/packages/13/02/58b0b8d9c17c93ab6340edd8b7308c0c5a5b81f94ce65705819b7416dba5/shapely-2.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:136ab87b17e733e22f0961504d05e77e7be8c9b5a8184f685b4a91a84efe3c26", size = 3110842, upload-time = "2025-09-24T13:50:21.77Z" },
+    { url = "https://files.pythonhosted.org/packages/af/61/8e389c97994d5f331dcffb25e2fa761aeedfb52b3ad9bcdd7b8671f4810a/shapely-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:16c5d0fc45d3aa0a69074979f4f1928ca2734fb2e0dde8af9611e134e46774e7", size = 4021316, upload-time = "2025-09-24T13:50:23.626Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/d4/9b2a9fe6039f9e42ccf2cb3e84f219fd8364b0c3b8e7bbc857b5fbe9c14c/shapely-2.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6ddc759f72b5b2b0f54a7e7cde44acef680a55019eb52ac63a7af2cf17cb9cd2", size = 4178586, upload-time = "2025-09-24T13:50:25.443Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f6/9840f6963ed4decf76b08fd6d7fed14f8779fb7a62cb45c5617fa8ac6eab/shapely-2.1.2-cp311-cp311-win32.whl", hash = "sha256:2fa78b49485391224755a856ed3b3bd91c8455f6121fee0db0e71cefb07d0ef6", size = 1543961, upload-time = "2025-09-24T13:50:26.968Z" },
+    { url = "https://files.pythonhosted.org/packages/38/1e/3f8ea46353c2a33c1669eb7327f9665103aa3a8dfe7f2e4ef714c210b2c2/shapely-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:c64d5c97b2f47e3cd9b712eaced3b061f2b71234b3fc263e0fcf7d889c6559dc", size = 1722856, upload-time = "2025-09-24T13:50:28.497Z" },
+    { url = "https://files.pythonhosted.org/packages/24/c0/f3b6453cf2dfa99adc0ba6675f9aaff9e526d2224cbd7ff9c1a879238693/shapely-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe2533caae6a91a543dec62e8360fe86ffcdc42a7c55f9dfd0128a977a896b94", size = 1833550, upload-time = "2025-09-24T13:50:30.019Z" },
+    { url = "https://files.pythonhosted.org/packages/86/07/59dee0bc4b913b7ab59ab1086225baca5b8f19865e6101db9ebb7243e132/shapely-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ba4d1333cc0bc94381d6d4308d2e4e008e0bd128bdcff5573199742ee3634359", size = 1643556, upload-time = "2025-09-24T13:50:32.291Z" },
+    { url = "https://files.pythonhosted.org/packages/26/29/a5397e75b435b9895cd53e165083faed5d12fd9626eadec15a83a2411f0f/shapely-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3", size = 2988308, upload-time = "2025-09-24T13:50:33.862Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b", size = 3099844, upload-time = "2025-09-24T13:50:35.459Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/f3/9876b64d4a5a321b9dc482c92bb6f061f2fa42131cba643c699f39317cb9/shapely-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e9eddfe513096a71896441a7c37db72da0687b34752c4e193577a145c71736fc", size = 3988842, upload-time = "2025-09-24T13:50:37.478Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a0/704c7292f7014c7e74ec84eddb7b109e1fbae74a16deae9c1504b1d15565/shapely-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:980c777c612514c0cf99bc8a9de6d286f5e186dcaf9091252fcd444e5638193d", size = 4152714, upload-time = "2025-09-24T13:50:39.9Z" },
+    { url = "https://files.pythonhosted.org/packages/53/46/319c9dc788884ad0785242543cdffac0e6530e4d0deb6c4862bc4143dcf3/shapely-2.1.2-cp312-cp312-win32.whl", hash = "sha256:9111274b88e4d7b54a95218e243282709b330ef52b7b86bc6aaf4f805306f454", size = 1542745, upload-time = "2025-09-24T13:50:41.414Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/bf/cb6c1c505cb31e818e900b9312d514f381fbfa5c4363edfce0fcc4f8c1a4/shapely-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:743044b4cfb34f9a67205cee9279feaf60ba7d02e69febc2afc609047cb49179", size = 1722861, upload-time = "2025-09-24T13:50:43.35Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/90/98ef257c23c46425dc4d1d31005ad7c8d649fe423a38b917db02c30f1f5a/shapely-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b510dda1a3672d6879beb319bc7c5fd302c6c354584690973c838f46ec3e0fa8", size = 1832644, upload-time = "2025-09-24T13:50:44.886Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/ab/0bee5a830d209adcd3a01f2d4b70e587cdd9fd7380d5198c064091005af8/shapely-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8cff473e81017594d20ec55d86b54bc635544897e13a7cfc12e36909c5309a2a", size = 1642887, upload-time = "2025-09-24T13:50:46.735Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/5e/7d7f54ba960c13302584c73704d8c4d15404a51024631adb60b126a4ae88/shapely-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe7b77dc63d707c09726b7908f575fc04ff1d1ad0f3fb92aec212396bc6cfe5e", size = 2970931, upload-time = "2025-09-24T13:50:48.374Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/a2/83fc37e2a58090e3d2ff79175a95493c664bcd0b653dd75cb9134645a4e5/shapely-2.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ed1a5bbfb386ee8332713bf7508bc24e32d24b74fc9a7b9f8529a55db9f4ee6", size = 3082855, upload-time = "2025-09-24T13:50:50.037Z" },
+    { url = "https://files.pythonhosted.org/packages/44/2b/578faf235a5b09f16b5f02833c53822294d7f21b242f8e2d0cf03fb64321/shapely-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a84e0582858d841d54355246ddfcbd1fce3179f185da7470f41ce39d001ee1af", size = 3979960, upload-time = "2025-09-24T13:50:51.74Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/04/167f096386120f692cc4ca02f75a17b961858997a95e67a3cb6a7bbd6b53/shapely-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc3487447a43d42adcdf52d7ac73804f2312cbfa5d433a7d2c506dcab0033dfd", size = 4142851, upload-time = "2025-09-24T13:50:53.49Z" },
+    { url = "https://files.pythonhosted.org/packages/48/74/fb402c5a6235d1c65a97348b48cdedb75fb19eca2b1d66d04969fc1c6091/shapely-2.1.2-cp313-cp313-win32.whl", hash = "sha256:9c3a3c648aedc9f99c09263b39f2d8252f199cb3ac154fadc173283d7d111350", size = 1541890, upload-time = "2025-09-24T13:50:55.337Z" },
+    { url = "https://files.pythonhosted.org/packages/41/47/3647fe7ad990af60ad98b889657a976042c9988c2807cf322a9d6685f462/shapely-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:ca2591bff6645c216695bdf1614fca9c82ea1144d4a7591a466fef64f28f0715", size = 1722151, upload-time = "2025-09-24T13:50:57.153Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/49/63953754faa51ffe7d8189bfbe9ca34def29f8c0e34c67cbe2a2795f269d/shapely-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2d93d23bdd2ed9dc157b46bc2f19b7da143ca8714464249bef6771c679d5ff40", size = 1834130, upload-time = "2025-09-24T13:50:58.49Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/ee/dce001c1984052970ff60eb4727164892fb2d08052c575042a47f5a9e88f/shapely-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01d0d304b25634d60bd7cf291828119ab55a3bab87dc4af1e44b07fb225f188b", size = 1642802, upload-time = "2025-09-24T13:50:59.871Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e7/fc4e9a19929522877fa602f705706b96e78376afb7fad09cad5b9af1553c/shapely-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8d8382dd120d64b03698b7298b89611a6ea6f55ada9d39942838b79c9bc89801", size = 3018460, upload-time = "2025-09-24T13:51:02.08Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/18/7519a25db21847b525696883ddc8e6a0ecaa36159ea88e0fef11466384d0/shapely-2.1.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19efa3611eef966e776183e338b2d7ea43569ae99ab34f8d17c2c054d3205cc0", size = 3095223, upload-time = "2025-09-24T13:51:04.472Z" },
+    { url = "https://files.pythonhosted.org/packages/48/de/b59a620b1f3a129c3fecc2737104a0a7e04e79335bd3b0a1f1609744cf17/shapely-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:346ec0c1a0fcd32f57f00e4134d1200e14bf3f5ae12af87ba83ca275c502498c", size = 4030760, upload-time = "2025-09-24T13:51:06.455Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b3/c6655ee7232b417562bae192ae0d3ceaadb1cc0ffc2088a2ddf415456cc2/shapely-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6305993a35989391bd3476ee538a5c9a845861462327efe00dd11a5c8c709a99", size = 4170078, upload-time = "2025-09-24T13:51:08.584Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/8e/605c76808d73503c9333af8f6cbe7e1354d2d238bda5f88eea36bfe0f42a/shapely-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:c8876673449f3401f278c86eb33224c5764582f72b653a415d0e6672fde887bf", size = 1559178, upload-time = "2025-09-24T13:51:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/36/f7/d317eb232352a1f1444d11002d477e54514a4a6045536d49d0c59783c0da/shapely-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:4a44bc62a10d84c11a7a3d7c1c4fe857f7477c3506e24c9062da0db0ae0c449c", size = 1739756, upload-time = "2025-09-24T13:51:12.105Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/c4/3ce4c2d9b6aabd27d26ec988f08cb877ba9e6e96086eff81bfea93e688c7/shapely-2.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:9a522f460d28e2bf4e12396240a5fc1518788b2fcd73535166d748399ef0c223", size = 1831290, upload-time = "2025-09-24T13:51:13.56Z" },
+    { url = "https://files.pythonhosted.org/packages/17/b9/f6ab8918fc15429f79cb04afa9f9913546212d7fb5e5196132a2af46676b/shapely-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ff629e00818033b8d71139565527ced7d776c269a49bd78c9df84e8f852190c", size = 1641463, upload-time = "2025-09-24T13:51:14.972Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/57/91d59ae525ca641e7ac5551c04c9503aee6f29b92b392f31790fcb1a4358/shapely-2.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f67b34271dedc3c653eba4e3d7111aa421d5be9b4c4c7d38d30907f796cb30df", size = 2970145, upload-time = "2025-09-24T13:51:16.961Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cb/4948be52ee1da6927831ab59e10d4c29baa2a714f599f1f0d1bc747f5777/shapely-2.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21952dc00df38a2c28375659b07a3979d22641aeb104751e769c3ee825aadecf", size = 3073806, upload-time = "2025-09-24T13:51:18.712Z" },
+    { url = "https://files.pythonhosted.org/packages/03/83/f768a54af775eb41ef2e7bec8a0a0dbe7d2431c3e78c0a8bdba7ab17e446/shapely-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1f2f33f486777456586948e333a56ae21f35ae273be99255a191f5c1fa302eb4", size = 3980803, upload-time = "2025-09-24T13:51:20.37Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/cb/559c7c195807c91c79d38a1f6901384a2878a76fbdf3f1048893a9b7534d/shapely-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cf831a13e0d5a7eb519e96f58ec26e049b1fad411fc6fc23b162a7ce04d9cffc", size = 4133301, upload-time = "2025-09-24T13:51:21.887Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cd/60d5ae203241c53ef3abd2ef27c6800e21afd6c94e39db5315ea0cbafb4a/shapely-2.1.2-cp314-cp314-win32.whl", hash = "sha256:61edcd8d0d17dd99075d320a1dd39c0cb9616f7572f10ef91b4b5b00c4aeb566", size = 1583247, upload-time = "2025-09-24T13:51:23.401Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d4/135684f342e909330e50d31d441ace06bf83c7dc0777e11043f99167b123/shapely-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:a444e7afccdb0999e203b976adb37ea633725333e5b119ad40b1ca291ecf311c", size = 1773019, upload-time = "2025-09-24T13:51:24.873Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/05/a44f3f9f695fa3ada22786dc9da33c933da1cbc4bfe876fe3a100bafe263/shapely-2.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:5ebe3f84c6112ad3d4632b1fd2290665aa75d4cef5f6c5d77c4c95b324527c6a", size = 1834137, upload-time = "2025-09-24T13:51:26.665Z" },
+    { url = "https://files.pythonhosted.org/packages/52/7e/4d57db45bf314573427b0a70dfca15d912d108e6023f623947fa69f39b72/shapely-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5860eb9f00a1d49ebb14e881f5caf6c2cf472c7fd38bd7f253bbd34f934eb076", size = 1642884, upload-time = "2025-09-24T13:51:28.029Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/27/4e29c0a55d6d14ad7422bf86995d7ff3f54af0eba59617eb95caf84b9680/shapely-2.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b705c99c76695702656327b819c9660768ec33f5ce01fa32b2af62b56ba400a1", size = 3018320, upload-time = "2025-09-24T13:51:29.903Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/bb/992e6a3c463f4d29d4cd6ab8963b75b1b1040199edbd72beada4af46bde5/shapely-2.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a1fd0ea855b2cf7c9cddaf25543e914dd75af9de08785f20ca3085f2c9ca60b0", size = 3094931, upload-time = "2025-09-24T13:51:32.699Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/16/82e65e21070e473f0ed6451224ed9fa0be85033d17e0c6e7213a12f59d12/shapely-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:df90e2db118c3671a0754f38e36802db75fe0920d211a27481daf50a711fdf26", size = 4030406, upload-time = "2025-09-24T13:51:34.189Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/75/c24ed871c576d7e2b64b04b1fe3d075157f6eb54e59670d3f5ffb36e25c7/shapely-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:361b6d45030b4ac64ddd0a26046906c8202eb60d0f9f53085f5179f1d23021a0", size = 4169511, upload-time = "2025-09-24T13:51:36.297Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f7/b3d1d6d18ebf55236eec1c681ce5e665742aab3c0b7b232720a7d43df7b6/shapely-2.1.2-cp314-cp314t-win32.whl", hash = "sha256:b54df60f1fbdecc8ebc2c5b11870461a6417b3d617f555e5033f1505d36e5735", size = 1602607, upload-time = "2025-09-24T13:51:37.757Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/f6/f09272a71976dfc138129b8faf435d064a811ae2f708cb147dccdf7aacdb/shapely-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:0036ac886e0923417932c2e6369b6c52e38e0ff5d9120b90eef5cd9a5fc5cae9", size = 1796682, upload-time = "2025-09-24T13:51:39.233Z" },
+]
+
+[[package]]
+name = "simplejson"
+version = "3.20.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/f4/a1ac5ed32f7ed9a088d62a59d410d4c204b3b3815722e2ccfb491fa8251b/simplejson-3.20.2.tar.gz", hash = "sha256:5fe7a6ce14d1c300d80d08695b7f7e633de6cd72c80644021874d985b3393649", size = 85784, upload-time = "2025-09-26T16:29:36.64Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/3e/96898c6c66d9dca3f9bd14d7487bf783b4acc77471b42f979babbb68d4ca/simplejson-3.20.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:06190b33cd7849efc413a5738d3da00b90e4a5382fd3d584c841ac20fb828c6f", size = 92633, upload-time = "2025-09-26T16:27:45.028Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/a2/cd2e10b880368305d89dd540685b8bdcc136df2b3c76b5ddd72596254539/simplejson-3.20.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4ad4eac7d858947a30d2c404e61f16b84d16be79eb6fb316341885bdde864fa8", size = 75309, upload-time = "2025-09-26T16:27:46.142Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/02/290f7282eaa6ebe945d35c47e6534348af97472446951dce0d144e013f4c/simplejson-3.20.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b392e11c6165d4a0fde41754a0e13e1d88a5ad782b245a973dd4b2bdb4e5076a", size = 75308, upload-time = "2025-09-26T16:27:47.542Z" },
+    { url = "https://files.pythonhosted.org/packages/43/91/43695f17b69e70c4b0b03247aa47fb3989d338a70c4b726bbdc2da184160/simplejson-3.20.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51eccc4e353eed3c50e0ea2326173acdc05e58f0c110405920b989d481287e51", size = 143733, upload-time = "2025-09-26T16:27:48.673Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/4b/fdcaf444ac1c3cbf1c52bf00320c499e1cf05d373a58a3731ae627ba5e2d/simplejson-3.20.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:306e83d7c331ad833d2d43c76a67f476c4b80c4a13334f6e34bb110e6105b3bd", size = 153397, upload-time = "2025-09-26T16:27:49.89Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/83/21550f81a50cd03599f048a2d588ffb7f4c4d8064ae091511e8e5848eeaa/simplejson-3.20.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f820a6ac2ef0bc338ae4963f4f82ccebdb0824fe9caf6d660670c578abe01013", size = 141654, upload-time = "2025-09-26T16:27:51.168Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/54/d76c0e72ad02450a3e723b65b04f49001d0e73218ef6a220b158a64639cb/simplejson-3.20.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21e7a066528a5451433eb3418184f05682ea0493d14e9aae690499b7e1eb6b81", size = 144913, upload-time = "2025-09-26T16:27:52.331Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/49/976f59b42a6956d4aeb075ada16ad64448a985704bc69cd427a2245ce835/simplejson-3.20.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:438680ddde57ea87161a4824e8de04387b328ad51cfdf1eaf723623a3014b7aa", size = 144568, upload-time = "2025-09-26T16:27:53.41Z" },
+    { url = "https://files.pythonhosted.org/packages/60/c7/30bae30424ace8cd791ca660fed454ed9479233810fe25c3f3eab3d9dc7b/simplejson-3.20.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:cac78470ae68b8d8c41b6fca97f5bf8e024ca80d5878c7724e024540f5cdaadb", size = 146239, upload-time = "2025-09-26T16:27:54.502Z" },
+    { url = "https://files.pythonhosted.org/packages/79/3e/7f3b7b97351c53746e7b996fcd106986cda1954ab556fd665314756618d2/simplejson-3.20.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:7524e19c2da5ef281860a3d74668050c6986be15c9dd99966034ba47c68828c2", size = 154497, upload-time = "2025-09-26T16:27:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/48/7241daa91d0bf19126589f6a8dcbe8287f4ed3d734e76fd4a092708947be/simplejson-3.20.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e9b6d845a603b2eef3394eb5e21edb8626cd9ae9a8361d14e267eb969dbe413", size = 148069, upload-time = "2025-09-26T16:27:57.039Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/f4/ef18d2962fe53e7be5123d3784e623859eec7ed97060c9c8536c69d34836/simplejson-3.20.2-cp311-cp311-win32.whl", hash = "sha256:47d8927e5ac927fdd34c99cc617938abb3624b06ff86e8e219740a86507eb961", size = 74158, upload-time = "2025-09-26T16:27:58.265Z" },
+    { url = "https://files.pythonhosted.org/packages/35/fd/3d1158ecdc573fdad81bf3cc78df04522bf3959758bba6597ba4c956c74d/simplejson-3.20.2-cp311-cp311-win_amd64.whl", hash = "sha256:ba4edf3be8e97e4713d06c3d302cba1ff5c49d16e9d24c209884ac1b8455520c", size = 75911, upload-time = "2025-09-26T16:27:59.292Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/9e/1a91e7614db0416885eab4136d49b7303de20528860ffdd798ce04d054db/simplejson-3.20.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4376d5acae0d1e91e78baeba4ee3cf22fbf6509d81539d01b94e0951d28ec2b6", size = 93523, upload-time = "2025-09-26T16:28:00.356Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2b/d2413f5218fc25608739e3d63fe321dfa85c5f097aa6648dbe72513a5f12/simplejson-3.20.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f8fe6de652fcddae6dec8f281cc1e77e4e8f3575249e1800090aab48f73b4259", size = 75844, upload-time = "2025-09-26T16:28:01.756Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/f1/efd09efcc1e26629e120fef59be059ce7841cc6e1f949a4db94f1ae8a918/simplejson-3.20.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25ca2663d99328d51e5a138f22018e54c9162438d831e26cfc3458688616eca8", size = 75655, upload-time = "2025-09-26T16:28:03.037Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ec/5c6db08e42f380f005d03944be1af1a6bd501cc641175429a1cbe7fb23b9/simplejson-3.20.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:12a6b2816b6cab6c3fd273d43b1948bc9acf708272074c8858f579c394f4cbc9", size = 150335, upload-time = "2025-09-26T16:28:05.027Z" },
+    { url = "https://files.pythonhosted.org/packages/81/f5/808a907485876a9242ec67054da7cbebefe0ee1522ef1c0be3bfc90f96f6/simplejson-3.20.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac20dc3fcdfc7b8415bfc3d7d51beccd8695c3f4acb7f74e3a3b538e76672868", size = 158519, upload-time = "2025-09-26T16:28:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/66/af/b8a158246834645ea890c36136584b0cc1c0e4b83a73b11ebd9c2a12877c/simplejson-3.20.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:db0804d04564e70862ef807f3e1ace2cc212ef0e22deb1b3d6f80c45e5882c6b", size = 148571, upload-time = "2025-09-26T16:28:07.715Z" },
+    { url = "https://files.pythonhosted.org/packages/20/05/ed9b2571bbf38f1a2425391f18e3ac11cb1e91482c22d644a1640dea9da7/simplejson-3.20.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:979ce23ea663895ae39106946ef3d78527822d918a136dbc77b9e2b7f006237e", size = 152367, upload-time = "2025-09-26T16:28:08.921Z" },
+    { url = "https://files.pythonhosted.org/packages/81/2c/bad68b05dd43e93f77994b920505634d31ed239418eb6a88997d06599983/simplejson-3.20.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a2ba921b047bb029805726800819675249ef25d2f65fd0edb90639c5b1c3033c", size = 150205, upload-time = "2025-09-26T16:28:10.086Z" },
+    { url = "https://files.pythonhosted.org/packages/69/46/90c7fc878061adafcf298ce60cecdee17a027486e9dce507e87396d68255/simplejson-3.20.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:12d3d4dc33770069b780cc8f5abef909fe4a3f071f18f55f6d896a370fd0f970", size = 151823, upload-time = "2025-09-26T16:28:11.329Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/27/b85b03349f825ae0f5d4f780cdde0bbccd4f06c3d8433f6a3882df887481/simplejson-3.20.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aff032a59a201b3683a34be1169e71ddda683d9c3b43b261599c12055349251e", size = 158997, upload-time = "2025-09-26T16:28:12.917Z" },
+    { url = "https://files.pythonhosted.org/packages/71/ad/d7f3c331fb930638420ac6d236db68e9f4c28dab9c03164c3cd0e7967e15/simplejson-3.20.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:30e590e133b06773f0dc9c3f82e567463df40598b660b5adf53eb1c488202544", size = 154367, upload-time = "2025-09-26T16:28:14.393Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/46/5c67324addd40fa2966f6e886cacbbe0407c03a500db94fb8bb40333fcdf/simplejson-3.20.2-cp312-cp312-win32.whl", hash = "sha256:8d7be7c99939cc58e7c5bcf6bb52a842a58e6c65e1e9cdd2a94b697b24cddb54", size = 74285, upload-time = "2025-09-26T16:28:15.931Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c9/5cc2189f4acd3a6e30ffa9775bf09b354302dbebab713ca914d7134d0f29/simplejson-3.20.2-cp312-cp312-win_amd64.whl", hash = "sha256:2c0b4a67e75b945489052af6590e7dca0ed473ead5d0f3aad61fa584afe814ab", size = 75969, upload-time = "2025-09-26T16:28:17.017Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/9e/f326d43f6bf47f4e7704a4426c36e044c6bedfd24e072fb8e27589a373a5/simplejson-3.20.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:90d311ba8fcd733a3677e0be21804827226a57144130ba01c3c6a325e887dd86", size = 93530, upload-time = "2025-09-26T16:28:18.07Z" },
+    { url = "https://files.pythonhosted.org/packages/35/28/5a4b8f3483fbfb68f3f460bc002cef3a5735ef30950e7c4adce9c8da15c7/simplejson-3.20.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:feed6806f614bdf7f5cb6d0123cb0c1c5f40407ef103aa935cffaa694e2e0c74", size = 75846, upload-time = "2025-09-26T16:28:19.12Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/4d/30dfef83b9ac48afae1cf1ab19c2867e27b8d22b5d9f8ca7ce5a0a157d8c/simplejson-3.20.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6b1d8d7c3e1a205c49e1aee6ba907dcb8ccea83651e6c3e2cb2062f1e52b0726", size = 75661, upload-time = "2025-09-26T16:28:20.219Z" },
+    { url = "https://files.pythonhosted.org/packages/09/1d/171009bd35c7099d72ef6afd4bb13527bab469965c968a17d69a203d62a6/simplejson-3.20.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:552f55745044a24c3cb7ec67e54234be56d5d6d0e054f2e4cf4fb3e297429be5", size = 150579, upload-time = "2025-09-26T16:28:21.337Z" },
+    { url = "https://files.pythonhosted.org/packages/61/ae/229bbcf90a702adc6bfa476e9f0a37e21d8c58e1059043038797cbe75b8c/simplejson-3.20.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c2da97ac65165d66b0570c9e545786f0ac7b5de5854d3711a16cacbcaa8c472d", size = 158797, upload-time = "2025-09-26T16:28:22.53Z" },
+    { url = "https://files.pythonhosted.org/packages/90/c5/fefc0ac6b86b9108e302e0af1cf57518f46da0baedd60a12170791d56959/simplejson-3.20.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f59a12966daa356bf68927fca5a67bebac0033cd18b96de9c2d426cd11756cd0", size = 148851, upload-time = "2025-09-26T16:28:23.733Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f1/b392952200f3393bb06fbc4dd975fc63a6843261705839355560b7264eb2/simplejson-3.20.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:133ae2098a8e162c71da97cdab1f383afdd91373b7ff5fe65169b04167da976b", size = 152598, upload-time = "2025-09-26T16:28:24.962Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/b4/d6b7279e52a3e9c0fa8c032ce6164e593e8d9cf390698ee981ed0864291b/simplejson-3.20.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7977640af7b7d5e6a852d26622057d428706a550f7f5083e7c4dd010a84d941f", size = 150498, upload-time = "2025-09-26T16:28:26.114Z" },
+    { url = "https://files.pythonhosted.org/packages/62/22/ec2490dd859224326d10c2fac1353e8ad5c84121be4837a6dd6638ba4345/simplejson-3.20.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b530ad6d55e71fa9e93e1109cf8182f427a6355848a4ffa09f69cc44e1512522", size = 152129, upload-time = "2025-09-26T16:28:27.552Z" },
+    { url = "https://files.pythonhosted.org/packages/33/ce/b60214d013e93dd9e5a705dcb2b88b6c72bada442a97f79828332217f3eb/simplejson-3.20.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bd96a7d981bf64f0e42345584768da4435c05b24fd3c364663f5fbc8fabf82e3", size = 159359, upload-time = "2025-09-26T16:28:28.667Z" },
+    { url = "https://files.pythonhosted.org/packages/99/21/603709455827cdf5b9d83abe726343f542491ca8dc6a2528eb08de0cf034/simplejson-3.20.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f28ee755fadb426ba2e464d6fcf25d3f152a05eb6b38e0b4f790352f5540c769", size = 154717, upload-time = "2025-09-26T16:28:30.288Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f9/dc7f7a4bac16cf7eb55a4df03ad93190e11826d2a8950052949d3dfc11e2/simplejson-3.20.2-cp313-cp313-win32.whl", hash = "sha256:472785b52e48e3eed9b78b95e26a256f59bb1ee38339be3075dad799e2e1e661", size = 74289, upload-time = "2025-09-26T16:28:31.809Z" },
+    { url = "https://files.pythonhosted.org/packages/87/10/d42ad61230436735c68af1120622b28a782877146a83d714da7b6a2a1c4e/simplejson-3.20.2-cp313-cp313-win_amd64.whl", hash = "sha256:a1a85013eb33e4820286139540accbe2c98d2da894b2dcefd280209db508e608", size = 75972, upload-time = "2025-09-26T16:28:32.883Z" },
+    { url = "https://files.pythonhosted.org/packages/05/5b/83e1ff87eb60ca706972f7e02e15c0b33396e7bdbd080069a5d1b53cf0d8/simplejson-3.20.2-py3-none-any.whl", hash = "sha256:3b6bb7fb96efd673eac2e4235200bfffdc2353ad12c54117e1e4e2fc485ac017", size = 57309, upload-time = "2025-09-26T16:29:35.312Z" },
+]
+
+[[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 = "soupsieve"
+version = "2.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/ae/2d9c981590ed9999a0d91755b47fc74f74de286b0f5cee14c9269041e6c4/soupsieve-2.8.3.tar.gz", hash = "sha256:3267f1eeea4251fb42728b6dfb746edc9acaffc4a45b27e19450b676586e8349", size = 118627, upload-time = "2026-01-20T04:27:02.457Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl", hash = "sha256:ed64f2ba4eebeab06cc4962affce381647455978ffc1e36bb79a545b91f45a95", size = 37016, upload-time = "2026-01-20T04:27:01.012Z" },
+]
+
+[[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 = "starlette"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
+]
+
+[[package]]
+name = "starlette-cramjam"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cramjam" },
+    { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6e/f8/ffcc61b1448f9ecb00134a27bdae2e156c2180fdf5f8de765657d9e1bcf1/starlette_cramjam-0.5.1.tar.gz", hash = "sha256:538fe9fad7a58af97ac32517fb0981d9462490cbaf332f73648005dd0a14eaef", size = 8038, upload-time = "2025-10-27T13:33:03.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/48/c8/3ad3cc9e2c431234fb940f31486f7ce3ebf3fe248d6d50a1e338ed2ecccf/starlette_cramjam-0.5.1-py3-none-any.whl", hash = "sha256:d3488b5648c7b3263c6b7d0f41d7856af6d6566c0cbd851f165838db0692c324", size = 7458, upload-time = "2025-10-27T13:33:02.902Z" },
+]
+
+[[package]]
+name = "supermorecado"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "morecantile" },
+    { name = "rasterio", version = "1.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "rasterio", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7e/cc/97693e7c34e56a9f3c869ff10a962e14d38c48b2c56436f0483ee77c3cc4/supermorecado-0.1.2.tar.gz", hash = "sha256:b51664d2eb12326e657a9d80c6849857c42ef3876545515ef988e266e6cc9654", size = 12171, upload-time = "2023-09-11T14:40:15.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/25/909292b8a012282d3b535e51c2626095f0ff0cfea796da637b34512fb9f6/supermorecado-0.1.2-py3-none-any.whl", hash = "sha256:5116b9ff8c8aa0b0da235cb5962449dc878515c8155adf1440268c3cf271bed6", size = 14486, upload-time = "2023-09-11T14:40:13.349Z" },
+]
+
+[[package]]
+name = "terminado"
+version = "0.18.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ptyprocess", marker = "os_name != 'nt'" },
+    { name = "pywinpty", marker = "os_name == 'nt'" },
+    { name = "tornado" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" },
+]
+
+[[package]]
+name = "tinycss2"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "webencodings" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" },
+]
+
+[[package]]
+name = "titiler"
+version = "2.0.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "titiler-application" },
+    { name = "titiler-core" },
+    { name = "titiler-extensions" },
+    { name = "titiler-mosaic", extra = ["mosaicjson"] },
+    { name = "titiler-xarray" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "aiohttp" },
+    { name = "boto3" },
+    { name = "brotlipy" },
+    { name = "folium" },
+    { name = "fsspec" },
+    { name = "h5netcdf" },
+    { name = "h5py" },
+    { name = "httpx" },
+    { name = "ipython", version = "9.10.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "ipython", version = "9.12.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "jupyter" },
+    { name = "matplotlib" },
+    { name = "obstore" },
+    { name = "owslib" },
+    { name = "pre-commit" },
+    { name = "pystac", extra = ["validation"] },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "requests" },
+    { name = "s3fs" },
+    { name = "zarr" },
+]
+docs = [
+    { name = "black" },
+    { name = "griffe-inherited-docstrings" },
+    { name = "mkdocs" },
+    { name = "mkdocs-jupyter" },
+    { name = "mkdocs-material", extra = ["imaging"] },
+    { name = "mkdocstrings", extra = ["python"] },
+]
+server = [
+    { name = "uvicorn" },
+]
+telemetry = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp" },
+    { name = "opentelemetry-instrumentation-fastapi" },
+    { name = "opentelemetry-instrumentation-logging" },
+    { name = "opentelemetry-sdk" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "titiler-application", editable = "src/titiler/application" },
+    { name = "titiler-core", editable = "src/titiler/core" },
+    { name = "titiler-extensions", editable = "src/titiler/extensions" },
+    { name = "titiler-mosaic", extras = ["mosaicjson"], editable = "src/titiler/mosaic" },
+    { name = "titiler-xarray", editable = "src/titiler/xarray" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "aiohttp" },
+    { name = "boto3" },
+    { name = "brotlipy" },
+    { name = "folium" },
+    { name = "fsspec" },
+    { name = "h5netcdf" },
+    { name = "h5py" },
+    { name = "httpx" },
+    { name = "ipython" },
+    { name = "jupyter" },
+    { name = "matplotlib" },
+    { name = "obstore" },
+    { name = "owslib" },
+    { name = "pre-commit" },
+    { name = "pystac", extras = ["validation"], specifier = ">=1.0.0,<2.0.0" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "requests" },
+    { name = "s3fs", specifier = ">=2025.2.0" },
+    { name = "zarr", specifier = ">=3,<4.0" },
+]
+docs = [
+    { name = "black", specifier = ">=23.10.1" },
+    { name = "griffe-inherited-docstrings", specifier = ">=1.0.0" },
+    { name = "mkdocs", specifier = ">=1.4.3" },
+    { name = "mkdocs-jupyter", specifier = ">=0.24.5" },
+    { name = "mkdocs-material", extras = ["imaging"], specifier = ">=9.5" },
+    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.25.1" },
+]
+server = [{ name = "uvicorn" }]
+telemetry = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp" },
+    { name = "opentelemetry-instrumentation-fastapi" },
+    { name = "opentelemetry-instrumentation-logging" },
+    { name = "opentelemetry-sdk" },
+]
+
+[[package]]
+name = "titiler-application"
+source = { editable = "src/titiler/application" }
+dependencies = [
+    { name = "pydantic-settings" },
+    { name = "starlette-cramjam" },
+    { name = "titiler-core", extra = ["telemetry"] },
+    { name = "titiler-extensions", extra = ["cogeo", "stac"] },
+    { name = "titiler-mosaic", extra = ["mosaicjson"] },
+    { name = "titiler-xarray" },
+]
+
+[package.optional-dependencies]
+server = [
+    { name = "uvicorn", extra = ["standard"] },
+]
+
+[package.dev-dependencies]
+test = [
+    { name = "boto3" },
+    { name = "brotlipy" },
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "pydantic-settings", specifier = "~=2.0" },
+    { name = "starlette-cramjam", specifier = ">=0.4,<0.6" },
+    { name = "titiler-core", extras = ["telemetry"], editable = "src/titiler/core" },
+    { name = "titiler-extensions", extras = ["cogeo", "stac"], editable = "src/titiler/extensions" },
+    { name = "titiler-mosaic", extras = ["mosaicjson"], editable = "src/titiler/mosaic" },
+    { name = "titiler-xarray", editable = "src/titiler/xarray" },
+    { name = "uvicorn", extras = ["standard"], marker = "extra == 'server'", specifier = ">=0.12.0" },
+]
+provides-extras = ["server"]
+
+[package.metadata.requires-dev]
+test = [
+    { name = "boto3" },
+    { name = "brotlipy" },
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+]
+
+[[package]]
+name = "titiler-core"
+source = { editable = "src/titiler/core" }
+dependencies = [
+    { name = "fastapi" },
+    { name = "geojson-pydantic" },
+    { name = "jinja2" },
+    { name = "morecantile" },
+    { name = "numpy" },
+    { name = "pydantic" },
+    { name = "rasterio", version = "1.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "rasterio", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "rio-tiler" },
+    { name = "simplejson" },
+]
+
+[package.optional-dependencies]
+telemetry = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp" },
+    { name = "opentelemetry-instrumentation-fastapi" },
+    { name = "opentelemetry-instrumentation-logging" },
+    { name = "opentelemetry-sdk" },
+]
+
+[package.dev-dependencies]
+test = [
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastapi", specifier = ">=0.108.0" },
+    { name = "geojson-pydantic", specifier = ">=1.1.2,<3.0" },
+    { name = "jinja2", specifier = ">=2.11.2,<4.0.0" },
+    { name = "morecantile" },
+    { name = "numpy" },
+    { name = "opentelemetry-api", marker = "extra == 'telemetry'" },
+    { name = "opentelemetry-exporter-otlp", marker = "extra == 'telemetry'" },
+    { name = "opentelemetry-instrumentation-fastapi", marker = "extra == 'telemetry'" },
+    { name = "opentelemetry-instrumentation-logging", marker = "extra == 'telemetry'" },
+    { name = "opentelemetry-sdk", marker = "extra == 'telemetry'" },
+    { name = "pydantic", specifier = "~=2.0" },
+    { name = "rasterio" },
+    { name = "rio-tiler", specifier = ">=9.0,<10.0" },
+    { name = "simplejson" },
+]
+provides-extras = ["telemetry"]
+
+[package.metadata.requires-dev]
+test = [
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+]
+
+[[package]]
+name = "titiler-extensions"
+source = { editable = "src/titiler/extensions" }
+dependencies = [
+    { name = "titiler-core" },
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+]
+
+[package.optional-dependencies]
+cogeo = [
+    { name = "rio-cogeo" },
+]
+stac = [
+    { name = "rio-stac" },
+]
+
+[package.dev-dependencies]
+test = [
+    { name = "httpx" },
+    { name = "owslib" },
+    { name = "pystac", extra = ["validation"] },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "rio-cogeo", marker = "extra == 'cogeo'", specifier = ">=7.0,<8.0" },
+    { name = "rio-stac", marker = "extra == 'stac'", specifier = ">=0.12,<0.13" },
+    { name = "titiler-core", editable = "src/titiler/core" },
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+]
+provides-extras = ["cogeo", "stac"]
+
+[package.metadata.requires-dev]
+test = [
+    { name = "httpx" },
+    { name = "owslib" },
+    { name = "pystac", extras = ["validation"], specifier = ">=1.0.0,<2.0.0" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+]
+
+[[package]]
+name = "titiler-mosaic"
+source = { editable = "src/titiler/mosaic" }
+dependencies = [
+    { name = "titiler-core" },
+]
+
+[package.optional-dependencies]
+mosaicjson = [
+    { name = "cogeo-mosaic" },
+]
+
+[package.dev-dependencies]
+test = [
+    { name = "httpx" },
+    { name = "owslib" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "cogeo-mosaic", marker = "extra == 'mosaicjson'", specifier = ">=9.0,<10.0" },
+    { name = "titiler-core", editable = "src/titiler/core" },
+]
+provides-extras = ["mosaicjson"]
+
+[package.metadata.requires-dev]
+test = [
+    { name = "httpx" },
+    { name = "owslib" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+]
+
+[[package]]
+name = "titiler-xarray"
+source = { editable = "src/titiler/xarray" }
+dependencies = [
+    { name = "obstore" },
+    { name = "rioxarray", version = "0.19.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "rioxarray", version = "0.22.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "titiler-core" },
+    { name = "xarray" },
+    { name = "zarr" },
+]
+
+[package.optional-dependencies]
+fs = [
+    { name = "aiohttp" },
+    { name = "fsspec" },
+    { name = "gcsfs" },
+    { name = "h5netcdf" },
+    { name = "h5py" },
+    { name = "requests" },
+    { name = "s3fs" },
+]
+telemetry = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp" },
+    { name = "opentelemetry-instrumentation-fastapi" },
+    { name = "opentelemetry-instrumentation-logging" },
+    { name = "opentelemetry-sdk" },
+]
+
+[package.dev-dependencies]
+test = [
+    { name = "aiohttp" },
+    { name = "fsspec" },
+    { name = "h5netcdf" },
+    { name = "h5py" },
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "requests" },
+    { name = "s3fs" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "aiohttp", marker = "extra == 'fs'" },
+    { name = "fsspec", marker = "extra == 'fs'" },
+    { name = "gcsfs", marker = "extra == 'fs'" },
+    { name = "h5netcdf", marker = "extra == 'fs'" },
+    { name = "h5py", marker = "extra == 'fs'" },
+    { name = "obstore" },
+    { name = "opentelemetry-api", marker = "extra == 'telemetry'" },
+    { name = "opentelemetry-exporter-otlp", marker = "extra == 'telemetry'" },
+    { name = "opentelemetry-instrumentation-fastapi", marker = "extra == 'telemetry'" },
+    { name = "opentelemetry-instrumentation-logging", marker = "extra == 'telemetry'" },
+    { name = "opentelemetry-sdk", marker = "extra == 'telemetry'" },
+    { name = "requests", marker = "extra == 'fs'" },
+    { name = "rioxarray" },
+    { name = "s3fs", marker = "extra == 'fs'", specifier = ">=2025.2.0" },
+    { name = "titiler-core", editable = "src/titiler/core" },
+    { name = "xarray" },
+    { name = "zarr", specifier = ">=3.1,<4.0" },
+]
+provides-extras = ["fs", "telemetry"]
+
+[package.metadata.requires-dev]
+test = [
+    { name = "aiohttp" },
+    { name = "fsspec" },
+    { name = "h5netcdf" },
+    { name = "h5py" },
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "requests" },
+    { name = "s3fs" },
+]
+
+[[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 = "tornado"
+version = "6.5.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/f1/3173dfa4a18db4a9b03e5d55325559dab51ee653763bb8745a75af491286/tornado-6.5.5.tar.gz", hash = "sha256:192b8f3ea91bd7f1f50c06955416ed76c6b72f96779b962f07f911b91e8d30e9", size = 516006, upload-time = "2026-03-10T21:31:02.067Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/8c/77f5097695f4dd8255ecbd08b2a1ed8ba8b953d337804dd7080f199e12bf/tornado-6.5.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:487dc9cc380e29f58c7ab88f9e27cdeef04b2140862e5076a66fb6bb68bb1bfa", size = 445983, upload-time = "2026-03-10T21:30:44.28Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/5e/7625b76cd10f98f1516c36ce0346de62061156352353ef2da44e5c21523c/tornado-6.5.5-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:65a7f1d46d4bb41df1ac99f5fcb685fb25c7e61613742d5108b010975a9a6521", size = 444246, upload-time = "2026-03-10T21:30:46.571Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/04/7b5705d5b3c0fab088f434f9c83edac1573830ca49ccf29fb83bf7178eec/tornado-6.5.5-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e74c92e8e65086b338fd56333fb9a68b9f6f2fe7ad532645a290a464bcf46be5", size = 447229, upload-time = "2026-03-10T21:30:48.273Z" },
+    { url = "https://files.pythonhosted.org/packages/34/01/74e034a30ef59afb4097ef8659515e96a39d910b712a89af76f5e4e1f93c/tornado-6.5.5-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:435319e9e340276428bbdb4e7fa732c2d399386d1de5686cb331ec8eee754f07", size = 448192, upload-time = "2026-03-10T21:30:51.22Z" },
+    { url = "https://files.pythonhosted.org/packages/be/00/fe9e02c5a96429fce1a1d15a517f5d8444f9c412e0bb9eadfbe3b0fc55bf/tornado-6.5.5-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3f54aa540bdbfee7b9eb268ead60e7d199de5021facd276819c193c0fb28ea4e", size = 448039, upload-time = "2026-03-10T21:30:53.52Z" },
+    { url = "https://files.pythonhosted.org/packages/82/9e/656ee4cec0398b1d18d0f1eb6372c41c6b889722641d84948351ae19556d/tornado-6.5.5-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36abed1754faeb80fbd6e64db2758091e1320f6bba74a4cf8c09cd18ccce8aca", size = 447445, upload-time = "2026-03-10T21:30:55.541Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/76/4921c00511f88af86a33de770d64141170f1cfd9c00311aea689949e274e/tornado-6.5.5-cp39-abi3-win32.whl", hash = "sha256:dd3eafaaeec1c7f2f8fdcd5f964e8907ad788fe8a5a32c4426fbbdda621223b7", size = 448582, upload-time = "2026-03-10T21:30:57.142Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/23/f6c6112a04d28eed765e374435fb1a9198f73e1ec4b4024184f21faeb1ad/tornado-6.5.5-cp39-abi3-win_amd64.whl", hash = "sha256:6443a794ba961a9f619b1ae926a2e900ac20c34483eea67be4ed8f1e58d3ef7b", size = 448990, upload-time = "2026-03-10T21:30:58.857Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/c8/876602cbc96469911f0939f703453c1157b0c826ecb05bdd32e023397d4e/tornado-6.5.5-cp39-abi3-win_arm64.whl", hash = "sha256:2c9a876e094109333f888539ddb2de4361743e5d21eece20688e3e351e4990a6", size = 448016, upload-time = "2026-03-10T21:31:00.43Z" },
+]
+
+[[package]]
+name = "traitlets"
+version = "5.14.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" },
+]
+
+[[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 = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2025.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" },
+]
+
+[[package]]
+name = "uri-template"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.42.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e3/ad/4a96c425be6fb67e0621e62d86c402b4a17ab2be7f7c055d9bd2f638b9e2/uvicorn-0.42.0.tar.gz", hash = "sha256:9b1f190ce15a2dd22e7758651d9b6d12df09a13d51ba5bf4fc33c383a48e1775", size = 85393, upload-time = "2026-03-16T06:19:50.077Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/89/f8827ccff89c1586027a105e5630ff6139a64da2515e24dafe860bd9ae4d/uvicorn-0.42.0-py3-none-any.whl", hash = "sha256:96c30f5c7abe6f74ae8900a70e92b85ad6613b745d4879eb9b16ccad15645359", size = 68830, upload-time = "2026-03-16T06:19:48.325Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "httptools" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" },
+    { name = "watchfiles" },
+    { name = "websockets" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/d5/69900f7883235562f1f50d8184bb7dd84a2fb61e9ec63f3782546fdbd057/uvloop-0.22.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c60ebcd36f7b240b30788554b6f0782454826a0ed765d8430652621b5de674b9", size = 1352420, upload-time = "2025-10-16T22:16:21.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/73/c4e271b3bce59724e291465cc936c37758886a4868787da0278b3b56b905/uvloop-0.22.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b7f102bf3cb1995cfeaee9321105e8f5da76fdb104cdad8986f85461a1b7b77", size = 748677, upload-time = "2025-10-16T22:16:22.558Z" },
+    { url = "https://files.pythonhosted.org/packages/86/94/9fb7fad2f824d25f8ecac0d70b94d0d48107ad5ece03769a9c543444f78a/uvloop-0.22.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53c85520781d84a4b8b230e24a5af5b0778efdb39142b424990ff1ef7c48ba21", size = 3753819, upload-time = "2025-10-16T22:16:23.903Z" },
+    { url = "https://files.pythonhosted.org/packages/74/4f/256aca690709e9b008b7108bc85fba619a2bc37c6d80743d18abad16ee09/uvloop-0.22.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56a2d1fae65fd82197cb8c53c367310b3eabe1bbb9fb5a04d28e3e3520e4f702", size = 3804529, upload-time = "2025-10-16T22:16:25.246Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/74/03c05ae4737e871923d21a76fe28b6aad57f5c03b6e6bfcfa5ad616013e4/uvloop-0.22.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40631b049d5972c6755b06d0bfe8233b1bd9a8a6392d9d1c45c10b6f9e9b2733", size = 3621267, upload-time = "2025-10-16T22:16:26.819Z" },
+    { url = "https://files.pythonhosted.org/packages/75/be/f8e590fe61d18b4a92070905497aec4c0e64ae1761498cad09023f3f4b3e/uvloop-0.22.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:535cc37b3a04f6cd2c1ef65fa1d370c9a35b6695df735fcff5427323f2cd5473", size = 3723105, upload-time = "2025-10-16T22:16:28.252Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "21.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+    { name = "python-discovery" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/92/58199fe10049f9703c2666e809c4f686c54ef0a68b0f6afccf518c0b1eb9/virtualenv-21.2.0.tar.gz", hash = "sha256:1720dc3a62ef5b443092e3f499228599045d7fea4c79199770499df8becf9098", size = 5840618, upload-time = "2026-03-09T17:24:38.013Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/59/7d02447a55b2e55755011a647479041bc92a82e143f96a8195cb33bd0a1c/virtualenv-21.2.0-py3-none-any.whl", hash = "sha256:1bd755b504931164a5a496d217c014d098426cddc79363ad66ac78125f9d908f", size = 5825084, upload-time = "2026-03-09T17:24:35.378Z" },
+]
+
+[[package]]
+name = "watchdog"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393, upload-time = "2024-11-01T14:06:31.756Z" },
+    { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392, upload-time = "2024-11-01T14:06:32.99Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019, upload-time = "2024-11-01T14:06:34.963Z" },
+    { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471, upload-time = "2024-11-01T14:06:37.745Z" },
+    { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449, upload-time = "2024-11-01T14:06:39.748Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054, upload-time = "2024-11-01T14:06:41.009Z" },
+    { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload-time = "2024-11-01T14:06:42.952Z" },
+    { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload-time = "2024-11-01T14:06:45.084Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload-time = "2024-11-01T14:06:47.324Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload-time = "2024-11-01T14:07:03.893Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload-time = "2024-11-01T14:07:05.189Z" },
+    { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload-time = "2024-11-01T14:07:06.376Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload-time = "2024-11-01T14:07:07.547Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload-time = "2024-11-01T14:07:09.525Z" },
+    { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload-time = "2024-11-01T14:07:10.686Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/f8/2c5f479fb531ce2f0564eda479faecf253d886b1ab3630a39b7bf7362d46/watchfiles-1.1.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f57b396167a2565a4e8b5e56a5a1c537571733992b226f4f1197d79e94cf0ae5", size = 406529, upload-time = "2025-10-14T15:04:32.899Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cd/f515660b1f32f65df671ddf6f85bfaca621aee177712874dc30a97397977/watchfiles-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:421e29339983e1bebc281fab40d812742268ad057db4aee8c4d2bce0af43b741", size = 394384, upload-time = "2025-10-14T15:04:33.761Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/c3/28b7dc99733eab43fca2d10f55c86e03bd6ab11ca31b802abac26b23d161/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e43d39a741e972bab5d8100b5cdacf69db64e34eb19b6e9af162bccf63c5cc6", size = 448789, upload-time = "2025-10-14T15:04:34.679Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/24/33e71113b320030011c8e4316ccca04194bf0cbbaeee207f00cbc7d6b9f5/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f537afb3276d12814082a2e9b242bdcf416c2e8fd9f799a737990a1dbe906e5b", size = 460521, upload-time = "2025-10-14T15:04:35.963Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/c3/3c9a55f255aa57b91579ae9e98c88704955fa9dac3e5614fb378291155df/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2cd9e04277e756a2e2d2543d65d1e2166d6fd4c9b183f8808634fda23f17b14", size = 488722, upload-time = "2025-10-14T15:04:37.091Z" },
+    { url = "https://files.pythonhosted.org/packages/49/36/506447b73eb46c120169dc1717fe2eff07c234bb3232a7200b5f5bd816e9/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3f58818dc0b07f7d9aa7fe9eb1037aecb9700e63e1f6acfed13e9fef648f5d", size = 596088, upload-time = "2025-10-14T15:04:38.39Z" },
+    { url = "https://files.pythonhosted.org/packages/82/ab/5f39e752a9838ec4d52e9b87c1e80f1ee3ccdbe92e183c15b6577ab9de16/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb9f66367023ae783551042d31b1d7fd422e8289eedd91f26754a66f44d5cff", size = 472923, upload-time = "2025-10-14T15:04:39.666Z" },
+    { url = "https://files.pythonhosted.org/packages/af/b9/a419292f05e302dea372fa7e6fda5178a92998411f8581b9830d28fb9edb/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebfd0861a83e6c3d1110b78ad54704486555246e542be3e2bb94195eabb2606", size = 456080, upload-time = "2025-10-14T15:04:40.643Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/c3/d5932fd62bde1a30c36e10c409dc5d54506726f08cb3e1d8d0ba5e2bc8db/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5fac835b4ab3c6487b5dbad78c4b3724e26bcc468e886f8ba8cc4306f68f6701", size = 629432, upload-time = "2025-10-14T15:04:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/77/16bddd9779fafb795f1a94319dc965209c5641db5bf1edbbccace6d1b3c0/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:399600947b170270e80134ac854e21b3ccdefa11a9529a3decc1327088180f10", size = 623046, upload-time = "2025-10-14T15:04:42.718Z" },
+    { url = "https://files.pythonhosted.org/packages/46/ef/f2ecb9a0f342b4bfad13a2787155c6ee7ce792140eac63a34676a2feeef2/watchfiles-1.1.1-cp311-cp311-win32.whl", hash = "sha256:de6da501c883f58ad50db3a32ad397b09ad29865b5f26f64c24d3e3281685849", size = 271473, upload-time = "2025-10-14T15:04:43.624Z" },
+    { url = "https://files.pythonhosted.org/packages/94/bc/f42d71125f19731ea435c3948cad148d31a64fccde3867e5ba4edee901f9/watchfiles-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:35c53bd62a0b885bf653ebf6b700d1bf05debb78ad9292cf2a942b23513dc4c4", size = 287598, upload-time = "2025-10-14T15:04:44.516Z" },
+    { url = "https://files.pythonhosted.org/packages/57/c9/a30f897351f95bbbfb6abcadafbaca711ce1162f4db95fc908c98a9165f3/watchfiles-1.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:57ca5281a8b5e27593cb7d82c2ac927ad88a96ed406aa446f6344e4328208e9e", size = 277210, upload-time = "2025-10-14T15:04:45.883Z" },
+    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" },
+    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" },
+    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" },
+    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" },
+    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" },
+    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" },
+    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" },
+    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" },
+    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" },
+    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" },
+    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" },
+    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" },
+    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" },
+    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8e/e500f8b0b77be4ff753ac94dc06b33d8f0d839377fee1b78e8c8d8f031bf/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:db476ab59b6765134de1d4fe96a1a9c96ddf091683599be0f26147ea1b2e4b88", size = 408250, upload-time = "2025-10-14T15:06:10.264Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/95/615e72cd27b85b61eec764a5ca51bd94d40b5adea5ff47567d9ebc4d275a/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:89eef07eee5e9d1fda06e38822ad167a044153457e6fd997f8a858ab7564a336", size = 396117, upload-time = "2025-10-14T15:06:11.28Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/81/e7fe958ce8a7fb5c73cc9fb07f5aeaf755e6aa72498c57d760af760c91f8/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce19e06cbda693e9e7686358af9cd6f5d61312ab8b00488bc36f5aabbaf77e24", size = 450493, upload-time = "2025-10-14T15:06:12.321Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" },
+]
+
+[[package]]
+name = "webcolors"
+version = "25.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" },
+]
+
+[[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 = "websocket-client"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/db/de907251b4ff46ae804ad0409809504153b3f30984daf82a1d84a9875830/websockets-16.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:31a52addea25187bde0797a97d6fc3d2f92b6f72a9370792d65a6e84615ac8a8", size = 177340, upload-time = "2026-01-10T09:22:34.539Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/fa/abe89019d8d8815c8781e90d697dec52523fb8ebe308bf11664e8de1877e/websockets-16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:417b28978cdccab24f46400586d128366313e8a96312e4b9362a4af504f3bbad", size = 175022, upload-time = "2026-01-10T09:22:36.332Z" },
+    { url = "https://files.pythonhosted.org/packages/58/5d/88ea17ed1ded2079358b40d31d48abe90a73c9e5819dbcde1606e991e2ad/websockets-16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:af80d74d4edfa3cb9ed973a0a5ba2b2a549371f8a741e0800cb07becdd20f23d", size = 175319, upload-time = "2026-01-10T09:22:37.602Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/0ee92b33087a33632f37a635e11e1d99d429d3d323329675a6022312aac2/websockets-16.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:08d7af67b64d29823fed316505a89b86705f2b7981c07848fb5e3ea3020c1abe", size = 184631, upload-time = "2026-01-10T09:22:38.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/c5/27178df583b6c5b31b29f526ba2da5e2f864ecc79c99dae630a85d68c304/websockets-16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be95cfb0a4dae143eaed2bcba8ac23f4892d8971311f1b06f3c6b78952ee70b", size = 185870, upload-time = "2026-01-10T09:22:39.893Z" },
+    { url = "https://files.pythonhosted.org/packages/87/05/536652aa84ddc1c018dbb7e2c4cbcd0db884580bf8e95aece7593fde526f/websockets-16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6297ce39ce5c2e6feb13c1a996a2ded3b6832155fcfc920265c76f24c7cceb5", size = 185361, upload-time = "2026-01-10T09:22:41.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/e2/d5332c90da12b1e01f06fb1b85c50cfc489783076547415bf9f0a659ec19/websockets-16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1c1b30e4f497b0b354057f3467f56244c603a79c0d1dafce1d16c283c25f6e64", size = 184615, upload-time = "2026-01-10T09:22:42.442Z" },
+    { url = "https://files.pythonhosted.org/packages/77/fb/d3f9576691cae9253b51555f841bc6600bf0a983a461c79500ace5a5b364/websockets-16.0-cp311-cp311-win32.whl", hash = "sha256:5f451484aeb5cafee1ccf789b1b66f535409d038c56966d6101740c1614b86c6", size = 178246, upload-time = "2026-01-10T09:22:43.654Z" },
+    { url = "https://files.pythonhosted.org/packages/54/67/eaff76b3dbaf18dcddabc3b8c1dba50b483761cccff67793897945b37408/websockets-16.0-cp311-cp311-win_amd64.whl", hash = "sha256:8d7f0659570eefb578dacde98e24fb60af35350193e4f56e11190787bee77dac", size = 178684, upload-time = "2026-01-10T09:22:44.941Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" },
+    { url = "https://files.pythonhosted.org/packages/72/07/c98a68571dcf256e74f1f816b8cc5eae6eb2d3d5cfa44d37f801619d9166/websockets-16.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:349f83cd6c9a415428ee1005cadb5c2c56f4389bc06a9af16103c3bc3dcc8b7d", size = 174947, upload-time = "2026-01-10T09:23:36.166Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/52/93e166a81e0305b33fe416338be92ae863563fe7bce446b0f687b9df5aea/websockets-16.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:4a1aba3340a8dca8db6eb5a7986157f52eb9e436b74813764241981ca4888f03", size = 175260, upload-time = "2026-01-10T09:23:37.409Z" },
+    { url = "https://files.pythonhosted.org/packages/56/0c/2dbf513bafd24889d33de2ff0368190a0e69f37bcfa19009ef819fe4d507/websockets-16.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f4a32d1bd841d4bcbffdcb3d2ce50c09c3909fbead375ab28d0181af89fd04da", size = 176071, upload-time = "2026-01-10T09:23:39.158Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/8f/aea9c71cc92bf9b6cc0f7f70df8f0b420636b6c96ef4feee1e16f80f75dd/websockets-16.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0298d07ee155e2e9fda5be8a9042200dd2e3bb0b8a38482156576f863a9d457c", size = 176968, upload-time = "2026-01-10T09:23:41.031Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/3f/f70e03f40ffc9a30d817eef7da1be72ee4956ba8d7255c399a01b135902a/websockets-16.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a653aea902e0324b52f1613332ddf50b00c06fdaf7e92624fbf8c77c78fa5767", size = 178735, upload-time = "2026-01-10T09:23:42.259Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
+]
+
+[[package]]
+name = "widgetsnbextension"
+version = "4.0.15"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/f4/c67440c7fb409a71b7404b7aefcd7569a9c0d6bd071299bf4198ae7a5d95/widgetsnbextension-4.0.15.tar.gz", hash = "sha256:de8610639996f1567952d763a5a41af8af37f2575a41f9852a38f947eb82a3b9", size = 1097402, upload-time = "2025-11-01T21:15:55.178Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/0e/fa3b193432cfc60c93b42f3be03365f5f909d2b3ea410295cf36df739e31/widgetsnbextension-4.0.15-py3-none-any.whl", hash = "sha256:8156704e4346a571d9ce73b84bee86a29906c9abfd7223b7228a28899ccf3366", size = 2196503, upload-time = "2025-11-01T21:15:53.565Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "xarray"
+version = "2026.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0f/03/e3353b72e518574b32993989d8f696277bf878e9d508c7dd22e86c0dab5b/xarray-2026.2.0.tar.gz", hash = "sha256:978b6acb018770554f8fd964af4eb02f9bcc165d4085dbb7326190d92aa74bcf", size = 3111388, upload-time = "2026-02-13T22:20:50.18Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/92/545eb2ca17fc0e05456728d7e4378bfee48d66433ae3b7e71948e46826fb/xarray-2026.2.0-py3-none-any.whl", hash = "sha256:e927d7d716ea71dea78a13417970850a640447d8dd2ceeb65c5687f6373837c9", size = 1405358, upload-time = "2026-02-13T22:20:47.847Z" },
+]
+
+[[package]]
+name = "xyzservices"
+version = "2025.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/0f/022795fc1201e7c29e742a509913badb53ce0b38f64b6db859e2f6339da9/xyzservices-2025.11.0.tar.gz", hash = "sha256:2fc72b49502b25023fd71e8f532fb4beddbbf0aa124d90ea25dba44f545e17ce", size = 1135703, upload-time = "2025-11-22T11:31:51.82Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/5c/2c189d18d495dd0fa3f27ccc60762bbc787eed95b9b0147266e72bb76585/xyzservices-2025.11.0-py3-none-any.whl", hash = "sha256:de66a7599a8d6dad63980b77defd1d8f5a5a9cb5fc8774ea1c6e89ca7c2a3d2f", size = 93916, upload-time = "2025-11-22T11:31:50.525Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.23.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
+    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
+    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
+    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
+    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
+    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
+    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
+    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
+    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
+    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
+    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
+    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
+    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
+    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
+    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
+    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
+    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
+    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
+    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
+    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
+    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
+    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
+    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
+    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
+    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
+    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
+    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
+    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
+    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
+    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
+    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
+    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
+    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+]
+
+[[package]]
+name = "zarr"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "donfig" },
+    { name = "google-crc32c" },
+    { name = "numcodecs" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/31/5a/b8a0cf39a14c770c30bd1f2d120c54000c8cd9e84e8e79f38d9a7ce58071/zarr-3.1.6.tar.gz", hash = "sha256:d95e72cbea4b90e9a70679468b8266400331756232576ae2b43400ac5108d0eb", size = 386531, upload-time = "2026-03-23T17:25:18.748Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/7c/ba8ca8cbe9dbef8e83a95fc208fed8e6686c98b4719aaa0aa7f3d31fe390/zarr-3.1.6-py3-none-any.whl", hash = "sha256:b5a82c5079d1c3d4ee8f06746fa3b9a98a7d804300fa3f4be154362a33e1207e", size = 295655, upload-time = "2026-03-23T17:25:17.189Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]